@kensio/yulin 1.1.0 → 1.3.0

package/dist/service/dynamodb/stream/sim-dynamodb-stream-read.js

@@ -0,0 +1,66 @@
+import { SimDynamoDbTrimmedDataAccessException } from "../error/dynamodb.error.js";
+import { simDynamoDbStreamAfter, } from "./sim-dynamodb-stream-position.js";
+import { compareSimDynamoDbSequenceNumbers } from "./sim-dynamodb-stream-sequence-numbers.js";
+/**
+ * Whether a shard has dropped the record a position names.
+ *
+ * `at` a trimmed sequence number is gone: that record is what was asked for.
+ * `after` one is not, as long as the record following it survived, which is why
+ * the two comparisons differ by the equal case.
+ */
+function isTrimmed(shard, sequenceNumber, inclusive) {
+    const trimmedThrough = shard.trimmedThrough;
+    if (trimmedThrough === undefined) {
+        return false;
+    }
+    const order = compareSimDynamoDbSequenceNumbers(sequenceNumber, trimmedThrough);
+    return inclusive ? order <= 0 : order < 0;
+}
+/**
+ * Ensure a shard still holds the position a reader is asking for.
+ *
+ * Checked when an iterator is handed out as well as when one is used, because a
+ * caller can name a sequence number the retention window has already outlived
+ * and should find that out at the request rather than one call later.
+ */
+export function assertSimDynamoDbStreamPositionReadable(shard, position) {
+    if (position.kind === "start" ||
+        !isTrimmed(shard, position.sequenceNumber, position.kind === "at")) {
+        return;
+    }
+    throw new SimDynamoDbTrimmedDataAccessException(`Stream record with sequence number ${position.sequenceNumber} on shard ` +
+        `${shard.shardId} is past the 24 hour trim point`);
+}
+/**
+ * Where in the records a position starts reading from.
+ */
+function startIndexOf(records, position) {
+    if (position.kind === "start") {
+        return 0;
+    }
+    const wanted = position.kind === "at" ? 0 : 1;
+    const found = records.findIndex((record) => compareSimDynamoDbSequenceNumbers(record.sequenceNumber, position.sequenceNumber) >= wanted);
+    return found === -1 ? records.length : found;
+}
+/**
+ * Read up to a limit of records from a shard, starting at a position.
+ *
+ * An empty result is an ordinary answer rather than a problem: a reader that
+ * has caught up with an open shard gets nothing back and the position it
+ * already had, which is what makes polling each successive iterator work.
+ */
+export function simDynamoDbStreamRead(shard, position, limit) {
+    assertSimDynamoDbStreamPositionReadable(shard, position);
+    const available = shard.records;
+    const start = startIndexOf(available, position);
+    const records = available.slice(start, start + limit);
+    const last = records.at(-1);
+    return {
+        records,
+        next: last === undefined
+            ? position
+            : simDynamoDbStreamAfter(last.sequenceNumber),
+        drained: !shard.isOpen && start + records.length >= available.length,
+    };
+}
+//# sourceMappingURL=sim-dynamodb-stream-read.js.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-read.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-read.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qCAAqC,EAAE,MAAM,4BAA4B,CAAC;AAEnF,OAAO,EACL,sBAAsB,GAEvB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,iCAAiC,EAAE,MAAM,2CAA2C,CAAC;AAiB9F;;;;;;GAMG;AACH,SAAS,SAAS,CAChB,KAA6B,EAC7B,cAAsB,EACtB,SAAkB;IAElB,MAAM,cAAc,GAAG,KAAK,CAAC,cAAc,CAAC;IAE5C,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;QACjC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,KAAK,GAAG,iCAAiC,CAC7C,cAAc,EACd,cAAc,CACf,CAAC;IAEF,OAAO,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uCAAuC,CACrD,KAA6B,EAC7B,QAAmC;IAEnC,IACE,QAAQ,CAAC,IAAI,KAAK,OAAO;QACzB,CAAC,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,IAAI,KAAK,IAAI,CAAC,EAClE,CAAC;QACD,OAAO;IACT,CAAC;IAED,MAAM,IAAI,qCAAqC,CAC7C,sCAAsC,QAAQ,CAAC,cAAc,YAAY;QACvE,GAAG,KAAK,CAAC,OAAO,iCAAiC,CACpD,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,YAAY,CACnB,OAA2C,EAC3C,QAAmC;IAEnC,IAAI,QAAQ,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC9B,OAAO,CAAC,CAAC;IACX,CAAC;IAED,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9C,MAAM,KAAK,GAAG,OAAO,CAAC,SAAS,CAC7B,CAAC,MAAM,EAAE,EAAE,CACT,iCAAiC,CAC/B,MAAM,CAAC,cAAc,EACrB,QAAQ,CAAC,cAAc,CACxB,IAAI,MAAM,CACd,CAAC;IAEF,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;AAC/C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACnC,KAA6B,EAC7B,QAAmC,EACnC,KAAa;IAEb,uCAAuC,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAEzD,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC;IAChC,MAAM,KAAK,GAAG,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAChD,MAAM,OAAO,GAAG,SAAS,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC;IACtD,MAAM,IAAI,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAE5B,OAAO;QACL,OAAO;QACP,IAAI,EACF,IAAI,KAAK,SAAS;YAChB,CAAC,CAAC,QAAQ;YACV,CAAC,CAAC,sBAAsB,CAAC,IAAI,CAAC,cAAc,CAAC;QACjD,OAAO,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,KAAK,GAAG,OAAO,CAAC,MAAM,IAAI,SAAS,CAAC,MAAM;KACrE,CAAC;AACJ,CAAC"}

