@kensio/yulin 0.44.0 → 0.47.0

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-attributes.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6CAA6C,CAAC;AAC3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAErF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,0BAA0B;IACzC;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,CAAC;IAEhD;;OAEG;IACH,sBAAsB,IAAI,IAAI,CAAC;IAE/B;;OAEG;IACH,kBAAkB,CAAC,KAAK,EAAE,SAAS,uBAAuB,EAAE,GAAG,IAAI,CAAC;CACrE;AAED;;GAEG;AACH,MAAM,WAAW,oCAAoC;IACnD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,0BAA0B,CAAC;IAChD,QAAQ,CAAC,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACjD"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-attributes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sim-dynamodb-index-attributes.js.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-attributes.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-attributes.ts"],"names":[],"mappings":""}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-key-types.d.ts

@@ -0,0 +1,20 @@
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbAttributeDefinitions } from "../table/sim-dynamodb-attribute-definitions.js";
+import type { SimDynamoDbKeySchema } from "../table/sim-dynamodb-key-schema.js";
+interface SimDynamoDbIndexKeyTypesProperties {
+    readonly indexName: string;
+    readonly keySchema: SimDynamoDbKeySchema;
+    readonly item: SimDynamoDbItem;
+    readonly attributeDefinitions: SimDynamoDbAttributeDefinitions;
+}
+/**
+ * Refuse an item carrying an index key attribute as another type.
+ *
+ * This is the one thing a write is held to on account of an index. An item
+ * missing an index key attribute is simply absent from the index, since a
+ * global secondary index is sparse, but one carrying the attribute as a type
+ * the index did not declare could never be held by it at all.
+ */
+export declare function assertSimDynamoDbIndexKeyTypes(properties: SimDynamoDbIndexKeyTypesProperties): void;
+export {};
+//# sourceMappingURL=sim-dynamodb-index-key-types.d.ts.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-key-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-key-types.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-key-types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,gDAAgD,CAAC;AACtG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAEhF,UAAU,kCAAkC;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,oBAAoB,EAAE,+BAA+B,CAAC;CAChE;AAED;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,kCAAkC,GAC7C,IAAI,CAeN"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-key-types.js

@@ -0,0 +1,22 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+/**
+ * Refuse an item carrying an index key attribute as another type.
+ *
+ * This is the one thing a write is held to on account of an index. An item
+ * missing an index key attribute is simply absent from the index, since a
+ * global secondary index is sparse, but one carrying the attribute as a type
+ * the index did not declare could never be held by it at all.
+ */
+export function assertSimDynamoDbIndexKeyTypes(properties) {
+    const { indexName, item, attributeDefinitions } = properties;
+    for (const attributeName of properties.keySchema.attributeNames()) {
+        const value = item.attribute(attributeName);
+        const declared = attributeDefinitions.typeOf(attributeName);
+        if (value !== undefined && value.kind !== declared) {
+            throw new SimDynamoDbValidationException(`One or more parameter values were invalid: Type mismatch for Index ` +
+                `Key ${attributeName} Expected: ${declared} Actual: ${value.kind} ` +
+                `IndexName: ${indexName}`);
+        }
+    }
+}
+//# sourceMappingURL=sim-dynamodb-index-key-types.js.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-key-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-key-types.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-key-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAY5E;;;;;;;GAOG;AACH,MAAM,UAAU,8BAA8B,CAC5C,UAA8C;IAE9C,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,oBAAoB,EAAE,GAAG,UAAU,CAAC;IAE7D,KAAK,MAAM,aAAa,IAAI,UAAU,CAAC,SAAS,CAAC,cAAc,EAAE,EAAE,CAAC;QAClE,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAC5C,MAAM,QAAQ,GAAG,oBAAoB,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QAE5D,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YACnD,MAAM,IAAI,8BAA8B,CACtC,qEAAqE;gBACnE,OAAO,aAAa,cAAc,QAAQ,YAAY,KAAK,CAAC,IAAI,GAAG;gBACnE,cAAc,SAAS,EAAE,CAC5B,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-keys.d.ts

