@kensio/yulin 1.1.0 → 1.3.0

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-delivery.d.ts

@@ -0,0 +1,17 @@
+import type { SimLambdaSqsEventSourceArn } from "../queue/sim-lambda-sqs-event-source-arn.js";
+import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import { SimLambdaEventSourceDelivery } from "./sim-lambda-event-source-delivery.js";
+interface SimLambdaSqsDeliveryProperties {
+    readonly mapping: SimLambdaEventSourceMapping;
+    readonly eventSourceArn: SimLambdaSqsEventSourceArn;
+}
+/**
+ * The delivery an SQS mapping hands its batches over with.
+ *
+ * What the event looks like and what the function's return value means are both
+ * the queue's, so they are put together here and handed to the delivery, which
+ * knows neither.
+ */
+export declare function makeSimLambdaSqsDelivery(properties: SimLambdaSqsDeliveryProperties): SimLambdaEventSourceDelivery;
+export {};
+//# sourceMappingURL=sim-lambda-sqs-delivery.d.ts.map

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-delivery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-sqs-delivery.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-sqs-delivery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,6CAA6C,CAAC;AAC9F,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uCAAuC,CAAC;AACzF,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AAIrF,UAAU,8BAA8B;IACtC,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC;IAC9C,QAAQ,CAAC,cAAc,EAAE,0BAA0B,CAAC;CACrD;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,8BAA8B,GACzC,4BAA4B,CAO9B"}

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

@@ -0,0 +1,17 @@
+import { SimLambdaEventSourceDelivery } from "./sim-lambda-event-source-delivery.js";
+import { SimLambdaSqsBatchResponse } from "./sim-lambda-sqs-batch-response.js";
+import { SimLambdaSqsEventBuilder } from "./sim-lambda-sqs-event.js";
+/**
+ * The delivery an SQS mapping hands its batches over with.
+ *
+ * What the event looks like and what the function's return value means are both
+ * the queue's, so they are put together here and handed to the delivery, which
+ * knows neither.
+ */
+export function makeSimLambdaSqsDelivery(properties) {
+    return new SimLambdaEventSourceDelivery({
+        eventBuilder: new SimLambdaSqsEventBuilder(properties.eventSourceArn),
+        batchResponse: new SimLambdaSqsBatchResponse(properties.mapping.reportsBatchItemFailures),
+    });
+}
+//# sourceMappingURL=sim-lambda-sqs-delivery.js.map

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-delivery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-sqs-delivery.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-sqs-delivery.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AACrF,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAOrE;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CACtC,UAA0C;IAE1C,OAAO,IAAI,4BAA4B,CAAC;QACtC,YAAY,EAAE,IAAI,wBAAwB,CAAC,UAAU,CAAC,cAAc,CAAC;QACrE,aAAa,EAAE,IAAI,yBAAyB,CAC1C,UAAU,CAAC,OAAO,CAAC,wBAAwB,CAC5C;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-event-source-poller.d.ts

