@kensio/yulin 1.2.0 → 1.4.0

package/dist/service/lambda/event-source/sim-lambda-event-source-starting-position.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Where on a stream a mapping starts reading.
+ *
+ * `AT_TIMESTAMP` is the third position real Lambda takes, and it is for a
+ * Kinesis stream rather than a DynamoDB one, so it is refused by name rather
+ * than left out of this type quietly.
+ */
+export type SimLambdaEventSourceStartingPosition = "TRIM_HORIZON" | "LATEST";
+/**
+ * The parts of a request that say where a mapping starts reading.
+ *
+ * Taken as its own small input rather than as the whole command input, so the
+ * rules stay with the event source they belong to rather than importing the
+ * command they are read from.
+ */
+export interface SimLambdaEventSourceStartingPositionInput {
+    readonly startingPosition?: string | undefined;
+    readonly startingPositionTimestamp?: Date | undefined;
+}
+/**
+ * Whether the event source a mapping names has a starting position, and which
+ * ones it takes.
+ *
+ * A queue has none: a mapping on one always delivers from the front of the
+ * queue, and real Lambda refuses a request that names a position for it. A
+ * stream has to be given one, because there is no sensible default between
+ * replaying everything the stream still holds and taking only what happens
+ * next.
+ */
+export interface SimLambdaEventSourceStartingPositionRules {
+    /**
+     * The position a mapping on this source starts from, refusing a request that
+     * asks for one this source does not have.
+     */
+    positionIn(input: SimLambdaEventSourceStartingPositionInput): SimLambdaEventSourceStartingPosition | undefined;
+}
+/**
+ * The rules for an event source with no starting position.
+ */
+export declare class SimLambdaNoStartingPosition implements SimLambdaEventSourceStartingPositionRules {
+    private readonly sourceDescription;
+    constructor(sourceDescription: string);
+    /**
+     * Refuse a starting position, since this source has nowhere else to start.
+     */
+    positionIn(input: SimLambdaEventSourceStartingPositionInput): SimLambdaEventSourceStartingPosition | undefined;
+}
+/**
+ * The rules for a DynamoDB stream, which takes one of two positions.
+ */
+export declare class SimLambdaStreamStartingPosition implements SimLambdaEventSourceStartingPositionRules {
+    /**
+     * The position a mapping on a stream starts from.
+     *
+     * `StartingPositionTimestamp` only goes with `AT_TIMESTAMP`, so it is refused
+     * along with it rather than being accepted and ignored.
+     */
+    positionIn(input: SimLambdaEventSourceStartingPositionInput): SimLambdaEventSourceStartingPosition;
+}
+//# sourceMappingURL=sim-lambda-event-source-starting-position.d.ts.map

package/dist/service/lambda/event-source/sim-lambda-event-source-starting-position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-event-source-starting-position.d.ts","sourceRoot":"","sources":["../../../../src/service/lambda/event-source/sim-lambda-event-source-starting-position.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,MAAM,oCAAoC,GAAG,cAAc,GAAG,QAAQ,CAAC;AAE7E;;;;;;GAMG;AACH,MAAM,WAAW,yCAAyC;IACxD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,yBAAyB,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC;CACvD;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,yCAAyC;IACxD;;;OAGG;IACH,UAAU,CACR,KAAK,EAAE,yCAAyC,GAC/C,oCAAoC,GAAG,SAAS,CAAC;CACrD;AAED;;GAEG;AACH,qBAAa,2BAA4B,YAAW,yCAAyC;IAC3F,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAE3C,YAAY,iBAAiB,EAAE,MAAM,EAEpC;IAED;;OAEG;IACH,UAAU,CACR,KAAK,EAAE,yCAAyC,GAC/C,oCAAoC,GAAG,SAAS,CAYlD;CACF;AAED;;GAEG;AACH,qBAAa,+BAAgC,YAAW,yCAAyC;IAC/F;;;;;OAKG;IACH,UAAU,CACR,KAAK,EAAE,yCAAyC,GAC/C,oCAAoC,CA2BtC;CACF"}

package/dist/service/lambda/event-source/sim-lambda-event-source-starting-position.js