package/dist/service/dynamodb/stream/sim-dynamodb-stream-record-keys.d.ts

@@ -0,0 +1,15 @@
+import { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbKeySchema } from "../table/sim-dynamodb-key-schema.js";
+/**
+ * The `Keys` of a stream record, cut from the item that changed.
+ *
+ * Every record carries these, whatever view type the stream was enabled with,
+ * because a reader that cannot say which item changed cannot do anything with
+ * the record. A `KEYS_ONLY` stream is that and nothing else.
+ *
+ * The item is whichever image the change has: an insertion and a modification
+ * have a new one, a removal has only the old one, and the key attributes are
+ * the same in either since an update cannot move an item's primary key.
+ */
+export declare function simDynamoDbStreamRecordKeys(item: SimDynamoDbItem, keySchema: SimDynamoDbKeySchema): SimDynamoDbItem;
+//# sourceMappingURL=sim-dynamodb-stream-record-keys.d.ts.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-record-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-record-keys.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-record-keys.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAE/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAEhF;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,eAAe,EACrB,SAAS,EAAE,oBAAoB,GAC9B,eAAe,CAajB"}

package/dist/service/dynamodb/stream/sim-dynamodb-stream-record-keys.js

@@ -0,0 +1,25 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+/**
+ * The `Keys` of a stream record, cut from the item that changed.
+ *
+ * Every record carries these, whatever view type the stream was enabled with,
+ * because a reader that cannot say which item changed cannot do anything with
+ * the record. A `KEYS_ONLY` stream is that and nothing else.
+ *
+ * The item is whichever image the change has: an insertion and a modification
+ * have a new one, a removal has only the old one, and the key attributes are
+ * the same in either since an update cannot move an item's primary key.
+ */
+export function simDynamoDbStreamRecordKeys(item, keySchema) {
+    const attributes = new Map();
+    for (const attributeName of keySchema.attributeNames()) {
+        const value = item.attribute(attributeName);
+        // An item is stored under its primary key, so one that changed carries
+        // every key attribute. Missing one would be the simulator's own fault.
+        assertDefined(value, `DynamoDB key attribute ${attributeName}`);
+        attributes.set(attributeName, value);
+    }
+    return SimDynamoDbItem.ofAttributes(attributes);
+}
+//# sourceMappingURL=sim-dynamodb-stream-record-keys.js.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-record-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-record-keys.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-record-keys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAI/D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,2BAA2B,CACzC,IAAqB,EACrB,SAA+B;IAE/B,MAAM,UAAU,GAAG,IAAI,GAAG,EAA4B,CAAC;IAEvD,KAAK,MAAM,aAAa,IAAI,SAAS,CAAC,cAAc,EAAE,EAAE,CAAC;QACvD,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAE5C,uEAAuE;QACvE,uEAAuE;QACvE,aAAa,CAAC,KAAK,EAAE,0BAA0B,aAAa,EAAE,CAAC,CAAC;QAChE,UAAU,CAAC,GAAG,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IACvC,CAAC;IAED,OAAO,eAAe,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;AAClD,CAAC"}

package/dist/service/dynamodb/stream/sim-dynamodb-stream-record-size.d.ts

@@ -0,0 +1,11 @@
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+/**
+ * The `SizeBytes` of a stream record carrying these images.
+ *
+ * Every image the record carries counts, together rather than one at a time:
+ * the keys, and then whichever of the old and new images the view type
+ * selected. A record carrying both images is close to twice the size of one
+ * carrying either, which is what AWS's published samples show.
+ */
+export declare function simDynamoDbStreamRecordSize(images: readonly SimDynamoDbItem[]): number;
+//# sourceMappingURL=sim-dynamodb-stream-record-size.d.ts.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-record-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-record-size.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-record-size.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAuFpE;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,SAAS,eAAe,EAAE,GACjC,MAAM,CAER"}