@@ -0,0 +1,58 @@
+import type { SimDynamoDbAttributeValue } from "../command/item/item.types.js";
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbAttributeDefinitions } from "../table/sim-dynamodb-attribute-definitions.js";
+import { SimDynamoDbItemKey } from "../table/sim-dynamodb-item-key.js";
+import type { SimDynamoDbKeySchema } from "../table/sim-dynamodb-key-schema.js";
+interface SimDynamoDbIndexKeysProperties {
+    readonly indexName: string;
+    readonly indexKeySchema: SimDynamoDbKeySchema;
+    readonly tableKeySchema: SimDynamoDbKeySchema;
+    readonly attributeDefinitions: SimDynamoDbAttributeDefinitions;
+    readonly tableItemKey: SimDynamoDbItemKey;
+}
+/**
+ * How one index entry is keyed and identified.
+ *
+ * An entry is keyed by the index key, which says where it sits, and identified
+ * by the table key, which says which item it is. An index key is not unique, so
+ * neither half names an entry on its own.
+ *
+ * That is why the entry has to carry both, why a pagination token carries both,
+ * and why a token missing either is refused rather than resumed from.
+ */
+export declare class SimDynamoDbIndexKeys {
+    /**
+     * The index key and the table key together.
+     */
+    readonly attributeNames: ReadonlySet<string>;
+    /**
+     * The index key as the entries are marshalled by, which a scan orders on.
+     */
+    readonly indexItemKey: SimDynamoDbItemKey;
+    private readonly indexName;
+    private readonly indexKeySchema;
+    private readonly tableKeySchema;
+    private readonly tableItemKey;
+    constructor(properties: SimDynamoDbIndexKeysProperties);
+    /**
+     * Whether the index holds an item, which needs the whole of the index key.
+     *
+     * This is what makes an index sparse. Nothing said so when the item was
+     * written: it is worked out here, when the index is read.
+     */
+    holds(item: SimDynamoDbItem): boolean;
+    /**
+     * The token naming the entry a walk stopped on, by both of its keys.
+     */
+    tokenKey(item: SimDynamoDbItem): Record<string, SimDynamoDbAttributeValue>;
+    /**
+     * Refuse an `ExclusiveStartKey` this index could not have handed out.
+     *
+     * Both keys are required and nothing else is allowed alongside them. Without
+     * the table key the token names several entries, so resuming from it would
+     * repeat one or skip one.
+     */
+    assertStartKey(key: SimDynamoDbItem): void;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-index-keys.d.ts.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-keys.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAE/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,gDAAgD,CAAC;AACtG,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAGhF,UAAU,8BAA8B;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC;IAC9C,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC;IAC9C,QAAQ,CAAC,oBAAoB,EAAE,+BAA+B,CAAC;IAC/D,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAC;CAC3C;AAED;;;;;;;;;GASG;AACH,qBAAa,oBAAoB;IAC/B;;OAEG;IACH,SAAgB,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAEpD;;OAEG;IACH,SAAgB,YAAY,EAAE,kBAAkB,CAAC;IAEjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuB;IACtD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuB;IACtD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAElD,YAAY,UAAU,EAAE,8BAA8B,EAarD;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAIpC;IAED;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAKzE;IAED;;;;;;OAMG;IACH,cAAc,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI,CAazC;CACF"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-keys.js

@@ -0,0 +1,77 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+import { SimDynamoDbItemKey } from "../table/sim-dynamodb-item-key.js";
+import { simDynamoDbPrimaryKeyAttributes } from "../table/sim-dynamodb-primary-key.js";
+/**
+ * How one index entry is keyed and identified.
+ *
+ * An entry is keyed by the index key, which says where it sits, and identified
+ * by the table key, which says which item it is. An index key is not unique, so
+ * neither half names an entry on its own.
+ *
+ * That is why the entry has to carry both, why a pagination token carries both,
+ * and why a token missing either is refused rather than resumed from.
+ */
+export class SimDynamoDbIndexKeys {
+    /**
+     * The index key and the table key together.
+     */
+    attributeNames;
+    /**
+     * The index key as the entries are marshalled by, which a scan orders on.
+     */
+    indexItemKey;
+    indexName;
+    indexKeySchema;
+    tableKeySchema;
+    tableItemKey;
+    constructor(properties) {
+        this.indexName = properties.indexName;
+        this.indexKeySchema = properties.indexKeySchema;
+        this.tableKeySchema = properties.tableKeySchema;
+        this.tableItemKey = properties.tableItemKey;
+        this.indexItemKey = new SimDynamoDbItemKey(properties.indexKeySchema, properties.attributeDefinitions);
+        this.attributeNames = new Set([
+            ...properties.indexKeySchema.attributeNames(),
+            ...properties.tableKeySchema.attributeNames(),
+        ]);
+    }
+    /**
+     * Whether the index holds an item, which needs the whole of the index key.
+     *
+     * This is what makes an index sparse. Nothing said so when the item was
+     * written: it is worked out here, when the index is read.
+     */
+    holds(item) {
+        return this.indexKeySchema
+            .attributeNames()
+            .every((attributeName) => item.attribute(attributeName) !== undefined);
+    }
+    /**
+     * The token naming the entry a walk stopped on, by both of its keys.
+     */
+    tokenKey(item) {
+        return {
+            ...simDynamoDbPrimaryKeyAttributes(item, this.indexKeySchema),
+            ...simDynamoDbPrimaryKeyAttributes(item, this.tableKeySchema),
+        };
+    }
+    /**
+     * Refuse an `ExclusiveStartKey` this index could not have handed out.
+     *
+     * Both keys are required and nothing else is allowed alongside them. Without
+     * the table key the token names several entries, so resuming from it would
+     * repeat one or skip one.
+     */
+    assertStartKey(key) {
+        for (const attributeName of key.attributeNames()) {
+            if (!this.attributeNames.has(attributeName)) {
+                throw new SimDynamoDbValidationException(`The provided starting key is invalid: the Key names the attribute ` +
+                    `${attributeName}, which is part of neither the index ` +
+                    `${this.indexName} key nor the table's primary key`);
+            }
+        }
+        this.indexItemKey.of(key);
+        this.tableItemKey.of(key);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-index-keys.js.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-keys.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-keys.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAG5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAEvE,OAAO,EAAE,+BAA+B,EAAE,MAAM,sCAAsC,CAAC;AAUvF;;;;;;;;;GASG;AACH,MAAM,OAAO,oBAAoB;IAC/B;;OAEG;IACa,cAAc,CAAsB;IAEpD;;OAEG;IACa,YAAY,CAAqB;IAEhC,SAAS,CAAS;IAClB,cAAc,CAAuB;IACrC,cAAc,CAAuB;IACrC,YAAY,CAAqB;IAElD,YAAY,UAA0C;QACpD,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;QACtC,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,cAAc,CAAC;QAChD,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,cAAc,CAAC;QAChD,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;QAC5C,IAAI,CAAC,YAAY,GAAG,IAAI,kBAAkB,CACxC,UAAU,CAAC,cAAc,EACzB,UAAU,CAAC,oBAAoB,CAChC,CAAC;QACF,IAAI,CAAC,cAAc,GAAG,IAAI,GAAG,CAAC;YAC5B,GAAG,UAAU,CAAC,cAAc,CAAC,cAAc,EAAE;YAC7C,GAAG,UAAU,CAAC,cAAc,CAAC,cAAc,EAAE;SAC9C,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAqB;QACzB,OAAO,IAAI,CAAC,cAAc;aACvB,cAAc,EAAE;aAChB,KAAK,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,SAAS,CAAC,CAAC;IAC3E,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,IAAqB;QAC5B,OAAO;YACL,GAAG,+BAA+B,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,CAAC;YAC7D,GAAG,+BAA+B,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,CAAC;SAC9D,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,cAAc,CAAC,GAAoB;QACjC,KAAK,MAAM,aAAa,IAAI,GAAG,CAAC,cAAc,EAAE,EAAE,CAAC;YACjD,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC;gBAC5C,MAAM,IAAI,8BAA8B,CACtC,oEAAoE;oBAClE,GAAG,aAAa,uCAAuC;oBACvD,GAAG,IAAI,CAAC,SAAS,kCAAkC,CACtD,CAAC;YACJ,CAAC;QACH,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAC1B,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAC5B,CAAC;CACF"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-lifecycle.d.ts

@@ -0,0 +1,55 @@
+import type { SimDynamoDbIndexStatus } from "../command/table/table.types.js";
+interface SimDynamoDbIndexLifecycleProperties {
+    readonly indexName: string;
+    readonly backfills: boolean;
+}
+/**
+ * Where one global secondary index is between being declared and being read.
+ *
+ * An index is CREATING until the work that builds it has run, and cannot be
+ * read until it is ACTIVE. An index added to a table that already holds items
+ * also backfills, which is DynamoDB copying those items into it, and that is
+ * what `Backfilling` reports. An index declared on CreateTable has nothing to
+ * copy, so real DynamoDB leaves `Backfilling` out of its description
+ * altogether.
+ */
+export declare class SimDynamoDbIndexLifecycle {
+    #private;
+    private readonly indexName;
+    private readonly backfills;
+    constructor(properties: SimDynamoDbIndexLifecycleProperties);
+    /**
+     * The lifecycle of an index declared on CreateTable, which does not backfill.
+     */
+    static withTable(indexName: string): SimDynamoDbIndexLifecycle;
+    /**
+     * The lifecycle of an index added to a live table, which backfills.
+     */
+    static backfilling(indexName: string): SimDynamoDbIndexLifecycle;
+    /**
+     * Where the index is now.
+     */
+    get status(): SimDynamoDbIndexStatus;
+    /**
+     * Whether the index is being filled with the items already on the table.
+     *
+     * Reported only while that is happening, which is how real DynamoDB reports
+     * it: an index that never backfilled has no `Backfilling` in its description.
+     */
+    get backfilling(): boolean | undefined;
+    /**
+     * Finish building the index.
+     */
+    activate(): void;
+    /**
+     * Refuse a read of an index that is not ready to answer one.
+     *
+     * Real DynamoDB refuses a Query or a Scan against an index it is still
+     * building, rather than answering with the part of it that is filled in. An
+     * application that reads a new index too early gets this rather than a short
+     * answer, which is the whole point of the index having a status.
+     */
+    assertReadable(): void;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-index-lifecycle.d.ts.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAG9E,UAAU,mCAAmC;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;GASG;AACH,qBAAa,yBAAyB;;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;IAGpC,YAAY,UAAU,EAAE,mCAAmC,EAG1D;IAED;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,yBAAyB,CAE7D;IAED;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,yBAAyB,CAE/D;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,sBAAsB,CAEnC;IAED;;;;;OAKG;IACH,IAAI,WAAW,IAAI,OAAO,GAAG,SAAS,CAMrC;IAED;;OAEG;IACH,QAAQ,IAAI,IAAI,CAEf;IAED;;;;;;;OAOG;IACH,cAAc,IAAI,IAAI,CAQrB;CACF"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-lifecycle.js

@@ -0,0 +1,71 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+/**
+ * Where one global secondary index is between being declared and being read.
+ *
+ * An index is CREATING until the work that builds it has run, and cannot be
+ * read until it is ACTIVE. An index added to a table that already holds items
+ * also backfills, which is DynamoDB copying those items into it, and that is
+ * what `Backfilling` reports. An index declared on CreateTable has nothing to
+ * copy, so real DynamoDB leaves `Backfilling` out of its description
+ * altogether.
+ */
+export class SimDynamoDbIndexLifecycle {
+    indexName;
+    backfills;
+    #status = "CREATING";
+    constructor(properties) {
+        this.indexName = properties.indexName;
+        this.backfills = properties.backfills;
+    }
+    /**
+     * The lifecycle of an index declared on CreateTable, which does not backfill.
+     */
+    static withTable(indexName) {
+        return new this({ indexName, backfills: false });
+    }
+    /**
+     * The lifecycle of an index added to a live table, which backfills.
+     */
+    static backfilling(indexName) {
+        return new this({ indexName, backfills: true });
+    }
+    /**
+     * Where the index is now.
+     */
+    get status() {
+        return this.#status;
+    }
+    /**
+     * Whether the index is being filled with the items already on the table.
+     *
+     * Reported only while that is happening, which is how real DynamoDB reports
+     * it: an index that never backfilled has no `Backfilling` in its description.
+     */
+    get backfilling() {
+        if (!this.backfills || this.#status !== "CREATING") {
+            return undefined;
+        }
+        return true;
+    }
+    /**
+     * Finish building the index.
+     */
+    activate() {
+        this.#status = "ACTIVE";
+    }
+    /**
+     * Refuse a read of an index that is not ready to answer one.
+     *
+     * Real DynamoDB refuses a Query or a Scan against an index it is still
+     * building, rather than answering with the part of it that is filled in. An
+     * application that reads a new index too early gets this rather than a short
+     * answer, which is the whole point of the index having a status.
+     */
+    assertReadable() {
+        if (this.#status === "ACTIVE") {
+            return;
+        }
+        throw new SimDynamoDbValidationException(`Cannot read from backfilling global secondary index: ${this.indexName}`);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-index-lifecycle.js.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-lifecycle.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-lifecycle.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAO5E;;;;;;;;;GASG;AACH,MAAM,OAAO,yBAAyB;IACnB,SAAS,CAAS;IAClB,SAAS,CAAU;IACpC,OAAO,GAA2B,UAAU,CAAC;IAE7C,YAAY,UAA+C;QACzD,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;QACtC,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,SAAiB;QAChC,OAAO,IAAI,IAAI,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;IACnD,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,SAAiB;QAClC,OAAO,IAAI,IAAI,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAClD,CAAC;IAED;;OAEG;IACH,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;;;OAKG;IACH,IAAI,WAAW;QACb,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;YACnD,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC;IAC1B,CAAC;IAED;;;;;;;OAOG;IACH,cAAc;QACZ,IAAI,IAAI,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;YAC9B,OAAO;QACT,CAAC;QAED,MAAM,IAAI,8BAA8B,CACtC,wDAAwD,IAAI,CAAC,SAAS,EAAE,CACzE,CAAC;IACJ,CAAC;CACF"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-limits.d.ts

@@ -0,0 +1,50 @@
+import type { SimDynamoDbSecondaryIndex } from "./sim-dynamodb-secondary-index.js";
+/**
+ * The most global secondary indexes one table holds.
+ */
+export declare const maxSimDynamoDbIndexes = 20;
+/**
+ * The most local secondary indexes one table holds.
+ *
+ * There are fewer of these because they share the table's partitions rather
+ * than living apart from them.
+ */
+export declare const maxSimDynamoDbLocalIndexes = 5;
+/**
+ * Refuse a request declaring more global secondary indexes than a table holds.
+ *
+ * This is checked before the indexes are read, so a request well over the cap
+ * is refused for being over it rather than for whatever is wrong with its
+ * twenty first index.
+ */
+export declare function assertSimDynamoDbIndexCount(count: number): void;
+/**
+ * Refuse a request declaring more local secondary indexes than a table holds.
+ */
+export declare function assertSimDynamoDbLocalIndexCount(count: number): void;
+/**
+ * Refuse a request declaring one index name twice.
+ *
+ * An index is reached by name, so two indexes sharing one leave a read with no
+ * way of saying which it meant. The two kinds share the one namespace, so a
+ * local secondary index cannot take the name of a global one either.
+ */
+export declare function assertSimDynamoDbIndexNamesDistinct(elements: readonly SimDynamoDbSecondaryIndex[]): void;
+/**
+ * Refuse an index a table has no room for, by count, name or projection.
+ *
+ * UpdateTable adds one index to a set that already passed these rules, so they
+ * are applied to the set the table would end up with rather than to the new
+ * index on its own.
+ */
+export declare function assertSimDynamoDbIndexAddable(elements: readonly SimDynamoDbSecondaryIndex[], added: SimDynamoDbSecondaryIndex): void;
+/**
+ * Refuse a table projecting more attributes than DynamoDB lets it.
+ *
+ * The 20 an index projects is not the whole rule: a table is capped at 100
+ * across all of its indexes too, which six fully projecting indexes reach. An
+ * attribute projected into two indexes counts twice, so this is a plain sum
+ * rather than a count of distinct names, as it is on AWS.
+ */
+export declare function assertSimDynamoDbProjectedAttributeCount(elements: readonly SimDynamoDbSecondaryIndex[]): void;
+//# sourceMappingURL=sim-dynamodb-index-limits.d.ts.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-limits.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-limits.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAEnF;;GAEG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAO5C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAO/D;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAOpE;AAED;;;;;;GAMG;AACH,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,SAAS,yBAAyB,EAAE,GAC7C,IAAI,CASN;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,SAAS,yBAAyB,EAAE,EAC9C,KAAK,EAAE,yBAAyB,GAC/B,IAAI,CAMN;AAED;;;;;;;GAOG;AACH,wBAAgB,wCAAwC,CACtD,QAAQ,EAAE,SAAS,yBAAyB,EAAE,GAC7C,IAAI,CAcN"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-limits.js

@@ -0,0 +1,82 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+/**
+ * The most global secondary indexes one table holds.
+ */
+export const maxSimDynamoDbIndexes = 20;
+/**
+ * The most local secondary indexes one table holds.
+ *
+ * There are fewer of these because they share the table's partitions rather
+ * than living apart from them.
+ */
+export const maxSimDynamoDbLocalIndexes = 5;
+/**
+ * The most NonKeyAttributes one table projects across all of its indexes.
+ */
+const maxProjectedAttributes = 100;
+/**
+ * Refuse a request declaring more global secondary indexes than a table holds.
+ *
+ * This is checked before the indexes are read, so a request well over the cap
+ * is refused for being over it rather than for whatever is wrong with its
+ * twenty first index.
+ */
+export function assertSimDynamoDbIndexCount(count) {
+    if (count > maxSimDynamoDbIndexes) {
+        throw new SimDynamoDbValidationException(`${count.toString()} GlobalSecondaryIndexes were given, and a table ` +
+            `holds at most ${maxSimDynamoDbIndexes.toString()}`);
+    }
+}
+/**
+ * Refuse a request declaring more local secondary indexes than a table holds.
+ */
+export function assertSimDynamoDbLocalIndexCount(count) {
+    if (count > maxSimDynamoDbLocalIndexes) {
+        throw new SimDynamoDbValidationException(`${count.toString()} LocalSecondaryIndexes were given, and a table ` +
+            `holds at most ${maxSimDynamoDbLocalIndexes.toString()}`);
+    }
+}
+/**
+ * Refuse a request declaring one index name twice.
+ *
+ * An index is reached by name, so two indexes sharing one leave a read with no
+ * way of saying which it meant. The two kinds share the one namespace, so a
+ * local secondary index cannot take the name of a global one either.
+ */
+export function assertSimDynamoDbIndexNamesDistinct(elements) {
+    const names = new Set(elements.map((index) => index.name));
+    if (names.size !== elements.length) {
+        throw new SimDynamoDbValidationException("The request names an index more than once, and an index name is " +
+            "unique within a table across both kinds of secondary index");
+    }
+}
+/**
+ * Refuse an index a table has no room for, by count, name or projection.
+ *
+ * UpdateTable adds one index to a set that already passed these rules, so they
+ * are applied to the set the table would end up with rather than to the new
+ * index on its own.
+ */
+export function assertSimDynamoDbIndexAddable(elements, added) {
+    const all = [...elements, added];
+    assertSimDynamoDbIndexCount(all.length);
+    assertSimDynamoDbIndexNamesDistinct(all);
+    assertSimDynamoDbProjectedAttributeCount(all);
+}
+/**
+ * Refuse a table projecting more attributes than DynamoDB lets it.
+ *
+ * The 20 an index projects is not the whole rule: a table is capped at 100
+ * across all of its indexes too, which six fully projecting indexes reach. An
+ * attribute projected into two indexes counts twice, so this is a plain sum
+ * rather than a count of distinct names, as it is on AWS.
+ */
+export function assertSimDynamoDbProjectedAttributeCount(elements) {
+    const projected = elements.reduce((total, index) => total + index.projection.nonKeyAttributeCount, 0);
+    if (projected > maxProjectedAttributes) {
+        const most = maxProjectedAttributes.toString();
+        throw new SimDynamoDbValidationException(`${projected.toString()} NonKeyAttributes are projected across the ` +
+            `table's indexes, and a table projects at most ${most}`);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-index-limits.js.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-limits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-limits.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-limits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAG5E;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAExC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC;AAE5C;;GAEG;AACH,MAAM,sBAAsB,GAAG,GAAG,CAAC;AAEnC;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CAAC,KAAa;IACvD,IAAI,KAAK,GAAG,qBAAqB,EAAE,CAAC;QAClC,MAAM,IAAI,8BAA8B,CACtC,GAAG,KAAK,CAAC,QAAQ,EAAE,kDAAkD;YACnE,iBAAiB,qBAAqB,CAAC,QAAQ,EAAE,EAAE,CACtD,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gCAAgC,CAAC,KAAa;IAC5D,IAAI,KAAK,GAAG,0BAA0B,EAAE,CAAC;QACvC,MAAM,IAAI,8BAA8B,CACtC,GAAG,KAAK,CAAC,QAAQ,EAAE,iDAAiD;YAClE,iBAAiB,0BAA0B,CAAC,QAAQ,EAAE,EAAE,CAC3D,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mCAAmC,CACjD,QAA8C;IAE9C,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IAE3D,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC;QACnC,MAAM,IAAI,8BAA8B,CACtC,kEAAkE;YAChE,4DAA4D,CAC/D,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,6BAA6B,CAC3C,QAA8C,EAC9C,KAAgC;IAEhC,MAAM,GAAG,GAAG,CAAC,GAAG,QAAQ,EAAE,KAAK,CAAC,CAAC;IAEjC,2BAA2B,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACxC,mCAAmC,CAAC,GAAG,CAAC,CAAC;IACzC,wCAAwC,CAAC,GAAG,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,wCAAwC,CACtD,QAA8C;IAE9C,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAC/B,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,CAAC,UAAU,CAAC,oBAAoB,EAC/D,CAAC,CACF,CAAC;IAEF,IAAI,SAAS,GAAG,sBAAsB,EAAE,CAAC;QACvC,MAAM,IAAI,GAAG,sBAAsB,CAAC,QAAQ,EAAE,CAAC;QAE/C,MAAM,IAAI,8BAA8B,CACtC,GAAG,SAAS,CAAC,QAAQ,EAAE,6CAA6C;YAClE,iDAAiD,IAAI,EAAE,CAC1D,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-lookup.d.ts

@@ -0,0 +1,13 @@
+import type { SimDynamoDbSecondaryIndex } from "./sim-dynamodb-secondary-index.js";
+/**
+ * The index an `IndexName` names, refusing a name the table does not have.
+ *
+ * Real DynamoDB answers a name it does not have with
+ * `ResourceNotFoundException` rather than reading the table instead, since a
+ * read of an index that is not there is a read of nothing.
+ *
+ * The two kinds share one namespace, so the lookup is over both of them at once
+ * rather than over either collection.
+ */
+export declare function requiredSimDynamoDbIndex(elements: readonly SimDynamoDbSecondaryIndex[], indexName: string, tableName: string): SimDynamoDbSecondaryIndex;
+//# sourceMappingURL=sim-dynamodb-index-lookup.d.ts.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-lookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-lookup.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-lookup.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAEnF;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,SAAS,yBAAyB,EAAE,EAC9C,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,yBAAyB,CAU3B"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-lookup.js

@@ -0,0 +1,19 @@
+import { SimDynamoDbResourceNotFoundException } from "../error/dynamodb.error.js";
+/**
+ * The index an `IndexName` names, refusing a name the table does not have.
+ *
+ * Real DynamoDB answers a name it does not have with
+ * `ResourceNotFoundException` rather than reading the table instead, since a
+ * read of an index that is not there is a read of nothing.
+ *
+ * The two kinds share one namespace, so the lookup is over both of them at once
+ * rather than over either collection.
+ */
+export function requiredSimDynamoDbIndex(elements, indexName, tableName) {
+    const index = elements.find((candidate) => candidate.name === indexName);
+    if (index === undefined) {
+        throw new SimDynamoDbResourceNotFoundException(`The table ${tableName} does not have the specified index: ${indexName}`);
+    }
+    return index;
+}
+//# sourceMappingURL=sim-dynamodb-index-lookup.js.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-lookup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-lookup.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-lookup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,MAAM,4BAA4B,CAAC;AAGlF;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CACtC,QAA8C,EAC9C,SAAiB,EACjB,SAAiB;IAEjB,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;IAEzE,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,MAAM,IAAI,oCAAoC,CAC5C,aAAa,SAAS,uCAAuC,SAAS,EAAE,CACzE,CAAC;IACJ,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-name.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Read the name a secondary index declares.
+ *
+ * The name is how a Query or a Scan reaches the index, so a name real DynamoDB
+ * would refuse is refused here rather than becoming an index nothing on AWS
+ * could name.
+ */
+export declare function readSimDynamoDbIndexName(name: string | undefined): string;
+//# sourceMappingURL=sim-dynamodb-index-name.d.ts.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-name.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-name.ts"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAgBzE"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-name.js

@@ -0,0 +1,25 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+/**
+ * Real DynamoDB allows letters, numbers, underscores, hyphens and periods in an
+ * index name, and between 3 and 255 of them, which is the table name rule.
+ */
+const indexNamePattern = /^[\w.-]{3,255}$/;
+/**
+ * Read the name a secondary index declares.
+ *
+ * The name is how a Query or a Scan reaches the index, so a name real DynamoDB
+ * would refuse is refused here rather than becoming an index nothing on AWS
+ * could name.
+ */
+export function readSimDynamoDbIndexName(name) {
+    if (name === undefined || name === "") {
+        throw new SimDynamoDbValidationException("A secondary index has no IndexName");
+    }
+    if (!indexNamePattern.test(name)) {
+        throw new SimDynamoDbValidationException(`IndexName '${name}' is invalid. It can only include letters, numbers, ` +
+            `underscores, hyphens and periods, and must be 3 to 255 characters ` +
+            `long.`);
+    }
+    return name;
+}
+//# sourceMappingURL=sim-dynamodb-index-name.js.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-name.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-name.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAE5E;;;GAGG;AACH,MAAM,gBAAgB,GAAG,iBAAiB,CAAC;AAE3C;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CAAC,IAAwB;IAC/D,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,8BAA8B,CACtC,oCAAoC,CACrC,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,8BAA8B,CACtC,cAAc,IAAI,sDAAsD;YACtE,oEAAoE;YACpE,OAAO,CACV,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-projection-input.d.ts

@@ -0,0 +1,17 @@
+import type { SimDynamoDbProjectionInput, SimDynamoDbProjectionType } from "../command/table/table.types.js";
+/**
+ * What a test says when it asks for an index projecting one thing or another.
+ */
+export interface SimDynamoDbIndexedTableProjection {
+    readonly projectionType: SimDynamoDbProjectionType;
+    readonly nonKeyAttributes: readonly string[];
+}
+/**
+ * The `Projection` an index is created with, which INCLUDE alone names
+ * attributes for.
+ *
+ * The two index kinds project the same way, so their factories build this the
+ * same way rather than each having a copy of the rule.
+ */
+export declare function simDynamoDbIndexProjectionInput(input: SimDynamoDbIndexedTableProjection): SimDynamoDbProjectionInput;
+//# sourceMappingURL=sim-dynamodb-index-projection-input.d.ts.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-projection-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-projection-input.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-projection-input.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAC1B,yBAAyB,EAC1B,MAAM,iCAAiC,CAAC;AAEzC;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,cAAc,EAAE,yBAAyB,CAAC;IACnD,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAED;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,iCAAiC,GACvC,0BAA0B,CAS5B"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-projection-input.js

@@ -0,0 +1,17 @@
+/**
+ * The `Projection` an index is created with, which INCLUDE alone names
+ * attributes for.
+ *
+ * The two index kinds project the same way, so their factories build this the
+ * same way rather than each having a copy of the rule.
+ */
+export function simDynamoDbIndexProjectionInput(input) {
+    if (input.projectionType !== "INCLUDE") {
+        return { ProjectionType: input.projectionType };
+    }
+    return {
+        ProjectionType: input.projectionType,
+        NonKeyAttributes: input.nonKeyAttributes,
+    };
+}
+//# sourceMappingURL=sim-dynamodb-index-projection-input.js.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-index-projection-input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-index-projection-input.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-index-projection-input.ts"],"names":[],"mappings":"AAaA;;;;;;GAMG;AACH,MAAM,UAAU,+BAA+B,CAC7C,KAAwC;IAExC,IAAI,KAAK,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QACvC,OAAO,EAAE,cAAc,EAAE,KAAK,CAAC,cAAc,EAAE,CAAC;IAClD,CAAC;IAED,OAAO;QACL,cAAc,EAAE,KAAK,CAAC,cAAc;QACpC,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;KACzC,CAAC;AACJ,CAAC"}