@@ -0,0 +1,88 @@
+import type { BackgroundScheduler } from "../../../../util/background/background.js";
+import type { SimLambdaFunctionLookup } from "../../function/url/sim-lambda-function-lookup.js";
+import type { SimLambdaEventSourceQueues, SimLambdaEventSourceQueueWatcher } from "../queue/sim-lambda-event-source-queues.js";
+import type { SimLambdaSqsEventSourceArn } from "../queue/sim-lambda-sqs-event-source-arn.js";
+import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaEventSourcePoller } from "./sim-lambda-event-source-poller.js";
+interface SimLambdaSqsEventSourcePollerProperties {
+    readonly mapping: SimLambdaEventSourceMapping;
+    readonly eventSourceArn: SimLambdaSqsEventSourceArn;
+    readonly functions: SimLambdaFunctionLookup;
+    readonly queues: SimLambdaEventSourceQueues;
+    readonly background: BackgroundScheduler;
+}
+/**
+ * Polls one event source mapping's queue and invokes its function.
+ *
+ * Real Lambda polls a queue continuously. Nothing in this simulation runs
+ * continuously, so the queue says when a message has arrived and a poll is
+ * scheduled in response. A test that awaits the simulation settling has
+ * therefore watched the whole delivery happen, rather than having waited a
+ * while and hoped.
+ *
+ * A batch the function returns from is deleted from the queue. A batch it
+ * throws on is left there, which hides it for the visibility timeout and hands
+ * it back afterwards, so a redrive policy eventually gives up on it exactly as
+ * it would for any other failing consumer. That is why the poller invokes the
+ * function directly rather than through the Invoke command: an asynchronous
+ * invocation drops its handler error, and this one has to be seen.
+ */
+export declare class SimLambdaSqsEventSourcePoller implements SimLambdaEventSourcePoller, SimLambdaEventSourceQueueWatcher {
+    private readonly mapping;
+    private readonly functions;
+    private readonly queue;
+    private readonly delivery;
+    private readonly schedule;
+    private stopped;
+    constructor(properties: SimLambdaSqsEventSourcePollerProperties);
+    /**
+     * Watch the queue this mapping polls.
+     *
+     * Watching starts as soon as the mapping is created, before it has finished
+     * creating, so a message sent in between is not missed. The poll it wakes
+     * finds a mapping that is not polling yet and does nothing, and the poll that
+     * follows activation picks the message up.
+     */
+    watch(): void;
+    /**
+     * Poll as soon as the simulation gets to it, which is what a newly enabled
+     * mapping does with whatever is already on its queue.
+     */
+    pollNow(): void;
+    /**
+     * Stop polling, as deleting the mapping does.
+     */
+    stop(): void;
+    /**
+     * Take a message arriving on the queue as something to poll for.
+     */
+    messageAvailable(availableFrom: Date): void;
+    /**
+     * Poll once: one batch, delivered and then deleted or left behind.
+     */
+    private run;
+    /**
+     * The function this mapping delivers to, while it should be delivering.
+     *
+     * A mapping still being created is not polling yet, and a disabled one never
+     * is. A function that is not there is not an error here: the mapping simply
+     * has nothing to deliver to.
+     */
+    private pollingFunction;
+    /**
+     * Look again when a message the queue could not hand out becomes
+     * receivable.
+     *
+     * A mapping created while every message on its queue is in flight, or one
+     * whose queue holds only delayed messages, has nothing to wake it otherwise.
+     */
+    private pollWhenSomethingComesBack;
+    /**
+     * Decide when this mapping polls again: when a returned batch becomes
+     * visible again, or straight away when a batch filled the request and there
+     * may be more waiting.
+     */
+    private pollAgainAfter;
+}
+export {};
+//# sourceMappingURL=sim-lambda-sqs-event-source-poller.d.ts.map

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-event-source-poller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-sqs-event-source-poller.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-sqs-event-source-poller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAErF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAChG,OAAO,KAAK,EACV,0BAA0B,EAC1B,gCAAgC,EACjC,MAAM,4CAA4C,CAAC;AACpD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,6CAA6C,CAAC;AAC9F,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uCAAuC,CAAC;AAIzF,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAItF,UAAU,uCAAuC;IAC/C,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC;IAC9C,QAAQ,CAAC,cAAc,EAAE,0BAA0B,CAAC;IACpD,QAAQ,CAAC,SAAS,EAAE,uBAAuB,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,0BAA0B,CAAC;IAC5C,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,6BACX,YAAW,0BAA0B,EAAE,gCAAgC;IAEvE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;IACtD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0B;IAChD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+B;IACxD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmC;IAE5D,OAAO,CAAC,OAAO,CAAS;IAExB,YAAY,UAAU,EAAE,uCAAuC,EAc9D;IAED;;;;;;;OAOG;IACH,KAAK,IAAI,IAAI,CAEZ;IAED;;;OAGG;IACH,OAAO,IAAI,IAAI,CAEd;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,CAGX;IAED;;OAEG;IACH,gBAAgB,CAAC,aAAa,EAAE,IAAI,GAAG,IAAI,CAE1C;IAED;;OAEG;YACW,GAAG;IA0BjB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAQvB;;;;;;OAMG;IACH,OAAO,CAAC,0BAA0B;IAQlC;;;;OAIG;IACH,OAAO,CAAC,cAAc;CAevB"}

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-event-source-poller.js

