@kensio/yulin 1.21.8 → 1.21.10

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-properties.d.ts

@@ -19,7 +19,7 @@ export declare class SimCfnLambdaEventSourceMappingProperties {
     private readonly parser;
     constructor(properties: SimCfnLambdaEventSourceMappingPropertiesProperties);
     /**
-     * The create input this Resource asks for, refusing what is not simulated.
+     * The create input this Resource asks for, recording what is left out of it.
      *
      * The event source ARN is read before anything else is judged, as the command
      * reads it first for the same reason: what a mapping may ask for depends on

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-properties.js

@@ -1,5 +1,6 @@
+import { simLambdaStreamDestinationConfig } from "../../event-source/sim-lambda-stream-destination-config.js";
 import { SimCfnLambdaPropertyParser } from "../function/sim-cfn-lambda-property-parser.js";
-import { assertSimulatedEventSourceMappingProperties } from "./sim-cfn-lambda-event-source-mapping-property-rules.js";
+import { recordUnsimulatedEventSourceMappingProperties } from "./sim-cfn-lambda-event-source-mapping-property-rules.js";
 import { simCfnLambdaTargetFunctionName } from "../function/sim-cfn-lambda-target-function.js";
 /**
  * What a CloudFormation Unix time seconds value is multiplied by to reach the
@@ -23,7 +24,7 @@ export class SimCfnLambdaEventSourceMappingProperties {
         this.properties = properties.properties;
     }
     /**
-     * The create input this Resource asks for, refusing what is not simulated.
+     * The create input this Resource asks for, recording what is left out of it.
      *
      * The event source ARN is read before anything else is judged, as the command
      * reads it first for the same reason: what a mapping may ask for depends on
@@ -31,15 +32,17 @@ export class SimCfnLambdaEventSourceMappingProperties {
      */
     createInput() {
         const eventSourceArn = this.parser.requiredString(this.resource, this.properties["EventSourceArn"], "EventSourceArn");
-        assertSimulatedEventSourceMappingProperties(this.resource, this.properties);
+        recordUnsimulatedEventSourceMappingProperties(this.resource, this.properties);
         return {
             EventSourceArn: eventSourceArn,
+            DestinationConfig: simLambdaStreamDestinationConfig(this.properties["DestinationConfig"]),
             FunctionName: simCfnLambdaTargetFunctionName(this.parser.requiredString(this.resource, this.properties["FunctionName"], "FunctionName")),
             BatchSize: this.parser.optionalNumber(this.resource, this.properties["BatchSize"], "BatchSize"),
             Enabled: this.parser.optionalBoolean(this.resource, this.properties["Enabled"], "Enabled"),
             MaximumBatchingWindowInSeconds: this.parser.optionalNumber(this.resource, this.properties["MaximumBatchingWindowInSeconds"], "MaximumBatchingWindowInSeconds"),
             MaximumRetryAttempts: this.parser.optionalNumber(this.resource, this.properties["MaximumRetryAttempts"], "MaximumRetryAttempts"),
             MaximumRecordAgeInSeconds: this.parser.optionalNumber(this.resource, this.properties["MaximumRecordAgeInSeconds"], "MaximumRecordAgeInSeconds"),
+            BisectBatchOnFunctionError: this.parser.optionalBoolean(this.resource, this.properties["BisectBatchOnFunctionError"], "BisectBatchOnFunctionError"),
             StartingPosition: this.parser.optionalString(this.resource, this.properties["StartingPosition"], "StartingPosition"),
             StartingPositionTimestamp: this.startingPositionTimestamp(),
             FunctionResponseTypes: this.functionResponseTypes(),

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-property-names.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The AWS::Lambda::EventSourceMapping properties this simulation acts on.
+ *
+ * The two starting position properties are here rather than among the
+ * unsimulated ones because whether a mapping may carry one is the event
+ * source's own rule: a stream has to be given a position and a queue is refused
+ * for naming one. That is decided by CreateEventSourceMapping, which knows
+ * which source the ARN names, so both are read and passed on. The two
+ * failed-batch limits are read for the same reason: a stream mapping keeps them
+ * and a queue mapping is refused for naming one.
+ */
+export declare const simulatedPropertyNames: ReadonlySet<string>;
+/**
+ * Real AWS::Lambda::EventSourceMapping properties this simulation does not act
+ * on, and what the mapping does in place of each.
+ *
+ * Every one of them changes what the function sees or when it sees it. That is
+ * what the record against the Resource is for. A mapping created without one
+ * still carries the records the template asked for to the function the
+ * template named, and the difference is there to be read.
+ */
+export declare const unsimulatedPropertyReasons: ReadonlyMap<string, string>;
+/**
+ * Why a property name this simulation has never heard of is recorded.
+ *
+ * A typo and a property AWS added after this simulation read the docs look
+ * identical from here. A mapping that deploys with the unread name reported is
+ * more use than a stack that fails over either.
+ */
+export declare const unknownPropertyReason: string;

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-property-names.js

@@ -0,0 +1,91 @@
+/**
+ * The AWS::Lambda::EventSourceMapping properties this simulation acts on.
+ *
+ * The two starting position properties are here rather than among the
+ * unsimulated ones because whether a mapping may carry one is the event
+ * source's own rule: a stream has to be given a position and a queue is refused
+ * for naming one. That is decided by CreateEventSourceMapping, which knows
+ * which source the ARN names, so both are read and passed on. The two
+ * failed-batch limits are read for the same reason: a stream mapping keeps them
+ * and a queue mapping is refused for naming one.
+ */
+export const simulatedPropertyNames = new Set([
+    "BatchSize",
+    "Enabled",
+    "EventSourceArn",
+    "FunctionName",
+    "FunctionResponseTypes",
+    "MaximumBatchingWindowInSeconds",
+    "MaximumRecordAgeInSeconds",
+    "MaximumRetryAttempts",
+    "BisectBatchOnFunctionError",
+    "DestinationConfig",
+    "StartingPosition",
+    "StartingPositionTimestamp",
+]);
+/**
+ * The event sources a mapping property can only be configuring, none of which
+ * this simulation has.
+ *
+ * A mapping naming one of these has an event source ARN to match, and that ARN
+ * is what the mapping is refused on. The property beside it is recorded.
+ */
+const absentEventSource = "the mapping polls the source its EventSourceArn names, and this " +
+    "simulation has SQS queues, DynamoDB streams and Kinesis streams";
+/**
+ * Real AWS::Lambda::EventSourceMapping properties this simulation does not act
+ * on, and what the mapping does in place of each.
+ *
+ * Every one of them changes what the function sees or when it sees it. That is
+ * what the record against the Resource is for. A mapping created without one
+ * still carries the records the template asked for to the function the
+ * template named, and the difference is there to be read.
+ */
+export const unsimulatedPropertyReasons = new Map([
+    ["AmazonManagedKafkaEventSourceConfig", absentEventSource],
+    ["DocumentDBEventSourceConfig", absentEventSource],
+    [
+        "FilterCriteria",
+        "every record on the event source is delivered to the function, unfiltered",
+    ],
+    [
+        "KmsKeyArn",
+        "the key encrypts filter criteria, and filter criteria are not simulated",
+    ],
+    ["MetricsConfig", "the mapping publishes no CloudWatch metrics"],
+    [
+        "ParallelizationFactor",
+        "polling concurrency is not simulated, and each shard of a stream is read " +
+            "by one reader",
+    ],
+    ["ProvisionedPollerConfig", "polling concurrency is not simulated"],
+    ["Queues", absentEventSource],
+    ["ScalingConfig", "polling concurrency is not simulated"],
+    ["SelfManagedEventSource", absentEventSource],
+    ["SelfManagedKafkaEventSourceConfig", absentEventSource],
+    [
+        "SourceAccessConfigurations",
+        "event source authentication is not simulated",
+    ],
+    [
+        "Tags",
+        "the mapping is created without them, and nothing reads them back or " +
+            "groups or bills by them",
+    ],
+    ["Topics", absentEventSource],
+    [
+        "TumblingWindowInSeconds",
+        "a batch carries no window state from the batch before it, and the " +
+            "function is handed no state to return",
+    ],
+]);
+/**
+ * Why a property name this simulation has never heard of is recorded.
+ *
+ * A typo and a property AWS added after this simulation read the docs look
+ * identical from here. A mapping that deploys with the unread name reported is
+ * more use than a stack that fails over either.
+ */
+export const unknownPropertyReason = "it is not an AWS::Lambda::EventSourceMapping property this simulation " +
+    "knows, whether because AWS added it or because the template misspelled " +
+    "something";

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-property-rules.d.ts

@@ -1,17 +1,12 @@
 import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-resource.js";
 import type { SimCfnTemplateValueRecord } from "../../../cloudformation/template/value/sim-cfn-template-value.js";
 /**
- * Build the error a property of an AWS::Lambda::EventSourceMapping Resource is
- * refused with.
+ * Record everything about an AWS::Lambda::EventSourceMapping Resource that the
+ * mapping is created without.
  *
- * The wording matters: sim CloudFormation skips a Resource whose error reads as
- * an unsupported Resource type, and skipping is the wrong answer for a mapping
- * that cannot be created as the template asks. The stack would deploy with the
- * queue and the function and nothing between them.
+ * Nothing here fails the Resource. A mapping missing one of these settings
+ * still carries records from the source to the function, and a stack that
+ * refused it would take every other Resource down over one line of a template.
+ * What the mapping does instead is in `stack.ignoredProperties`.
  */
-export declare function eventSourceMappingPropertyError(logicalId: string, reason: string): Error;
-/**
- * Refuse everything about an AWS::Lambda::EventSourceMapping Resource that is
- * not simulated, and record what the mapping is created without.
- */
-export declare function assertSimulatedEventSourceMappingProperties(resource: SimCfnResource, properties: SimCfnTemplateValueRecord): void;
+export declare function recordUnsimulatedEventSourceMappingProperties(resource: SimCfnResource, properties: SimCfnTemplateValueRecord): void;

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-property-rules.js

@@ -1,100 +1,20 @@
+import { simulatedPropertyNames, unknownPropertyReason, unsimulatedPropertyReasons, } from "./sim-cfn-lambda-event-source-mapping-property-names.js";
 /**
- * The AWS::Lambda::EventSourceMapping properties this simulation acts on.
+ * Record everything about an AWS::Lambda::EventSourceMapping Resource that the
+ * mapping is created without.
  *
- * The two starting position properties are here rather than among the
- * unsimulated ones because whether a mapping may carry one is the event
- * source's own rule: a stream has to be given a position and a queue is refused
- * for naming one. That is decided by CreateEventSourceMapping, which knows
- * which source the ARN names, so both are read and passed on. The two
- * failed-batch limits are read for the same reason: a stream mapping keeps them
- * and a queue mapping is refused for naming one.
+ * Nothing here fails the Resource. A mapping missing one of these settings
+ * still carries records from the source to the function, and a stack that
+ * refused it would take every other Resource down over one line of a template.
+ * What the mapping does instead is in `stack.ignoredProperties`.
  */
-const simulatedPropertyNames = new Set([
-    "BatchSize",
-    "Enabled",
-    "EventSourceArn",
-    "FunctionName",
-    "FunctionResponseTypes",
-    "MaximumBatchingWindowInSeconds",
-    "MaximumRecordAgeInSeconds",
-    "MaximumRetryAttempts",
-    "StartingPosition",
-    "StartingPositionTimestamp",
-]);
-/**
- * Real AWS::Lambda::EventSourceMapping properties this simulation does not
- * model.
- *
- * Every one of them changes what the function sees or when it sees it, so a
- * template asking for one fails the Resource rather than deploying a mapping
- * that quietly ignores it.
- */
-const unsimulatedPropertyNames = new Set([
-    "AmazonManagedKafkaEventSourceConfig",
-    "BisectBatchOnFunctionError",
-    "DestinationConfig",
-    "DocumentDBEventSourceConfig",
-    "FilterCriteria",
-    "KmsKeyArn",
-    "MetricsConfig",
-    "ParallelizationFactor",
-    "ProvisionedPollerConfig",
-    "Queues",
-    "ScalingConfig",
-    "SelfManagedEventSource",
-    "SelfManagedKafkaEventSourceConfig",
-    "SourceAccessConfigurations",
-    "Topics",
-    "TumblingWindowInSeconds",
-]);
-/**
- * Real AWS::Lambda::EventSourceMapping properties this simulation has nothing
- * to act on and no reason to fail a stack over.
- *
- * `Tags` is the whole list. The mapping is created without them and the
- * omission is recorded against the Resource. A mapping delivers the same
- * records with a tag and without one, and a CDK app calling
- * `Tags.of(app).add(...)` tags every mapping in it.
- */
-const ignoredPropertyReasons = new Map([
-    [
-        "Tags",
-        "AWS::Lambda::EventSourceMapping property Tags is not simulated, so the " +
-            "mapping is created without them. Nothing reads them back and nothing " +
-            "is grouped or billed by them.",
-    ],
-]);
-/**
- * Build the error a property of an AWS::Lambda::EventSourceMapping Resource is
- * refused with.
- *
- * The wording matters: sim CloudFormation skips a Resource whose error reads as
- * an unsupported Resource type, and skipping is the wrong answer for a mapping
- * that cannot be created as the template asks. The stack would deploy with the
- * queue and the function and nothing between them.
- */
-export function eventSourceMappingPropertyError(logicalId, reason) {
-    return new Error(`Invalid AWS::Lambda::EventSourceMapping Resource ${logicalId}: ${reason}`);
-}
-/**
- * Refuse everything about an AWS::Lambda::EventSourceMapping Resource that is
- * not simulated, and record what the mapping is created without.
- */
-export function assertSimulatedEventSourceMappingProperties(resource, properties) {
-    const logicalId = resource.logicalId;
+export function recordUnsimulatedEventSourceMappingProperties(resource, properties) {
     for (const name of Object.keys(properties)) {
-        const ignoredReason = ignoredPropertyReasons.get(name);
-        if (ignoredReason !== undefined) {
-            resource.ignoreProperty(name, ignoredReason);
+        if (simulatedPropertyNames.has(name)) {
             continue;
         }
-        if (unsimulatedPropertyNames.has(name)) {
-            throw eventSourceMappingPropertyError(logicalId, `${name} is a real AWS::Lambda::EventSourceMapping property that ` +
-                "this simulation does not simulate, so it is refused rather than " +
-                "ignored");
-        }
-        if (!simulatedPropertyNames.has(name)) {
-            throw eventSourceMappingPropertyError(logicalId, `${name} is not an AWS::Lambda::EventSourceMapping property`);
-        }
+        const reason = unsimulatedPropertyReasons.get(name) ?? unknownPropertyReason;
+        resource.ignoreProperty(name, `AWS::Lambda::EventSourceMapping property ${name} is not simulated: ` +
+            `${reason}.`);
     }
 }

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping-input.d.ts

@@ -1,3 +1,4 @@
+import { type SimLambdaStreamDestinationConfiguration } from "../../event-source/sim-lambda-stream-destination-config.js";
 import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-region-scope.js";
 import { type SimLambdaEventSourceArn } from "../../event-source/sim-lambda-event-source-arn.js";
 import type { SimLambdaFunctionResponseType } from "../../event-source/sim-lambda-event-source-mapping.js";
@@ -29,6 +30,7 @@ export declare class SimLambdaEventSourceMappingInput {
     readonly start: SimLambdaEventSourceStart | undefined;
     readonly enabled: boolean;
     readonly functionResponseTypes: readonly SimLambdaFunctionResponseType[];
+    readonly destinationConfig: SimLambdaStreamDestinationConfiguration | undefined;
     /**
      * When a failed batch stops being delivered again, for a source that leaves
      * the counting to the mapping.

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping-input.js

@@ -1,3 +1,4 @@
+import { simLambdaStreamDestinationConfig, } from "../../event-source/sim-lambda-stream-destination-config.js";
 import { simLambdaEventSourceArnOf, } from "../../event-source/sim-lambda-event-source-arn.js";
 import { SimLambdaInvalidParameterValueException } from "../../error/sim-lambda.error.js";
 import { simLambdaFunctionReferenceOf } from "../../function/sim-lambda-function-reference.js";
@@ -28,6 +29,7 @@ export class SimLambdaEventSourceMappingInput {
     start;
     enabled;
     functionResponseTypes;
+    destinationConfig;
     /**
      * When a failed batch stops being delivered again, for a source that leaves
      * the counting to the mapping.
@@ -41,6 +43,7 @@ export class SimLambdaEventSourceMappingInput {
         this.start = properties.start;
         this.enabled = properties.enabled;
         this.functionResponseTypes = properties.functionResponseTypes;
+        this.destinationConfig = properties.destinationConfig;
         this.streamRetryLimits = properties.streamRetryLimits;
     }
     /**
@@ -53,6 +56,7 @@ export class SimLambdaEventSourceMappingInput {
         refuseUnsimulatedInput(input);
         return new this({
             eventSourceArn,
+            destinationConfig: simLambdaStreamDestinationConfig(input.DestinationConfig, eventSourceArn.kind),
             ...simLambdaFunctionReferenceOf(requiredString(input.FunctionName, "functionName")),
             batchSize: eventSourceArn.batchRules.sizeIn(input.BatchSize),
             start: eventSourceArn.startingPositionRules.startIn({
@@ -64,6 +68,7 @@ export class SimLambdaEventSourceMappingInput {
             streamRetryLimits: eventSourceArn.retryLimitRules.limitsIn({
                 maximumRetryAttempts: input.MaximumRetryAttempts,
                 maximumRecordAgeInSeconds: input.MaximumRecordAgeInSeconds,
+                bisectBatchOnFunctionError: input.BisectBatchOnFunctionError,
             }),
         });
     }

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping-refusals.js

@@ -12,16 +12,6 @@ const unsimulatedInputs = new Map([
     ["FilterCriteria", "event filtering is not simulated"],
     ["ScalingConfig", "polling concurrency is not simulated"],
     ["ProvisionedPollerConfig", "polling concurrency is not simulated"],
-    [
-        "DestinationConfig",
-        "failure destinations are not simulated, so a stream batch that runs out " +
-            "of attempts is discarded rather than sent anywhere",
-    ],
-    [
-        "BisectBatchOnFunctionError",
-        "batch bisection is not simulated, so a failing stream batch is retried " +
-            "whole",
-    ],
     [
         "ParallelizationFactor",
         "polling concurrency is not simulated, so each shard of a stream is read " +

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping.handler.d.ts

@@ -1,3 +1,4 @@
+import type { SimLambdaDestinationTargets } from "../../destination/sim-lambda-destination-targets.js";
 import type { CommandHandler } from "../../../../command/command-handler.js";
 import type { BackgroundScheduler } from "../../../../util/background/background.js";
 import type { SimAwsCaller } from "../../../aws/caller/sim-aws-caller.js";
@@ -19,6 +20,7 @@ interface CreateEventSourceMappingCommandHandlerProperties {
     readonly kinesisStreams: SimLambdaKinesisStreams;
     readonly functions: SimLambdaFunctionLookup;
     readonly iam: SimIamInterServiceAuthZ;
+    readonly destinations?: SimLambdaDestinationTargets;
     readonly background: BackgroundScheduler;
 }
 interface CreateEventSourceMappingCommandHandlerOptions {

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping.handler.js

@@ -81,6 +81,8 @@ export class CreateEventSourceMappingCommandHandler {
             enabled: input.enabled,
             functionResponseTypes: input.functionResponseTypes,
             streamRetryLimits: input.streamRetryLimits,
+            destinationConfig: input.destinationConfig,
+            destinations: this.properties.destinations,
             createdAt: this.properties.background.now(),
         });
         this.properties.mappings.add(mapping);

package/dist/service/lambda/command/event-source-mapping/sim-lambda-event-source-mapping-commands.d.ts

@@ -1,3 +1,4 @@
+import type { SimLambdaDestinationTargets } from "../../destination/sim-lambda-destination-targets.js";
 import type { BackgroundScheduler } from "../../../../util/background/background.js";
 import type { SimAwsCaller } from "../../../aws/caller/sim-aws-caller.js";
 import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-region-scope.js";
@@ -17,6 +18,7 @@ interface SimLambdaEventSourceMappingCommandsProperties {
     readonly kinesisStreams: SimLambdaKinesisStreams;
     readonly functions: SimLambdaFunctionLookup;
     readonly iam: SimIamInterServiceAuthZ;
+    readonly destinations?: SimLambdaDestinationTargets;
     readonly background: BackgroundScheduler;
 }
 interface SimLambdaEventSourceMappingCommandOptions {

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

@@ -1,3 +1,4 @@
+import type { SimLambdaStreamFailureRecord } from "../event-source/poll/sim-lambda-stream-failure-record.js";
 import type { SimLambdaDestinationArn } from "./sim-lambda-destination-arn.js";
 import type { SimLambdaDestinationRecord } from "./sim-lambda-destination-record.js";
 /**
@@ -5,7 +6,7 @@ import type { SimLambdaDestinationRecord } from "./sim-lambda-destination-record
  */
 export interface SimLambdaDestinationDeliveryRequest {
     readonly destinationArn: SimLambdaDestinationArn;
-    readonly record: SimLambdaDestinationRecord;
+    readonly record: SimLambdaDestinationRecord | SimLambdaStreamFailureRecord;
     /**
      * The function whose invocation produced this record, which is what the
      * delivery is attributed to.

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

@@ -49,9 +49,5 @@ export declare class SimLambdaKinesisShardPoller implements SimLambdaEventSource
      * reading the same records.
      */
     poll(): Promise<void>;
-    /**
-     * The function this mapping delivers to, while it should be delivering.
-     */
-    private pollingFunction;
 }
 export {};

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

@@ -1,3 +1,5 @@
+import { processSimLambdaStreamBatch } from "../sim-lambda-stream-batch-processing.js";
+import { simLambdaKinesisStreamRecordTimes } from "../sim-lambda-stream-record-times.js";
 import { simLambdaEventSourceFunction } from "../sim-lambda-event-source-function.js";
 import { SimLambdaEventSourcePollTurn, } from "../sim-lambda-event-source-poll-turn.js";
 import { SimLambdaStreamProgress } from "../sim-lambda-stream-progress.js";
@@ -57,27 +59,20 @@ export class SimLambdaKinesisShardPoller {
      * reading the same records.
      */
     async poll() {
-        const simFunction = this.pollingFunction();
+        const simFunction = simLambdaEventSourceFunction(this.functions, this.mapping, this.stopped);
         if (simFunction === undefined) {
             return;
         }
         const { progress } = this;
         // Reading is done as the function's execution role, as on real Lambda, so
         // simulated IAM decides whether this mapping may read its stream.
-        const batch = await this.shard.read(progress.position, this.mapping.batchSize);
-        if (batch.records.length === 0) {
-            progress.caughtUp(batch);
-            return;
-        }
-        progress.after(await this.delivery.to(simFunction, batch.records), batch);
-    }
-    /**
-     * The function this mapping delivers to, while it should be delivering.
-     */
-    pollingFunction() {
-        if (this.stopped || !this.mapping.isPolling) {
-            return undefined;
-        }
-        return simLambdaEventSourceFunction(this.functions, this.mapping);
+        const batch = await this.shard.read(progress.position, progress.batchSizeWithin(this.mapping.batchSize));
+        await processSimLambdaStreamBatch({
+            batch,
+            progress,
+            simFunction,
+            times: simLambdaKinesisStreamRecordTimes,
+            deliver: async (records) => await this.delivery.to(simFunction, records),
+        });
     }
 }

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

@@ -26,10 +26,9 @@ interface SimLambdaDynamoDbStreamEventSourcePollerProperties {
  * overlapping the first would hand the same records to the function twice.
  */
 export declare class SimLambdaDynamoDbStreamEventSourcePoller implements SimLambdaEventSourcePoller, SimLambdaEventSourcePolls {
-    private readonly mapping;
-    private readonly functions;
     private readonly stream;
     private readonly delivery;
+    private readonly polling;
     private readonly progress;
     private readonly turn;
     private stopped;
@@ -68,9 +67,5 @@ export declare class SimLambdaDynamoDbStreamEventSourcePoller implements SimLamb
      * reading the same records.
      */
     poll(): Promise<void>;
-    /**
-     * The function this mapping delivers to, while it should be delivering.
-     */
-    private pollingFunction;
 }
 export {};

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

@@ -1,4 +1,4 @@
-import { simLambdaEventSourceFunction } from "./sim-lambda-event-source-function.js";
+import { SimLambdaDynamoDbStreamPolling } from "./sim-lambda-dynamodb-stream-polling.js";
 import { SimLambdaDynamoDbPolledStream } from "./sim-lambda-dynamodb-polled-stream.js";
 import { SimLambdaDynamoDbStreamDelivery } from "./sim-lambda-dynamodb-stream-delivery.js";
 import { SimLambdaEventSourcePollTurn, } from "./sim-lambda-event-source-poll-turn.js";
@@ -17,17 +17,14 @@ import { SimLambdaStreamProgress } from "./sim-lambda-stream-progress.js";
  * overlapping the first would hand the same records to the function twice.
  */
 export class SimLambdaDynamoDbStreamEventSourcePoller {
-    mapping;
-    functions;
     stream;
     delivery;
+    polling;
     progress;
     turn = new SimLambdaEventSourcePollTurn(this);
     stopped = false;
     constructor(properties) {
         const { eventSourceArn, mapping } = properties;
-        this.mapping = mapping;
-        this.functions = properties.functions;
         this.stream = new SimLambdaDynamoDbPolledStream(properties.streams, eventSourceArn.value);
         this.delivery = new SimLambdaDynamoDbStreamDelivery({
             mapping,
@@ -40,6 +37,12 @@ export class SimLambdaDynamoDbStreamEventSourcePoller {
                 await this.turn.take();
             },
         });
+        this.polling = new SimLambdaDynamoDbStreamPolling({
+            ...properties,
+            stream: this.stream,
+            progress: this.progress,
+            delivery: this.delivery,
+        });
     }
     /**
      * Watch the stream this mapping polls.
@@ -88,27 +91,6 @@ export class SimLambdaDynamoDbStreamEventSourcePoller {
      * reading the same records.
      */
     async poll() {
-        const simFunction = this.pollingFunction();
-        if (simFunction === undefined) {
-            return;
-        }
-        const { progress } = this;
-        // Reading is done as the function's execution role, as on real Lambda, so
-        // simulated IAM decides whether this mapping may read its stream.
-        const batch = await this.stream.read(simFunction.roleArn, progress.position, this.mapping.batchSize);
-        if (batch.records.length === 0) {
-            progress.caughtUp(batch);
-            return;
-        }
-        progress.after(await this.delivery.to(simFunction, batch.records), batch);
-    }
-    /**
-     * The function this mapping delivers to, while it should be delivering.
-     */
-    pollingFunction() {
-        if (this.stopped || !this.mapping.isPolling) {
-            return undefined;
-        }
-        return simLambdaEventSourceFunction(this.functions, this.mapping);
+        await this.polling.poll(this.stopped);
     }
 }

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

@@ -0,0 +1,19 @@
+import type { SimLambdaFunctionLookup } from "../../function/url/sim-lambda-function-lookup.js";
+import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaDynamoDbPolledStream } from "./sim-lambda-dynamodb-polled-stream.js";
+import type { SimLambdaDynamoDbStreamDelivery } from "./sim-lambda-dynamodb-stream-delivery.js";
+import type { SimLambdaStreamProgress } from "./sim-lambda-stream-progress.js";
+interface DynamoDbStreamPollingProperties {
+    readonly functions: SimLambdaFunctionLookup;
+    readonly mapping: SimLambdaEventSourceMapping;
+    readonly stream: SimLambdaDynamoDbPolledStream;
+    readonly delivery: SimLambdaDynamoDbStreamDelivery;
+    readonly progress: SimLambdaStreamProgress;
+}
+/** Read and process DynamoDB batches as the function execution role. */
+export declare class SimLambdaDynamoDbStreamPolling {
+    private readonly properties;
+    constructor(properties: DynamoDbStreamPollingProperties);
+    poll(stopped: boolean): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,27 @@
+import { simLambdaDynamoDbStreamRecordTimes } from "./sim-lambda-stream-record-times.js";
+import { processSimLambdaStreamBatch } from "./sim-lambda-stream-batch-processing.js";
+import { simLambdaEventSourceFunction } from "./sim-lambda-event-source-function.js";
+/** Read and process DynamoDB batches as the function execution role. */
+export class SimLambdaDynamoDbStreamPolling {
+    properties;
+    constructor(properties) {
+        this.properties = properties;
+    }
+    async poll(stopped) {
+        const simFunction = simLambdaEventSourceFunction(this.properties.functions, this.properties.mapping, stopped);
+        if (simFunction === undefined) {
+            return;
+        }
+        const { progress, stream, mapping, delivery } = this.properties;
+        // Reading is done as the function's execution role, as on real Lambda, so
+        // simulated IAM decides whether this mapping may read its stream.
+        const batch = await stream.read(simFunction.roleArn, progress.position, progress.batchSizeWithin(mapping.batchSize));
+        await processSimLambdaStreamBatch({
+            batch,
+            progress,
+            simFunction,
+            times: simLambdaDynamoDbStreamRecordTimes,
+            deliver: async (records) => await delivery.to(simFunction, records),
+        });
+    }
+}

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

@@ -9,4 +9,4 @@ import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-map
  * delivers to. A function that has gone, and a qualifier that names nothing,
  * both answer with nothing, and the poll then does nothing.
  */
-export declare function simLambdaEventSourceFunction(functions: SimLambdaFunctionLookup, mapping: SimLambdaEventSourceMapping): SimLambdaFunction | undefined;
+export declare function simLambdaEventSourceFunction(functions: SimLambdaFunctionLookup, mapping: SimLambdaEventSourceMapping, stopped?: boolean): SimLambdaFunction | undefined;

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

@@ -6,7 +6,9 @@
  * delivers to. A function that has gone, and a qualifier that names nothing,
  * both answer with nothing, and the poll then does nothing.
  */
-export function simLambdaEventSourceFunction(functions, mapping) {
+export function simLambdaEventSourceFunction(functions, mapping, stopped = false) {
+    if (stopped || !mapping.isPolling)
+        return undefined;
     return functions.findTarget(mapping.functionName, mapping.qualifier)
         ?.simFunction;
 }