package/dist/service/dynamodb/stream/sim-dynamodb-stream-record-size.js

@@ -0,0 +1,74 @@
+import { simDynamoDbBinaryText } from "../item/sim-dynamodb-binary.js";
+import { simDynamoDbTextSize } from "../item/sim-dynamodb-value-size.js";
+/**
+ * The bytes one value counts towards a stream record's size.
+ *
+ * This is not `simDynamoDbValueSize`, and the difference is deliberate. That
+ * one implements the 400 KB item rule, where a number costs
+ * `ceil(significantDigits / 2) + 1` and a list or a map carries three bytes of
+ * overhead. A stream record is measured as the text it carries instead, so an
+ * eight digit number costs 8 here and 5 there. The two agree on AWS's own
+ * published samples only because `101` is three characters either way.
+ *
+ * A boolean and a null are the text the record carries them as, `true` or
+ * `false`, and a collection is its elements with no overhead. AWS publishes no
+ * sample covering those, so they follow the same rule the rest do rather than
+ * inventing a second one.
+ */
+function streamValueSize(value) {
+    switch (value.kind) {
+        case "S": {
+            return simDynamoDbTextSize(value.text);
+        }
+        case "N": {
+            return simDynamoDbTextSize(value.number.text);
+        }
+        case "B": {
+            return simDynamoDbTextSize(simDynamoDbBinaryText(value.bytes));
+        }
+        case "BOOL": {
+            return simDynamoDbTextSize(String(value.boolean));
+        }
+        case "NULL": {
+            return simDynamoDbTextSize("true");
+        }
+        case "SS": {
+            return value.texts.reduce((total, text) => total + simDynamoDbTextSize(text), 0);
+        }
+        case "NS": {
+            return value.numbers.reduce((total, number) => total + simDynamoDbTextSize(number.text), 0);
+        }
+        case "BS": {
+            return value.bytes.reduce((total, bytes) => total + simDynamoDbTextSize(simDynamoDbBinaryText(bytes)), 0);
+        }
+        case "L": {
+            return value.values.reduce((total, element) => total + streamValueSize(element), 0);
+        }
+        case "M": {
+            return value.entries
+                .entries()
+                .reduce((total, [name, element]) => total + simDynamoDbTextSize(name) + streamValueSize(element), 0);
+        }
+    }
+}
+/**
+ * The bytes one image counts towards a stream record's size.
+ */
+function streamImageSize(image) {
+    return image
+        .entries()
+        .entries()
+        .reduce((total, [name, value]) => total + simDynamoDbTextSize(name) + streamValueSize(value), 0);
+}
+/**
+ * The `SizeBytes` of a stream record carrying these images.
+ *
+ * Every image the record carries counts, together rather than one at a time:
+ * the keys, and then whichever of the old and new images the view type
+ * selected. A record carrying both images is close to twice the size of one
+ * carrying either, which is what AWS's published samples show.
+ */
+export function simDynamoDbStreamRecordSize(images) {
+    return images.reduce((total, image) => total + streamImageSize(image), 0);
+}
+//# sourceMappingURL=sim-dynamodb-stream-record-size.js.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-record-size.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-record-size.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-record-size.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAGzE;;;;;;;;;;;;;;GAcG;AACH,SAAS,eAAe,CAAC,KAAuB;IAC9C,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,GAAG,EAAE,CAAC;YACT,OAAO,mBAAmB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACzC,CAAC;QACD,KAAK,GAAG,EAAE,CAAC;YACT,OAAO,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAChD,CAAC;QACD,KAAK,GAAG,EAAE,CAAC;YACT,OAAO,mBAAmB,CAAC,qBAAqB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QACjE,CAAC;QACD,KAAK,MAAM,EAAE,CAAC;YACZ,OAAO,mBAAmB,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QACpD,CAAC;QACD,KAAK,MAAM,EAAE,CAAC;YACZ,OAAO,mBAAmB,CAAC,MAAM,CAAC,CAAC;QACrC,CAAC;QACD,KAAK,IAAI,EAAE,CAAC;YACV,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,CACvB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,KAAK,GAAG,mBAAmB,CAAC,IAAI,CAAC,EAClD,CAAC,CACF,CAAC;QACJ,CAAC;QACD,KAAK,IAAI,EAAE,CAAC;YACV,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,CACzB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,KAAK,GAAG,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,EAC3D,CAAC,CACF,CAAC;QACJ,CAAC;QACD,KAAK,IAAI,EAAE,CAAC;YACV,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,CACvB,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CACf,KAAK,GAAG,mBAAmB,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,EAC3D,CAAC,CACF,CAAC;QACJ,CAAC;QACD,KAAK,GAAG,EAAE,CAAC;YACT,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,CACxB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,KAAK,GAAG,eAAe,CAAC,OAAO,CAAC,EACpD,CAAC,CACF,CAAC;QACJ,CAAC;QACD,KAAK,GAAG,EAAE,CAAC;YACT,OAAO,KAAK,CAAC,OAAO;iBACjB,OAAO,EAAE;iBACT,MAAM,CACL,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,EAAE,CACzB,KAAK,GAAG,mBAAmB,CAAC,IAAI,CAAC,GAAG,eAAe,CAAC,OAAO,CAAC,EAC9D,CAAC,CACF,CAAC;QACN,CAAC;IACH,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,eAAe,CAAC,KAAsB;IAC7C,OAAO,KAAK;SACT,OAAO,EAAE;SACT,OAAO,EAAE;SACT,MAAM,CACL,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,CACvB,KAAK,GAAG,mBAAmB,CAAC,IAAI,CAAC,GAAG,eAAe,CAAC,KAAK,CAAC,EAC5D,CAAC,CACF,CAAC;AACN,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,2BAA2B,CACzC,MAAkC;IAElC,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAC5E,CAAC"}

