How to fix ExpiredIteratorException: The shard iterator has expired in DynamoDB

import { DynamoDBStreamsClient, GetShardIteratorCommand, GetRecordsCommand }
  from "@aws-sdk/client-dynamodb-streams";

const client = new DynamoDBStreamsClient({ region: "us-east-1" });

// Initial iterator
const iteratorResponse = await client.send(new GetShardIteratorCommand({
  StreamArn: "arn:aws:dynamodb:region:account:table/my-table/stream/...",
  ShardId: "shard-id",
  ShardIteratorType: "TRIM_HORIZON"
}));

let shardIterator = iteratorResponse.ShardIterator;

// Loop: always use the NextShardIterator returned
while (true) {
  const recordsResponse = await client.send(new GetRecordsCommand({
    ShardIterator: shardIterator
  }));

  // Process records...
  console.log("Records:", recordsResponse.Records);

  // THIS IS CRITICAL: Use NextShardIterator, not the original
  shardIterator = recordsResponse.NextShardIterator;

  if (!shardIterator) break; // Shard has closed
}

async function getRecordsWithRetry(streamArn, shardId, currentIterator) {
  try {
    const response = await client.send(new GetRecordsCommand({
      ShardIterator: currentIterator
    }));
    return response;
  } catch (error) {
    if (error.name === "ExpiredIteratorException") {
      console.warn("Iterator expired, obtaining fresh iterator...");

      // Get a new iterator starting from LATEST (don't replay)
      const newIterator = await client.send(new GetShardIteratorCommand({
        StreamArn: streamArn,
        ShardId: shardId,
        ShardIteratorType: "LATEST" // Skip expired records
      }));

      // Retry with new iterator
      return await client.send(new GetRecordsCommand({
        ShardIterator: newIterator.ShardIterator
      }));
    }
    throw error;
  }
}

exports.handler = async (event) => {
  // Don't wait for all processing to complete
  const promises = event.Records.map(record => {
    return processRecordAsync(record).catch(err => {
      console.error("Record processing failed:", err);
      // Still return success to avoid re-processing expired records
    });
  });

  // Use Promise.allSettled to not block on one slow record
  await Promise.allSettled(promises);
};