@@ -0,0 +1,132 @@
+import { SimLambdaEventSourcePollSchedule } from "./sim-lambda-event-source-poll-schedule.js";
+import { makeSimLambdaSqsDelivery } from "./sim-lambda-sqs-delivery.js";
+import { SimLambdaSqsPolledQueue } from "./sim-lambda-sqs-polled-queue.js";
+/**
+ * Polls one event source mapping's queue and invokes its function.
+ *
+ * Real Lambda polls a queue continuously. Nothing in this simulation runs
+ * continuously, so the queue says when a message has arrived and a poll is
+ * scheduled in response. A test that awaits the simulation settling has
+ * therefore watched the whole delivery happen, rather than having waited a
+ * while and hoped.
+ *
+ * A batch the function returns from is deleted from the queue. A batch it
+ * throws on is left there, which hides it for the visibility timeout and hands
+ * it back afterwards, so a redrive policy eventually gives up on it exactly as
+ * it would for any other failing consumer. That is why the poller invokes the
+ * function directly rather than through the Invoke command: an asynchronous
+ * invocation drops its handler error, and this one has to be seen.
+ */
+export class SimLambdaSqsEventSourcePoller {
+    mapping;
+    functions;
+    queue;
+    delivery;
+    schedule;
+    stopped = false;
+    constructor(properties) {
+        this.mapping = properties.mapping;
+        this.functions = properties.functions;
+        this.queue = new SimLambdaSqsPolledQueue(properties.queues, properties.eventSourceArn.value);
+        this.delivery = makeSimLambdaSqsDelivery(properties);
+        this.schedule = new SimLambdaEventSourcePollSchedule({
+            background: properties.background,
+            poll: async () => {
+                await this.run();
+            },
+        });
+    }
+    /**
+     * Watch the queue this mapping polls.
+     *
+     * Watching starts as soon as the mapping is created, before it has finished
+     * creating, so a message sent in between is not missed. The poll it wakes
+     * finds a mapping that is not polling yet and does nothing, and the poll that
+     * follows activation picks the message up.
+     */
+    watch() {
+        this.queue.watch(this);
+    }
+    /**
+     * Poll as soon as the simulation gets to it, which is what a newly enabled
+     * mapping does with whatever is already on its queue.
+     */
+    pollNow() {
+        this.schedule.now();
+    }
+    /**
+     * Stop polling, as deleting the mapping does.
+     */
+    stop() {
+        this.stopped = true;
+        this.queue.unwatch(this);
+    }
+    /**
+     * Take a message arriving on the queue as something to poll for.
+     */
+    messageAvailable(availableFrom) {
+        this.schedule.at(availableFrom);
+    }
+    /**
+     * Poll once: one batch, delivered and then deleted or left behind.
+     */
+    async run() {
+        const simFunction = this.pollingFunction();
+        if (simFunction === undefined) {
+            return;
+        }
+        // Polling is done as the function's execution role, as on real Lambda, so
+        // simulated IAM decides whether this mapping may read its queue.
+        const { roleArn } = simFunction;
+        const timeout = await this.queue.visibilityTimeoutSeconds(roleArn);
+        const messages = await this.queue.receive(roleArn, this.mapping.batchSize);
+        if (messages.length === 0) {
+            this.pollWhenSomethingComesBack();
+            return;
+        }
+        const outcome = await this.delivery.to(simFunction, messages);
+        await this.queue.deleteMessages(roleArn, outcome.handledReceiptHandles);
+        this.pollAgainAfter(outcome, messages.length, timeout);
+    }
+    /**
+     * The function this mapping delivers to, while it should be delivering.
+     *
+     * A mapping still being created is not polling yet, and a disabled one never
+     * is. A function that is not there is not an error here: the mapping simply
+     * has nothing to deliver to.
+     */
+    pollingFunction() {
+        if (this.stopped || !this.mapping.isPolling) {
+            return undefined;
+        }
+        return this.functions.find(this.mapping.functionName);
+    }
+    /**
+     * Look again when a message the queue could not hand out becomes
+     * receivable.
+     *
+     * A mapping created while every message on its queue is in flight, or one
+     * whose queue holds only delayed messages, has nothing to wake it otherwise.
+     */
+    pollWhenSomethingComesBack() {
+        const availableFrom = this.queue.nextAvailability();
+        if (availableFrom !== undefined) {
+            this.schedule.at(availableFrom);
+        }
+    }
+    /**
+     * Decide when this mapping polls again: when a returned batch becomes
+     * visible again, or straight away when a batch filled the request and there
+     * may be more waiting.
+     */
+    pollAgainAfter(outcome, receivedCount, visibilityTimeoutSeconds) {
+        if (outcome.hasReturnedMessages) {
+            this.schedule.afterSeconds(visibilityTimeoutSeconds);
+            return;
+        }
+        if (receivedCount >= this.mapping.batchSize) {
+            this.schedule.now();
+        }
+    }
+}
+//# sourceMappingURL=sim-lambda-sqs-event-source-poller.js.map

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-event-source-poller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-sqs-event-source-poller.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-sqs-event-source-poller.ts"],"names":[],"mappings":"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"}

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-polled-queue.d.ts

