@kensio/yulin 1.21.2 → 1.21.4

package/dist/service/lambda/destination/sim-aws-lambda-destinations.js

@@ -10,12 +10,10 @@ import { SimLambdaDestinationTopic } from "./deliver/sim-lambda-destination-topi
  * built: reaching another service while this one is being constructed is a
  * cycle with no bottom to it.
  *
- * Real Lambda delivers under the function's own execution role, and delivers
- * nothing when that role cannot write to the destination. The permission is
- * left unchecked here, so a delivery is made as the destination Account's own
- * root. A record that silently goes nowhere is the harder failure to find, and
- * a destination needs no resource policy on real AWS either, so nothing about
- * the destination itself has to be set up for a record to arrive.
+ * Every delivery uses the source function's execution Role as its caller. The
+ * destination service applies its ordinary IAM checks to that Role before it
+ * changes any state.
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/invocation-async-retain-records.html
  */
 export class SimAwsLambdaDestinations {
     simAws;
@@ -58,6 +56,7 @@ export class SimAwsLambdaDestinations {
             arn: request.targetArn,
             body: JSON.stringify(request.payload),
             sourceFunctionArn: request.sourceFunctionArn,
+            sourceFunctionRoleArn: request.sourceFunctionRoleArn,
         };
         await (request.targetArn.service === "sqs"
             ? this.queue.deliver(send)
@@ -69,6 +68,7 @@ export class SimAwsLambdaDestinations {
             arn: request.destinationArn,
             body: JSON.stringify(request.record),
             sourceFunctionArn: request.sourceFunctionArn,
+            sourceFunctionRoleArn: request.sourceFunctionRoleArn,
         };
     }
     scopeOf(arn) {

package/dist/service/lambda/destination/sim-lambda-destination-targets.d.ts

@@ -11,6 +11,8 @@ export interface SimLambdaDestinationDeliveryRequest {
      * delivery is attributed to.
      */
     readonly sourceFunctionArn: string;
+    /** The execution Role Lambda uses to deliver this record. */
+    readonly sourceFunctionRoleArn: string;
 }
 /**
  * One asynchronous invocation's event on its way to a dead-letter target.
@@ -23,6 +25,7 @@ export interface SimLambdaDeadLetterRequest {
     readonly targetArn: SimLambdaDestinationArn;
     readonly payload: unknown;
     readonly sourceFunctionArn: string;
+    readonly sourceFunctionRoleArn: string;
 }
 /**
  * Everywhere a simulated function's asynchronous invocation results can go.

package/dist/service/lambda/event-source/poll/kinesis/sim-lambda-kinesis-stream-delivery.js

@@ -1,6 +1,6 @@
 import { SimLambdaStreamCascadeGuard } from "../../stream/sim-lambda-stream-cascade-guard.js";
 import { countSimLambdaKinesisIteratorAge } from "../sim-lambda-stream-iterator-age.js";
-import { simLambdaStreamSequenceNumbers } from "../sim-lambda-stream-sequence-numbers.js";
+import { simLambdaKinesisStreamRecordTimes } from "../sim-lambda-stream-record-times.js";
 import { SimLambdaStreamBatchResponse } from "../sim-lambda-stream-batch-response.js";
 import { SimLambdaKinesisStreamEventBuilder } from "./sim-lambda-kinesis-stream-event.js";
 /**
@@ -50,22 +50,17 @@ export class SimLambdaKinesisStreamDelivery {
         return this.cascade.noteRecordWritten();
     }
     async handled(simFunction, records) {
+        const times = simLambdaKinesisStreamRecordTimes(records);
         try {
-            return this.batchResponse.handled(sequenceNumbersOf(records), await simFunction.invoke(this.eventBuilder.of(records)));
+            return this.batchResponse.handled(times, await simFunction.invoke(this.eventBuilder.of(records)));
         }
         catch {
             // As on real Lambda, the handler error goes to the function's logs. What
             // the stream sees is the batch being tried again.
-            return this.batchResponse.failed();
+            return this.batchResponse.failed(times);
         }
         finally {
             countSimLambdaKinesisIteratorAge(simFunction, records);
         }
     }
 }
-/**
- * The sequence numbers this batch's records can be named by.
- */
-function sequenceNumbersOf(records) {
-    return simLambdaStreamSequenceNumbers(records.map((one) => one.SequenceNumber));
-}

package/dist/service/lambda/event-source/poll/sim-lambda-dynamodb-stream-delivery.js

@@ -1,7 +1,7 @@
 import { SimLambdaStreamCascadeGuard } from "../stream/sim-lambda-stream-cascade-guard.js";
 import { SimLambdaDynamoDbStreamEventBuilder } from "./sim-lambda-dynamodb-stream-event.js";
 import { countSimLambdaDynamoDbIteratorAge } from "./sim-lambda-stream-iterator-age.js";
-import { simLambdaStreamSequenceNumbers } from "./sim-lambda-stream-sequence-numbers.js";
+import { simLambdaDynamoDbStreamRecordTimes } from "./sim-lambda-stream-record-times.js";
 import { SimLambdaStreamBatchResponse } from "./sim-lambda-stream-batch-response.js";
 /**
  * Hands one batch of stream records to a function and says what became of it.
@@ -49,22 +49,17 @@ export class SimLambdaDynamoDbStreamDelivery {
         return this.cascade.noteRecordWritten();
     }
     async handled(simFunction, records) {
+        const times = simLambdaDynamoDbStreamRecordTimes(records);
         try {
-            return this.batchResponse.handled(sequenceNumbersOf(records), await simFunction.invoke(this.eventBuilder.of(records)));
+            return this.batchResponse.handled(times, await simFunction.invoke(this.eventBuilder.of(records)));
         }
         catch {
             // As on real Lambda, the handler error goes to the function's logs. What
             // the table sees is the batch being tried again.
-            return this.batchResponse.failed();
+            return this.batchResponse.failed(times);
         }
         finally {
             countSimLambdaDynamoDbIteratorAge(simFunction, records);
         }
     }
 }
-/**
- * The sequence numbers this batch's records can be named by.
- */
-function sequenceNumbersOf(records) {
-    return simLambdaStreamSequenceNumbers(records.map((one) => one.dynamodb?.SequenceNumber));
-}

package/dist/service/lambda/event-source/poll/sim-lambda-stream-batch-outcome.d.ts

@@ -1,4 +1,5 @@
 import type { SimLambdaEventSourceStreamPosition } from "../stream/sim-lambda-event-source-streams.js";
+import type { SimLambdaStreamRecordTime } from "./sim-lambda-stream-record-times.js";
 /**
  * What became of one batch of stream records handed to a function.
  *
@@ -7,24 +8,42 @@ import type { SimLambdaEventSourceStreamPosition } from "../stream/sim-lambda-ev
  * batch does not split. The mapping holds one place on the shard, so the answer
  * is one place: either the batch is finished with, or reading goes back to a
  * record and everything from there is delivered again.
+ *
+ * The batch's own records travel with the answer, because what happens to a
+ * batch that failed depends on them: they carry the names it can be sent back
+ * to and the instants its records are aged from.
  */
 export declare class SimLambdaStreamBatchOutcome {
     readonly isHandled: boolean;
+    /**
+     * The records the batch carried, in stream order.
+     */
+    readonly records: readonly SimLambdaStreamRecordTime[];
     private readonly rewindTo;
     private constructor();
     /**
      * A batch the function took in full.
      */
-    static handled(): SimLambdaStreamBatchOutcome;
+    static handled(records: readonly SimLambdaStreamRecordTime[]): SimLambdaStreamBatchOutcome;
     /**
      * A batch the function did not take, which is read again from where it was.
      */
-    static failed(): SimLambdaStreamBatchOutcome;
+    static failed(records: readonly SimLambdaStreamRecordTime[]): SimLambdaStreamBatchOutcome;
     /**
      * A batch the function reported failing partway through, which is read again
      * from the record it named.
      */
-    static failedFrom(sequenceNumber: string): SimLambdaStreamBatchOutcome;
+    static failedFrom(records: readonly SimLambdaStreamRecordTime[], sequenceNumber: string): SimLambdaStreamBatchOutcome;
+    /**
+     * Where in the batch the next delivery starts, as a position in the records
+     * the batch carried.
+     *
+     * A batch that failed whole starts at the first record. One the function
+     * reported on starts at the record it named, which the batch response has
+     * already checked was in the batch, so a name that is not there is the whole
+     * batch again rather than a guess.
+     */
+    get retryIndex(): number;
     /**
      * Where the next read starts when the batch goes back.
      *

package/dist/service/lambda/event-source/poll/sim-lambda-stream-batch-outcome.js

@@ -6,32 +6,62 @@
  * batch does not split. The mapping holds one place on the shard, so the answer
  * is one place: either the batch is finished with, or reading goes back to a
  * record and everything from there is delivered again.
+ *
+ * The batch's own records travel with the answer, because what happens to a
+ * batch that failed depends on them: they carry the names it can be sent back
+ * to and the instants its records are aged from.
  */
 export class SimLambdaStreamBatchOutcome {
     isHandled;
+    /**
+     * The records the batch carried, in stream order.
+     */
+    records;
     rewindTo;
-    constructor(isHandled, rewindTo) {
-        this.isHandled = isHandled;
-        this.rewindTo = rewindTo;
+    constructor(properties) {
+        this.isHandled = properties.isHandled;
+        this.records = properties.records;
+        this.rewindTo = properties.rewindTo;
     }
     /**
      * A batch the function took in full.
      */
-    static handled() {
-        return new SimLambdaStreamBatchOutcome(true, undefined);
+    static handled(records) {
+        return new SimLambdaStreamBatchOutcome({ isHandled: true, records });
     }
     /**
      * A batch the function did not take, which is read again from where it was.
      */
-    static failed() {
-        return new SimLambdaStreamBatchOutcome(false, undefined);
+    static failed(records) {
+        return new SimLambdaStreamBatchOutcome({ isHandled: false, records });
     }
     /**
      * A batch the function reported failing partway through, which is read again
      * from the record it named.
      */
-    static failedFrom(sequenceNumber) {
-        return new SimLambdaStreamBatchOutcome(false, sequenceNumber);
+    static failedFrom(records, sequenceNumber) {
+        return new SimLambdaStreamBatchOutcome({
+            isHandled: false,
+            records,
+            rewindTo: sequenceNumber,
+        });
+    }
+    /**
+     * Where in the batch the next delivery starts, as a position in the records
+     * the batch carried.
+     *
+     * A batch that failed whole starts at the first record. One the function
+     * reported on starts at the record it named, which the batch response has
+     * already checked was in the batch, so a name that is not there is the whole
+     * batch again rather than a guess.
+     */
+    get retryIndex() {
+        const sequenceNumber = this.rewindTo;
+        if (sequenceNumber === undefined) {
+            return 0;
+        }
+        const index = this.records.findIndex((record) => record.sequenceNumber === sequenceNumber);
+        return index === -1 ? 0 : index;
     }
     /**
      * Where the next read starts when the batch goes back.

package/dist/service/lambda/event-source/poll/sim-lambda-stream-batch-response.d.ts

@@ -1,4 +1,5 @@
 import { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+import type { SimLambdaStreamRecordTime } from "./sim-lambda-stream-record-times.js";
 /**
  * Reads what a function said about the batch of stream records it was given.
  *
@@ -18,15 +19,15 @@ export declare class SimLambdaStreamBatchResponse {
     /**
      * What became of a batch the function returned from.
      *
-     * The sequence numbers are the batch's own, in stream order, and each source
-     * cuts them out of its own record shape. A record carrying none is left out
-     * rather than given an empty name, so a report entry with no identifier names
-     * nothing and the whole batch goes back.
+     * The records are the batch's own, in stream order, and each source cuts them
+     * out of its own record shape. A record carrying no sequence number cannot be
+     * named, and is left out of the names a report is read against, so a report
+     * entry with no identifier names nothing and the whole batch goes back.
      */
-    handled(sequenceNumbers: readonly string[], result: unknown): SimLambdaStreamBatchOutcome;
+    handled(records: readonly SimLambdaStreamRecordTime[], result: unknown): SimLambdaStreamBatchOutcome;
     /**
      * What becomes of a batch the function threw on: the whole of it is read
      * again.
      */
-    failed(): SimLambdaStreamBatchOutcome;
+    failed(records: readonly SimLambdaStreamRecordTime[]): SimLambdaStreamBatchOutcome;
 }

package/dist/service/lambda/event-source/poll/sim-lambda-stream-batch-response.js

@@ -1,5 +1,6 @@
 import { SimLambdaBatchItemFailures } from "./sim-lambda-batch-item-failures.js";
 import { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+import { simLambdaStreamSequenceNumbers } from "./sim-lambda-stream-sequence-numbers.js";
 /**
  * Reads what a function said about the batch of stream records it was given.
  *
@@ -21,28 +22,28 @@ export class SimLambdaStreamBatchResponse {
     /**
      * What became of a batch the function returned from.
      *
-     * The sequence numbers are the batch's own, in stream order, and each source
-     * cuts them out of its own record shape. A record carrying none is left out
-     * rather than given an empty name, so a report entry with no identifier names
-     * nothing and the whole batch goes back.
+     * The records are the batch's own, in stream order, and each source cuts them
+     * out of its own record shape. A record carrying no sequence number cannot be
+     * named, and is left out of the names a report is read against, so a report
+     * entry with no identifier names nothing and the whole batch goes back.
      */
-    handled(sequenceNumbers, result) {
+    handled(records, result) {
         const failedIds = this.batchItemFailures.idsIn(result);
         if (failedIds === undefined) {
-            return SimLambdaStreamBatchOutcome.handled();
+            return SimLambdaStreamBatchOutcome.handled(records);
         }
-        const rewindTo = rewindPoint(failedIds, sequenceNumbers);
+        const rewindTo = rewindPoint(failedIds, records);
         if (rewindTo === undefined) {
-            return this.failed();
+            return this.failed(records);
         }
-        return SimLambdaStreamBatchOutcome.failedFrom(rewindTo);
+        return SimLambdaStreamBatchOutcome.failedFrom(records, rewindTo);
     }
     /**
      * What becomes of a batch the function threw on: the whole of it is read
      * again.
      */
-    failed() {
-        return SimLambdaStreamBatchOutcome.failed();
+    failed(records) {
+        return SimLambdaStreamBatchOutcome.failed(records);
     }
 }
 /**
@@ -52,7 +53,8 @@ export class SimLambdaStreamBatchResponse {
  * The batch is in stream order, so the first record the report names is the
  * lowest sequence number it named.
  */
-function rewindPoint(failedIds, sequenceNumbers) {
+function rewindPoint(failedIds, records) {
+    const sequenceNumbers = simLambdaStreamSequenceNumbers(records.map((record) => record.sequenceNumber));
     if (failedIds.some((failedId) => !sequenceNumbers.includes(failedId))) {
         return undefined;
     }

package/dist/service/lambda/event-source/poll/sim-lambda-stream-checkpoint.d.ts

@@ -1,15 +1,16 @@
 import type { SimLambdaEventSourceStart } from "../sim-lambda-event-source-starting-position.js";
 import type { SimLambdaEventSourceStreamPosition } from "../stream/sim-lambda-event-source-streams.js";
-import type { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
 /**
  * How far along its stream one mapping has got.
  *
  * This is the difference between a stream and a queue. A queue hands a message
  * out and hides it, so a failed batch is the queue's problem afterwards. A
  * stream hands out a place, and the reader is the only thing that remembers it,
- * so a batch that failed is read again from exactly where it was. The
- * checkpoint therefore only moves when a batch is finished with: handled, or
- * discarded after its retries.
+ * so a batch that failed is read again from exactly where it was.
+ *
+ * The place is all this holds. Which place the next read starts from is decided
+ * by what became of the batch and what the mapping is willing to keep trying,
+ * and that decision is made elsewhere.
  */
 export declare class SimLambdaStreamCheckpoint {
     #private;
@@ -19,17 +20,10 @@ export declare class SimLambdaStreamCheckpoint {
      */
     get position(): SimLambdaEventSourceStreamPosition;
     /**
-     * Move past a batch that is finished with.
-     */
-    advanceTo(position: SimLambdaEventSourceStreamPosition): void;
-    /**
-     * Take a batch the function did not finish.
+     * Move to where the next read starts.
      *
-     * A batch that failed whole is read again from where it was. One the function
-     * reported failing partway through moves the checkpoint to the record it
-     * named, so that record and everything after it goes over again, including
-     * the records after it that the function did handle. The records before it
-     * are finished with.
+     * That is past a batch the mapping is finished with, and back to the record a
+     * batch it is not finished with is delivered again from.
      */
-    retry(outcome: SimLambdaStreamBatchOutcome): void;
+    advanceTo(position: SimLambdaEventSourceStreamPosition): void;
 }

package/dist/service/lambda/event-source/poll/sim-lambda-stream-checkpoint.js

@@ -4,9 +4,11 @@
  * This is the difference between a stream and a queue. A queue hands a message
  * out and hides it, so a failed batch is the queue's problem afterwards. A
  * stream hands out a place, and the reader is the only thing that remembers it,
- * so a batch that failed is read again from exactly where it was. The
- * checkpoint therefore only moves when a batch is finished with: handled, or
- * discarded after its retries.
+ * so a batch that failed is read again from exactly where it was.
+ *
+ * The place is all this holds. Which place the next read starts from is decided
+ * by what became of the batch and what the mapping is willing to keep trying,
+ * and that decision is made elsewhere.
  */
 export class SimLambdaStreamCheckpoint {
     #position;
@@ -20,21 +22,12 @@ export class SimLambdaStreamCheckpoint {
         return this.#position;
     }
     /**
-     * Move past a batch that is finished with.
+     * Move to where the next read starts.
+     *
+     * That is past a batch the mapping is finished with, and back to the record a
+     * batch it is not finished with is delivered again from.
      */
     advanceTo(position) {
         this.#position = position;
     }
-    /**
-     * Take a batch the function did not finish.
-     *
-     * A batch that failed whole is read again from where it was. One the function
-     * reported failing partway through moves the checkpoint to the record it
-     * named, so that record and everything after it goes over again, including
-     * the records after it that the function did handle. The records before it
-     * are finished with.
-     */
-    retry(outcome) {
-        this.#position = outcome.retryPosition(this.#position);
-    }
 }

package/dist/service/lambda/event-source/poll/sim-lambda-stream-progress.d.ts

@@ -20,7 +20,7 @@ interface SimLambdaStreamProgressProperties {
  */
 export declare class SimLambdaStreamProgress {
     private readonly checkpoint;
-    private readonly backoff;
+    private readonly retry;
     private readonly schedule;
     constructor(properties: SimLambdaStreamProgressProperties);
     /**
@@ -44,7 +44,10 @@ export declare class SimLambdaStreamProgress {
      */
     after(outcome: SimLambdaStreamBatchOutcome, batch: SimLambdaEventSourceStreamProgressBatch): void;
     /**
-     * Move past a batch the function took, and read on.
+     * Move past a batch that is finished with, and read on.
+     *
+     * A batch the function took is finished with, and so is one the mapping has
+     * given up on.
      */
     handled(batch: SimLambdaEventSourceStreamProgressBatch): void;
     /**
@@ -54,10 +57,11 @@ export declare class SimLambdaStreamProgress {
      * what AWS does when a stream mapping's error handling runs out. Parking the
      * shard instead would be a simulator invention.
      *
-     * A report naming a record moves the checkpoint before the wait, so what goes
-     * over again is the batch from that record on. The attempts are still counted
-     * against the same limit: a batch that keeps failing partway through has as
-     * many tries as one that keeps failing whole.
+     * A batch runs out either by having had its retries or by every record left
+     * in it being older than the mapping will carry. Records that aged out of the
+     * front of a batch are left behind, and the ones behind them go over again,
+     * so a mapping given a record age keeps working through its shard rather than
+     * stalling on the oldest record on it.
      */
     failed(outcome: SimLambdaStreamBatchOutcome, batch: SimLambdaEventSourceStreamProgressBatch): void;
 }

package/dist/service/lambda/event-source/poll/sim-lambda-stream-progress.js

@@ -1,7 +1,7 @@
 import { assertDefined } from "../../../../util/type-guard/defined.js";
 import { PollSchedule } from "../../../../util/background/poll-schedule.js";
 import { SimLambdaStreamCheckpoint } from "./sim-lambda-stream-checkpoint.js";
-import { SimLambdaStreamRetryBackoff } from "./sim-lambda-stream-retry-backoff.js";
+import { SimLambdaStreamRetry } from "./sim-lambda-stream-retry.js";
 /**
  * How far along its stream one mapping has got, and what it does next.
  *
@@ -15,15 +15,20 @@ import { SimLambdaStreamRetryBackoff } from "./sim-lambda-stream-retry-backoff.j
  */
 export class SimLambdaStreamProgress {
     checkpoint;
-    backoff = new SimLambdaStreamRetryBackoff();
+    retry;
     schedule;
     constructor(properties) {
         // A stream mapping is refused at creation unless it names a starting
         // position, so one that has got this far without one is the simulator
         // having gone wrong rather than a request having been wrong.
-        const { start } = properties.mapping;
+        const { start, streamRetryLimits } = properties.mapping;
         assertDefined(start, "stream mapping start position");
+        assertDefined(streamRetryLimits, "stream mapping retry limits");
         this.checkpoint = new SimLambdaStreamCheckpoint(start);
+        this.retry = new SimLambdaStreamRetry({
+            limits: streamRetryLimits,
+            clock: properties.background,
+        });
         this.schedule = new PollSchedule(properties);
     }
     /**
@@ -59,10 +64,13 @@ export class SimLambdaStreamProgress {
         this.failed(outcome, batch);
     }
     /**
-     * Move past a batch the function took, and read on.
+     * Move past a batch that is finished with, and read on.
+     *
+     * A batch the function took is finished with, and so is one the mapping has
+     * given up on.
      */
     handled(batch) {
-        this.backoff.reset();
+        this.retry.reset();
         this.checkpoint.advanceTo(batch.next);
         if (!batch.drained) {
             this.schedule.now();
@@ -75,17 +83,19 @@ export class SimLambdaStreamProgress {
      * what AWS does when a stream mapping's error handling runs out. Parking the
      * shard instead would be a simulator invention.
      *
-     * A report naming a record moves the checkpoint before the wait, so what goes
-     * over again is the batch from that record on. The attempts are still counted
-     * against the same limit: a batch that keeps failing partway through has as
-     * many tries as one that keeps failing whole.
+     * A batch runs out either by having had its retries or by every record left
+     * in it being older than the mapping will carry. Records that aged out of the
+     * front of a batch are left behind, and the ones behind them go over again,
+     * so a mapping given a record age keeps working through its shard rather than
+     * stalling on the oldest record on it.
      */
     failed(outcome, batch) {
-        if (this.backoff.isExhausted) {
+        const again = this.retry.after(outcome, this.checkpoint.position);
+        if (again === undefined) {
             this.handled(batch);
             return;
         }
-        this.checkpoint.retry(outcome);
-        this.schedule.afterSeconds(this.backoff.nextSeconds());
+        this.checkpoint.advanceTo(again.position);
+        this.schedule.afterSeconds(again.afterSeconds);
     }
 }

package/dist/service/lambda/event-source/poll/sim-lambda-stream-record-times.d.ts

@@ -0,0 +1,23 @@
+import type { SimLambdaKinesisStreamRecord } from "../stream/kinesis/sim-lambda-kinesis-streams.js";
+import type { SimLambdaEventSourceStreamRecord } from "../stream/sim-lambda-event-source-streams.js";
+/**
+ * One record of a delivered batch, as deciding what to do with a failed batch
+ * sees it.
+ *
+ * Two things about a record matter once its function has failed: the name the
+ * mapping can be sent back to, and the instant its age is measured from. Each
+ * stream service cuts both out of its own record shape, the way it already does
+ * for the sequence numbers a batch item failure report names.
+ */
+export interface SimLambdaStreamRecordTime {
+    readonly sequenceNumber: string | undefined;
+    readonly at: Date | undefined;
+}
+/**
+ * What a DynamoDB Streams batch's records are named by and dated from.
+ */
+export declare function simLambdaDynamoDbStreamRecordTimes(records: readonly SimLambdaEventSourceStreamRecord[]): readonly SimLambdaStreamRecordTime[];
+/**
+ * What a Kinesis batch's records are named by and dated from.
+ */
+export declare function simLambdaKinesisStreamRecordTimes(records: readonly SimLambdaKinesisStreamRecord[]): readonly SimLambdaStreamRecordTime[];

package/dist/service/lambda/event-source/poll/sim-lambda-stream-record-times.js

@@ -0,0 +1,18 @@
+/**
+ * What a DynamoDB Streams batch's records are named by and dated from.
+ */
+export function simLambdaDynamoDbStreamRecordTimes(records) {
+    return records.map((one) => ({
+        sequenceNumber: one.dynamodb?.SequenceNumber,
+        at: one.dynamodb?.ApproximateCreationDateTime,
+    }));
+}
+/**
+ * What a Kinesis batch's records are named by and dated from.
+ */
+export function simLambdaKinesisStreamRecordTimes(records) {
+    return records.map((one) => ({
+        sequenceNumber: one.SequenceNumber,
+        at: one.ApproximateArrivalTimestamp,
+    }));
+}

package/dist/service/lambda/event-source/poll/sim-lambda-stream-retry-backoff.d.ts

@@ -1,25 +1,24 @@
 /**
  * How long a mapping waits before handing a failed batch to its function
- * again, and when it stops trying.
+ * again, and how many waits it has left.
  *
- * Both are simulator constraints rather than AWS behaviour, and both are
- * deliberate.
- *
- * AWS documents no delay between attempts. A delay of zero here would be
- * scheduled at the instant the clock already reads, and advancing the clock
- * keeps dispatching whatever falls due inside the interval it is moving
+ * The delay is a simulator constraint rather than AWS behaviour, and it is
+ * deliberate. AWS documents no delay between attempts. A delay of zero here
+ * would be scheduled at the instant the clock already reads, and advancing the
+ * clock keeps dispatching whatever falls due inside the interval it is moving
  * through, so a batch the function always throws on would leave `advanceBy`
  * with work to do forever. The delay is therefore strictly positive and grows
- * with each attempt, which is also what a consumer under load actually wants.
+ * with each attempt, which is also what a consumer under load actually wants,
+ * and it is what lets a test walk through the attempts by advancing the clock.
  *
- * AWS retries a stream batch until the records age out of the stream, which is
- * a day. Waiting out a simulated day for a handler that is never going to
- * succeed is the same hang with more steps, so the attempts are counted
- * instead. What happens at the end is AWS's own behaviour: the records are
- * discarded and the mapping carries on with the stream.
+ * How many attempts there are belongs to the mapping rather than to this: a
+ * mapping that asked for a retry quota gets the quota it asked for, and one
+ * that asked for neither limit gets the simulator's own cap.
  */
 export declare class SimLambdaStreamRetryBackoff {
+    private readonly attemptLimit;
     private attempts;
+    constructor(attemptLimit: number);
     /**
      * Whether this batch has had all the attempts it gets.
      */