@kensio/yulin 0.44.0 → 0.47.0

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

@@ -0,0 +1,21 @@
+import type { SimDynamoDbKeySchemaElementInput } from "../command/table/table.types.js";
+import { SimDynamoDbKeySchema } from "../table/sim-dynamodb-key-schema.js";
+/**
+ * Refuse a local secondary index on a table with no sort key of its own.
+ *
+ * The index adds a second sort key to an item collection, and a table keyed by
+ * a partition key alone holds one item per collection. There is nothing there
+ * to sort, which is why AWS refuses the whole request rather than the index.
+ */
+export declare function assertSimDynamoDbTableSortsForLocalIndexes(tableKeySchema: SimDynamoDbKeySchema): void;
+/**
+ * Read the KeySchema of one local secondary index.
+ *
+ * The key schema is what makes the index local. Its partition key is the
+ * table's own, so an entry sits in the same partition as the item it indexes,
+ * and its sort key is some other attribute, so the collection has a second
+ * order to be read in. An index sorted by the attribute the table is already
+ * sorted by would be the table written twice.
+ */
+export declare function readSimDynamoDbLocalIndexKeySchema(input: readonly SimDynamoDbKeySchemaElementInput[] | undefined, indexName: string, tableKeySchema: SimDynamoDbKeySchema): SimDynamoDbKeySchema;
+//# sourceMappingURL=sim-dynamodb-local-index-key-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-local-index-key-schema.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-local-index-key-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,iCAAiC,CAAC;AAExF,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAG3E;;;;;;GAMG;AACH,wBAAgB,0CAA0C,CACxD,cAAc,EAAE,oBAAoB,GACnC,IAAI,CAUN;AAED;;;;;;;;GAQG;AACH,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,SAAS,gCAAgC,EAAE,GAAG,SAAS,EAC9D,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,oBAAoB,GACnC,oBAAoB,CA+BtB"}

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

@@ -0,0 +1,47 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+import { SimDynamoDbKeySchema } from "../table/sim-dynamodb-key-schema.js";
+import { SimDynamoDbKeySchemaSubject } from "../table/sim-dynamodb-key-schema-subject.js";
+/**
+ * Refuse a local secondary index on a table with no sort key of its own.
+ *
+ * The index adds a second sort key to an item collection, and a table keyed by
+ * a partition key alone holds one item per collection. There is nothing there
+ * to sort, which is why AWS refuses the whole request rather than the index.
+ */
+export function assertSimDynamoDbTableSortsForLocalIndexes(tableKeySchema) {
+    if (tableKeySchema.rangeKeyAttributeName !== undefined) {
+        return;
+    }
+    throw new SimDynamoDbValidationException("One or more parameter values were invalid: Table KeySchema does not " +
+        "have a range key, which is required when specifying a " +
+        "LocalSecondaryIndex");
+}
+/**
+ * Read the KeySchema of one local secondary index.
+ *
+ * The key schema is what makes the index local. Its partition key is the
+ * table's own, so an entry sits in the same partition as the item it indexes,
+ * and its sort key is some other attribute, so the collection has a second
+ * order to be read in. An index sorted by the attribute the table is already
+ * sorted by would be the table written twice.
+ */
+export function readSimDynamoDbLocalIndexKeySchema(input, indexName, tableKeySchema) {
+    const subject = SimDynamoDbKeySchemaSubject.index(indexName);
+    const keySchema = SimDynamoDbKeySchema.fromInput(input, subject);
+    const partitionKey = keySchema.hashKeyAttributeName;
+    if (partitionKey !== tableKeySchema.hashKeyAttributeName) {
+        throw subject.refuse(`the HASH element names ${partitionKey}, and a local secondary index ` +
+            `shares the table's partition key, which is ${tableKeySchema.hashKeyAttributeName}`);
+    }
+    const sortKey = keySchema.rangeKeyAttributeName;
+    if (sortKey === undefined) {
+        throw subject.refuse("a local secondary index gives an item collection a second sort key, " +
+            "and this key schema has no RANGE element");
+    }
+    if (sortKey === tableKeySchema.rangeKeyAttributeName) {
+        throw subject.refuse(`the RANGE element names ${sortKey}, which is the table's own sort ` +
+            `key, so the index would repeat the order the table is already in`);
+    }
+    return keySchema;
+}
+//# sourceMappingURL=sim-dynamodb-local-index-key-schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-local-index-key-schema.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-local-index-key-schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,2BAA2B,EAAE,MAAM,6CAA6C,CAAC;AAE1F;;;;;;GAMG;AACH,MAAM,UAAU,0CAA0C,CACxD,cAAoC;IAEpC,IAAI,cAAc,CAAC,qBAAqB,KAAK,SAAS,EAAE,CAAC;QACvD,OAAO;IACT,CAAC;IAED,MAAM,IAAI,8BAA8B,CACtC,sEAAsE;QACpE,wDAAwD;QACxD,qBAAqB,CACxB,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kCAAkC,CAChD,KAA8D,EAC9D,SAAiB,EACjB,cAAoC;IAEpC,MAAM,OAAO,GAAG,2BAA2B,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAC7D,MAAM,SAAS,GAAG,oBAAoB,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACjE,MAAM,YAAY,GAAG,SAAS,CAAC,oBAAoB,CAAC;IAEpD,IAAI,YAAY,KAAK,cAAc,CAAC,oBAAoB,EAAE,CAAC;QACzD,MAAM,OAAO,CAAC,MAAM,CAClB,0BAA0B,YAAY,gCAAgC;YACpE,8CACE,cAAc,CAAC,oBACjB,EAAE,CACL,CAAC;IACJ,CAAC;IAED,MAAM,OAAO,GAAG,SAAS,CAAC,qBAAqB,CAAC;IAEhD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,MAAM,OAAO,CAAC,MAAM,CAClB,sEAAsE;YACpE,0CAA0C,CAC7C,CAAC;IACJ,CAAC;IAED,IAAI,OAAO,KAAK,cAAc,CAAC,qBAAqB,EAAE,CAAC;QACrD,MAAM,OAAO,CAAC,MAAM,CAClB,2BAA2B,OAAO,kCAAkC;YAClE,kEAAkE,CACrE,CAAC;IACJ,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC"}

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