@@ -0,0 +1,41 @@
+import type { SimLambdaEventSourceMessage, SimLambdaEventSourceQueues, SimLambdaEventSourceQueueWatcher } from "../queue/sim-lambda-event-source-queues.js";
+/**
+ * The one queue a mapping polls.
+ *
+ * Every call names the same queue, and the ones a poll makes are all made as
+ * the function's execution role, so both are fixed here rather than written out
+ * at each call. Simulated IAM still decides each one, exactly as real IAM does.
+ */
+export declare class SimLambdaSqsPolledQueue {
+    private readonly queues;
+    private readonly queueArn;
+    constructor(queues: SimLambdaEventSourceQueues, queueArn: string);
+    /**
+     * Watch for messages arriving on the queue.
+     */
+    watch(watcher: SimLambdaEventSourceQueueWatcher): void;
+    /**
+     * Stop watching the queue.
+     */
+    unwatch(watcher: SimLambdaEventSourceQueueWatcher): void;
+    /**
+     * When the earliest message the queue cannot hand out yet becomes
+     * receivable.
+     */
+    nextAvailability(): Date | undefined;
+    /**
+     * How long a received message stays hidden, and by asking, whether the queue
+     * is there to be polled at all.
+     */
+    visibilityTimeoutSeconds(roleArn: string): Promise<number>;
+    /**
+     * Take up to a batch of messages off the queue.
+     */
+    receive(roleArn: string, batchSize: number): Promise<readonly SimLambdaEventSourceMessage[]>;
+    /**
+     * Delete the messages the function handled.
+     */
+    deleteMessages(roleArn: string, receiptHandles: readonly string[]): Promise<void>;
+    private requestAs;
+}
+//# sourceMappingURL=sim-lambda-sqs-polled-queue.d.ts.map

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-polled-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-sqs-polled-queue.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-sqs-polled-queue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAE3B,0BAA0B,EAC1B,gCAAgC,EACjC,MAAM,4CAA4C,CAAC;AAEpD;;;;;;GAMG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC,YAAY,MAAM,EAAE,0BAA0B,EAAE,QAAQ,EAAE,MAAM,EAG/D;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,gCAAgC,GAAG,IAAI,CAErD;IAED;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,gCAAgC,GAAG,IAAI,CAEvD;IAED;;;OAGG;IACH,gBAAgB,IAAI,IAAI,GAAG,SAAS,CAEnC;IAED;;;OAGG;IACG,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAE/D;IAED;;OAEG;IACG,OAAO,CACX,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,SAAS,2BAA2B,EAAE,CAAC,CAEjD;IAED;;OAEG;IACG,cAAc,CAClB,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,SAAS,MAAM,EAAE,GAChC,OAAO,CAAC,IAAI,CAAC,CAKf;IAED,OAAO,CAAC,SAAS;CAGlB"}

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-polled-queue.js