package/dist/service/dynamodb/stream/sim-dynamodb-stream-record.d.ts

@@ -0,0 +1,49 @@
+import type { SimDynamoDbStreamViewType } from "./sim-dynamodb-stream.types.js";
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbKeySchema } from "../table/sim-dynamodb-key-schema.js";
+import type { SimDynamoDbItemChange } from "./sim-dynamodb-item-change.js";
+/**
+ * What kind of change one stream record reports.
+ */
+export type SimDynamoDbStreamEventName = "INSERT" | "MODIFY" | "REMOVE";
+/**
+ * Who made the change a record reports, when it was not the application.
+ *
+ * Only a time to live deletion carries one. It is how an application tells a
+ * deletion it never asked for from one of its own, which matters because the
+ * two want completely different handling downstream.
+ */
+export interface SimDynamoDbStreamUserIdentity {
+    readonly type: "Service";
+    readonly principalId: "dynamodb.amazonaws.com";
+}
+interface SimDynamoDbStreamRecordProperties {
+    readonly change: SimDynamoDbItemChange;
+    readonly keySchema: SimDynamoDbKeySchema;
+    readonly viewType: SimDynamoDbStreamViewType;
+    readonly sequenceNumber: string;
+    readonly at: Date;
+}
+/**
+ * One record on a table's stream: one change, as the stream carries it.
+ *
+ * A record is fixed once it is written. The images it holds are the items as
+ * they were at the moment of the change, rather than references to whatever the
+ * table holds now, which is what makes a stream a log of transitions rather
+ * than a view of the table.
+ */
+export declare class SimDynamoDbStreamRecord {
+    readonly eventId: string;
+    readonly eventName: SimDynamoDbStreamEventName;
+    readonly sequenceNumber: string;
+    readonly approximateCreationDateTime: Date;
+    readonly streamViewType: SimDynamoDbStreamViewType;
+    readonly keys: SimDynamoDbItem;
+    readonly newImage: SimDynamoDbItem | undefined;
+    readonly oldImage: SimDynamoDbItem | undefined;
+    readonly sizeBytes: number;
+    readonly userIdentity: SimDynamoDbStreamUserIdentity | undefined;
+    constructor(properties: SimDynamoDbStreamRecordProperties);
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-stream-record.d.ts.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-record.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-record.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAChF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAK3E;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAExE;;;;;;GAMG;AACH,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,wBAAwB,CAAC;CAChD;AAUD,UAAU,iCAAiC;IACzC,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,yBAAyB,CAAC;IAC7C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;CACnB;AAeD;;;;;;;GAOG;AACH,qBAAa,uBAAuB;IAClC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,SAAS,EAAE,0BAA0B,CAAC;IACtD,SAAgB,cAAc,EAAE,MAAM,CAAC;IACvC,SAAgB,2BAA2B,EAAE,IAAI,CAAC;IAClD,SAAgB,cAAc,EAAE,yBAAyB,CAAC;IAC1D,SAAgB,IAAI,EAAE,eAAe,CAAC;IACtC,SAAgB,QAAQ,EAAE,eAAe,GAAG,SAAS,CAAC;IACtD,SAAgB,QAAQ,EAAE,eAAe,GAAG,SAAS,CAAC;IACtD,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,SAAgB,YAAY,EAAE,6BAA6B,GAAG,SAAS,CAAC;IAExE,YAAY,UAAU,EAAE,iCAAiC,EAwBxD;CACF"}

package/dist/service/dynamodb/stream/sim-dynamodb-stream-record.js

@@ -0,0 +1,60 @@
+import { randomUUID } from "node:crypto";
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { simDynamoDbStreamImages } from "./sim-dynamodb-stream-images.js";
+import { simDynamoDbStreamRecordKeys } from "./sim-dynamodb-stream-record-keys.js";
+import { simDynamoDbStreamRecordSize } from "./sim-dynamodb-stream-record-size.js";
+/**
+ * The identity a time to live deletion is written under.
+ */
+const timeToLiveIdentity = {
+    type: "Service",
+    principalId: "dynamodb.amazonaws.com",
+};
+/**
+ * Which of the three kinds of change these images are.
+ */
+function eventNameOf(change) {
+    if (change.newImage === undefined) {
+        return "REMOVE";
+    }
+    return change.oldImage === undefined ? "INSERT" : "MODIFY";
+}
+/**
+ * One record on a table's stream: one change, as the stream carries it.
+ *
+ * A record is fixed once it is written. The images it holds are the items as
+ * they were at the moment of the change, rather than references to whatever the
+ * table holds now, which is what makes a stream a log of transitions rather
+ * than a view of the table.
+ */
+export class SimDynamoDbStreamRecord {
+    eventId;
+    eventName;
+    sequenceNumber;
+    approximateCreationDateTime;
+    streamViewType;
+    keys;
+    newImage;
+    oldImage;
+    sizeBytes;
+    userIdentity;
+    constructor(properties) {
+        const { change, viewType } = properties;
+        // A change with neither image never happened, and the stream is never told
+        // about one, so the item the keys are cut from is always there.
+        const changed = change.newImage ?? change.oldImage;
+        assertDefined(changed, "DynamoDB stream record item image");
+        const images = simDynamoDbStreamImages(change, viewType);
+        this.eventId = randomUUID().replaceAll("-", "");
+        this.eventName = eventNameOf(change);
+        this.sequenceNumber = properties.sequenceNumber;
+        this.approximateCreationDateTime = properties.at;
+        this.streamViewType = viewType;
+        this.keys = simDynamoDbStreamRecordKeys(changed, properties.keySchema);
+        this.newImage = images.newImage;
+        this.oldImage = images.oldImage;
+        this.sizeBytes = simDynamoDbStreamRecordSize([this.keys, images.newImage, images.oldImage].filter((image) => image !== undefined));
+        this.userIdentity = change.expired ? timeToLiveIdentity : undefined;
+    }
+}
+//# sourceMappingURL=sim-dynamodb-stream-record.js.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-record.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-record.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAKpE,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAmBnF;;GAEG;AACH,MAAM,kBAAkB,GAAkC;IACxD,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,wBAAwB;CACtC,CAAC;AAUF;;GAEG;AACH,SAAS,WAAW,CAClB,MAA6B;IAE7B,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;QAClC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,OAAO,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC7D,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,uBAAuB;IAClB,OAAO,CAAS;IAChB,SAAS,CAA6B;IACtC,cAAc,CAAS;IACvB,2BAA2B,CAAO;IAClC,cAAc,CAA4B;IAC1C,IAAI,CAAkB;IACtB,QAAQ,CAA8B;IACtC,QAAQ,CAA8B;IACtC,SAAS,CAAS;IAClB,YAAY,CAA4C;IAExE,YAAY,UAA6C;QACvD,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,UAAU,CAAC;QAExC,2EAA2E;QAC3E,gEAAgE;QAChE,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC;QACnD,aAAa,CAAC,OAAO,EAAE,mCAAmC,CAAC,CAAC;QAE5D,MAAM,MAAM,GAAG,uBAAuB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAEzD,IAAI,CAAC,OAAO,GAAG,UAAU,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QAChD,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;QACrC,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,cAAc,CAAC;QAChD,IAAI,CAAC,2BAA2B,GAAG,UAAU,CAAC,EAAE,CAAC;QACjD,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC;QAC/B,IAAI,CAAC,IAAI,GAAG,2BAA2B,CAAC,OAAO,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;QACvE,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAChC,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAChC,IAAI,CAAC,SAAS,GAAG,2BAA2B,CAC1C,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,CAClD,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CAC/B,CACF,CAAC;QACF,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,SAAS,CAAC;IACtE,CAAC;CACF"}

package/dist/service/dynamodb/stream/sim-dynamodb-stream-retention.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The instant a stream's records have to be newer than to still be readable.
+ *
+ * Trimming is applied when a stream is read rather than scheduled, because it
+ * is a pure function of the current time: whatever a read finds is what the
+ * retention window holds at the instant of that read, and nothing has to have
+ * run in between for that to be true. Compare `SimSqsQueue.applyLifecycle`,
+ * which is the same shape for the same reason.
+ *
+ * A stream itself is not dropped once everything on it has been trimmed. Real
+ * DynamoDB eventually stops listing a disabled stream whose records have all
+ * aged out, which is a divergence in a test's favour: the ARN a test is holding
+ * goes on resolving, and reading it gives an empty result rather than a
+ * resource that has silently disappeared.
+ */
+export declare function simDynamoDbStreamTrimPoint(now: Date): Date;
+//# sourceMappingURL=sim-dynamodb-stream-retention.d.ts.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-retention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-retention.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-retention.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,CAE1D"}

package/dist/service/dynamodb/stream/sim-dynamodb-stream-retention.js

@@ -0,0 +1,24 @@
+/**
+ * How long DynamoDB Streams keeps a record before trimming it.
+ */
+const retentionHours = 24;
+const millisecondsPerHour = 60 * 60 * 1000;
+/**
+ * The instant a stream's records have to be newer than to still be readable.
+ *
+ * Trimming is applied when a stream is read rather than scheduled, because it
+ * is a pure function of the current time: whatever a read finds is what the
+ * retention window holds at the instant of that read, and nothing has to have
+ * run in between for that to be true. Compare `SimSqsQueue.applyLifecycle`,
+ * which is the same shape for the same reason.
+ *
+ * A stream itself is not dropped once everything on it has been trimmed. Real
+ * DynamoDB eventually stops listing a disabled stream whose records have all
+ * aged out, which is a divergence in a test's favour: the ARN a test is holding
+ * goes on resolving, and reading it gives an empty result rather than a
+ * resource that has silently disappeared.
+ */
+export function simDynamoDbStreamTrimPoint(now) {
+    return new Date(now.getTime() - retentionHours * millisecondsPerHour);
+}
+//# sourceMappingURL=sim-dynamodb-stream-retention.js.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-retention.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-retention.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-retention.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,cAAc,GAAG,EAAE,CAAC;AAE1B,MAAM,mBAAmB,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE3C;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,0BAA0B,CAAC,GAAS;IAClD,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,cAAc,GAAG,mBAAmB,CAAC,CAAC;AACxE,CAAC"}

package/dist/service/dynamodb/stream/sim-dynamodb-stream-sequence-numbers.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The sequence numbers one stream hands out.
+ *
+ * This is a counter rather than a clock. Records are commonly written inside
+ * one millisecond, and a clock cannot tell those apart, so a clock-derived
+ * sequence number would leave two records claiming the same position on the
+ * stream. Real DynamoDB varies the width between 21 and 40 digits, where these
+ * stay at 21, which is a divergence in a reader's favour: lexicographic order
+ * is numeric order here whatever two numbers are compared.
+ */
+export declare class SimDynamoDbStreamSequenceNumbers {
+    private next;
+    /**
+     * Take the next sequence number, as the text a record carries.
+     */
+    take(): string;
+}
+/**
+ * Read a sequence number a request carries.
+ *
+ * Real DynamoDB refuses anything that is not a run of digits, so a caller that
+ * passes a shard identifier or a truncated value here finds out at the request
+ * rather than reading from a position nothing could ever be at.
+ */
+export declare function readSimDynamoDbSequenceNumber(value: string | undefined, operationName: string): string;
+/**
+ * Order two sequence numbers, as a comparator does.
+ *
+ * These are compared as numbers rather than as text. The ones a simulated
+ * stream hands out are a fixed width, where the two orders agree, but one a
+ * request carries came from outside and need not be.
+ */
+export declare function compareSimDynamoDbSequenceNumbers(left: string, right: string): number;
+//# sourceMappingURL=sim-dynamodb-stream-sequence-numbers.d.ts.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-sequence-numbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-sequence-numbers.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-sequence-numbers.ts"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,qBAAa,gCAAgC;IAC3C,OAAO,CAAC,IAAI,CAAuB;IAEnC;;OAEG;IACH,IAAI,IAAI,MAAM,CAMb;CACF;AAOD;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,aAAa,EAAE,MAAM,GACpB,MAAM,CAQR;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,MAAM,CAQR"}

package/dist/service/dynamodb/stream/sim-dynamodb-stream-sequence-numbers.js

@@ -0,0 +1,63 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+/**
+ * The number the first record on a stream is given.
+ *
+ * A sequence number is compared as text by anything reading a stream, so the
+ * width has to be fixed and the first digit has to be something other than a
+ * zero. Starting at 10^20 gives 21 digits of room, which is a hundred billion
+ * billion records before the width changes.
+ */
+const firstSequenceNumber = 100000000000000000000n;
+/**
+ * The sequence numbers one stream hands out.
+ *
+ * This is a counter rather than a clock. Records are commonly written inside
+ * one millisecond, and a clock cannot tell those apart, so a clock-derived
+ * sequence number would leave two records claiming the same position on the
+ * stream. Real DynamoDB varies the width between 21 and 40 digits, where these
+ * stay at 21, which is a divergence in a reader's favour: lexicographic order
+ * is numeric order here whatever two numbers are compared.
+ */
+export class SimDynamoDbStreamSequenceNumbers {
+    next = firstSequenceNumber;
+    /**
+     * Take the next sequence number, as the text a record carries.
+     */
+    take() {
+        const taken = this.next;
+        this.next += 1n;
+        return taken.toString();
+    }
+}
+/**
+ * A sequence number is digits and nothing else.
+ */
+const digitsOnly = /^\d+$/u;
+/**
+ * Read a sequence number a request carries.
+ *
+ * Real DynamoDB refuses anything that is not a run of digits, so a caller that
+ * passes a shard identifier or a truncated value here finds out at the request
+ * rather than reading from a position nothing could ever be at.
+ */
+export function readSimDynamoDbSequenceNumber(value, operationName) {
+    if (value === undefined || !digitsOnly.test(value)) {
+        throw new SimDynamoDbValidationException(`${operationName} needs a numeric SequenceNumber`);
+    }
+    return value;
+}
+/**
+ * Order two sequence numbers, as a comparator does.
+ *
+ * These are compared as numbers rather than as text. The ones a simulated
+ * stream hands out are a fixed width, where the two orders agree, but one a
+ * request carries came from outside and need not be.
+ */
+export function compareSimDynamoDbSequenceNumbers(left, right) {
+    const difference = BigInt(left) - BigInt(right);
+    if (difference === 0n) {
+        return 0;
+    }
+    return difference > 0n ? 1 : -1;
+}
+//# sourceMappingURL=sim-dynamodb-stream-sequence-numbers.js.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-sequence-numbers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-sequence-numbers.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-sequence-numbers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAE5E;;;;;;;GAOG;AACH,MAAM,mBAAmB,GAAG,sBAA4B,CAAC;AAEzD;;;;;;;;;GASG;AACH,MAAM,OAAO,gCAAgC;IACnC,IAAI,GAAG,mBAAmB,CAAC;IAEnC;;OAEG;IACH,IAAI;QACF,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC;QAExB,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;QAEhB,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;IAC1B,CAAC;CACF;AAED;;GAEG;AACH,MAAM,UAAU,GAAG,QAAQ,CAAC;AAE5B;;;;;;GAMG;AACH,MAAM,UAAU,6BAA6B,CAC3C,KAAyB,EACzB,aAAqB;IAErB,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,8BAA8B,CACtC,GAAG,aAAa,iCAAiC,CAClD,CAAC;IACJ,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iCAAiC,CAC/C,IAAY,EACZ,KAAa;IAEb,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAEhD,IAAI,UAAU,KAAK,EAAE,EAAE,CAAC;QACtB,OAAO,CAAC,CAAC;IACX,CAAC;IAED,OAAO,UAAU,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAClC,CAAC"}

package/dist/service/dynamodb/stream/sim-dynamodb-stream-shard-iterator.d.ts

@@ -0,0 +1,25 @@
+import type { SimDynamoDbStreamPosition } from "./sim-dynamodb-stream-position.js";
+/**
+ * What a shard iterator stands for: one place on one shard of one stream.
+ */
+export interface SimDynamoDbShardIterator {
+    readonly streamArn: string;
+    readonly shardId: string;
+    readonly position: SimDynamoDbStreamPosition;
+}
+/**
+ * The opaque token a caller is handed to read on from a place.
+ *
+ * Real shard iterators are opaque strings a caller passes back unread, and this
+ * one is the same shape: the place it stands for travels inside it rather than
+ * in a table of handed-out iterators. That is what lets an iterator be used
+ * against the stream it names without the stream having to remember it, which
+ * is also why the 15 minute expiry is deliberately absent here rather than
+ * approximated.
+ */
+export declare function simDynamoDbShardIteratorToken(iterator: SimDynamoDbShardIterator): string;
+/**
+ * Read the place a shard iterator a request carries stands for.
+ */
+export declare function readSimDynamoDbShardIteratorToken(token: string | undefined): SimDynamoDbShardIterator;
+//# sourceMappingURL=sim-dynamodb-stream-shard-iterator.d.ts.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-shard-iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-shard-iterator.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-shard-iterator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAEnF;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,yBAAyB,CAAC;CAC9C;AA4CD;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,wBAAwB,GACjC,MAAM,CAER;AAED;;GAEG;AACH,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,wBAAwB,CA2B1B"}

package/dist/service/dynamodb/stream/sim-dynamodb-stream-shard-iterator.js

@@ -0,0 +1,74 @@
+import { isRecord } from "../../../util/type-guard/record.js";
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+/**
+ * The three position kinds, as a value read back out of a token has to be one
+ * of them before it is trusted.
+ */
+const positionKinds = new Set(["start", "at", "after"]);
+/**
+ * Refuse a shard iterator a request carries that this simulation never made.
+ */
+function refuse() {
+    throw new SimDynamoDbValidationException("The provided ShardIterator is not valid");
+}
+/**
+ * Read a position back out of a decoded token.
+ */
+function readPosition(value) {
+    if (!isRecord(value) || typeof value["kind"] !== "string") {
+        refuse();
+    }
+    const kind = value["kind"];
+    if (!positionKinds.has(kind)) {
+        refuse();
+    }
+    if (kind === "start") {
+        return { kind: "start" };
+    }
+    const sequenceNumber = value["sequenceNumber"];
+    if (typeof sequenceNumber !== "string") {
+        refuse();
+    }
+    return kind === "at"
+        ? { kind: "at", sequenceNumber }
+        : { kind: "after", sequenceNumber };
+}
+/**
+ * The opaque token a caller is handed to read on from a place.
+ *
+ * Real shard iterators are opaque strings a caller passes back unread, and this
+ * one is the same shape: the place it stands for travels inside it rather than
+ * in a table of handed-out iterators. That is what lets an iterator be used
+ * against the stream it names without the stream having to remember it, which
+ * is also why the 15 minute expiry is deliberately absent here rather than
+ * approximated.
+ */
+export function simDynamoDbShardIteratorToken(iterator) {
+    return Buffer.from(JSON.stringify(iterator), "utf8").toString("base64url");
+}
+/**
+ * Read the place a shard iterator a request carries stands for.
+ */
+export function readSimDynamoDbShardIteratorToken(token) {
+    if (token === undefined || token === "") {
+        throw new SimDynamoDbValidationException("GetRecords requires a ShardIterator");
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(Buffer.from(token, "base64url").toString("utf8"));
+    }
+    catch {
+        refuse();
+    }
+    if (!isRecord(decoded) ||
+        typeof decoded["streamArn"] !== "string" ||
+        typeof decoded["shardId"] !== "string") {
+        refuse();
+    }
+    return {
+        streamArn: decoded["streamArn"],
+        shardId: decoded["shardId"],
+        position: readPosition(decoded["position"]),
+    };
+}
+//# sourceMappingURL=sim-dynamodb-stream-shard-iterator.js.map

package/dist/service/dynamodb/stream/sim-dynamodb-stream-shard-iterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stream-shard-iterator.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/stream/sim-dynamodb-stream-shard-iterator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAC9D,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAY5E;;;GAGG;AACH,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;AAExD;;GAEG;AACH,SAAS,MAAM;IACb,MAAM,IAAI,8BAA8B,CACtC,yCAAyC,CAC1C,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,YAAY,CAAC,KAAc;IAClC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1D,MAAM,EAAE,CAAC;IACX,CAAC;IAED,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IAC3B,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,MAAM,EAAE,CAAC;IACX,CAAC;IAED,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;QACrB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED,MAAM,cAAc,GAAG,KAAK,CAAC,gBAAgB,CAAC,CAAC;IAC/C,IAAI,OAAO,cAAc,KAAK,QAAQ,EAAE,CAAC;QACvC,MAAM,EAAE,CAAC;IACX,CAAC;IAED,OAAO,IAAI,KAAK,IAAI;QAClB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE;QAChC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;AACxC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,6BAA6B,CAC3C,QAAkC;IAElC,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AAC7E,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iCAAiC,CAC/C,KAAyB;IAEzB,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;QACxC,MAAM,IAAI,8BAA8B,CACtC,qCAAqC,CACtC,CAAC;IACJ,CAAC;IAED,IAAI,OAAgB,CAAC;IACrB,IAAI,CAAC;QACH,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;IACzE,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,EAAE,CAAC;IACX,CAAC;IAED,IACE,CAAC,QAAQ,CAAC,OAAO,CAAC;QAClB,OAAO,OAAO,CAAC,WAAW,CAAC,KAAK,QAAQ;QACxC,OAAO,OAAO,CAAC,SAAS,CAAC,KAAK,QAAQ,EACtC,CAAC;QACD,MAAM,EAAE,CAAC;IACX,CAAC;IAED,OAAO;QACL,SAAS,EAAE,OAAO,CAAC,WAAW,CAAC;QAC/B,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC;QAC3B,QAAQ,EAAE,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;KAC5C,CAAC;AACJ,CAAC"}