@kensio/yulin 0.44.0 → 0.45.0

package/dist/service/dynamodb/table/sim-dynamodb-key-schema-element.js

@@ -0,0 +1,31 @@
+/**
+ * The key type belonging at a position in a key schema.
+ */
+function keyTypeAt(index) {
+    if (index === 0) {
+        return "HASH";
+    }
+    return "RANGE";
+}
+/**
+ * Read one key schema element, in the position the request put it in.
+ *
+ * DynamoDB takes the key schema in order: a partition key first, then a sort
+ * key when there is one. Position is the whole of it, so an element of the
+ * wrong type for where it is gets refused rather than quietly sorted out.
+ *
+ * A secondary index key schema takes the same shape the table's does, so the
+ * subject is what a refusal names rather than the rules being written twice.
+ */
+export function readSimDynamoDbKeySchemaElement(element, index, subject) {
+    const expectedKeyType = keyTypeAt(index);
+    if (element.KeyType !== expectedKeyType) {
+        throw subject.refuse(`KeySchema element ${(index + 1).toString()} is not a ` +
+            `${expectedKeyType} key type`);
+    }
+    if (element.AttributeName === undefined || element.AttributeName === "") {
+        throw subject.refuse(`the ${expectedKeyType} key element has no AttributeName`);
+    }
+    return { AttributeName: element.AttributeName, KeyType: expectedKeyType };
+}
+//# sourceMappingURL=sim-dynamodb-key-schema-element.js.map

package/dist/service/dynamodb/table/sim-dynamodb-key-schema-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-schema-element.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-key-schema-element.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,SAAS,SAAS,CAAC,KAAa;IAC9B,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QAChB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,+BAA+B,CAC7C,OAAyC,EACzC,KAAa,EACb,OAAoC;IAEpC,MAAM,eAAe,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IAEzC,IAAI,OAAO,CAAC,OAAO,KAAK,eAAe,EAAE,CAAC;QACxC,MAAM,OAAO,CAAC,MAAM,CAClB,qBAAqB,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,YAAY;YACrD,GAAG,eAAe,WAAW,CAChC,CAAC;IACJ,CAAC;IAED,IAAI,OAAO,CAAC,aAAa,KAAK,SAAS,IAAI,OAAO,CAAC,aAAa,KAAK,EAAE,EAAE,CAAC;QACxE,MAAM,OAAO,CAAC,MAAM,CAClB,OAAO,eAAe,mCAAmC,CAC1D,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,aAAa,EAAE,OAAO,EAAE,eAAe,EAAE,CAAC;AAC5E,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-key-schema-subject.d.ts

@@ -0,0 +1,31 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+/**
+ * Which KeySchema of a request a refusal is about.
+ *
+ * A CreateTable request carries one key schema for the table and one for every
+ * secondary index it declares, and all of them are read the same way. A refusal
+ * saying only "KeySchema" would leave the reader working out which of them was
+ * meant, so the subject travels with the key schema and names it.
+ */
+export declare class SimDynamoDbKeySchemaSubject {
+    /**
+     * How a message says where this key schema belongs, such as
+     * " for index byStatus". The table's own key schema needs no such words,
+     * since a request that names no index has only the one.
+     */
+    readonly owner: string;
+    private constructor();
+    /**
+     * The key schema of the table itself.
+     */
+    static table(): SimDynamoDbKeySchemaSubject;
+    /**
+     * The key schema of one secondary index.
+     */
+    static index(indexName: string): SimDynamoDbKeySchemaSubject;
+    /**
+     * Refuse this key schema for what it says, naming which one it is.
+     */
+    refuse(reason: string): SimDynamoDbValidationException;
+}
+//# sourceMappingURL=sim-dynamodb-key-schema-subject.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-key-schema-subject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-schema-subject.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-key-schema-subject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAE5E;;;;;;;GAOG;AACH,qBAAa,2BAA2B;IACtC;;;;OAIG;IACH,SAAgB,KAAK,EAAE,MAAM,CAAC;IAE9B,OAAO,eAEN;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,IAAI,2BAA2B,CAE1C;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,2BAA2B,CAE3D;IAED;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,8BAA8B,CAIrD;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-key-schema-subject.js