@@ -0,0 +1,51 @@
+import { SimLambdaInvalidParameterValueException } from "../error/sim-lambda.error.js";
+/**
+ * The rules for an event source with no starting position.
+ */
+export class SimLambdaNoStartingPosition {
+    sourceDescription;
+    constructor(sourceDescription) {
+        this.sourceDescription = sourceDescription;
+    }
+    /**
+     * Refuse a starting position, since this source has nowhere else to start.
+     */
+    positionIn(input) {
+        if (input.startingPosition === undefined &&
+            input.startingPositionTimestamp === undefined) {
+            return undefined;
+        }
+        throw new SimLambdaInvalidParameterValueException(`StartingPosition is not valid for ${this.sourceDescription}: a mapping ` +
+            "on one always starts from the front");
+    }
+}
+/**
+ * The rules for a DynamoDB stream, which takes one of two positions.
+ */
+export class SimLambdaStreamStartingPosition {
+    /**
+     * The position a mapping on a stream starts from.
+     *
+     * `StartingPositionTimestamp` only goes with `AT_TIMESTAMP`, so it is refused
+     * along with it rather than being accepted and ignored.
+     */
+    positionIn(input) {
+        const requested = input.startingPosition;
+        if (requested === undefined) {
+            throw new SimLambdaInvalidParameterValueException("StartingPosition is required for a DynamoDB stream event source " +
+                "mapping. TRIM_HORIZON reads what the stream still holds, LATEST " +
+                "reads only what the table changes from now on");
+        }
+        if (requested !== "TRIM_HORIZON" && requested !== "LATEST") {
+            throw new SimLambdaInvalidParameterValueException(`StartingPosition ${requested} is not valid for a DynamoDB stream: ` +
+                "TRIM_HORIZON and LATEST are the two a DynamoDB stream takes, and " +
+                "AT_TIMESTAMP is for a Kinesis stream");
+        }
+        if (input.startingPositionTimestamp !== undefined) {
+            throw new SimLambdaInvalidParameterValueException("StartingPositionTimestamp only goes with the StartingPosition " +
+                "AT_TIMESTAMP, which is for a Kinesis stream");
+        }
+        return requested;
+    }
+}
+//# sourceMappingURL=sim-lambda-event-source-starting-position.js.map

package/dist/service/lambda/event-source/sim-lambda-event-source-starting-position.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-event-source-starting-position.js","sourceRoot":"","sources":["../../../../src/service/lambda/event-source/sim-lambda-event-source-starting-position.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uCAAuC,EAAE,MAAM,8BAA8B,CAAC;AA2CvF;;GAEG;AACH,MAAM,OAAO,2BAA2B;IACrB,iBAAiB,CAAS;IAE3C,YAAY,iBAAyB;QACnC,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,UAAU,CACR,KAAgD;QAEhD,IACE,KAAK,CAAC,gBAAgB,KAAK,SAAS;YACpC,KAAK,CAAC,yBAAyB,KAAK,SAAS,EAC7C,CAAC;YACD,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,IAAI,uCAAuC,CAC/C,qCAAqC,IAAI,CAAC,iBAAiB,cAAc;YACvE,qCAAqC,CACxC,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,+BAA+B;IAC1C;;;;;OAKG;IACH,UAAU,CACR,KAAgD;QAEhD,MAAM,SAAS,GAAG,KAAK,CAAC,gBAAgB,CAAC;QAEzC,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,IAAI,uCAAuC,CAC/C,kEAAkE;gBAChE,kEAAkE;gBAClE,+CAA+C,CAClD,CAAC;QACJ,CAAC;QAED,IAAI,SAAS,KAAK,cAAc,IAAI,SAAS,KAAK,QAAQ,EAAE,CAAC;YAC3D,MAAM,IAAI,uCAAuC,CAC/C,oBAAoB,SAAS,uCAAuC;gBAClE,mEAAmE;gBACnE,sCAAsC,CACzC,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,yBAAyB,KAAK,SAAS,EAAE,CAAC;YAClD,MAAM,IAAI,uCAAuC,CAC/C,gEAAgE;gBAC9D,6CAA6C,CAChD,CAAC;QACJ,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;CACF"}

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

@@ -0,0 +1,31 @@
+import type { SimLambdaEventSourceStreamPosition } from "./sim-lambda-event-source-streams.js";
+/**
+ * A place named as something other than an iterator, which is what an iterator
+ * has to be asked for.
+ */
+export type SimLambdaEventSourceStreamNamedPosition = Exclude<SimLambdaEventSourceStreamPosition, {
+    readonly kind: "iterator";
+}>;
+/**
+ * What GetShardIterator is asked for a named place with.
+ */
+export interface SimDynamoDbEventSourceIteratorType {
+    readonly ShardIteratorType: string;
+    readonly SequenceNumber?: string;
+}
+/**
+ * The GetShardIterator input fields a named place asks for.
+ *
+ * A sequence number is asked for with `AT_SEQUENCE_NUMBER` rather than
+ * `AFTER_SEQUENCE_NUMBER`: the record named is one the function is to be given
+ * again, not one it is finished with.
+ */
+export declare function simDynamoDbEventSourceIteratorTypeOf(position: SimLambdaEventSourceStreamNamedPosition): SimDynamoDbEventSourceIteratorType;
+/**
+ * Where a read leaves the reader.
+ *
+ * A shard with no next iterator is finished with, so there is nowhere to carry
+ * on from and the place the read started at stands.
+ */
+export declare function simDynamoDbEventSourceNextPosition(shardIterator: string | undefined, readFrom: SimLambdaEventSourceStreamPosition): SimLambdaEventSourceStreamPosition;
+//# sourceMappingURL=sim-dynamodb-event-source-stream-positions.d.ts.map