@@ -0,0 +1,60 @@
+/**
+ * The one queue a mapping polls.
+ *
+ * Every call names the same queue, and the ones a poll makes are all made as
+ * the function's execution role, so both are fixed here rather than written out
+ * at each call. Simulated IAM still decides each one, exactly as real IAM does.
+ */
+export class SimLambdaSqsPolledQueue {
+    queues;
+    queueArn;
+    constructor(queues, queueArn) {
+        this.queues = queues;
+        this.queueArn = queueArn;
+    }
+    /**
+     * Watch for messages arriving on the queue.
+     */
+    watch(watcher) {
+        this.queues.watch(this.queueArn, watcher);
+    }
+    /**
+     * Stop watching the queue.
+     */
+    unwatch(watcher) {
+        this.queues.unwatch(this.queueArn, watcher);
+    }
+    /**
+     * When the earliest message the queue cannot hand out yet becomes
+     * receivable.
+     */
+    nextAvailability() {
+        return this.queues.nextAvailability(this.queueArn);
+    }
+    /**
+     * How long a received message stays hidden, and by asking, whether the queue
+     * is there to be polled at all.
+     */
+    async visibilityTimeoutSeconds(roleArn) {
+        return await this.queues.visibilityTimeoutSeconds(this.requestAs(roleArn));
+    }
+    /**
+     * Take up to a batch of messages off the queue.
+     */
+    async receive(roleArn, batchSize) {
+        return await this.queues.receive({ ...this.requestAs(roleArn), batchSize });
+    }
+    /**
+     * Delete the messages the function handled.
+     */
+    async deleteMessages(roleArn, receiptHandles) {
+        await this.queues.deleteMessages({
+            ...this.requestAs(roleArn),
+            receiptHandles,
+        });
+    }
+    requestAs(roleArn) {
+        return { queueArn: this.queueArn, caller: { kind: "arn", arn: roleArn } };
+    }
+}
+//# sourceMappingURL=sim-lambda-sqs-polled-queue.js.map

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-polled-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-sqs-polled-queue.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-sqs-polled-queue.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,MAAM,OAAO,uBAAuB;IACjB,MAAM,CAA6B;IACnC,QAAQ,CAAS;IAElC,YAAY,MAAkC,EAAE,QAAgB;QAC9D,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAyC;QAC7C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,OAAyC;QAC/C,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACH,gBAAgB;QACd,OAAO,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACrD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,wBAAwB,CAAC,OAAe;QAC5C,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,wBAAwB,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;IAC7E,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,CACX,OAAe,EACf,SAAiB;QAEjB,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;IAC9E,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,cAAc,CAClB,OAAe,EACf,cAAiC;QAEjC,MAAM,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC;YAC/B,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;YAC1B,cAAc;SACf,CAAC,CAAC;IACL,CAAC;IAEO,SAAS,CAAC,OAAe;QAC/B,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,CAAC;IAC5E,CAAC;CACF"}

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

