基于Node.js+Lambda实现Alexa技能多日期DynamoDB异步查询问题

Got it, let's solve this problem. The main issue you're facing is handling asynchronous DynamoDB queries—since each query runs in the background, callbacks make it hard to collect and merge results from multiple date queries. Here's a refactored approach using Promises and Promise.all to handle up to 7 days of data cleanly:

Step 1: Refactor readDynamoItem to Return a Promise #

First, convert your callback-based DynamoDB query function into one that returns a Promise. This lets us use modern async/await syntax or Promise.all to manage multiple async calls:

function readDynamoItem(params) {
  return new Promise((resolve, reject) => {
    docClient.query(params, (err, data) => {
      if (err) {
        console.error("DynamoDB query error:", err);
        reject("Failed to fetch data");
      } else {
        console.log("Query succeeded.");
        let speechOutput = "";
        const items = data.Items;
        
        if (items.length === 0) {
          resolve("No events found for this date.");
          return;
        }

        items.forEach((item, index) => {
          if (index === items.length - 1) {
            speechOutput += ` and ${item.title} at ${item.time}.`;
          } else if (index === 0) {
            speechOutput += `${item.title} at ${item.time}`;
          } else {
            speechOutput += `, ${item.title} at ${item.time}`;
          }
        });

        resolve(speechOutput);
      }
    });
  });
}

Step 2: Modify queryDynamoDate_multiple to Handle Multiple Dates #

Next, update your main function to generate the list of dates you need to query (up to 7 days starting from startdate), run all queries in parallel with Promise.all, then merge the results into a single speech output:

async function queryDynamoDate_multiple() {
  const startdate = this.attributes['startdate'];
  const maxDays = 7;
  const dateQueries = [];

  // Generate date list (assuming startdate is in YYYYMMDD format)
  for (let i = 0; i < maxDays; i++) {
    const currentDate = new Date(
      parseInt(startdate.slice(0,4)),
      parseInt(startdate.slice(4,6)) - 1, // Months are 0-indexed
      parseInt(startdate.slice(6,8)) + i
    );
    // Format back to YYYYMMDD
    const formattedDate = currentDate.toISOString().split('T')[0].replace(/-/g, '');
    
    // Create params for each date
    const params = {
      TableName: 'RegalCinema',
      KeyConditionExpression: "#date = :yymmdd and #time between :time1 and :time2",
      ExpressionAttributeNames: { "#date": "date", "#time": "time" },
      ExpressionAttributeValues: { 
        ":yymmdd": formattedDate,
        ":time1": '0', 
        ":time2": '2' 
      }
    };

    // Add the promise to our list (we'll run all at once later)
    dateQueries.push(
      readDynamoItem(params).then(result => {
        return `On ${formattedDate}, you have: ${result}`;
      })
    );
  }

  try {
    // Wait for all queries to complete
    const allResults = await Promise.all(dateQueries);
    // Merge results into a single string (filter out empty/no-result entries if needed)
    const mergedSpeech = allResults.filter(result => !result.includes("No events found")).join(" ");
    
    const finalSpeech = mergedSpeech.length > 0 
      ? `You asked for up to 7 days of data. Here's what we found: ${mergedSpeech}`
      : "No events found in the requested date range.";

    this.response.speak(finalSpeech).listen('Would you like to try another date range?');
    this.emit(':responseReady');
  } catch (error) {
    this.response.speak('Sorry, there was an error fetching your data. Please try again later.');
    this.emit(':responseReady');
  }
}

Key Changes Explained #

• Promise Wrapper: By returning a Promise from readDynamoItem, we can use await and Promise.all to wait for all queries to finish before merging results, avoiding callback hell.
• Parallel Queries: Promise.all runs all DynamoDB queries at the same time (instead of sequentially), which is more efficient and cuts down on total execution time.
• Date Handling: The loop generates the next 6 days after startdate (total 7 days) and formats them to match your DynamoDB date format—adjust the formatting logic if your table uses a different date string structure.
• Error Handling: Added try/catch to handle any failures in the queries, ensuring Alexa gives a friendly error message instead of crashing.
• Clean Result Merging: We format each date's result with a clear date label, then join them all into one coherent speech output. We also filter out dates with no events to keep the response concise.

Important Notes #

• Make sure your Lambda execution role has the necessary permissions to query DynamoDB for all these requests.
• If you need to let users specify a custom date range (instead of fixed 7 days), adjust the loop logic to generate dates between a user-provided start and end date.
• Test the date formatting thoroughly to ensure it matches exactly what's stored in your DynamoDB table—small mismatches (like leading zeros for months/days) will cause empty results.

内容的提问来源于stack exchange，提问作者C-Bertram