package/dist/service/lambda/event-source/stream/sim-dynamodb-event-source-stream-positions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-event-source-stream-positions.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/stream/sim-dynamodb-event-source-stream-positions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,sCAAsC,CAAC;AAE/F;;;GAGG;AACH,MAAM,MAAM,uCAAuC,GAAG,OAAO,CAC3D,kCAAkC,EAClC;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAC9B,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;GAMG;AACH,wBAAgB,oCAAoC,CAClD,QAAQ,EAAE,uCAAuC,GAChD,kCAAkC,CASpC;AAED;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAChD,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,QAAQ,EAAE,kCAAkC,GAC3C,kCAAkC,CAMpC"}

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

@@ -0,0 +1,29 @@
+/**
+ * The GetShardIterator input fields a named place asks for.
+ *
+ * A sequence number is asked for with `AT_SEQUENCE_NUMBER` rather than
+ * `AFTER_SEQUENCE_NUMBER`: the record named is one the function is to be given
+ * again, not one it is finished with.
+ */
+export function simDynamoDbEventSourceIteratorTypeOf(position) {
+    if (position.kind === "starting") {
+        return { ShardIteratorType: position.startingPosition };
+    }
+    return {
+        ShardIteratorType: "AT_SEQUENCE_NUMBER",
+        SequenceNumber: position.sequenceNumber,
+    };
+}
+/**
+ * Where a read leaves the reader.
+ *
+ * A shard with no next iterator is finished with, so there is nowhere to carry
+ * on from and the place the read started at stands.
+ */
+export function simDynamoDbEventSourceNextPosition(shardIterator, readFrom) {
+    if (shardIterator === undefined) {
+        return readFrom;
+    }
+    return { kind: "iterator", shardIterator };
+}
+//# sourceMappingURL=sim-dynamodb-event-source-stream-positions.js.map

package/dist/service/lambda/event-source/stream/sim-dynamodb-event-source-stream-positions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-event-source-stream-positions.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/stream/sim-dynamodb-event-source-stream-positions.ts"],"names":[],"mappings":"AAmBA;;;;;;GAMG;AACH,MAAM,UAAU,oCAAoC,CAClD,QAAiD;IAEjD,IAAI,QAAQ,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QACjC,OAAO,EAAE,iBAAiB,EAAE,QAAQ,CAAC,gBAAgB,EAAE,CAAC;IAC1D,CAAC;IAED,OAAO;QACL,iBAAiB,EAAE,oBAAoB;QACvC,cAAc,EAAE,QAAQ,CAAC,cAAc;KACxC,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kCAAkC,CAChD,aAAiC,EACjC,QAA4C;IAE5C,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;QAChC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC;AAC7C,CAAC"}

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