@@ -0,0 +1,39 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+/**
+ * Which KeySchema of a request a refusal is about.
+ *
+ * A CreateTable request carries one key schema for the table and one for every
+ * secondary index it declares, and all of them are read the same way. A refusal
+ * saying only "KeySchema" would leave the reader working out which of them was
+ * meant, so the subject travels with the key schema and names it.
+ */
+export class SimDynamoDbKeySchemaSubject {
+    /**
+     * How a message says where this key schema belongs, such as
+     * " for index byStatus". The table's own key schema needs no such words,
+     * since a request that names no index has only the one.
+     */
+    owner;
+    constructor(owner) {
+        this.owner = owner;
+    }
+    /**
+     * The key schema of the table itself.
+     */
+    static table() {
+        return new this("");
+    }
+    /**
+     * The key schema of one secondary index.
+     */
+    static index(indexName) {
+        return new this(` for index ${indexName}`);
+    }
+    /**
+     * Refuse this key schema for what it says, naming which one it is.
+     */
+    refuse(reason) {
+        return new SimDynamoDbValidationException(`Invalid KeySchema${this.owner}: ${reason}`);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-key-schema-subject.js.map

package/dist/service/dynamodb/table/sim-dynamodb-key-schema-subject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-schema-subject.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-key-schema-subject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAE5E;;;;;;;GAOG;AACH,MAAM,OAAO,2BAA2B;IACtC;;;;OAIG;IACa,KAAK,CAAS;IAE9B,YAAoB,KAAa;QAC/B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAK;QACV,OAAO,IAAI,IAAI,CAAC,EAAE,CAAC,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,SAAiB;QAC5B,OAAO,IAAI,IAAI,CAAC,cAAc,SAAS,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,MAAc;QACnB,OAAO,IAAI,8BAA8B,CACvC,oBAAoB,IAAI,CAAC,KAAK,KAAK,MAAM,EAAE,CAC5C,CAAC;IACJ,CAAC;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-key-schema.d.ts

@@ -0,0 +1,29 @@
+import type { SimDynamoDbKeySchemaElement, SimDynamoDbKeySchemaElementInput } from "../command/table/table.types.js";
+import { SimDynamoDbKeySchemaSubject } from "./sim-dynamodb-key-schema-subject.js";
+/**
+ * The key of one simulated table or one of its secondary indexes.
+ *
+ * A key schema is one HASH element, optionally followed by one RANGE element,
+ * in that order. Anything else is refused here as it is on AWS. The subject is
+ * what the key schema belongs to, so a request carrying several of them is
+ * refused naming the one that was wrong.
+ */
+export declare class SimDynamoDbKeySchema {
+    readonly elements: readonly SimDynamoDbKeySchemaElement[];
+    readonly subject: SimDynamoDbKeySchemaSubject;
+    readonly hashKeyAttributeName: string;
+    readonly rangeKeyAttributeName: string | undefined;
+    private constructor();
+    /**
+     * Read a key schema a CreateTable request carries.
+     *
+     * The subject defaults to the table's own key schema, which is the one a
+     * request always has.
+     */
+    static fromInput(input: readonly SimDynamoDbKeySchemaElementInput[] | undefined, subject?: SimDynamoDbKeySchemaSubject): SimDynamoDbKeySchema;
+    /**
+     * The attributes this key schema names, partition key first.
+     */
+    attributeNames(): readonly string[];
+}
+//# sourceMappingURL=sim-dynamodb-key-schema.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-key-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-schema.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-key-schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,2BAA2B,EAC3B,gCAAgC,EACjC,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAEnF;;;;;;;GAOG;AACH,qBAAa,oBAAoB;IAC/B,SAAgB,QAAQ,EAAE,SAAS,2BAA2B,EAAE,CAAC;IACjE,SAAgB,OAAO,EAAE,2BAA2B,CAAC;IACrD,SAAgB,oBAAoB,EAAE,MAAM,CAAC;IAC7C,SAAgB,qBAAqB,EAAE,MAAM,GAAG,SAAS,CAAC;IAE1D,OAAO,eAkBN;IAED;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CACd,KAAK,EAAE,SAAS,gCAAgC,EAAE,GAAG,SAAS,EAC9D,OAAO,GAAE,2BAAiE,GACzE,oBAAoB,CAoBtB;IAED;;OAEG;IACH,cAAc,IAAI,SAAS,MAAM,EAAE,CAElC;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-key-schema.js

@@ -0,0 +1,53 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+import { readSimDynamoDbKeySchemaElement } from "./sim-dynamodb-key-schema-element.js";
+import { SimDynamoDbKeySchemaSubject } from "./sim-dynamodb-key-schema-subject.js";
+/**
+ * The key of one simulated table or one of its secondary indexes.
+ *
+ * A key schema is one HASH element, optionally followed by one RANGE element,
+ * in that order. Anything else is refused here as it is on AWS. The subject is
+ * what the key schema belongs to, so a request carrying several of them is
+ * refused naming the one that was wrong.
+ */
+export class SimDynamoDbKeySchema {
+    elements;
+    subject;
+    hashKeyAttributeName;
+    rangeKeyAttributeName;
+    constructor(elements, subject) {
+        const [hashKey, rangeKey] = elements;
+        assertDefined(hashKey, "DynamoDB HASH key schema element");
+        const hashKeyName = hashKey.AttributeName;
+        if (rangeKey?.AttributeName === hashKeyName) {
+            throw subject.refuse(`the HASH and RANGE elements both name the attribute ${hashKeyName}`);
+        }
+        this.elements = elements;
+        this.subject = subject;
+        this.hashKeyAttributeName = hashKey.AttributeName;
+        this.rangeKeyAttributeName = rangeKey?.AttributeName;
+    }
+    /**
+     * Read a key schema a CreateTable request carries.
+     *
+     * The subject defaults to the table's own key schema, which is the one a
+     * request always has.
+     */
+    static fromInput(input, subject = SimDynamoDbKeySchemaSubject.table()) {
+        if (input === undefined || input.length === 0) {
+            throw new SimDynamoDbValidationException(`A KeySchema with a HASH key element is required${subject.owner}`);
+        }
+        if (input.length > 2) {
+            throw subject.refuse(`a key schema holds a HASH element and at most one RANGE element, ` +
+                `but ${input.length.toString()} elements were given`);
+        }
+        return new this(input.map((element, index) => readSimDynamoDbKeySchemaElement(element, index, subject)), subject);
+    }
+    /**
+     * The attributes this key schema names, partition key first.
+     */
+    attributeNames() {
+        return this.elements.map((element) => element.AttributeName);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-key-schema.js.map

package/dist/service/dynamodb/table/sim-dynamodb-key-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-schema.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-key-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAKpE,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,EAAE,+BAA+B,EAAE,MAAM,sCAAsC,CAAC;AACvF,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAEnF;;;;;;;GAOG;AACH,MAAM,OAAO,oBAAoB;IACf,QAAQ,CAAyC;IACjD,OAAO,CAA8B;IACrC,oBAAoB,CAAS;IAC7B,qBAAqB,CAAqB;IAE1D,YACE,QAAgD,EAChD,OAAoC;QAEpC,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAC;QACrC,aAAa,CAAC,OAAO,EAAE,kCAAkC,CAAC,CAAC;QAC3D,MAAM,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;QAE1C,IAAI,QAAQ,EAAE,aAAa,KAAK,WAAW,EAAE,CAAC;YAC5C,MAAM,OAAO,CAAC,MAAM,CAClB,uDAAuD,WAAW,EAAE,CACrE,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,oBAAoB,GAAG,OAAO,CAAC,aAAa,CAAC;QAClD,IAAI,CAAC,qBAAqB,GAAG,QAAQ,EAAE,aAAa,CAAC;IACvD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CACd,KAA8D,EAC9D,OAAO,GAAgC,2BAA2B,CAAC,KAAK,EAAE;QAE1E,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9C,MAAM,IAAI,8BAA8B,CACtC,kDAAkD,OAAO,CAAC,KAAK,EAAE,CAClE,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACrB,MAAM,OAAO,CAAC,MAAM,CAClB,mEAAmE;gBACjE,OAAO,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,sBAAsB,CACvD,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,IAAI,CACb,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAC3B,+BAA+B,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,CACzD,EACD,OAAO,CACR,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;IAC/D,CAAC;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-partition-key-hash.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The hash of a marshalled partition key value.
+ *
+ * Two things read this. A scan walks partition key values in hash order, which
+ * is an order that is stable within a process and is not the sorted one. A
+ * parallel scan puts a partition key value in a segment by the same hash, so
+ * every item sharing a partition key lands in the same segment.
+ *
+ * Real DynamoDB hashes the partition key to decide which physical partition an
+ * item lives on, and both of those follow from that. The hash itself is not
+ * DynamoDB's, which is unpublished, so the segment an item lands in here is not
+ * the segment it lands in on AWS. What matches is the shape: whole item
+ * collections move together, and segments come out uneven.
+ */
+export declare function simDynamoDbPartitionKeyHash(partitionKey: string): number;
+//# sourceMappingURL=sim-dynamodb-partition-key-hash.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-partition-key-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-partition-key-hash.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-partition-key-hash.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAOxE"}

package/dist/service/dynamodb/table/sim-dynamodb-partition-key-hash.js

@@ -0,0 +1,23 @@
+/**
+ * The offset basis and prime of 32 bit FNV-1a.
+ */
+const offsetBasis = 2_166_136_261;
+const prime = 16_777_619;
+/**
+ * The hash of a marshalled partition key value.
+ *
+ * Two things read this. A scan walks partition key values in hash order, which
+ * is an order that is stable within a process and is not the sorted one. A
+ * parallel scan puts a partition key value in a segment by the same hash, so
+ * every item sharing a partition key lands in the same segment.
+ *
+ * Real DynamoDB hashes the partition key to decide which physical partition an
+ * item lives on, and both of those follow from that. The hash itself is not
+ * DynamoDB's, which is unpublished, so the segment an item lands in here is not
+ * the segment it lands in on AWS. What matches is the shape: whole item
+ * collections move together, and segments come out uneven.
+ */
+export function simDynamoDbPartitionKeyHash(partitionKey) {
+    return (Buffer.from(partitionKey, "utf8").reduce((hash, byte) => Math.imul(hash ^ byte, prime), offsetBasis) >>> 0);
+}
+//# sourceMappingURL=sim-dynamodb-partition-key-hash.js.map

package/dist/service/dynamodb/table/sim-dynamodb-partition-key-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-partition-key-hash.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-partition-key-hash.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,GAAG,aAAa,CAAC;AAClC,MAAM,KAAK,GAAG,UAAU,CAAC;AAEzB;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,2BAA2B,CAAC,YAAoB;IAC9D,OAAO,CACL,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,MAAM,CACtC,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,EAAE,KAAK,CAAC,EAC7C,WAAW,CACZ,KAAK,CAAC,CACR,CAAC;AACJ,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-primary-key.d.ts

@@ -0,0 +1,16 @@
+import type { SimDynamoDbAttributeValue } from "../command/item/item.types.js";
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbKeySchema } from "./sim-dynamodb-key-schema.js";
+/**
+ * The primary key of a stored item, as the attribute values a pagination token
+ * carries.
+ *
+ * `LastEvaluatedKey` is the primary key of the item a walk stopped on, and the
+ * `ExclusiveStartKey` of the next request is the same thing read back, so it is
+ * written here once for whatever hands out a page.
+ *
+ * Every item in a table carries its key attributes. A write that left one out
+ * was refused, so the value is there by the time an item is stored.
+ */
+export declare function simDynamoDbPrimaryKeyAttributes(item: SimDynamoDbItem, keySchema: SimDynamoDbKeySchema): Record<string, SimDynamoDbAttributeValue>;
+//# sourceMappingURL=sim-dynamodb-primary-key.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-primary-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-primary-key.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-primary-key.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEzE;;;;;;;;;;GAUG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,eAAe,EACrB,SAAS,EAAE,oBAAoB,GAC9B,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAU3C"}

package/dist/service/dynamodb/table/sim-dynamodb-primary-key.js

@@ -0,0 +1,21 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { writeSimDynamoDbValue } from "../item/sim-dynamodb-value-writer.js";
+/**
+ * The primary key of a stored item, as the attribute values a pagination token
+ * carries.
+ *
+ * `LastEvaluatedKey` is the primary key of the item a walk stopped on, and the
+ * `ExclusiveStartKey` of the next request is the same thing read back, so it is
+ * written here once for whatever hands out a page.
+ *
+ * Every item in a table carries its key attributes. A write that left one out
+ * was refused, so the value is there by the time an item is stored.
+ */
+export function simDynamoDbPrimaryKeyAttributes(item, keySchema) {
+    return Object.fromEntries(keySchema.attributeNames().map((attributeName) => {
+        const value = item.attribute(attributeName);
+        assertDefined(value, `key attribute ${attributeName} of a stored item`);
+        return [attributeName, writeSimDynamoDbValue(value)];
+    }));
+}
+//# sourceMappingURL=sim-dynamodb-primary-key.js.map

package/dist/service/dynamodb/table/sim-dynamodb-primary-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-primary-key.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-primary-key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAGpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAG7E;;;;;;;;;;GAUG;AACH,MAAM,UAAU,+BAA+B,CAC7C,IAAqB,EACrB,SAA+B;IAE/B,OAAO,MAAM,CAAC,WAAW,CACvB,SAAS,CAAC,cAAc,EAAE,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE;QAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAE5C,aAAa,CAAC,KAAK,EAAE,iBAAiB,aAAa,mBAAmB,CAAC,CAAC;QAExE,OAAO,CAAC,aAAa,EAAE,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC;IACvD,CAAC,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-scan-position.d.ts

@@ -0,0 +1,46 @@
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbScanSegment } from "./sim-dynamodb-scan-segment.js";
+import type { SimDynamoDbSortKeyOrder } from "./sim-dynamodb-sort-key-order.js";
+interface SimDynamoDbScanPositionProperties {
+    readonly item: SimDynamoDbItem;
+    readonly partitionKey: string;
+    readonly sortKeyOrder: SimDynamoDbSortKeyOrder;
+}
+/**
+ * Where one item sits in the order a scan walks a table in.
+ *
+ * The order is by the hash of the partition key first, then by sort key inside
+ * one partition key value. That gives two things a scan needs. Items under one
+ * partition key come back together and ascending, as they do on AWS. Partition
+ * key values come back in an order that is not the sorted one, so a test cannot
+ * quietly come to depend on a global ordering that real DynamoDB does not give.
+ *
+ * The order has to be a total order all the same, otherwise an
+ * `ExclusiveStartKey` could not say where to resume from. Partition key values
+ * that hash alike are ordered by their marshalled bytes to settle that.
+ *
+ * A position is also worked out for the Key a request resumes after, which is
+ * why it is built from a key and a sort key order rather than read off a stored
+ * item: the item the token names may since have been deleted.
+ */
+export declare class SimDynamoDbScanPosition {
+    readonly item: SimDynamoDbItem;
+    private readonly partitionKey;
+    private readonly hash;
+    private readonly sortKeyOrder;
+    constructor(properties: SimDynamoDbScanPositionProperties);
+    /**
+     * Whether a parallel scan segment holds this item.
+     */
+    inSegment(segment: SimDynamoDbScanSegment): boolean;
+    /**
+     * Order this position against another position in the same table.
+     */
+    compareTo(other: SimDynamoDbScanPosition): number;
+    /**
+     * Order two partition key values, by their hash and then by their bytes.
+     */
+    private comparePartitions;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-scan-position.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-scan-position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-scan-position.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-scan-position.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAEhF,UAAU,iCAAiC;IACzC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,uBAAuB,CAAC;CAChD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,uBAAuB;IAClC,SAAgB,IAAI,EAAE,eAAe,CAAC;IAEtC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0B;IAEvD,YAAY,UAAU,EAAE,iCAAiC,EAKxD;IAED;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAElD;IAED;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,uBAAuB,GAAG,MAAM,CAQhD;IAED;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAU1B"}

package/dist/service/dynamodb/table/sim-dynamodb-scan-position.js

@@ -0,0 +1,57 @@
+import { compareSimDynamoDbBytes } from "../item/sim-dynamodb-value-order.js";
+import { simDynamoDbPartitionKeyHash } from "./sim-dynamodb-partition-key-hash.js";
+/**
+ * Where one item sits in the order a scan walks a table in.
+ *
+ * The order is by the hash of the partition key first, then by sort key inside
+ * one partition key value. That gives two things a scan needs. Items under one
+ * partition key come back together and ascending, as they do on AWS. Partition
+ * key values come back in an order that is not the sorted one, so a test cannot
+ * quietly come to depend on a global ordering that real DynamoDB does not give.
+ *
+ * The order has to be a total order all the same, otherwise an
+ * `ExclusiveStartKey` could not say where to resume from. Partition key values
+ * that hash alike are ordered by their marshalled bytes to settle that.
+ *
+ * A position is also worked out for the Key a request resumes after, which is
+ * why it is built from a key and a sort key order rather than read off a stored
+ * item: the item the token names may since have been deleted.
+ */
+export class SimDynamoDbScanPosition {
+    item;
+    partitionKey;
+    hash;
+    sortKeyOrder;
+    constructor(properties) {
+        this.item = properties.item;
+        this.partitionKey = properties.partitionKey;
+        this.hash = simDynamoDbPartitionKeyHash(properties.partitionKey);
+        this.sortKeyOrder = properties.sortKeyOrder;
+    }
+    /**
+     * Whether a parallel scan segment holds this item.
+     */
+    inSegment(segment) {
+        return segment.holds(this.partitionKey);
+    }
+    /**
+     * Order this position against another position in the same table.
+     */
+    compareTo(other) {
+        const partitions = this.comparePartitions(other);
+        if (partitions !== 0) {
+            return partitions;
+        }
+        return this.sortKeyOrder.compareItems(this.item, other.item);
+    }
+    /**
+     * Order two partition key values, by their hash and then by their bytes.
+     */
+    comparePartitions(other) {
+        if (this.hash !== other.hash) {
+            return this.hash - other.hash;
+        }
+        return compareSimDynamoDbBytes(Buffer.from(this.partitionKey, "utf8"), Buffer.from(other.partitionKey, "utf8"));
+    }
+}
+//# sourceMappingURL=sim-dynamodb-scan-position.js.map

package/dist/service/dynamodb/table/sim-dynamodb-scan-position.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-scan-position.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-scan-position.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAC9E,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAUnF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,uBAAuB;IAClB,IAAI,CAAkB;IAErB,YAAY,CAAS;IACrB,IAAI,CAAS;IACb,YAAY,CAA0B;IAEvD,YAAY,UAA6C;QACvD,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAC5B,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;QAC5C,IAAI,CAAC,IAAI,GAAG,2BAA2B,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;QACjE,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,OAA+B;QACvC,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,KAA8B;QACtC,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAEjD,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;YACrB,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,OAAO,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;IAC/D,CAAC;IAED;;OAEG;IACK,iBAAiB,CAAC,KAA8B;QACtD,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QAChC,CAAC;QAED,OAAO,uBAAuB,CAC5B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,EACtC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,MAAM,CAAC,CACxC,CAAC;IACJ,CAAC;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-scan-segment.d.ts

@@ -0,0 +1,37 @@
+interface SimDynamoDbScanSegmentProperties {
+    readonly index: number;
+    readonly totalSegments: number;
+}
+/**
+ * One segment of a parallel scan.
+ *
+ * A segment is a share of the table's partition key values rather than a share
+ * of its items. Every item under one partition key belongs to one segment, so a
+ * segment holds whole item collections, and two segments of the same table can
+ * hold very different numbers of items. A segment holding nothing at all is
+ * ordinary rather than a failure.
+ *
+ * There is no concurrency to gain here, since a simulated scan walks a map in
+ * memory. What a segment models is the caller's side of a parallel scan: code
+ * that divides a table between workers can be run against a simulated table.
+ */
+export declare class SimDynamoDbScanSegment {
+    /** The zero based number of this segment. */
+    readonly index: number;
+    /** How many segments the table is divided into. */
+    readonly totalSegments: number;
+    constructor(properties: SimDynamoDbScanSegmentProperties);
+    /**
+     * The whole table as one segment, which is what a sequential scan reads.
+     */
+    static whole(): SimDynamoDbScanSegment;
+    /**
+     * Whether this segment holds the items under a marshalled partition key.
+     *
+     * A `TotalSegments` of 1 holds everything, which is what makes a parallel
+     * scan of one segment the same read as a sequential scan.
+     */
+    holds(partitionKey: string): boolean;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-scan-segment.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-scan-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-scan-segment.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-scan-segment.ts"],"names":[],"mappings":"AAQA,UAAU,gCAAgC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAsB;IACjC,6CAA6C;IAC7C,SAAgB,KAAK,EAAE,MAAM,CAAC;IAE9B,mDAAmD;IACnD,SAAgB,aAAa,EAAE,MAAM,CAAC;IAEtC,YAAY,UAAU,EAAE,gCAAgC,EAMvD;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,IAAI,sBAAsB,CAErC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAKnC;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-scan-segment.js

@@ -0,0 +1,69 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+import { simDynamoDbPartitionKeyHash } from "./sim-dynamodb-partition-key-hash.js";
+/**
+ * The most segments a parallel scan can be divided into, as on AWS.
+ */
+const greatestTotalSegments = 1_000_000;
+/**
+ * One segment of a parallel scan.
+ *
+ * A segment is a share of the table's partition key values rather than a share
+ * of its items. Every item under one partition key belongs to one segment, so a
+ * segment holds whole item collections, and two segments of the same table can
+ * hold very different numbers of items. A segment holding nothing at all is
+ * ordinary rather than a failure.
+ *
+ * There is no concurrency to gain here, since a simulated scan walks a map in
+ * memory. What a segment models is the caller's side of a parallel scan: code
+ * that divides a table between workers can be run against a simulated table.
+ */
+export class SimDynamoDbScanSegment {
+    /** The zero based number of this segment. */
+    index;
+    /** How many segments the table is divided into. */
+    totalSegments;
+    constructor(properties) {
+        assertTotalSegments(properties.totalSegments);
+        assertIndex(properties.index, properties.totalSegments);
+        this.index = properties.index;
+        this.totalSegments = properties.totalSegments;
+    }
+    /**
+     * The whole table as one segment, which is what a sequential scan reads.
+     */
+    static whole() {
+        return new this({ index: 0, totalSegments: 1 });
+    }
+    /**
+     * Whether this segment holds the items under a marshalled partition key.
+     *
+     * A `TotalSegments` of 1 holds everything, which is what makes a parallel
+     * scan of one segment the same read as a sequential scan.
+     */
+    holds(partitionKey) {
+        return (simDynamoDbPartitionKeyHash(partitionKey) % this.totalSegments ===
+            this.index);
+    }
+}
+/**
+ * Refuse a `TotalSegments` outside the range a parallel scan takes.
+ */
+function assertTotalSegments(totalSegments) {
+    if (!Number.isSafeInteger(totalSegments) ||
+        totalSegments < 1 ||
+        totalSegments > greatestTotalSegments) {
+        throw new SimDynamoDbValidationException(`TotalSegments ${totalSegments.toString()} is invalid. It is a whole ` +
+            `number between 1 and ${greatestTotalSegments.toString()}.`);
+    }
+}
+/**
+ * Refuse a `Segment` that names no segment of the division asked for.
+ */
+function assertIndex(index, totalSegments) {
+    if (!Number.isSafeInteger(index) || index < 0 || index >= totalSegments) {
+        throw new SimDynamoDbValidationException(`Segment ${index.toString()} is invalid. It is zero based, so it is a ` +
+            `whole number between 0 and ${(totalSegments - 1).toString()} for a ` +
+            `TotalSegments of ${totalSegments.toString()}.`);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-scan-segment.js.map

package/dist/service/dynamodb/table/sim-dynamodb-scan-segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-scan-segment.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-scan-segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAEnF;;GAEG;AACH,MAAM,qBAAqB,GAAG,SAAS,CAAC;AAOxC;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,sBAAsB;IACjC,6CAA6C;IAC7B,KAAK,CAAS;IAE9B,mDAAmD;IACnC,aAAa,CAAS;IAEtC,YAAY,UAA4C;QACtD,mBAAmB,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;QAC9C,WAAW,CAAC,UAAU,CAAC,KAAK,EAAE,UAAU,CAAC,aAAa,CAAC,CAAC;QAExD,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAK;QACV,OAAO,IAAI,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,CAAC;IAClD,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAoB;QACxB,OAAO,CACL,2BAA2B,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,aAAa;YAC9D,IAAI,CAAC,KAAK,CACX,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,SAAS,mBAAmB,CAAC,aAAqB;IAChD,IACE,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC;QACpC,aAAa,GAAG,CAAC;QACjB,aAAa,GAAG,qBAAqB,EACrC,CAAC;QACD,MAAM,IAAI,8BAA8B,CACtC,iBAAiB,aAAa,CAAC,QAAQ,EAAE,6BAA6B;YACpE,wBAAwB,qBAAqB,CAAC,QAAQ,EAAE,GAAG,CAC9D,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,WAAW,CAAC,KAAa,EAAE,aAAqB;IACvD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,aAAa,EAAE,CAAC;QACxE,MAAM,IAAI,8BAA8B,CACtC,WAAW,KAAK,CAAC,QAAQ,EAAE,4CAA4C;YACrE,8BAA8B,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,SAAS;YACrE,oBAAoB,aAAa,CAAC,QAAQ,EAAE,GAAG,CAClD,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-sort-key-order.d.ts

@@ -0,0 +1,53 @@
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbValue } from "../item/sim-dynamodb-value.js";
+/**
+ * The order a table's sort key puts an item collection in.
+ *
+ * A table with no sort key holds at most one item under a partition key, so
+ * every question here has a trivial answer for one. That is why the attribute
+ * name is optional rather than each caller asking whether there is one.
+ *
+ * The order is DynamoDB's rather than JavaScript's, through
+ * `compareSimDynamoDbValues`: numbers order by value however they were written,
+ * strings by their UTF-8 bytes, and binary as unsigned bytes.
+ */
+export declare class SimDynamoDbSortKeyOrder {
+    private readonly attributeName;
+    constructor(attributeName: string | undefined);
+    /**
+     * The sort key of an item, or nothing when the table has no sort key.
+     */
+    valueOf(item: SimDynamoDbItem): SimDynamoDbValue | undefined;
+    /**
+     * Items in ascending sort key order.
+     */
+    ascending(items: readonly SimDynamoDbItem[]): readonly SimDynamoDbItem[];
+    /**
+     * The items past the one a request resumes after, in the walk direction.
+     *
+     * With no sort key a collection holds one item, and that is the item the
+     * token names, so nothing comes after it.
+     */
+    beyond(items: readonly SimDynamoDbItem[], after: SimDynamoDbItem, forward: boolean): readonly SimDynamoDbItem[];
+    /**
+     * Order two items of one table by their sort keys.
+     *
+     * With no sort key a partition key value names at most one item, so two items
+     * that reach here are the same item and nothing separates them. A scan orders
+     * a whole table this way once it has ordered by partition key.
+     */
+    compareItems(first: SimDynamoDbItem, second: SimDynamoDbItem): number;
+    /**
+     * Which way along the sort key the walk is going.
+     */
+    private direction;
+    /**
+     * Order two items by their sort keys.
+     *
+     * Two items in one table always order: the table checks the type of every key
+     * attribute on the way in, so no collection holds two sort keys of different
+     * types.
+     */
+    private compare;
+}
+//# sourceMappingURL=sim-dynamodb-sort-key-order.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-sort-key-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-sort-key-order.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-sort-key-order.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEtE;;;;;;;;;;GAUG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IAEnD,YAAY,aAAa,EAAE,MAAM,GAAG,SAAS,EAE5C;IAED;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,eAAe,GAAG,gBAAgB,GAAG,SAAS,CAQ3D;IAED;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,eAAe,EAAE,CAUvE;IAED;;;;;OAKG;IACH,MAAM,CACJ,KAAK,EAAE,SAAS,eAAe,EAAE,EACjC,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE,OAAO,GACf,SAAS,eAAe,EAAE,CAY5B;IAED;;;;;;OAMG;IACH,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,eAAe,GAAG,MAAM,CAQpE;IAED;;OAEG;IACH,OAAO,CAAC,SAAS;IAQjB;;;;;;OAMG;IACH,OAAO,CAAC,OAAO;CAchB"}