@kensio/yulin 0.43.0 → 0.45.0

package/dist/service/dynamodb/table/sim-dynamodb-attribute-definitions.d.ts

@@ -0,0 +1,35 @@
+import type { SimDynamoDbAttributeDefinition, SimDynamoDbAttributeDefinitionInput, SimDynamoDbScalarAttributeType } from "../command/table/table.types.js";
+import type { SimDynamoDbKeySchema } from "./sim-dynamodb-key-schema.js";
+/**
+ * The attributes a simulated table's keys are made of.
+ *
+ * DynamoDB only defines the attributes its keys use, and it wants them named
+ * exactly: an attribute defined that no key uses is refused, and so is a key
+ * attribute with no definition. Everything else about an item is schemaless.
+ */
+export declare class SimDynamoDbAttributeDefinitions {
+    readonly elements: readonly SimDynamoDbAttributeDefinition[];
+    private constructor();
+    /**
+     * Read the attribute definitions a CreateTable request carries.
+     */
+    static fromInput(input: readonly SimDynamoDbAttributeDefinitionInput[] | undefined): SimDynamoDbAttributeDefinitions;
+    /**
+     * The type declared for an attribute.
+     *
+     * Every key attribute has a definition by the time a table exists, since
+     * CreateTable refuses a key schema and definitions that do not match.
+     */
+    typeOf(attributeName: string): SimDynamoDbScalarAttributeType;
+    /**
+     * Check these definitions and the key schemas using them name exactly the
+     * same attributes.
+     *
+     * Every key schema a request carries takes part: the table's own, and one for
+     * each secondary index. Declaring an index whose key attribute has no
+     * definition is the mistake this catches, and it is where CreateTable input
+     * most often goes wrong.
+     */
+    assertMatches(keySchemas: readonly SimDynamoDbKeySchema[]): void;
+}
+//# sourceMappingURL=sim-dynamodb-attribute-definitions.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-attribute-definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-attribute-definitions.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-attribute-definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,8BAA8B,EAC9B,mCAAmC,EACnC,8BAA8B,EAC/B,MAAM,iCAAiC,CAAC;AAGzC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AA+BzE;;;;;;GAMG;AACH,qBAAa,+BAA+B;IAC1C,SAAgB,QAAQ,EAAE,SAAS,8BAA8B,EAAE,CAAC;IAEpE,OAAO,eAEN;IAED;;OAEG;IACH,MAAM,CAAC,SAAS,CACd,KAAK,EAAE,SAAS,mCAAmC,EAAE,GAAG,SAAS,GAChE,+BAA+B,CAiBjC;IAED;;;;;OAKG;IACH,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,8BAA8B,CAQ5D;IAED;;;;;;;;OAQG;IACH,aAAa,CAAC,UAAU,EAAE,SAAS,oBAAoB,EAAE,GAAG,IAAI,CA2B/D;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-attribute-definitions.js