@@ -0,0 +1,11 @@
+import type { SimDynamoDbSecondaryIndexInput } from "../command/table/table.types.js";
+/**
+ * Refuse the capacity a local secondary index cannot be given.
+ *
+ * A local secondary index sits in the same partition as the items it indexes
+ * and shares the table's throughput, so there is nothing to provision for it.
+ * Real DynamoDB has no throughput field on a `LocalSecondaryIndex` at all, so a
+ * request carrying one is refused rather than stored and ignored.
+ */
+export declare function refuseSimDynamoDbLocalIndexThroughput(input: SimDynamoDbSecondaryIndexInput, indexName: string): void;
+//# sourceMappingURL=sim-dynamodb-local-index-throughput.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-local-index-throughput.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-local-index-throughput.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AAiBtF;;;;;;;GAOG;AACH,wBAAgB,qCAAqC,CACnD,KAAK,EAAE,8BAA8B,EACrC,SAAS,EAAE,MAAM,GAChB,IAAI,CAYN"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-local-index-throughput.js

@@ -0,0 +1,29 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+/**
+ * How a refusal says a local secondary index has no capacity of its own.
+ */
+function refuseSetting(setting, indexName) {
+    return new SimDynamoDbValidationException(`One or more parameter values were invalid: ${setting} cannot be ` +
+        `specified for index: ${indexName} because it is a local secondary ` +
+        `index, which is read and written out of the table's own throughput`);
+}
+/**
+ * Refuse the capacity a local secondary index cannot be given.
+ *
+ * A local secondary index sits in the same partition as the items it indexes
+ * and shares the table's throughput, so there is nothing to provision for it.
+ * Real DynamoDB has no throughput field on a `LocalSecondaryIndex` at all, so a
+ * request carrying one is refused rather than stored and ignored.
+ */
+export function refuseSimDynamoDbLocalIndexThroughput(input, indexName) {
+    if (input.ProvisionedThroughput !== undefined) {
+        throw refuseSetting("ProvisionedThroughput", indexName);
+    }
+    if (input.OnDemandThroughput !== undefined) {
+        throw refuseSetting("OnDemandThroughput", indexName);
+    }
+    if (input.WarmThroughput !== undefined) {
+        throw refuseSetting("WarmThroughput", indexName);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-local-index-throughput.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-local-index-throughput.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-local-index-throughput.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAE5E;;GAEG;AACH,SAAS,aAAa,CACpB,OAAe,EACf,SAAiB;IAEjB,OAAO,IAAI,8BAA8B,CACvC,8CAA8C,OAAO,aAAa;QAChE,wBAAwB,SAAS,mCAAmC;QACpE,oEAAoE,CACvE,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,qCAAqC,CACnD,KAAqC,EACrC,SAAiB;IAEjB,IAAI,KAAK,CAAC,qBAAqB,KAAK,SAAS,EAAE,CAAC;QAC9C,MAAM,aAAa,CAAC,uBAAuB,EAAE,SAAS,CAAC,CAAC;IAC1D,CAAC;IAED,IAAI,KAAK,CAAC,kBAAkB,KAAK,SAAS,EAAE,CAAC;QAC3C,MAAM,aAAa,CAAC,oBAAoB,EAAE,SAAS,CAAC,CAAC;IACvD,CAAC;IAED,IAAI,KAAK,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QACvC,MAAM,aAAa,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC;IACnD,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,65 @@
+import type { SimArn } from "../../aws/arn.js";
+import type { SimDynamoDbLocalSecondaryIndexDescription, SimDynamoDbSecondaryIndexInput } from "../command/table/table.types.js";
+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";
+import type { SimDynamoDbIndexAttributes } from "./sim-dynamodb-index-attributes.js";
+import { SimDynamoDbIndexProjection } from "./sim-dynamodb-index-projection.js";
+import type { SimDynamoDbSecondaryIndex, SimDynamoDbSecondaryIndexTable } from "./sim-dynamodb-secondary-index.js";
+/**
+ * One simulated local secondary index.
+ *
+ * A local secondary index gives an item collection a second sort key. It shares
+ * the table's partition key, so an entry sits in the same partition as the item
+ * it indexes, which is what lets it answer a strongly consistent read and lets a
+ * read of it reach the base table for an attribute it does not project.
+ *
+ * `CreateTable` is the only place one can be declared. AWS has no call that
+ * adds, changes or removes one afterwards, so neither does this.
+ */
+export declare class SimDynamoDbLocalSecondaryIndex implements SimDynamoDbSecondaryIndex {
+    readonly name: string;
+    readonly arn: SimArn;
+    readonly keySchema: SimDynamoDbKeySchema;
+    readonly projection: SimDynamoDbIndexProjection;
+    private constructor();
+    /**
+     * Read one `LocalSecondaryIndexes` entry a CreateTable request carries.
+     *
+     * The name is read first, since every other refusal names the index it is
+     * about.
+     */
+    static fromInput(input: SimDynamoDbSecondaryIndexInput, table: SimDynamoDbSecondaryIndexTable): SimDynamoDbLocalSecondaryIndex;
+    /**
+     * Which attributes a read of this index answers with.
+     */
+    attributesOf(keyAttributeNames: ReadonlySet<string>): SimDynamoDbIndexAttributes;
+    /**
+     * A local secondary index answers a strongly consistent read.
+     *
+     * It is written in the same partition as the item it indexes, in the same
+     * operation, so there is no window in which it lags behind the table. That is
+     * the difference from a global secondary index, which is maintained
+     * asynchronously and refuses one.
+     */
+    assertAnswersConsistentRead(): void;
+    /**
+     * A local secondary index is always ready to be read.
+     *
+     * It is built with the table that carries it, and AWS has no call that adds
+     * one afterwards, so there is no window in which it exists and cannot answer.
+     */
+    assertReadable(): void;
+    /**
+     * Refuse an item carrying one of this index's key attributes as another type.
+     */
+    assertItemKeyTypes(item: SimDynamoDbItem, attributeDefinitions: SimDynamoDbAttributeDefinitions): void;
+    /**
+     * Describe this index the way DynamoDB reports it.
+     *
+     * There is no `IndexStatus` and no `ProvisionedThroughput`, since a local
+     * secondary index is built with the table and shares its capacity.
+     */
+    toDescription(): SimDynamoDbLocalSecondaryIndexDescription;
+}
+//# sourceMappingURL=sim-dynamodb-local-secondary-index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-local-secondary-index.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-local-secondary-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EACV,yCAAyC,EACzC,8BAA8B,EAC/B,MAAM,iCAAiC,CAAC;AACzC,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,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAGrF,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAGhF,OAAO,KAAK,EACV,yBAAyB,EACzB,8BAA8B,EAC/B,MAAM,mCAAmC,CAAC;AAS3C;;;;;;;;;;GAUG;AACH,qBAAa,8BAA+B,YAAW,yBAAyB;IAC9E,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,GAAG,EAAE,MAAM,CAAC;IAC5B,SAAgB,SAAS,EAAE,oBAAoB,CAAC;IAChD,SAAgB,UAAU,EAAE,0BAA0B,CAAC;IAEvD,OAAO,eAON;IAED;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CACd,KAAK,EAAE,8BAA8B,EACrC,KAAK,EAAE,8BAA8B,GACpC,8BAA8B,CAehC;IAED;;OAEG;IACH,YAAY,CACV,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,GACrC,0BAA0B,CAM5B;IAED;;;;;;;OAOG;IACH,2BAA2B,IAAI,IAAI,CAElC;IAED;;;;;OAKG;IACH,cAAc,IAAI,IAAI,CAErB;IAED;;OAEG;IACH,kBAAkB,CAChB,IAAI,EAAE,eAAe,EACrB,oBAAoB,EAAE,+BAA+B,GACpD,IAAI,CAON;IAED;;;;;OAKG;IACH,aAAa,IAAI,yCAAyC,CAUzD;CACF"}

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

@@ -0,0 +1,106 @@
+import { SimDynamoDbFetchedIndexAttributes } from "./sim-dynamodb-fetched-index-attributes.js";
+import { assertSimDynamoDbIndexKeyTypes } from "./sim-dynamodb-index-key-types.js";
+import { readSimDynamoDbIndexName } from "./sim-dynamodb-index-name.js";
+import { SimDynamoDbIndexProjection } from "./sim-dynamodb-index-projection.js";
+import { readSimDynamoDbLocalIndexKeySchema } from "./sim-dynamodb-local-index-key-schema.js";
+import { refuseSimDynamoDbLocalIndexThroughput } from "./sim-dynamodb-local-index-throughput.js";
+/**
+ * One simulated local secondary index.
+ *
+ * A local secondary index gives an item collection a second sort key. It shares
+ * the table's partition key, so an entry sits in the same partition as the item
+ * it indexes, which is what lets it answer a strongly consistent read and lets a
+ * read of it reach the base table for an attribute it does not project.
+ *
+ * `CreateTable` is the only place one can be declared. AWS has no call that
+ * adds, changes or removes one afterwards, so neither does this.
+ */
+export class SimDynamoDbLocalSecondaryIndex {
+    name;
+    arn;
+    keySchema;
+    projection;
+    constructor(properties) {
+        this.name = properties.name;
+        // An index ARN is the table's own with the index named under it, which is
+        // the resource an IAM policy naming one index is written against.
+        this.arn = `${properties.tableArn}/index/${properties.name}`;
+        this.keySchema = properties.keySchema;
+        this.projection = properties.projection;
+    }
+    /**
+     * Read one `LocalSecondaryIndexes` entry a CreateTable request carries.
+     *
+     * The name is read first, since every other refusal names the index it is
+     * about.
+     */
+    static fromInput(input, table) {
+        const name = readSimDynamoDbIndexName(input.IndexName);
+        refuseSimDynamoDbLocalIndexThroughput(input, name);
+        return new this({
+            name,
+            tableArn: table.tableArn,
+            keySchema: readSimDynamoDbLocalIndexKeySchema(input.KeySchema, name, table.keySchema),
+            projection: SimDynamoDbIndexProjection.fromInput(input.Projection, name),
+        });
+    }
+    /**
+     * Which attributes a read of this index answers with.
+     */
+    attributesOf(keyAttributeNames) {
+        return new SimDynamoDbFetchedIndexAttributes({
+            indexName: this.name,
+            projection: this.projection,
+            keyAttributeNames,
+        });
+    }
+    /**
+     * A local secondary index answers a strongly consistent read.
+     *
+     * It is written in the same partition as the item it indexes, in the same
+     * operation, so there is no window in which it lags behind the table. That is
+     * the difference from a global secondary index, which is maintained
+     * asynchronously and refuses one.
+     */
+    assertAnswersConsistentRead() {
+        return;
+    }
+    /**
+     * A local secondary index is always ready to be read.
+     *
+     * It is built with the table that carries it, and AWS has no call that adds
+     * one afterwards, so there is no window in which it exists and cannot answer.
+     */
+    assertReadable() {
+        return;
+    }
+    /**
+     * Refuse an item carrying one of this index's key attributes as another type.
+     */
+    assertItemKeyTypes(item, attributeDefinitions) {
+        assertSimDynamoDbIndexKeyTypes({
+            indexName: this.name,
+            keySchema: this.keySchema,
+            item,
+            attributeDefinitions,
+        });
+    }
+    /**
+     * Describe this index the way DynamoDB reports it.
+     *
+     * There is no `IndexStatus` and no `ProvisionedThroughput`, since a local
+     * secondary index is built with the table and shares its capacity.
+     */
+    toDescription() {
+        return {
+            IndexName: this.name,
+            IndexArn: this.arn,
+            KeySchema: this.keySchema.elements,
+            Projection: this.projection.toDescription(),
+            // Neither figure is tracked, the same way the table's are not.
+            ItemCount: 0,
+            IndexSizeBytes: 0,
+        };
+    }
+}
+//# sourceMappingURL=sim-dynamodb-local-secondary-index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-local-secondary-index.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-local-secondary-index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,iCAAiC,EAAE,MAAM,4CAA4C,CAAC;AAE/F,OAAO,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAC;AACnF,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,EAAE,kCAAkC,EAAE,MAAM,0CAA0C,CAAC;AAC9F,OAAO,EAAE,qCAAqC,EAAE,MAAM,0CAA0C,CAAC;AAajG;;;;;;;;;;GAUG;AACH,MAAM,OAAO,8BAA8B;IACzB,IAAI,CAAS;IACb,GAAG,CAAS;IACZ,SAAS,CAAuB;IAChC,UAAU,CAA6B;IAEvD,YAAoB,UAAoD;QACtE,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAC5B,0EAA0E;QAC1E,kEAAkE;QAClE,IAAI,CAAC,GAAG,GAAG,GAAG,UAAU,CAAC,QAAQ,UAAU,UAAU,CAAC,IAAI,EAAE,CAAC;QAC7D,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;QACtC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;IAC1C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CACd,KAAqC,EACrC,KAAqC;QAErC,MAAM,IAAI,GAAG,wBAAwB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAEvD,qCAAqC,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAEnD,OAAO,IAAI,IAAI,CAAC;YACd,IAAI;YACJ,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,SAAS,EAAE,kCAAkC,CAC3C,KAAK,CAAC,SAAS,EACf,IAAI,EACJ,KAAK,CAAC,SAAS,CAChB;YACD,UAAU,EAAE,0BAA0B,CAAC,SAAS,CAAC,KAAK,CAAC,UAAU,EAAE,IAAI,CAAC;SACzE,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,YAAY,CACV,iBAAsC;QAEtC,OAAO,IAAI,iCAAiC,CAAC;YAC3C,SAAS,EAAE,IAAI,CAAC,IAAI;YACpB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,iBAAiB;SAClB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACH,2BAA2B;QACzB,OAAO;IACT,CAAC;IAED;;;;;OAKG;IACH,cAAc;QACZ,OAAO;IACT,CAAC;IAED;;OAEG;IACH,kBAAkB,CAChB,IAAqB,EACrB,oBAAqD;QAErD,8BAA8B,CAAC;YAC7B,SAAS,EAAE,IAAI,CAAC,IAAI;YACpB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,IAAI;YACJ,oBAAoB;SACrB,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,aAAa;QACX,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,IAAI;YACpB,QAAQ,EAAE,IAAI,CAAC,GAAG;YAClB,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ;YAClC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE;YAC3C,+DAA+D;YAC/D,SAAS,EAAE,CAAC;YACZ,cAAc,EAAE,CAAC;SAClB,CAAC;IACJ,CAAC;CACF"}

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

@@ -0,0 +1,31 @@
+import type { SimDynamoDbLocalSecondaryIndexDescription, SimDynamoDbSecondaryIndexInput } from "../command/table/table.types.js";
+import { SimDynamoDbLocalSecondaryIndex } from "./sim-dynamodb-local-secondary-index.js";
+import type { SimDynamoDbSecondaryIndexTable } from "./sim-dynamodb-secondary-index.js";
+/**
+ * The local secondary indexes one table carries.
+ *
+ * As with the global ones, the collection owns what is about how many there
+ * are and each index owns what is about itself. What is added here is the one
+ * rule about the table rather than about any index: a table with no sort key
+ * has no collection for a second sort key to reorder.
+ */
+export declare class SimDynamoDbLocalSecondaryIndexes {
+    readonly elements: readonly SimDynamoDbLocalSecondaryIndex[];
+    private constructor();
+    /**
+     * The indexes of a table declaring none.
+     */
+    static none(): SimDynamoDbLocalSecondaryIndexes;
+    /**
+     * Read the `LocalSecondaryIndexes` a CreateTable request carries.
+     */
+    static fromInput(input: readonly SimDynamoDbSecondaryIndexInput[] | undefined, table: SimDynamoDbSecondaryIndexTable): SimDynamoDbLocalSecondaryIndexes;
+    /**
+     * How a table reports its indexes, which is not at all when it has none.
+     *
+     * Real DynamoDB leaves `LocalSecondaryIndexes` out of the description of a
+     * table with no index, rather than reporting an empty list.
+     */
+    descriptions(): readonly SimDynamoDbLocalSecondaryIndexDescription[] | undefined;
+}
+//# sourceMappingURL=sim-dynamodb-local-secondary-indexes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-local-secondary-indexes.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-local-secondary-indexes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yCAAyC,EACzC,8BAA8B,EAC/B,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AACzF,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAC;AAExF;;;;;;;GAOG;AACH,qBAAa,gCAAgC;IAC3C,SAAgB,QAAQ,EAAE,SAAS,8BAA8B,EAAE,CAAC;IAEpE,OAAO,eAEN;IAED;;OAEG;IACH,MAAM,CAAC,IAAI,IAAI,gCAAgC,CAE9C;IAED;;OAEG;IACH,MAAM,CAAC,SAAS,CACd,KAAK,EAAE,SAAS,8BAA8B,EAAE,GAAG,SAAS,EAC5D,KAAK,EAAE,8BAA8B,GACpC,gCAAgC,CAalC;IAED;;;;;OAKG;IACH,YAAY,IACV,SAAS,yCAAyC,EAAE,GAAG,SAAS,CAMjE;CACF"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-local-secondary-indexes.js

@@ -0,0 +1,47 @@
+import { assertSimDynamoDbLocalIndexCount } from "./sim-dynamodb-index-limits.js";
+import { assertSimDynamoDbTableSortsForLocalIndexes } from "./sim-dynamodb-local-index-key-schema.js";
+import { SimDynamoDbLocalSecondaryIndex } from "./sim-dynamodb-local-secondary-index.js";
+/**
+ * The local secondary indexes one table carries.
+ *
+ * As with the global ones, the collection owns what is about how many there
+ * are and each index owns what is about itself. What is added here is the one
+ * rule about the table rather than about any index: a table with no sort key
+ * has no collection for a second sort key to reorder.
+ */
+export class SimDynamoDbLocalSecondaryIndexes {
+    elements;
+    constructor(elements) {
+        this.elements = elements;
+    }
+    /**
+     * The indexes of a table declaring none.
+     */
+    static none() {
+        return new this([]);
+    }
+    /**
+     * Read the `LocalSecondaryIndexes` a CreateTable request carries.
+     */
+    static fromInput(input, table) {
+        if (input === undefined || input.length === 0) {
+            return this.none();
+        }
+        assertSimDynamoDbLocalIndexCount(input.length);
+        assertSimDynamoDbTableSortsForLocalIndexes(table.keySchema);
+        return new this(input.map((index) => SimDynamoDbLocalSecondaryIndex.fromInput(index, table)));
+    }
+    /**
+     * How a table reports its indexes, which is not at all when it has none.
+     *
+     * Real DynamoDB leaves `LocalSecondaryIndexes` out of the description of a
+     * table with no index, rather than reporting an empty list.
+     */
+    descriptions() {
+        if (this.elements.length === 0) {
+            return undefined;
+        }
+        return this.elements.map((index) => index.toDescription());
+    }
+}
+//# sourceMappingURL=sim-dynamodb-local-secondary-indexes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-local-secondary-indexes.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-local-secondary-indexes.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,gCAAgC,EAAE,MAAM,gCAAgC,CAAC;AAClF,OAAO,EAAE,0CAA0C,EAAE,MAAM,0CAA0C,CAAC;AACtG,OAAO,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AAGzF;;;;;;;GAOG;AACH,MAAM,OAAO,gCAAgC;IAC3B,QAAQ,CAA4C;IAEpE,YAAoB,QAAmD;QACrE,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,IAAI;QACT,OAAO,IAAI,IAAI,CAAC,EAAE,CAAC,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,SAAS,CACd,KAA4D,EAC5D,KAAqC;QAErC,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9C,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC;QACrB,CAAC;QAED,gCAAgC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC/C,0CAA0C,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAE5D,OAAO,IAAI,IAAI,CACb,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAClB,8BAA8B,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CACvD,CACF,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,YAAY;QAEV,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/B,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC;IAC7D,CAAC;CACF"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-locally-indexed-orders.d.ts

@@ -0,0 +1,6 @@
+import type { SimDynamoDbAttributeValue } from "../command/item/item.types.js";
+/**
+ * The orders a locally indexed table holds, as the items they are written as.
+ */
+export declare function simDynamoDbLocallyIndexedOrders(): readonly Readonly<Record<string, SimDynamoDbAttributeValue>>[];
+//# sourceMappingURL=sim-dynamodb-locally-indexed-orders.d.ts.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-locally-indexed-orders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-locally-indexed-orders.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-locally-indexed-orders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAqD/E;;GAEG;AACH,wBAAgB,+BAA+B,IAAI,SAAS,QAAQ,CAClE,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAC1C,EAAE,CAEF"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-locally-indexed-orders.js

@@ -0,0 +1,40 @@
+/**
+ * The orders a locally indexed table holds.
+ *
+ * The months run out of order against the order ids, so the index reads a
+ * customer's orders in an order the table's own sort key does not give. One
+ * month repeats within a customer, so two index entries share a whole index key
+ * and only the table sort key separates them.
+ */
+const orders = [
+    { customerId: "customer-1", orderId: "order-01", placedAt: "2026-03" },
+    { customerId: "customer-1", orderId: "order-02", placedAt: "2026-01" },
+    { customerId: "customer-1", orderId: "order-03" },
+    { customerId: "customer-1", orderId: "order-04", placedAt: "2026-01" },
+    { customerId: "customer-2", orderId: "order-05", placedAt: "2026-03" },
+    { customerId: "customer-2", orderId: "order-06" },
+];
+/**
+ * The item one order is written as.
+ *
+ * `title` is on every order and in no key, so it is the attribute a test names
+ * to find out whether a read reached the base table.
+ */
+function orderItem(order) {
+    const item = {
+        customerId: { S: order.customerId },
+        orderId: { S: order.orderId },
+        title: { S: `Order ${order.orderId}` },
+    };
+    if (order.placedAt === undefined) {
+        return item;
+    }
+    return { ...item, placedAt: { S: order.placedAt } };
+}
+/**
+ * The orders a locally indexed table holds, as the items they are written as.
+ */
+export function simDynamoDbLocallyIndexedOrders() {
+    return orders.map((order) => orderItem(order));
+}
+//# sourceMappingURL=sim-dynamodb-locally-indexed-orders.js.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-locally-indexed-orders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-locally-indexed-orders.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-locally-indexed-orders.ts"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH,MAAM,MAAM,GAA8C;IACxD,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE;IACtE,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE;IACtE,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE;IACjD,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE;IACtE,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE;IACtE,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE;CAClD,CAAC;AAEF;;;;;GAKG;AACH,SAAS,SAAS,CAChB,KAAqC;IAErC,MAAM,IAAI,GAAG;QACX,UAAU,EAAE,EAAE,CAAC,EAAE,KAAK,CAAC,UAAU,EAAE;QACnC,OAAO,EAAE,EAAE,CAAC,EAAE,KAAK,CAAC,OAAO,EAAE;QAC7B,KAAK,EAAE,EAAE,CAAC,EAAE,SAAS,KAAK,CAAC,OAAO,EAAE,EAAE;KACvC,CAAC;IAEF,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,EAAE,GAAG,IAAI,EAAE,QAAQ,EAAE,EAAE,CAAC,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC;AACtD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,+BAA+B;IAG7C,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;AACjD,CAAC"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-locally-indexed-table.factory.d.ts

@@ -0,0 +1,34 @@
+import { AsyncMappedFactory } from "@kensio/part-factory";
+import type { SimAws } from "../../aws/sim-aws.js";
+import type { SimDynamoDbProjectionType } from "../command/table/table.types.js";
+import type { SimDynamoDbTable } from "../table/sim-dynamodb-table.js";
+/**
+ * What a test asks for when it wants a table with a local secondary index.
+ *
+ * The projection is the input because it is what a read of a local secondary
+ * index turns on: which attributes come back by default, and which of them the
+ * read has to reach the base table for.
+ */
+export interface SimDynamoDbLocallyIndexedTableInput {
+    readonly tableName: string;
+    readonly indexName: string;
+    readonly projectionType: SimDynamoDbProjectionType;
+    readonly nonKeyAttributes: readonly string[];
+}
+/**
+ * Creates a table with one local secondary index, holding orders to read.
+ *
+ * The table is keyed by `customerId` and `orderId`, and the index re-sorts each
+ * customer's orders by `placedAt`. One order per customer carries no
+ * `placedAt`, which is what makes the index sparse rather than a second copy of
+ * the table.
+ *
+ * ```typescript
+ * const table = await simDynamoDbLocallyIndexedTableFactory.make(
+ *   { projectionType: "KEYS_ONLY" },
+ *   simAws,
+ * );
+ * ```
+ */
+export declare const simDynamoDbLocallyIndexedTableFactory: AsyncMappedFactory<SimDynamoDbLocallyIndexedTableInput, SimDynamoDbTable, SimAws>;
+//# sourceMappingURL=sim-dynamodb-locally-indexed-table.factory.d.ts.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-locally-indexed-table.factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-locally-indexed-table.factory.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-locally-indexed-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,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAIvE;;;;;;GAMG;AACH,MAAM,WAAW,mCAAmC;IAClD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,yBAAyB,CAAC;IACnD,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qCAAqC,mFA0DjD,CAAC"}

package/dist/service/dynamodb/secondary-index/sim-dynamodb-locally-indexed-table.factory.js

@@ -0,0 +1,61 @@
+import { AsyncMappedFactory } from "@kensio/part-factory";
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { simDynamoDbIndexProjectionInput } from "./sim-dynamodb-index-projection-input.js";
+import { simDynamoDbLocallyIndexedOrders } from "./sim-dynamodb-locally-indexed-orders.js";
+/**
+ * Creates a table with one local secondary index, holding orders to read.
+ *
+ * The table is keyed by `customerId` and `orderId`, and the index re-sorts each
+ * customer's orders by `placedAt`. One order per customer carries no
+ * `placedAt`, which is what makes the index sparse rather than a second copy of
+ * the table.
+ *
+ * ```typescript
+ * const table = await simDynamoDbLocallyIndexedTableFactory.make(
+ *   { projectionType: "KEYS_ONLY" },
+ *   simAws,
+ * );
+ * ```
+ */
+export const simDynamoDbLocallyIndexedTableFactory = new AsyncMappedFactory(() => ({
+    tableName: "OrdersTable",
+    indexName: "byPlacedAt",
+    projectionType: "ALL",
+    nonKeyAttributes: [],
+}), async (input, simAws) => {
+    const simDynamoDb = simAws.dynamoDb();
+    await simDynamoDb.createTable({
+        input: {
+            TableName: input.tableName,
+            KeySchema: [
+                { AttributeName: "customerId", KeyType: "HASH" },
+                { AttributeName: "orderId", KeyType: "RANGE" },
+            ],
+            AttributeDefinitions: [
+                { AttributeName: "customerId", AttributeType: "S" },
+                { AttributeName: "orderId", AttributeType: "S" },
+                { AttributeName: "placedAt", AttributeType: "S" },
+            ],
+            BillingMode: "PAY_PER_REQUEST",
+            LocalSecondaryIndexes: [
+                {
+                    IndexName: input.indexName,
+                    KeySchema: [
+                        { AttributeName: "customerId", KeyType: "HASH" },
+                        { AttributeName: "placedAt", KeyType: "RANGE" },
+                    ],
+                    Projection: simDynamoDbIndexProjectionInput(input),
+                },
+            ],
+        },
+    });
+    await simAws.backgroundTasksComplete();
+    await Promise.all(simDynamoDbLocallyIndexedOrders().map(async (order) => simDynamoDb.putItem({
+        input: { TableName: input.tableName, Item: order },
+    })));
+    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-locally-indexed-table.factory.js.map

package/dist/service/dynamodb/secondary-index/sim-dynamodb-locally-indexed-table.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-locally-indexed-table.factory.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-locally-indexed-table.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAIpE,OAAO,EAAE,+BAA+B,EAAE,MAAM,0CAA0C,CAAC;AAC3F,OAAO,EAAE,+BAA+B,EAAE,MAAM,0CAA0C,CAAC;AAgB3F;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,qCAAqC,GAAG,IAAI,kBAAkB,CAKzE,GAAG,EAAE,CAAC,CAAC;IACL,SAAS,EAAE,aAAa;IACxB,SAAS,EAAE,YAAY;IACvB,cAAc,EAAE,KAAK;IACrB,gBAAgB,EAAE,EAAE;CACrB,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,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE;gBAChD,EAAE,aAAa,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE;aAC/C;YACD,oBAAoB,EAAE;gBACpB,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,EAAE;gBACnD,EAAE,aAAa,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,EAAE;gBAChD,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,GAAG,EAAE;aAClD;YACD,WAAW,EAAE,iBAAiB;YAC9B,qBAAqB,EAAE;gBACrB;oBACE,SAAS,EAAE,KAAK,CAAC,SAAS;oBAC1B,SAAS,EAAE;wBACT,EAAE,aAAa,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE;wBAChD,EAAE,aAAa,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE;qBAChD;oBACD,UAAU,EAAE,+BAA+B,CAAC,KAAK,CAAC;iBACnD;aACF;SACF;KACF,CAAC,CAAC;IACH,MAAM,MAAM,CAAC,uBAAuB,EAAE,CAAC;IAEvC,MAAM,OAAO,CAAC,GAAG,CACf,+BAA+B,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CACpD,WAAW,CAAC,OAAO,CAAC;QAClB,KAAK,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE;KACnD,CAAC,CACH,CACF,CAAC;IAEF,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/secondary-index/sim-dynamodb-projected-index-attributes.d.ts

@@ -0,0 +1,38 @@
+import type { SimDynamoDbDocumentPath } from "../expression/sim-dynamodb-document-path.js";
+import { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbIndexAttributes, SimDynamoDbIndexAttributesProperties } from "./sim-dynamodb-index-attributes.js";
+/**
+ * The attributes a global secondary index carries, and nothing else.
+ *
+ * A global secondary index is a copy of the table held apart from it, so a read
+ * of one never reaches the table. Anything the index does not project is not
+ * there to answer with, which is why asking for it is refused rather than
+ * served.
+ */
+export declare class SimDynamoDbProjectedIndexAttributes implements SimDynamoDbIndexAttributes {
+    private readonly indexName;
+    private readonly projection;
+    private readonly keyAttributeNames;
+    constructor(properties: SimDynamoDbIndexAttributesProperties);
+    /**
+     * Cut an item down to the attributes the index carries.
+     */
+    project(item: SimDynamoDbItem): SimDynamoDbItem;
+    /**
+     * Refuse a read asking for whole items from a projection holding part of one.
+     *
+     * Real DynamoDB reads the table for each item to answer this, at a cost the
+     * request did not ask for, so it refuses it on an index that projects less
+     * than everything.
+     */
+    assertCarriesWholeItem(): void;
+    /**
+     * Refuse an expression naming an attribute the index does not project.
+     */
+    assertCarriesPaths(paths: readonly SimDynamoDbDocumentPath[]): void;
+    /**
+     * Whether the index carries one attribute of the items it holds.
+     */
+    private carries;
+}
+//# sourceMappingURL=sim-dynamodb-projected-index-attributes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-projected-index-attributes.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/secondary-index/sim-dynamodb-projected-index-attributes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6CAA6C,CAAC;AAC3F,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,KAAK,EACV,0BAA0B,EAC1B,oCAAoC,EACrC,MAAM,oCAAoC,CAAC;AAG5C;;;;;;;GAOG;AACH,qBAAa,mCAAoC,YAAW,0BAA0B;IACpF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAsB;IAExD,YAAY,UAAU,EAAE,oCAAoC,EAI3D;IAED;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,CAa9C;IAED;;;;;;OAMG;IACH,sBAAsB,IAAI,IAAI,CAU7B;IAED;;OAEG;IACH,kBAAkB,CAAC,KAAK,EAAE,SAAS,uBAAuB,EAAE,GAAG,IAAI,CAmBlE;IAED;;OAEG;IACH,OAAO,CAAC,OAAO;CAMhB"}