@@ -0,0 +1,32 @@
+import type { SimDynamoDbEventSourceStreamShard } from "./sim-dynamodb-event-source-stream-shard.js";
+import type { SimLambdaEventSourceStreamCommands } from "./sim-lambda-event-source-stream-service.js";
+import type { SimLambdaEventSourceStreamBatch, SimLambdaEventSourceStreamReadRequest } from "./sim-lambda-event-source-streams.js";
+interface SimDynamoDbEventSourceStreamReaderProperties {
+    readonly commands: SimLambdaEventSourceStreamCommands;
+    readonly shard: SimDynamoDbEventSourceStreamShard;
+}
+/**
+ * Reads batches of records off the shard a mapping polls.
+ *
+ * The iterator a read hands back is the place to carry on from, and a caller
+ * that does not take it reads the same records again. That is what makes a
+ * failed batch go over again from where it was rather than being skipped, and
+ * what makes a batch item failure report able to send the reader back to a
+ * record it has already been given.
+ */
+export declare class SimDynamoDbEventSourceStreamReader {
+    private readonly commands;
+    private readonly shard;
+    constructor(properties: SimDynamoDbEventSourceStreamReaderProperties);
+    /**
+     * Read up to a batch of records from where a position left off.
+     */
+    read(request: SimLambdaEventSourceStreamReadRequest): Promise<SimLambdaEventSourceStreamBatch>;
+    /**
+     * The place a read starts from: the one the caller already has, or one the
+     * stream is asked for when the caller names a place instead.
+     */
+    private iteratorOf;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-event-source-stream-reader.d.ts.map

package/dist/service/lambda/event-source/stream/sim-dynamodb-event-source-stream-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-event-source-stream-reader.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/stream/sim-dynamodb-event-source-stream-reader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,6CAA6C,CAAC;AAErG,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,6CAA6C,CAAC;AACtG,OAAO,KAAK,EACV,+BAA+B,EAC/B,qCAAqC,EACtC,MAAM,sCAAsC,CAAC;AAE9C,UAAU,4CAA4C;IACpD,QAAQ,CAAC,QAAQ,EAAE,kCAAkC,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,iCAAiC,CAAC;CACnD;AAED;;;;;;;;GAQG;AACH,qBAAa,kCAAkC;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqC;IAC9D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;IAE1D,YAAY,UAAU,EAAE,4CAA4C,EAGnE;IAED;;OAEG;IACG,IAAI,CACR,OAAO,EAAE,qCAAqC,GAC7C,OAAO,CAAC,+BAA+B,CAAC,CAkB1C;IAED;;;OAGG;YACW,UAAU;CAWzB"}

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

@@ -0,0 +1,48 @@
+import { simDynamoDbEventSourceNextPosition } from "./sim-dynamodb-event-source-stream-positions.js";
+/**
+ * Reads batches of records off the shard a mapping polls.
+ *
+ * The iterator a read hands back is the place to carry on from, and a caller
+ * that does not take it reads the same records again. That is what makes a
+ * failed batch go over again from where it was rather than being skipped, and
+ * what makes a batch item failure report able to send the reader back to a
+ * record it has already been given.
+ */
+export class SimDynamoDbEventSourceStreamReader {
+    commands;
+    shard;
+    constructor(properties) {
+        this.commands = properties.commands;
+        this.shard = properties.shard;
+    }
+    /**
+     * Read up to a batch of records from where a position left off.
+     */
+    async read(request) {
+        const { batchSize, caller, position } = request;
+        const output = await this.commands.getRecords({
+            input: {
+                ShardIterator: await this.iteratorOf(request),
+                Limit: batchSize,
+            },
+        }, { caller });
+        const next = output.NextShardIterator;
+        return {
+            records: output.Records ?? [],
+            next: simDynamoDbEventSourceNextPosition(next, position),
+            drained: next === undefined,
+        };
+    }
+    /**
+     * The place a read starts from: the one the caller already has, or one the
+     * stream is asked for when the caller names a place instead.
+     */
+    async iteratorOf(request) {
+        const { position } = request;
+        if (position.kind === "iterator") {
+            return position.shardIterator;
+        }
+        return await this.shard.iteratorFor(request, position);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-event-source-stream-reader.js.map

package/dist/service/lambda/event-source/stream/sim-dynamodb-event-source-stream-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-event-source-stream-reader.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/stream/sim-dynamodb-event-source-stream-reader.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kCAAkC,EAAE,MAAM,iDAAiD,CAAC;AAYrG;;;;;;;;GAQG;AACH,MAAM,OAAO,kCAAkC;IAC5B,QAAQ,CAAqC;IAC7C,KAAK,CAAoC;IAE1D,YAAY,UAAwD;QAClE,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;QACpC,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAI,CACR,OAA8C;QAE9C,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;QAChD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,UAAU,CAC3C;YACE,KAAK,EAAE;gBACL,aAAa,EAAE,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;gBAC7C,KAAK,EAAE,SAAS;aACjB;SACF,EACD,EAAE,MAAM,EAAE,CACX,CAAC;QACF,MAAM,IAAI,GAAG,MAAM,CAAC,iBAAiB,CAAC;QAEtC,OAAO;YACL,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,EAAE;YAC7B,IAAI,EAAE,kCAAkC,CAAC,IAAI,EAAE,QAAQ,CAAC;YACxD,OAAO,EAAE,IAAI,KAAK,SAAS;SAC5B,CAAC;IACJ,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,UAAU,CACtB,OAA8C;QAE9C,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;QAE7B,IAAI,QAAQ,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YACjC,OAAO,QAAQ,CAAC,aAAa,CAAC;QAChC,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACzD,CAAC;CACF"}

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

@@ -0,0 +1,28 @@
+import type { SimLambdaEventSourceStreamCommands } from "./sim-lambda-event-source-stream-service.js";
+import { type SimLambdaEventSourceStreamNamedPosition } from "./sim-dynamodb-event-source-stream-positions.js";
+import type { SimLambdaEventSourceStreamRequest } from "./sim-lambda-event-source-streams.js";
+/**
+ * What DescribeStream tells a poller about the stream it is about to read.
+ *
+ * Both answers come from the same call, which is why they are together: the
+ * table a stream carries changes for, and the shard those changes are on. A
+ * mapping asks for the table once, when it is created, and for a place on the
+ * shard whenever it has nowhere to carry on from.
+ */
+export declare class SimDynamoDbEventSourceStreamShard {
+    private readonly commands;
+    constructor(commands: SimLambdaEventSourceStreamCommands);
+    /**
+     * The table whose changes a stream carries.
+     */
+    tableName(request: SimLambdaEventSourceStreamRequest): Promise<string>;
+    /**
+     * A place on the shard to read from.
+     *
+     * A simulated stream has one shard, so the first shard DescribeStream reports
+     * is the shard.
+     */
+    iteratorFor(request: SimLambdaEventSourceStreamRequest, position: SimLambdaEventSourceStreamNamedPosition): Promise<string>;
+    private describe;
+}
+//# sourceMappingURL=sim-dynamodb-event-source-stream-shard.d.ts.map

package/dist/service/lambda/event-source/stream/sim-dynamodb-event-source-stream-shard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-event-source-stream-shard.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/stream/sim-dynamodb-event-source-stream-shard.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,kCAAkC,EAEnC,MAAM,6CAA6C,CAAC;AACrD,OAAO,EACL,KAAK,uCAAuC,EAE7C,MAAM,iDAAiD,CAAC;AACzD,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,sCAAsC,CAAC;AAE9F;;;;;;;GAOG;AACH,qBAAa,iCAAiC;IAC5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqC;IAE9D,YAAY,QAAQ,EAAE,kCAAkC,EAEvD;IAED;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE,iCAAiC,GAAG,OAAO,CAAC,MAAM,CAAC,CAS3E;IAED;;;;;OAKG;IACG,WAAW,CACf,OAAO,EAAE,iCAAiC,EAC1C,QAAQ,EAAE,uCAAuC,GAChD,OAAO,CAAC,MAAM,CAAC,CAyBjB;YAEa,QAAQ;CAevB"}

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

@@ -0,0 +1,71 @@
+import { SimLambdaError } from "../../error/sim-lambda.error.js";
+import { simDynamoDbEventSourceIteratorTypeOf, } from "./sim-dynamodb-event-source-stream-positions.js";
+/**
+ * What DescribeStream tells a poller about the stream it is about to read.
+ *
+ * Both answers come from the same call, which is why they are together: the
+ * table a stream carries changes for, and the shard those changes are on. A
+ * mapping asks for the table once, when it is created, and for a place on the
+ * shard whenever it has nowhere to carry on from.
+ */
+export class SimDynamoDbEventSourceStreamShard {
+    commands;
+    constructor(commands) {
+        this.commands = commands;
+    }
+    /**
+     * The table whose changes a stream carries.
+     */
+    async tableName(request) {
+        const described = await this.describe(request);
+        const tableName = described.TableName;
+        if (tableName === undefined) {
+            refuse(request, "reports no table to poll changes from");
+        }
+        return tableName;
+    }
+    /**
+     * A place on the shard to read from.
+     *
+     * A simulated stream has one shard, so the first shard DescribeStream reports
+     * is the shard.
+     */
+    async iteratorFor(request, position) {
+        const { caller, streamArn } = request;
+        const description = await this.describe(request);
+        const shardId = description.Shards?.[0]?.ShardId;
+        if (shardId === undefined) {
+            refuse(request, "reports no shard to read records from");
+        }
+        const iterator = await this.commands.getShardIterator({
+            input: {
+                StreamArn: streamArn,
+                ShardId: shardId,
+                ...simDynamoDbEventSourceIteratorTypeOf(position),
+            },
+        }, { caller });
+        if (iterator.ShardIterator === undefined) {
+            refuse(request, "gave out no shard iterator");
+        }
+        return iterator.ShardIterator;
+    }
+    async describe(request) {
+        const { caller, streamArn } = request;
+        const described = await this.commands.describeStream({ input: { StreamArn: streamArn } }, { caller });
+        if (described.StreamDescription === undefined) {
+            refuse(request, "could not be described");
+        }
+        return described.StreamDescription;
+    }
+}
+/**
+ * Refuse a stream that answered with something a poller cannot read on from.
+ *
+ * Nothing simulated DynamoDB answers with reaches these, since a stream it
+ * resolved by ARN has a table and a shard. They are here because the port is
+ * shaped as the SDK shapes it, where every part of an answer is optional.
+ */
+function refuse(request, problem) {
+    throw new SimLambdaError(`Stream ${request.streamArn} ${problem}`);
+}
+//# sourceMappingURL=sim-dynamodb-event-source-stream-shard.js.map

package/dist/service/lambda/event-source/stream/sim-dynamodb-event-source-stream-shard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-event-source-stream-shard.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/stream/sim-dynamodb-event-source-stream-shard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAKjE,OAAO,EAEL,oCAAoC,GACrC,MAAM,iDAAiD,CAAC;AAGzD;;;;;;;GAOG;AACH,MAAM,OAAO,iCAAiC;IAC3B,QAAQ,CAAqC;IAE9D,YAAY,QAA4C;QACtD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,OAA0C;QACxD,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAC/C,MAAM,SAAS,GAAG,SAAS,CAAC,SAAS,CAAC;QAEtC,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,CAAC,OAAO,EAAE,uCAAuC,CAAC,CAAC;QAC3D,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,WAAW,CACf,OAA0C,EAC1C,QAAiD;QAEjD,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;QACtC,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACjD,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC;QAEjD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,CAAC,OAAO,EAAE,uCAAuC,CAAC,CAAC;QAC3D,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CACnD;YACE,KAAK,EAAE;gBACL,SAAS,EAAE,SAAS;gBACpB,OAAO,EAAE,OAAO;gBAChB,GAAG,oCAAoC,CAAC,QAAQ,CAAC;aAClD;SACF,EACD,EAAE,MAAM,EAAE,CACX,CAAC;QAEF,IAAI,QAAQ,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;YACzC,MAAM,CAAC,OAAO,EAAE,4BAA4B,CAAC,CAAC;QAChD,CAAC;QAED,OAAO,QAAQ,CAAC,aAAa,CAAC;IAChC,CAAC;IAEO,KAAK,CAAC,QAAQ,CACpB,OAA0C;QAE1C,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;QACtC,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,cAAc,CAClD,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,EACnC,EAAE,MAAM,EAAE,CACX,CAAC;QAEF,IAAI,SAAS,CAAC,iBAAiB,KAAK,SAAS,EAAE,CAAC;YAC9C,MAAM,CAAC,OAAO,EAAE,wBAAwB,CAAC,CAAC;QAC5C,CAAC;QAED,OAAO,SAAS,CAAC,iBAAiB,CAAC;IACrC,CAAC;CACF;AAED;;;;;;GAMG;AACH,SAAS,MAAM,CACb,OAA0C,EAC1C,OAAe;IAEf,MAAM,IAAI,cAAc,CAAC,UAAU,OAAO,CAAC,SAAS,IAAI,OAAO,EAAE,CAAC,CAAC;AACrE,CAAC"}

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

@@ -0,0 +1,42 @@
+import type { SimLambdaEventSourceStreamService } from "./sim-lambda-event-source-stream-service.js";
+import type { SimLambdaEventSourceStreamBatch, SimLambdaEventSourceStreamReadRequest, SimLambdaEventSourceStreamRequest, SimLambdaEventSourceStreams, SimLambdaEventSourceStreamWatcher } from "./sim-lambda-event-source-streams.js";
+interface SimDynamoDbEventSourceStreamsProperties {
+    readonly dynamoDb: SimLambdaEventSourceStreamService;
+}
+/**
+ * Simulated DynamoDB as the streams a Lambda event source mapping polls.
+ *
+ * Every call goes through the DynamoDB Streams command it would go through on
+ * real AWS, as the function's execution role, so a role without
+ * `dynamodb:DescribeStream`, `dynamodb:GetShardIterator` or
+ * `dynamodb:GetRecords` on the stream is refused here rather than quietly
+ * polling anyway.
+ */
+export declare class SimDynamoDbEventSourceStreams implements SimLambdaEventSourceStreams {
+    private readonly activity;
+    private readonly shard;
+    private readonly reader;
+    constructor(properties: SimDynamoDbEventSourceStreamsProperties);
+    /**
+     * The table whose changes a stream carries.
+     *
+     * This is a DescribeStream call, which is also how a mapping finds out
+     * whether the stream it names is there at all: real Lambda needs the same
+     * permission for the same reason.
+     */
+    tableName(request: SimLambdaEventSourceStreamRequest): Promise<string>;
+    /**
+     * Read up to a batch of records from where a position left off.
+     */
+    read(request: SimLambdaEventSourceStreamReadRequest): Promise<SimLambdaEventSourceStreamBatch>;
+    /**
+     * Watch a stream for the records written to it.
+     */
+    watch(streamArn: string, watcher: SimLambdaEventSourceStreamWatcher): void;
+    /**
+     * Stop watching a stream.
+     */
+    unwatch(streamArn: string, watcher: SimLambdaEventSourceStreamWatcher): void;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-event-source-streams.d.ts.map

package/dist/service/lambda/event-source/stream/sim-dynamodb-event-source-streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-event-source-streams.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/stream/sim-dynamodb-event-source-streams.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,iCAAiC,EAClC,MAAM,6CAA6C,CAAC;AACrD,OAAO,KAAK,EACV,+BAA+B,EAC/B,qCAAqC,EACrC,iCAAiC,EACjC,2BAA2B,EAC3B,iCAAiC,EAClC,MAAM,sCAAsC,CAAC;AAE9C,UAAU,uCAAuC;IAC/C,QAAQ,CAAC,QAAQ,EAAE,iCAAiC,CAAC;CACtD;AAED;;;;;;;;GAQG;AACH,qBAAa,6BAA8B,YAAW,2BAA2B;IAC/E,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqC;IAC9D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqC;IAE5D,YAAY,UAAU,EAAE,uCAAuC,EAU9D;IAED;;;;;;OAMG;IACG,SAAS,CAAC,OAAO,EAAE,iCAAiC,GAAG,OAAO,CAAC,MAAM,CAAC,CAE3E;IAED;;OAEG;IACG,IAAI,CACR,OAAO,EAAE,qCAAqC,GAC7C,OAAO,CAAC,+BAA+B,CAAC,CAE1C;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,iCAAiC,GAAG,IAAI,CAEzE;IAED;;OAEG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,iCAAiC,GAAG,IAAI,CAE3E;CACF"}

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

@@ -0,0 +1,55 @@
+import { SimDynamoDbEventSourceStreamReader } from "./sim-dynamodb-event-source-stream-reader.js";
+import { SimDynamoDbEventSourceStreamShard } from "./sim-dynamodb-event-source-stream-shard.js";
+/**
+ * Simulated DynamoDB as the streams a Lambda event source mapping polls.
+ *
+ * Every call goes through the DynamoDB Streams command it would go through on
+ * real AWS, as the function's execution role, so a role without
+ * `dynamodb:DescribeStream`, `dynamodb:GetShardIterator` or
+ * `dynamodb:GetRecords` on the stream is refused here rather than quietly
+ * polling anyway.
+ */
+export class SimDynamoDbEventSourceStreams {
+    activity;
+    shard;
+    reader;
+    constructor(properties) {
+        const { dynamoDb } = properties;
+        const commands = dynamoDb.streams();
+        this.activity = dynamoDb.streamActivity();
+        this.shard = new SimDynamoDbEventSourceStreamShard(commands);
+        this.reader = new SimDynamoDbEventSourceStreamReader({
+            commands,
+            shard: this.shard,
+        });
+    }
+    /**
+     * The table whose changes a stream carries.
+     *
+     * This is a DescribeStream call, which is also how a mapping finds out
+     * whether the stream it names is there at all: real Lambda needs the same
+     * permission for the same reason.
+     */
+    async tableName(request) {
+        return await this.shard.tableName(request);
+    }
+    /**
+     * Read up to a batch of records from where a position left off.
+     */
+    async read(request) {
+        return await this.reader.read(request);
+    }
+    /**
+     * Watch a stream for the records written to it.
+     */
+    watch(streamArn, watcher) {
+        this.activity.watch(streamArn, watcher);
+    }
+    /**
+     * Stop watching a stream.
+     */
+    unwatch(streamArn, watcher) {
+        this.activity.unwatch(streamArn, watcher);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-event-source-streams.js.map

package/dist/service/lambda/event-source/stream/sim-dynamodb-event-source-streams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-event-source-streams.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/stream/sim-dynamodb-event-source-streams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,MAAM,8CAA8C,CAAC;AAClG,OAAO,EAAE,iCAAiC,EAAE,MAAM,6CAA6C,CAAC;AAiBhG;;;;;;;;GAQG;AACH,MAAM,OAAO,6BAA6B;IACvB,QAAQ,CAAqC;IAC7C,KAAK,CAAoC;IACzC,MAAM,CAAqC;IAE5D,YAAY,UAAmD;QAC7D,MAAM,EAAE,QAAQ,EAAE,GAAG,UAAU,CAAC;QAChC,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,EAAE,CAAC;QAEpC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,cAAc,EAAE,CAAC;QAC1C,IAAI,CAAC,KAAK,GAAG,IAAI,iCAAiC,CAAC,QAAQ,CAAC,CAAC;QAC7D,IAAI,CAAC,MAAM,GAAG,IAAI,kCAAkC,CAAC;YACnD,QAAQ;YACR,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,SAAS,CAAC,OAA0C;QACxD,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAI,CACR,OAA8C;QAE9C,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAiB,EAAE,OAA0C;QACjE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,SAAiB,EAAE,OAA0C;QACnE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC;CACF"}

package/dist/service/lambda/event-source/stream/sim-lambda-dynamodb-attribute-value.d.ts

@@ -0,0 +1,150 @@
+/**
+ * One attribute value in the images a stream record carries.
+ *
+ * Exactly one tag is set and the rest are absent, which is how the AWS SDK
+ * declares an attribute value. Saying that, rather than allowing any
+ * combination, is what lets a handler pass an image straight to `unmarshall`
+ * without a cast.
+ *
+ * This is declared here rather than taken from simulated DynamoDB so that
+ * neither service imports the other. What crosses between them is the shape of
+ * a record, not either service's own types.
+ */
+export type SimLambdaDynamoDbAttributeValue = {
+    readonly B: Uint8Array;
+    readonly BOOL?: never;
+    readonly BS?: never;
+    readonly L?: never;
+    readonly M?: never;
+    readonly N?: never;
+    readonly NS?: never;
+    readonly NULL?: never;
+    readonly S?: never;
+    readonly SS?: never;
+    readonly $unknown?: never;
+} | {
+    readonly BOOL: boolean;
+    readonly B?: never;
+    readonly BS?: never;
+    readonly L?: never;
+    readonly M?: never;
+    readonly N?: never;
+    readonly NS?: never;
+    readonly NULL?: never;
+    readonly S?: never;
+    readonly SS?: never;
+    readonly $unknown?: never;
+} | {
+    readonly BS: Uint8Array[];
+    readonly B?: never;
+    readonly BOOL?: never;
+    readonly L?: never;
+    readonly M?: never;
+    readonly N?: never;
+    readonly NS?: never;
+    readonly NULL?: never;
+    readonly S?: never;
+    readonly SS?: never;
+    readonly $unknown?: never;
+} | {
+    readonly L: SimLambdaDynamoDbAttributeValue[];
+    readonly B?: never;
+    readonly BOOL?: never;
+    readonly BS?: never;
+    readonly M?: never;
+    readonly N?: never;
+    readonly NS?: never;
+    readonly NULL?: never;
+    readonly S?: never;
+    readonly SS?: never;
+    readonly $unknown?: never;
+} | {
+    readonly M: Readonly<Record<string, SimLambdaDynamoDbAttributeValue>>;
+    readonly B?: never;
+    readonly BOOL?: never;
+    readonly BS?: never;
+    readonly L?: never;
+    readonly N?: never;
+    readonly NS?: never;
+    readonly NULL?: never;
+    readonly S?: never;
+    readonly SS?: never;
+    readonly $unknown?: never;
+} | {
+    readonly N: string;
+    readonly B?: never;
+    readonly BOOL?: never;
+    readonly BS?: never;
+    readonly L?: never;
+    readonly M?: never;
+    readonly NS?: never;
+    readonly NULL?: never;
+    readonly S?: never;
+    readonly SS?: never;
+    readonly $unknown?: never;
+} | {
+    readonly NS: string[];
+    readonly B?: never;
+    readonly BOOL?: never;
+    readonly BS?: never;
+    readonly L?: never;
+    readonly M?: never;
+    readonly N?: never;
+    readonly NULL?: never;
+    readonly S?: never;
+    readonly SS?: never;
+    readonly $unknown?: never;
+} | {
+    readonly NULL: boolean;
+    readonly B?: never;
+    readonly BOOL?: never;
+    readonly BS?: never;
+    readonly L?: never;
+    readonly M?: never;
+    readonly N?: never;
+    readonly NS?: never;
+    readonly S?: never;
+    readonly SS?: never;
+    readonly $unknown?: never;
+} | {
+    readonly S: string;
+    readonly B?: never;
+    readonly BOOL?: never;
+    readonly BS?: never;
+    readonly L?: never;
+    readonly M?: never;
+    readonly N?: never;
+    readonly NS?: never;
+    readonly NULL?: never;
+    readonly SS?: never;
+    readonly $unknown?: never;
+} | {
+    readonly SS: string[];
+    readonly B?: never;
+    readonly BOOL?: never;
+    readonly BS?: never;
+    readonly L?: never;
+    readonly M?: never;
+    readonly N?: never;
+    readonly NS?: never;
+    readonly NULL?: never;
+    readonly S?: never;
+    readonly $unknown?: never;
+} | {
+    readonly $unknown: [string, unknown];
+    readonly B?: never;
+    readonly BOOL?: never;
+    readonly BS?: never;
+    readonly L?: never;
+    readonly M?: never;
+    readonly N?: never;
+    readonly NS?: never;
+    readonly NULL?: never;
+    readonly S?: never;
+    readonly SS?: never;
+};
+/**
+ * One item image as a stream record carries it.
+ */
+export type SimLambdaDynamoDbImage = Readonly<Record<string, SimLambdaDynamoDbAttributeValue>>;
+//# sourceMappingURL=sim-lambda-dynamodb-attribute-value.d.ts.map