@@ -0,0 +1,87 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+const scalarAttributeTypes = new Set(["S", "N", "B"]);
+/**
+ * Read one attribute definition a request carries.
+ */
+function attributeDefinition(definition) {
+    const { AttributeName: name, AttributeType: type } = definition;
+    if (name === undefined || name === "") {
+        throw new SimDynamoDbValidationException("An AttributeDefinition has no AttributeName");
+    }
+    if (type === undefined || !scalarAttributeTypes.has(type)) {
+        throw new SimDynamoDbValidationException(`AttributeDefinition for ${name} has AttributeType '${type ?? ""}'. A ` +
+            `key attribute is one of S, N or B.`);
+    }
+    return {
+        AttributeName: name,
+        AttributeType: type,
+    };
+}
+/**
+ * The attributes a simulated table's keys are made of.
+ *
+ * DynamoDB only defines the attributes its keys use, and it wants them named
+ * exactly: an attribute defined that no key uses is refused, and so is a key
+ * attribute with no definition. Everything else about an item is schemaless.
+ */
+export class SimDynamoDbAttributeDefinitions {
+    elements;
+    constructor(elements) {
+        this.elements = elements;
+    }
+    /**
+     * Read the attribute definitions a CreateTable request carries.
+     */
+    static fromInput(input) {
+        if (input === undefined || input.length === 0) {
+            throw new SimDynamoDbValidationException("An AttributeDefinitions entry is required for every key attribute");
+        }
+        const elements = input.map((definition) => attributeDefinition(definition));
+        const names = new Set(elements.map((element) => element.AttributeName));
+        if (names.size !== elements.length) {
+            throw new SimDynamoDbValidationException("AttributeDefinitions names an attribute more than once");
+        }
+        return new this(elements);
+    }
+    /**
+     * The type declared for an attribute.
+     *
+     * Every key attribute has a definition by the time a table exists, since
+     * CreateTable refuses a key schema and definitions that do not match.
+     */
+    typeOf(attributeName) {
+        const definition = this.elements.find((element) => element.AttributeName === attributeName);
+        assertDefined(definition, `AttributeDefinition for ${attributeName}`);
+        return definition.AttributeType;
+    }
+    /**
+     * Check these definitions and the key schemas using them name exactly the
+     * same attributes.
+     *
+     * Every key schema a request carries takes part: the table's own, and one for
+     * each secondary index. Declaring an index whose key attribute has no
+     * definition is the mistake this catches, and it is where CreateTable input
+     * most often goes wrong.
+     */
+    assertMatches(keySchemas) {
+        const definedNames = new Set(this.elements.map((element) => element.AttributeName));
+        const keyNames = new Set();
+        for (const keySchema of keySchemas) {
+            for (const keyName of keySchema.attributeNames()) {
+                keyNames.add(keyName);
+                if (!definedNames.has(keyName)) {
+                    throw new SimDynamoDbValidationException(`The KeySchema${keySchema.subject.owner} names the attribute ` +
+                        `${keyName}, which has no AttributeDefinition`);
+                }
+            }
+        }
+        for (const definedName of definedNames) {
+            if (!keyNames.has(definedName)) {
+                throw new SimDynamoDbValidationException(`AttributeDefinitions defines the attribute ${definedName}, which ` +
+                    `no key uses`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=sim-dynamodb-attribute-definitions.js.map

package/dist/service/dynamodb/table/sim-dynamodb-attribute-definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-attribute-definitions.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-attribute-definitions.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAG5E,MAAM,oBAAoB,GAAwB,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAE3E;;GAEG;AACH,SAAS,mBAAmB,CAC1B,UAA+C;IAE/C,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC;IAEhE,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,8BAA8B,CACtC,6CAA6C,CAC9C,CAAC;IACJ,CAAC;IAED,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1D,MAAM,IAAI,8BAA8B,CACtC,2BAA2B,IAAI,uBAAuB,IAAI,IAAI,EAAE,OAAO;YACrE,oCAAoC,CACvC,CAAC;IACJ,CAAC;IAED,OAAO;QACL,aAAa,EAAE,IAAI;QACnB,aAAa,EAAE,IAAsC;KACtD,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,OAAO,+BAA+B;IAC1B,QAAQ,CAA4C;IAEpE,YAAoB,QAAmD;QACrE,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,SAAS,CACd,KAAiE;QAEjE,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9C,MAAM,IAAI,8BAA8B,CACtC,mEAAmE,CACpE,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC,CAAC;QAC5E,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC;QAExE,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC;YACnC,MAAM,IAAI,8BAA8B,CACtC,wDAAwD,CACzD,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,aAAqB;QAC1B,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CACnC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,aAAa,KAAK,aAAa,CACrD,CAAC;QAEF,aAAa,CAAC,UAAU,EAAE,2BAA2B,aAAa,EAAE,CAAC,CAAC;QAEtE,OAAO,UAAU,CAAC,aAAa,CAAC;IAClC,CAAC;IAED;;;;;;;;OAQG;IACH,aAAa,CAAC,UAA2C;QACvD,MAAM,YAAY,GAAG,IAAI,GAAG,CAC1B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,CACtD,CAAC;QACF,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;QAEnC,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,KAAK,MAAM,OAAO,IAAI,SAAS,CAAC,cAAc,EAAE,EAAE,CAAC;gBACjD,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAEtB,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;oBAC/B,MAAM,IAAI,8BAA8B,CACtC,gBAAgB,SAAS,CAAC,OAAO,CAAC,KAAK,uBAAuB;wBAC5D,GAAG,OAAO,oCAAoC,CACjD,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAED,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;YACvC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;gBAC/B,MAAM,IAAI,8BAA8B,CACtC,8CAA8C,WAAW,UAAU;oBACjE,aAAa,CAChB,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-collection-table.factory.d.ts

@@ -0,0 +1,31 @@
+import { AsyncMappedFactory } from "@kensio/part-factory";
+import type { SimAws } from "../../aws/sim-aws.js";
+import type { SimDynamoDbScalarAttributeType } from "../command/table/table.types.js";
+import type { SimDynamoDbTable } from "./sim-dynamodb-table.js";
+/**
+ * What a test asks for when it wants a table whose items form collections.
+ */
+export interface SimDynamoDbCollectionTableInput {
+    readonly tableName: string;
+    readonly partitionKeyName: string;
+    readonly sortKeyName: string;
+    readonly sortKeyType: SimDynamoDbScalarAttributeType;
+}
+/**
+ * Creates a table with both a partition key and a sort key, through CreateTable.
+ *
+ * A sort key is what makes several items one item collection, so this is the
+ * table a Query reads. Use `simDynamoDbCreatedTableFactory` for a table keyed
+ * by partition key alone, which holds at most one item under each key.
+ *
+ * The table is ACTIVE by the time this answers, the same way it is there.
+ *
+ * ```typescript
+ * const table = await simDynamoDbCollectionTableFactory.make(
+ *   { tableName: "OrdersTable", partitionKeyName: "customerId" },
+ *   simAws,
+ * );
+ * ```
+ */
+export declare const simDynamoDbCollectionTableFactory: AsyncMappedFactory<SimDynamoDbCollectionTableInput, SimDynamoDbTable, SimAws>;
+//# sourceMappingURL=sim-dynamodb-collection-table.factory.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-collection-table.factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-collection-table.factory.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-collection-table.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AACtF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,8BAA8B,CAAC;CACtD;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iCAAiC,+EA4C7C,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-collection-table.factory.js

@@ -0,0 +1,51 @@
+import { AsyncMappedFactory } from "@kensio/part-factory";
+import { assertDefined } from "../../../util/type-guard/defined.js";
+/**
+ * Creates a table with both a partition key and a sort key, through CreateTable.
+ *
+ * A sort key is what makes several items one item collection, so this is the
+ * table a Query reads. Use `simDynamoDbCreatedTableFactory` for a table keyed
+ * by partition key alone, which holds at most one item under each key.
+ *
+ * The table is ACTIVE by the time this answers, the same way it is there.
+ *
+ * ```typescript
+ * const table = await simDynamoDbCollectionTableFactory.make(
+ *   { tableName: "OrdersTable", partitionKeyName: "customerId" },
+ *   simAws,
+ * );
+ * ```
+ */
+export const simDynamoDbCollectionTableFactory = new AsyncMappedFactory(() => ({
+    tableName: "OrdersTable",
+    partitionKeyName: "customerId",
+    sortKeyName: "orderId",
+    sortKeyType: "S",
+}), async (input, simAws) => {
+    const simDynamoDb = simAws.dynamoDb();
+    await simDynamoDb.createTable({
+        input: {
+            TableName: input.tableName,
+            KeySchema: [
+                { AttributeName: input.partitionKeyName, KeyType: "HASH" },
+                { AttributeName: input.sortKeyName, KeyType: "RANGE" },
+            ],
+            AttributeDefinitions: [
+                { AttributeName: input.partitionKeyName, AttributeType: "S" },
+                {
+                    AttributeName: input.sortKeyName,
+                    AttributeType: input.sortKeyType,
+                },
+            ],
+            BillingMode: "PAY_PER_REQUEST",
+        },
+    });
+    await simAws.backgroundTasksComplete();
+    // A name CreateTable accepted is a table the store holds, so this is only
+    // missing if something is wrong with the simulator itself.
+    const table = simDynamoDb.findTable(input.tableName);
+    assertDefined(table, `Simulated DynamoDB created the table ${input.tableName} and then did ` +
+        `not hold it`);
+    return table;
+});
+//# sourceMappingURL=sim-dynamodb-collection-table.factory.js.map

package/dist/service/dynamodb/table/sim-dynamodb-collection-table.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-collection-table.factory.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-collection-table.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAepE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,IAAI,kBAAkB,CAKrE,GAAG,EAAE,CAAC,CAAC;IACL,SAAS,EAAE,aAAa;IACxB,gBAAgB,EAAE,YAAY;IAC9B,WAAW,EAAE,SAAS;IACtB,WAAW,EAAE,GAAG;CACjB,CAAC,EACF,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;IACtB,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;IAEtC,MAAM,WAAW,CAAC,WAAW,CAAC;QAC5B,KAAK,EAAE;YACL,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS,EAAE;gBACT,EAAE,aAAa,EAAE,KAAK,CAAC,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE;gBAC1D,EAAE,aAAa,EAAE,KAAK,CAAC,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE;aACvD;YACD,oBAAoB,EAAE;gBACpB,EAAE,aAAa,EAAE,KAAK,CAAC,gBAAgB,EAAE,aAAa,EAAE,GAAG,EAAE;gBAC7D;oBACE,aAAa,EAAE,KAAK,CAAC,WAAW;oBAChC,aAAa,EAAE,KAAK,CAAC,WAAW;iBACjC;aACF;YACD,WAAW,EAAE,iBAAiB;SAC/B;KACF,CAAC,CAAC;IACH,MAAM,MAAM,CAAC,uBAAuB,EAAE,CAAC;IAEvC,0EAA0E;IAC1E,2DAA2D;IAC3D,MAAM,KAAK,GAAG,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IACrD,aAAa,CACX,KAAK,EACL,wCAAwC,KAAK,CAAC,SAAS,gBAAgB;QACrE,aAAa,CAChB,CAAC;IAEF,OAAO,KAAK,CAAC;AACf,CAAC,CACF,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-created-table.factory.d.ts

@@ -0,0 +1,43 @@
+import { AsyncMappedFactory } from "@kensio/part-factory";
+import type { SimAws } from "../../aws/sim-aws.js";
+import type { SimDynamoDbBillingMode, SimDynamoDbScalarAttributeType } from "../command/table/table.types.js";
+import type { SimDynamoDbTable } from "./sim-dynamodb-table.js";
+/**
+ * What a test asks for when it wants a table to work on.
+ *
+ * A table is mostly its name and its key, and the rest of a CreateTable request
+ * is the same every time. Naming the key as one attribute rather than as a key
+ * schema and a matching attribute definition is what makes a table one line
+ * here.
+ */
+export interface SimDynamoDbCreatedTableInput {
+    readonly tableName: string;
+    readonly partitionKeyName: string;
+    readonly partitionKeyType: SimDynamoDbScalarAttributeType;
+    readonly billingMode: SimDynamoDbBillingMode;
+}
+/**
+ * Creates a table a simulated DynamoDB knows about, through CreateTable.
+ *
+ * This is the table an application would have: it went through the ordinary
+ * command, so it was checked the way a real request is checked. Use
+ * `simDynamoDbTableFactory` instead for a table on its own, with no simulated
+ * DynamoDB holding it.
+ *
+ * The table is ACTIVE by the time this answers. Creating one schedules its
+ * activation, and a test that has just asked for a table is asking for one it
+ * can write to, so the scheduled work is drained here rather than in every
+ * caller.
+ *
+ * ```typescript
+ * const table = await simDynamoDbCreatedTableFactory.make(
+ *   { tableName: "OrdersTable", partitionKeyName: "orderId" },
+ *   simAws,
+ * );
+ * ```
+ *
+ * The table is created in the default Account and Region of the simulated AWS
+ * it is given. A test working in another scope calls CreateTable itself.
+ */
+export declare const simDynamoDbCreatedTableFactory: AsyncMappedFactory<SimDynamoDbCreatedTableInput, SimDynamoDbTable, SimAws>;
+//# sourceMappingURL=sim-dynamodb-created-table.factory.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-created-table.factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-created-table.factory.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-created-table.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EACV,sBAAsB,EACtB,8BAA8B,EAC/B,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;GAOG;AACH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,8BAA8B,CAAC;IAC1D,QAAQ,CAAC,WAAW,EAAE,sBAAsB,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,8BAA8B,4EAwC1C,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-created-table.factory.js

@@ -0,0 +1,54 @@
+import { AsyncMappedFactory } from "@kensio/part-factory";
+import { assertDefined } from "../../../util/type-guard/defined.js";
+/**
+ * Creates a table a simulated DynamoDB knows about, through CreateTable.
+ *
+ * This is the table an application would have: it went through the ordinary
+ * command, so it was checked the way a real request is checked. Use
+ * `simDynamoDbTableFactory` instead for a table on its own, with no simulated
+ * DynamoDB holding it.
+ *
+ * The table is ACTIVE by the time this answers. Creating one schedules its
+ * activation, and a test that has just asked for a table is asking for one it
+ * can write to, so the scheduled work is drained here rather than in every
+ * caller.
+ *
+ * ```typescript
+ * const table = await simDynamoDbCreatedTableFactory.make(
+ *   { tableName: "OrdersTable", partitionKeyName: "orderId" },
+ *   simAws,
+ * );
+ * ```
+ *
+ * The table is created in the default Account and Region of the simulated AWS
+ * it is given. A test working in another scope calls CreateTable itself.
+ */
+export const simDynamoDbCreatedTableFactory = new AsyncMappedFactory(() => ({
+    tableName: "FoobarTable",
+    partitionKeyName: "id",
+    partitionKeyType: "S",
+    billingMode: "PAY_PER_REQUEST",
+}), async (input, simAws) => {
+    const simDynamoDb = simAws.dynamoDb();
+    await simDynamoDb.createTable({
+        input: {
+            TableName: input.tableName,
+            KeySchema: [{ AttributeName: input.partitionKeyName, KeyType: "HASH" }],
+            AttributeDefinitions: [
+                {
+                    AttributeName: input.partitionKeyName,
+                    AttributeType: input.partitionKeyType,
+                },
+            ],
+            BillingMode: input.billingMode,
+        },
+    });
+    await simAws.backgroundTasksComplete();
+    // A name CreateTable accepted is a table the store holds, so this is only
+    // missing if something is wrong with the simulator itself.
+    const table = simDynamoDb.findTable(input.tableName);
+    assertDefined(table, `Simulated DynamoDB created the table ${input.tableName} and then did ` +
+        `not hold it`);
+    return table;
+});
+//# sourceMappingURL=sim-dynamodb-created-table.factory.js.map

package/dist/service/dynamodb/table/sim-dynamodb-created-table.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-created-table.factory.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-created-table.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAuBpE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,IAAI,kBAAkB,CAKlE,GAAG,EAAE,CAAC,CAAC;IACL,SAAS,EAAE,aAAa;IACxB,gBAAgB,EAAE,IAAI;IACtB,gBAAgB,EAAE,GAAG;IACrB,WAAW,EAAE,iBAAiB;CAC/B,CAAC,EACF,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;IACtB,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;IAEtC,MAAM,WAAW,CAAC,WAAW,CAAC;QAC5B,KAAK,EAAE;YACL,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,SAAS,EAAE,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;YACvE,oBAAoB,EAAE;gBACpB;oBACE,aAAa,EAAE,KAAK,CAAC,gBAAgB;oBACrC,aAAa,EAAE,KAAK,CAAC,gBAAgB;iBACtC;aACF;YACD,WAAW,EAAE,KAAK,CAAC,WAAW;SAC/B;KACF,CAAC,CAAC;IACH,MAAM,MAAM,CAAC,uBAAuB,EAAE,CAAC;IAEvC,0EAA0E;IAC1E,2DAA2D;IAC3D,MAAM,KAAK,GAAG,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IACrD,aAAa,CACX,KAAK,EACL,wCAAwC,KAAK,CAAC,SAAS,gBAAgB;QACrE,aAAa,CAChB,CAAC;IAEF,OAAO,KAAK,CAAC;AACf,CAAC,CACF,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-item-collection.d.ts

@@ -0,0 +1,42 @@
+import type { SimDynamoDbKeyCondition } from "../expression/key-condition/sim-dynamodb-key-condition.js";
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbKeySchema } from "./sim-dynamodb-key-schema.js";
+interface SimDynamoDbItemCollectionProperties {
+    readonly items: Iterable<SimDynamoDbItem>;
+    readonly keySchema: SimDynamoDbKeySchema;
+    readonly keyCondition: SimDynamoDbKeyCondition;
+}
+interface SimDynamoDbItemCollectionWalk {
+    readonly forward: boolean;
+    readonly after?: SimDynamoDbItem | undefined;
+}
+/**
+ * The items one key condition names, in sort key order.
+ *
+ * A table holds its items in a map keyed by the marshalled primary key, which
+ * carries no order at all, so an item collection is gathered and ordered when
+ * it is read rather than kept that way. Real DynamoDB keeps a collection in
+ * sort key order, and a query reads the same items in the same order either
+ * way.
+ */
+export declare class SimDynamoDbItemCollection {
+    private readonly order;
+    private readonly ascending;
+    constructor(properties: SimDynamoDbItemCollectionProperties);
+    /**
+     * The collection in the order a query walks it, from the key it resumes
+     * after.
+     */
+    walk(properties: SimDynamoDbItemCollectionWalk): readonly SimDynamoDbItem[];
+    /**
+     * Whether a key condition names an item: it belongs to the item collection,
+     * and its sort key is inside the run the condition asks for.
+     */
+    private named;
+    /**
+     * The collection in the direction `ScanIndexForward` asked for.
+     */
+    private inOrder;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-item-collection.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-item-collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-item-collection.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-item-collection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,2DAA2D,CAAC;AACzG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAGzE,UAAU,mCAAmC;IAC3C,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IAC1C,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,QAAQ,CAAC,YAAY,EAAE,uBAAuB,CAAC;CAChD;AAED,UAAU,6BAA6B;IACrC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;CAC9C;AAED;;;;;;;;GAQG;AACH,qBAAa,yBAAyB;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0B;IAChD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IAEvD,YAAY,UAAU,EAAE,mCAAmC,EAU1D;IAED;;;OAGG;IACH,IAAI,CAAC,UAAU,EAAE,6BAA6B,GAAG,SAAS,eAAe,EAAE,CAS1E;IAED;;;OAGG;IACH,OAAO,CAAC,KAAK;IAeb;;OAEG;IACH,OAAO,CAAC,OAAO;CAOhB"}

package/dist/service/dynamodb/table/sim-dynamodb-item-collection.js

@@ -0,0 +1,54 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { simDynamoDbValuesEqual } from "../item/sim-dynamodb-value-comparison.js";
+import { SimDynamoDbSortKeyOrder } from "./sim-dynamodb-sort-key-order.js";
+/**
+ * The items one key condition names, in sort key order.
+ *
+ * A table holds its items in a map keyed by the marshalled primary key, which
+ * carries no order at all, so an item collection is gathered and ordered when
+ * it is read rather than kept that way. Real DynamoDB keeps a collection in
+ * sort key order, and a query reads the same items in the same order either
+ * way.
+ */
+export class SimDynamoDbItemCollection {
+    order;
+    ascending;
+    constructor(properties) {
+        const { keySchema, keyCondition } = properties;
+        const order = new SimDynamoDbSortKeyOrder(keySchema.rangeKeyAttributeName);
+        this.order = order;
+        this.ascending = order.ascending([...properties.items].filter((item) => this.named(item, keySchema, keyCondition)));
+    }
+    /**
+     * The collection in the order a query walks it, from the key it resumes
+     * after.
+     */
+    walk(properties) {
+        const inOrder = this.inOrder(properties.forward);
+        const after = properties.after;
+        if (after === undefined) {
+            return inOrder;
+        }
+        return this.order.beyond(inOrder, after, properties.forward);
+    }
+    /**
+     * Whether a key condition names an item: it belongs to the item collection,
+     * and its sort key is inside the run the condition asks for.
+     */
+    named(item, keySchema, keyCondition) {
+        const partitionKey = item.attribute(keySchema.hashKeyAttributeName);
+        assertDefined(partitionKey, "partition key of a stored item");
+        return (simDynamoDbValuesEqual(partitionKey, keyCondition.partitionKeyValue) &&
+            keyCondition.holdsForSortKey(this.order.valueOf(item)));
+    }
+    /**
+     * The collection in the direction `ScanIndexForward` asked for.
+     */
+    inOrder(forward) {
+        if (forward) {
+            return this.ascending;
+        }
+        return this.ascending.toReversed();
+    }
+}
+//# sourceMappingURL=sim-dynamodb-item-collection.js.map

package/dist/service/dynamodb/table/sim-dynamodb-item-collection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-item-collection.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-item-collection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAGpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAElF,OAAO,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAa3E;;;;;;;;GAQG;AACH,MAAM,OAAO,yBAAyB;IACnB,KAAK,CAA0B;IAC/B,SAAS,CAA6B;IAEvD,YAAY,UAA+C;QACzD,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,GAAG,UAAU,CAAC;QAC/C,MAAM,KAAK,GAAG,IAAI,uBAAuB,CAAC,SAAS,CAAC,qBAAqB,CAAC,CAAC;QAE3E,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAC9B,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CACpC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,YAAY,CAAC,CAC1C,CACF,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,IAAI,CAAC,UAAyC;QAC5C,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACjD,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAE/B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IAC/D,CAAC;IAED;;;OAGG;IACK,KAAK,CACX,IAAqB,EACrB,SAA+B,EAC/B,YAAqC;QAErC,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;QAEpE,aAAa,CAAC,YAAY,EAAE,gCAAgC,CAAC,CAAC;QAE9D,OAAO,CACL,sBAAsB,CAAC,YAAY,EAAE,YAAY,CAAC,iBAAiB,CAAC;YACpE,YAAY,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CACvD,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,OAAO,CAAC,OAAgB;QAC9B,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC,SAAS,CAAC;QACxB,CAAC;QAED,OAAO,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;IACrC,CAAC;CACF"}

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

@@ -0,0 +1,44 @@
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbAttributeDefinitions } from "./sim-dynamodb-attribute-definitions.js";
+import type { SimDynamoDbKeySchema } from "./sim-dynamodb-key-schema.js";
+/**
+ * Reads the primary key of an item, following a table's key schema.
+ *
+ * A key attribute has to be there, has to be the type the table declared for
+ * it, and cannot be empty. Real DynamoDB checks all three before it writes,
+ * because an item that broke any of them could never be read back by key.
+ */
+export declare class SimDynamoDbItemKey {
+    private readonly keySchema;
+    private readonly attributeDefinitions;
+    constructor(keySchema: SimDynamoDbKeySchema, attributeDefinitions: SimDynamoDbAttributeDefinitions);
+    /**
+     * Make the primary key string for an item.
+     */
+    of(item: SimDynamoDbItem): string;
+    /**
+     * Make the primary key string for the Key a request names an item by.
+     *
+     * A Key is the whole primary key and nothing else. An item may carry any
+     * attributes alongside its key, but the commands that name one item by its
+     * key cannot: an attribute that is not part of the key has nothing to match
+     * against, so DynamoDB refuses it rather than ignoring it.
+     *
+     * Real DynamoDB answers `The provided key element does not match the schema`
+     * without saying which attribute was at fault. The attribute is named here as
+     * well, since a test reading the failure is better off knowing.
+     */
+    ofKey(key: SimDynamoDbItem): string;
+    /**
+     * The marshalled partition key of an item, on its own.
+     *
+     * A Scan orders a table by this and a parallel Scan divides one by it, since
+     * the items sharing a partition key are the items DynamoDB keeps together.
+     */
+    partitionOf(item: SimDynamoDbItem): string;
+    /**
+     * Read one key attribute of an item, checking it against the key schema.
+     */
+    private keyValue;
+}
+//# sourceMappingURL=sim-dynamodb-item-key.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-item-key.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-item-key.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAQpE,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,yCAAyC,CAAC;AAC/F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AA+CzE;;;;;;GAMG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IACjD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAkC;IAEvE,YACE,SAAS,EAAE,oBAAoB,EAC/B,oBAAoB,EAAE,+BAA+B,EAItD;IAED;;OAEG;IACH,EAAE,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAOhC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAYlC;IAED;;;;;OAKG;IACH,WAAW,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAEzC;IAED;;OAEG;IACH,OAAO,CAAC,QAAQ;CA0BjB"}

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

@@ -0,0 +1,105 @@
+import { jsonStringify } from "../../../util/type-guard/json.js";
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+import { simDynamoDbBinaryText } from "../item/sim-dynamodb-binary.js";
+/**
+ * Refuse a key value of a type the table did not declare for it.
+ */
+function assertDeclaredType(attributeName, value, declared) {
+    if (value.kind !== declared) {
+        throw new SimDynamoDbValidationException(`One or more parameter values were invalid: Type mismatch for key ` +
+            `attribute ${attributeName}, expected ${declared} but got ${value.kind}`);
+    }
+}
+/**
+ * The text a key value is marshalled to, which is what makes two items with
+ * the same key the same item.
+ *
+ * Binary goes through base64, so two key values holding the same bytes marshal
+ * the same way. A number goes through its normalised digits, so `1` and `1.0`
+ * are one key rather than two.
+ */
+function keyText(value) {
+    switch (value.kind) {
+        case "S": {
+            return value.text;
+        }
+        case "N": {
+            return value.number.text;
+        }
+        case "B": {
+            return simDynamoDbBinaryText(value.bytes);
+        }
+    }
+}
+/**
+ * Reads the primary key of an item, following a table's key schema.
+ *
+ * A key attribute has to be there, has to be the type the table declared for
+ * it, and cannot be empty. Real DynamoDB checks all three before it writes,
+ * because an item that broke any of them could never be read back by key.
+ */
+export class SimDynamoDbItemKey {
+    keySchema;
+    attributeDefinitions;
+    constructor(keySchema, attributeDefinitions) {
+        this.keySchema = keySchema;
+        this.attributeDefinitions = attributeDefinitions;
+    }
+    /**
+     * Make the primary key string for an item.
+     */
+    of(item) {
+        return jsonStringify(this.keySchema.elements.map((element) => [
+            element.AttributeName,
+            this.keyValue(item, element.AttributeName),
+        ]));
+    }
+    /**
+     * Make the primary key string for the Key a request names an item by.
+     *
+     * A Key is the whole primary key and nothing else. An item may carry any
+     * attributes alongside its key, but the commands that name one item by its
+     * key cannot: an attribute that is not part of the key has nothing to match
+     * against, so DynamoDB refuses it rather than ignoring it.
+     *
+     * Real DynamoDB answers `The provided key element does not match the schema`
+     * without saying which attribute was at fault. The attribute is named here as
+     * well, since a test reading the failure is better off knowing.
+     */
+    ofKey(key) {
+        for (const attributeName of key.attributeNames()) {
+            if (!this.keySchema.attributeNames().includes(attributeName)) {
+                throw new SimDynamoDbValidationException(`The provided key element does not match the schema: the Key names ` +
+                    `the attribute ${attributeName}, which is not part of the ` +
+                    `table's primary key`);
+            }
+        }
+        return this.of(key);
+    }
+    /**
+     * The marshalled partition key of an item, on its own.
+     *
+     * A Scan orders a table by this and a parallel Scan divides one by it, since
+     * the items sharing a partition key are the items DynamoDB keeps together.
+     */
+    partitionOf(item) {
+        return this.keyValue(item, this.keySchema.hashKeyAttributeName);
+    }
+    /**
+     * Read one key attribute of an item, checking it against the key schema.
+     */
+    keyValue(item, attributeName) {
+        const value = item.attribute(attributeName);
+        if (value === undefined) {
+            throw new SimDynamoDbValidationException(`One of the required keys was not given a value: ${attributeName}`);
+        }
+        assertDeclaredType(attributeName, value, this.attributeDefinitions.typeOf(attributeName));
+        const text = keyText(value);
+        if (text === "") {
+            throw new SimDynamoDbValidationException(`One or more parameter values are not valid. The AttributeValue for ` +
+                `key attribute ${attributeName} cannot be empty`);
+        }
+        return `${value.kind}:${text}`;
+    }
+}
+//# sourceMappingURL=sim-dynamodb-item-key.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-item-key.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-item-key.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,14 @@
+import type { SimDynamoDbKeySchemaElement, SimDynamoDbKeySchemaElementInput } from "../command/table/table.types.js";
+import type { SimDynamoDbKeySchemaSubject } from "./sim-dynamodb-key-schema-subject.js";
+/**
+ * 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 declare function readSimDynamoDbKeySchemaElement(element: SimDynamoDbKeySchemaElementInput, index: number, subject: SimDynamoDbKeySchemaSubject): SimDynamoDbKeySchemaElement;
+//# sourceMappingURL=sim-dynamodb-key-schema-element.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-schema-element.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-key-schema-element.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,gCAAgC,EAEjC,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAaxF;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,gCAAgC,EACzC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,2BAA2B,GACnC,2BAA2B,CAiB7B"}