@@ -0,0 +1,37 @@
+import type { SimLambdaEventSourceStreamPosition } from "../stream/sim-lambda-event-source-streams.js";
+/**
+ * What became of one batch of stream records handed to a function.
+ *
+ * A queue batch splits into the messages that were handled and the ones that
+ * go back, because each message is deleted or returned on its own. A stream
+ * 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.
+ */
+export declare class SimLambdaStreamBatchOutcome {
+    readonly isHandled: boolean;
+    private readonly rewindTo;
+    private constructor();
+    /**
+     * A batch the function took in full.
+     */
+    static handled(): SimLambdaStreamBatchOutcome;
+    /**
+     * A batch the function did not take, which is read again from where it was.
+     */
+    static failed(): SimLambdaStreamBatchOutcome;
+    /**
+     * A batch the function reported failing partway through, which is read again
+     * from the record it named.
+     */
+    static failedFrom(sequenceNumber: string): SimLambdaStreamBatchOutcome;
+    /**
+     * Where the next read starts when the batch goes back.
+     *
+     * A batch that failed whole goes back to where it was read from, which is the
+     * place handed in. One the function reported on goes back to the record it
+     * named, which may be behind or ahead of that place.
+     */
+    retryPosition(readFrom: SimLambdaEventSourceStreamPosition): SimLambdaEventSourceStreamPosition;
+}
+//# sourceMappingURL=sim-lambda-stream-batch-outcome.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-batch-outcome.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-batch-outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,8CAA8C,CAAC;AAEvG;;;;;;;;GAQG;AACH,qBAAa,2BAA2B;IACtC,SAAgB,SAAS,EAAE,OAAO,CAAC;IAEnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAE9C,OAAO,eAGN;IAED;;OAEG;IACH,MAAM,CAAC,OAAO,IAAI,2BAA2B,CAE5C;IAED;;OAEG;IACH,MAAM,CAAC,MAAM,IAAI,2BAA2B,CAE3C;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,MAAM,GAAG,2BAA2B,CAErE;IAED;;;;;;OAMG;IACH,aAAa,CACX,QAAQ,EAAE,kCAAkC,GAC3C,kCAAkC,CAQpC;CACF"}

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

@@ -0,0 +1,51 @@
+/**
+ * What became of one batch of stream records handed to a function.
+ *
+ * A queue batch splits into the messages that were handled and the ones that
+ * go back, because each message is deleted or returned on its own. A stream
+ * 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.
+ */
+export class SimLambdaStreamBatchOutcome {
+    isHandled;
+    rewindTo;
+    constructor(isHandled, rewindTo) {
+        this.isHandled = isHandled;
+        this.rewindTo = rewindTo;
+    }
+    /**
+     * A batch the function took in full.
+     */
+    static handled() {
+        return new SimLambdaStreamBatchOutcome(true, undefined);
+    }
+    /**
+     * A batch the function did not take, which is read again from where it was.
+     */
+    static failed() {
+        return new SimLambdaStreamBatchOutcome(false, undefined);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Where the next read starts when the batch goes back.
+     *
+     * A batch that failed whole goes back to where it was read from, which is the
+     * place handed in. One the function reported on goes back to the record it
+     * named, which may be behind or ahead of that place.
+     */
+    retryPosition(readFrom) {
+        const sequenceNumber = this.rewindTo;
+        if (sequenceNumber === undefined) {
+            return readFrom;
+        }
+        return { kind: "sequence", sequenceNumber };
+    }
+}
+//# sourceMappingURL=sim-lambda-stream-batch-outcome.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-batch-outcome.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-batch-outcome.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,OAAO,2BAA2B;IACtB,SAAS,CAAU;IAElB,QAAQ,CAAqB;IAE9C,YAAoB,SAAkB,EAAE,QAA4B;QAClE,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,OAAO;QACZ,OAAO,IAAI,2BAA2B,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAC1D,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,MAAM;QACX,OAAO,IAAI,2BAA2B,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IAC3D,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,cAAsB;QACtC,OAAO,IAAI,2BAA2B,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;IAChE,CAAC;IAED;;;;;;OAMG;IACH,aAAa,CACX,QAA4C;QAE5C,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC;QAErC,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YACjC,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC;IAC9C,CAAC;CACF"}

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

@@ -0,0 +1,29 @@
+import type { SimLambdaEventSourceStreamRecord } from "../stream/sim-lambda-event-source-streams.js";
+import { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+/**
+ * Reads what a function said about the batch of stream records it was given.
+ *
+ * A sibling of the queue's batch response rather than a variation on it, and
+ * the rule is the one AWS states for a stream: the lowest sequence number the
+ * report names becomes the checkpoint, and everything from there is delivered
+ * again. Records after it that the function did handle are delivered again too,
+ * which is why a stream consumer has to be idempotent.
+ *
+ * A report naming a record that was not in the batch returns the whole batch,
+ * as it does for a queue: the alternative is to guess which record was meant,
+ * and guessing wrong on a stream skips records rather than repeating them.
+ */
+export declare class SimLambdaStreamBatchResponse {
+    private readonly batchItemFailures;
+    constructor(reportsBatchItemFailures: boolean);
+    /**
+     * What became of a batch the function returned from.
+     */
+    handled(records: readonly SimLambdaEventSourceStreamRecord[], result: unknown): SimLambdaStreamBatchOutcome;
+    /**
+     * What becomes of a batch the function threw on: the whole of it is read
+     * again.
+     */
+    failed(): SimLambdaStreamBatchOutcome;
+}
+//# sourceMappingURL=sim-lambda-stream-batch-response.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-batch-response.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-batch-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,8CAA8C,CAAC;AAErG,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAEnF;;;;;;;;;;;;GAYG;AACH,qBAAa,4BAA4B;IACvC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6B;IAE/D,YAAY,wBAAwB,EAAE,OAAO,EAI5C;IAED;;OAEG;IACH,OAAO,CACL,OAAO,EAAE,SAAS,gCAAgC,EAAE,EACpD,MAAM,EAAE,OAAO,GACd,2BAA2B,CAc7B;IAED;;;OAGG;IACH,MAAM,IAAI,2BAA2B,CAEpC;CACF"}

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

@@ -0,0 +1,71 @@
+import { SimLambdaBatchItemFailures } from "./sim-lambda-batch-item-failures.js";
+import { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+/**
+ * Reads what a function said about the batch of stream records it was given.
+ *
+ * A sibling of the queue's batch response rather than a variation on it, and
+ * the rule is the one AWS states for a stream: the lowest sequence number the
+ * report names becomes the checkpoint, and everything from there is delivered
+ * again. Records after it that the function did handle are delivered again too,
+ * which is why a stream consumer has to be idempotent.
+ *
+ * A report naming a record that was not in the batch returns the whole batch,
+ * as it does for a queue: the alternative is to guess which record was meant,
+ * and guessing wrong on a stream skips records rather than repeating them.
+ */
+export class SimLambdaStreamBatchResponse {
+    batchItemFailures;
+    constructor(reportsBatchItemFailures) {
+        this.batchItemFailures = new SimLambdaBatchItemFailures(reportsBatchItemFailures);
+    }
+    /**
+     * What became of a batch the function returned from.
+     */
+    handled(records, result) {
+        const failedIds = this.batchItemFailures.idsIn(result);
+        if (failedIds === undefined) {
+            return SimLambdaStreamBatchOutcome.handled();
+        }
+        const rewindTo = rewindPoint(failedIds, sequenceNumbersOf(records));
+        if (rewindTo === undefined) {
+            return this.failed();
+        }
+        return SimLambdaStreamBatchOutcome.failedFrom(rewindTo);
+    }
+    /**
+     * What becomes of a batch the function threw on: the whole of it is read
+     * again.
+     */
+    failed() {
+        return SimLambdaStreamBatchOutcome.failed();
+    }
+}
+/**
+ * The sequence numbers a batch's records can be named by, in stream order.
+ *
+ * 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.
+ */
+function sequenceNumbersOf(records) {
+    return records.flatMap((record) => {
+        const sequenceNumber = record.dynamodb?.SequenceNumber;
+        if (sequenceNumber === undefined || sequenceNumber === "") {
+            return [];
+        }
+        return [sequenceNumber];
+    });
+}
+/**
+ * The record a report sends the mapping back to, or undefined for a report it
+ * cannot be trusted.
+ *
+ * The batch is in stream order, so the first record the report names is the
+ * lowest sequence number it named.
+ */
+function rewindPoint(failedIds, sequenceNumbers) {
+    if (failedIds.some((failedId) => !sequenceNumbers.includes(failedId))) {
+        return undefined;
+    }
+    return sequenceNumbers.find((sequenceNumber) => failedIds.includes(sequenceNumber));
+}
+//# sourceMappingURL=sim-lambda-stream-batch-response.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-batch-response.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-batch-response.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAEnF;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,4BAA4B;IACtB,iBAAiB,CAA6B;IAE/D,YAAY,wBAAiC;QAC3C,IAAI,CAAC,iBAAiB,GAAG,IAAI,0BAA0B,CACrD,wBAAwB,CACzB,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,OAAO,CACL,OAAoD,EACpD,MAAe;QAEf,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAEvD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO,2BAA2B,CAAC,OAAO,EAAE,CAAC;QAC/C,CAAC;QAED,MAAM,QAAQ,GAAG,WAAW,CAAC,SAAS,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;QAEpE,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;QACvB,CAAC;QAED,OAAO,2BAA2B,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACH,MAAM;QACJ,OAAO,2BAA2B,CAAC,MAAM,EAAE,CAAC;IAC9C,CAAC;CACF;AAED;;;;;GAKG;AACH,SAAS,iBAAiB,CACxB,OAAoD;IAEpD,OAAO,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;QAChC,MAAM,cAAc,GAAG,MAAM,CAAC,QAAQ,EAAE,cAAc,CAAC;QAEvD,IAAI,cAAc,KAAK,SAAS,IAAI,cAAc,KAAK,EAAE,EAAE,CAAC;YAC1D,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,OAAO,CAAC,cAAc,CAAC,CAAC;IAC1B,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,SAAS,WAAW,CAClB,SAA4B,EAC5B,eAAkC;IAElC,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,eAAe,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC;QACtE,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,cAAc,EAAE,EAAE,CAC7C,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,CACnC,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,36 @@
+import type { SimLambdaEventSourceStartingPosition } 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.
+ */
+export declare class SimLambdaStreamCheckpoint {
+    #private;
+    constructor(startingPosition: SimLambdaEventSourceStartingPosition);
+    /**
+     * Where the next read starts.
+     */
+    get position(): SimLambdaEventSourceStreamPosition;
+    /**
+     * Move past a batch that is finished with.
+     */
+    advanceTo(position: SimLambdaEventSourceStreamPosition): void;
+    /**
+     * 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: SimLambdaStreamBatchOutcome): void;
+}
+//# sourceMappingURL=sim-lambda-stream-checkpoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-checkpoint.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-checkpoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,iDAAiD,CAAC;AAC5G,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,8CAA8C,CAAC;AACvG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAExF;;;;;;;;;GASG;AACH,qBAAa,yBAAyB;;IAGpC,YAAY,gBAAgB,EAAE,oCAAoC,EAEjE;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,kCAAkC,CAEjD;IAED;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,kCAAkC,GAAG,IAAI,CAE5D;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,OAAO,EAAE,2BAA2B,GAAG,IAAI,CAEhD;CACF"}