@kensio/yulin 0.44.0 → 0.47.0

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

@@ -0,0 +1,67 @@
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbValue } from "../item/sim-dynamodb-value.js";
+import type { SimDynamoDbItemKey } from "./sim-dynamodb-item-key.js";
+interface SimDynamoDbSortKeyOrderProperties {
+    readonly attributeName: string | undefined;
+    readonly identity?: SimDynamoDbItemKey | undefined;
+}
+/**
+ * The order a sort key puts an item collection in.
+ *
+ * A table with no sort key holds at most one item under a partition key, so
+ * every question here has a trivial answer for one. That is why the attribute
+ * name is optional rather than each caller asking whether there is one.
+ *
+ * The order is DynamoDB's rather than JavaScript's: numbers order by value
+ * however they were written, strings by their UTF-8 bytes, and binary as
+ * unsigned bytes.
+ *
+ * An index needs one thing more. Index key values are not unique, so a sort key
+ * settles nothing between two items sharing one, and a walk that could not tell
+ * them apart could not resume after either. The identity is what separates
+ * them: the table primary key, which is unique by definition. That is why a
+ * read of an index hands out a token carrying both.
+ */
+export declare class SimDynamoDbSortKeyOrder {
+    private readonly attributeName;
+    private readonly identity;
+    constructor(properties: SimDynamoDbSortKeyOrderProperties);
+    /**
+     * The sort key of an item, or nothing when the collection has no sort key.
+     */
+    valueOf(item: SimDynamoDbItem): SimDynamoDbValue | undefined;
+    /**
+     * Items in ascending sort key order.
+     */
+    ascending(items: readonly SimDynamoDbItem[]): readonly SimDynamoDbItem[];
+    /**
+     * The items past the one a request resumes after, in the walk direction.
+     *
+     * With nothing to order a collection by, it holds one item, and that is the
+     * item the token names, so nothing comes after it.
+     */
+    beyond(items: readonly SimDynamoDbItem[], after: SimDynamoDbItem, forward: boolean): readonly SimDynamoDbItem[];
+    /**
+     * Order two items of one collection, by sort key and then by identity.
+     *
+     * With neither a sort key nor an identity, a partition key value names at
+     * most one item, so two items that reach here are the same item and nothing
+     * separates them. A scan orders a whole table this way once it has ordered by
+     * partition key.
+     */
+    compareItems(first: SimDynamoDbItem, second: SimDynamoDbItem): number;
+    /**
+     * Order two items by their sort keys, if the collection has one.
+     */
+    private compareSortKeys;
+    /**
+     * Separate two items their sort keys did not, where something can.
+     */
+    private compareIdentities;
+    /**
+     * Which way along the sort key the walk is going.
+     */
+    private direction;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-sort-key-order.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-sort-key-order.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-sort-key-order.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAOrE,UAAU,iCAAiC;IACzC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,QAAQ,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;CACpD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IACnD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiC;IAE1D,YAAY,UAAU,EAAE,iCAAiC,EAGxD;IAED;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,eAAe,GAAG,gBAAgB,GAAG,SAAS,CAQ3D;IAED;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,eAAe,EAAE,CAEvE;IAED;;;;;OAKG;IACH,MAAM,CACJ,KAAK,EAAE,SAAS,eAAe,EAAE,EACjC,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE,OAAO,GACf,SAAS,eAAe,EAAE,CAM5B;IAED;;;;;;;OAOG;IACH,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,eAAe,GAAG,MAAM,CAQpE;IAED;;OAEG;IACH,OAAO,CAAC,eAAe;IAavB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAazB;;OAEG;IACH,OAAO,CAAC,SAAS;CAOlB"}

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

@@ -0,0 +1,97 @@
+import { compareSimDynamoDbItemIdentities, compareSimDynamoDbSortKeys, simDynamoDbSortKeyValue, } from "./sim-dynamodb-sort-key-compare.js";
+/**
+ * The order a sort key puts an item collection in.
+ *
+ * A table with no sort key holds at most one item under a partition key, so
+ * every question here has a trivial answer for one. That is why the attribute
+ * name is optional rather than each caller asking whether there is one.
+ *
+ * The order is DynamoDB's rather than JavaScript's: numbers order by value
+ * however they were written, strings by their UTF-8 bytes, and binary as
+ * unsigned bytes.
+ *
+ * An index needs one thing more. Index key values are not unique, so a sort key
+ * settles nothing between two items sharing one, and a walk that could not tell
+ * them apart could not resume after either. The identity is what separates
+ * them: the table primary key, which is unique by definition. That is why a
+ * read of an index hands out a token carrying both.
+ */
+export class SimDynamoDbSortKeyOrder {
+    attributeName;
+    identity;
+    constructor(properties) {
+        this.attributeName = properties.attributeName;
+        this.identity = properties.identity;
+    }
+    /**
+     * The sort key of an item, or nothing when the collection has no sort key.
+     */
+    valueOf(item) {
+        const attributeName = this.attributeName;
+        if (attributeName === undefined) {
+            return undefined;
+        }
+        return simDynamoDbSortKeyValue(item, attributeName);
+    }
+    /**
+     * Items in ascending sort key order.
+     */
+    ascending(items) {
+        return items.toSorted((first, second) => this.compareItems(first, second));
+    }
+    /**
+     * The items past the one a request resumes after, in the walk direction.
+     *
+     * With nothing to order a collection by, it holds one item, and that is the
+     * item the token names, so nothing comes after it.
+     */
+    beyond(items, after, forward) {
+        const direction = this.direction(forward);
+        return items.filter((item) => this.compareItems(item, after) * direction > 0);
+    }
+    /**
+     * Order two items of one collection, by sort key and then by identity.
+     *
+     * With neither a sort key nor an identity, a partition key value names at
+     * most one item, so two items that reach here are the same item and nothing
+     * separates them. A scan orders a whole table this way once it has ordered by
+     * partition key.
+     */
+    compareItems(first, second) {
+        const bySortKey = this.compareSortKeys(first, second);
+        if (bySortKey !== 0) {
+            return bySortKey;
+        }
+        return this.compareIdentities(first, second);
+    }
+    /**
+     * Order two items by their sort keys, if the collection has one.
+     */
+    compareSortKeys(first, second) {
+        const attributeName = this.attributeName;
+        if (attributeName === undefined) {
+            return 0;
+        }
+        return compareSimDynamoDbSortKeys(first, second, attributeName);
+    }
+    /**
+     * Separate two items their sort keys did not, where something can.
+     */
+    compareIdentities(first, second) {
+        const identity = this.identity;
+        if (identity === undefined) {
+            return 0;
+        }
+        return compareSimDynamoDbItemIdentities(first, second, identity);
+    }
+    /**
+     * Which way along the sort key the walk is going.
+     */
+    direction(forward) {
+        if (forward) {
+            return 1;
+        }
+        return -1;
+    }
+}
+//# sourceMappingURL=sim-dynamodb-sort-key-order.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-sort-key-order.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-sort-key-order.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,gCAAgC,EAChC,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,oCAAoC,CAAC;AAO5C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,uBAAuB;IACjB,aAAa,CAAqB;IAClC,QAAQ,CAAiC;IAE1D,YAAY,UAA6C;QACvD,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC;QAC9C,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,IAAqB;QAC3B,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QAEzC,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;YAChC,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,uBAAuB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;IACtD,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,KAAiC;QACzC,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IAC7E,CAAC;IAED;;;;;OAKG;IACH,MAAM,CACJ,KAAiC,EACjC,KAAsB,EACtB,OAAgB;QAEhB,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAE1C,OAAO,KAAK,CAAC,MAAM,CACjB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,SAAS,GAAG,CAAC,CACzD,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,YAAY,CAAC,KAAsB,EAAE,MAAuB;QAC1D,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAEtD,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;YACpB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACK,eAAe,CACrB,KAAsB,EACtB,MAAuB;QAEvB,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QAEzC,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;YAChC,OAAO,CAAC,CAAC;QACX,CAAC;QAED,OAAO,0BAA0B,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC;IAClE,CAAC;IAED;;OAEG;IACK,iBAAiB,CACvB,KAAsB,EACtB,MAAuB;QAEvB,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAE/B,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,CAAC,CAAC;QACX,CAAC;QAED,OAAO,gCAAgC,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IACnE,CAAC;IAED;;OAEG;IACK,SAAS,CAAC,OAAgB;QAChC,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,CAAC,CAAC;QACX,CAAC;QAED,OAAO,CAAC,CAAC,CAAC;IACZ,CAAC;CACF"}

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

@@ -0,0 +1,43 @@
+import { AsyncMappedFactory } from "@kensio/part-factory";
+import type { SimAws } from "../../aws/sim-aws.js";
+import type { SimDynamoDbTable } from "./sim-dynamodb-table.js";
+/**
+ * What a test asks for when it wants a table with items already in it.
+ *
+ * The customers and orders are counts rather than the values themselves, so a
+ * test asking for fewer than the default gets fewer rather than the first few
+ * defaults with its own in place of them.
+ */
+export interface SimDynamoDbStockedTableInput {
+    readonly tableName: string;
+    readonly customerCount: number;
+    readonly orderCount: number;
+}
+/**
+ * The customers a stocked table holds orders for, so a test can name them.
+ */
+export declare function simDynamoDbStockedCustomerIds(customerCount: number): readonly string[];
+/**
+ * Creates a table keyed by customer and order, holding one item per pair.
+ *
+ * This is the table a Scan reads: several item collections rather than one, so
+ * a walk of the whole table has more than one partition key value to put in
+ * order. Use `simDynamoDbCollectionTableFactory` for the same table with
+ * nothing written to it.
+ *
+ * Each order carries a `status` of `OPEN` or `SHIPPED`, alternating over the
+ * table, and a `total` counting up from 1 in the same order. Both are there so
+ * a read can filter, project or compare by something outside the key.
+ *
+ * The orders are written together rather than in order, so the order a scan
+ * answers in is the table's rather than the order they arrived in.
+ *
+ * ```typescript
+ * const table = await simDynamoDbStockedTableFactory.make(
+ *   { customerCount: 20 },
+ *   simAws,
+ * );
+ * ```
+ */
+export declare const simDynamoDbStockedTableFactory: AsyncMappedFactory<SimDynamoDbStockedTableInput, SimDynamoDbTable, SimAws>;
+//# sourceMappingURL=sim-dynamodb-stocked-table.factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stocked-table.factory.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-stocked-table.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;GAMG;AACH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,MAAM,GACpB,SAAS,MAAM,EAAE,CAKnB;AA2CD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,8BAA8B,4EAsC1C,CAAC"}

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

@@ -0,0 +1,77 @@
+import { AsyncMappedFactory } from "@kensio/part-factory";
+import { simDynamoDbCollectionTableFactory } from "./sim-dynamodb-collection-table.factory.js";
+/**
+ * The customers a stocked table holds orders for, so a test can name them.
+ */
+export function simDynamoDbStockedCustomerIds(customerCount) {
+    return Array.from({ length: customerCount }, (_, customer) => `c-${(customer + 1).toString()}`);
+}
+/**
+ * The orders a stocked table holds for each customer.
+ */
+function orderIds(orderCount) {
+    return Array.from({ length: orderCount }, (_, order) => `2026-${(order + 1).toString().padStart(2, "0")}`);
+}
+/**
+ * The status the order in one place of the table carries.
+ *
+ * Statuses alternate over the table as a whole, so a read filtering by one has
+ * something to keep and something to drop however few orders a test asks for,
+ * and a table of one order per customer alternates by customer.
+ */
+function orderStatus(position) {
+    if (position % 2 === 0) {
+        return "OPEN";
+    }
+    return "SHIPPED";
+}
+/**
+ * One order a stocked table holds, as the item it is written as.
+ */
+function orderItem(customerId, orderId, position) {
+    return {
+        customerId: { S: customerId },
+        orderId: { S: orderId },
+        status: { S: orderStatus(position) },
+        total: { N: (position + 1).toString() },
+    };
+}
+/**
+ * Creates a table keyed by customer and order, holding one item per pair.
+ *
+ * This is the table a Scan reads: several item collections rather than one, so
+ * a walk of the whole table has more than one partition key value to put in
+ * order. Use `simDynamoDbCollectionTableFactory` for the same table with
+ * nothing written to it.
+ *
+ * Each order carries a `status` of `OPEN` or `SHIPPED`, alternating over the
+ * table, and a `total` counting up from 1 in the same order. Both are there so
+ * a read can filter, project or compare by something outside the key.
+ *
+ * The orders are written together rather than in order, so the order a scan
+ * answers in is the table's rather than the order they arrived in.
+ *
+ * ```typescript
+ * const table = await simDynamoDbStockedTableFactory.make(
+ *   { customerCount: 20 },
+ *   simAws,
+ * );
+ * ```
+ */
+export const simDynamoDbStockedTableFactory = new AsyncMappedFactory(() => ({
+    tableName: "OrdersTable",
+    customerCount: 3,
+    orderCount: 2,
+}), async (input, simAws) => {
+    const table = await simDynamoDbCollectionTableFactory.make({ tableName: input.tableName }, simAws);
+    const simDynamoDb = simAws.dynamoDb();
+    const orders = orderIds(input.orderCount);
+    await Promise.all(simDynamoDbStockedCustomerIds(input.customerCount).flatMap((customerId, customer) => orders.map(async (orderId, order) => simDynamoDb.putItem({
+        input: {
+            TableName: input.tableName,
+            Item: orderItem(customerId, orderId, customer * orders.length + order),
+        },
+    }))));
+    return table;
+});
+//# sourceMappingURL=sim-dynamodb-stocked-table.factory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-stocked-table.factory.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-stocked-table.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,EAAE,iCAAiC,EAAE,MAAM,4CAA4C,CAAC;AAgB/F;;GAEG;AACH,MAAM,UAAU,6BAA6B,CAC3C,aAAqB;IAErB,OAAO,KAAK,CAAC,IAAI,CACf,EAAE,MAAM,EAAE,aAAa,EAAE,EACzB,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAE,CAClD,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,QAAQ,CAAC,UAAkB;IAClC,OAAO,KAAK,CAAC,IAAI,CACf,EAAE,MAAM,EAAE,UAAU,EAAE,EACtB,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAChE,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,WAAW,CAAC,QAAgB;IACnC,IAAI,QAAQ,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;GAEG;AACH,SAAS,SAAS,CAChB,UAAkB,EAClB,OAAe,EACf,QAAgB;IAEhB,OAAO;QACL,UAAU,EAAE,EAAE,CAAC,EAAE,UAAU,EAAE;QAC7B,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE;QACvB,MAAM,EAAE,EAAE,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAC,EAAE;QACpC,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAE;KACxC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,IAAI,kBAAkB,CAKlE,GAAG,EAAE,CAAC,CAAC;IACL,SAAS,EAAE,aAAa;IACxB,aAAa,EAAE,CAAC;IAChB,UAAU,EAAE,CAAC;CACd,CAAC,EACF,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;IACtB,MAAM,KAAK,GAAG,MAAM,iCAAiC,CAAC,IAAI,CACxD,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,EAC9B,MAAM,CACP,CAAC;IACF,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;IACtC,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAE1C,MAAM,OAAO,CAAC,GAAG,CACf,6BAA6B,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,OAAO,CACxD,CAAC,UAAU,EAAE,QAAQ,EAAE,EAAE,CACvB,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,CAClC,WAAW,CAAC,OAAO,CAAC;QAClB,KAAK,EAAE;YACL,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,IAAI,EAAE,SAAS,CACb,UAAU,EACV,OAAO,EACP,QAAQ,GAAG,MAAM,CAAC,MAAM,GAAG,KAAK,CACjC;SACF;KACF,CAAC,CACH,CACJ,CACF,CAAC;IAEF,OAAO,KAAK,CAAC;AACf,CAAC,CACF,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-table-arn.d.ts

@@ -0,0 +1,10 @@
+import type { SimArn } from "../../aws/arn.js";
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+/**
+ * The ARN a table has in an Account and Region.
+ *
+ * The table need not exist. CreateTable authorizes against the ARN the table is
+ * about to have, as real IAM does before the service handles the request.
+ */
+export declare function simDynamoDbTableArn(accountRegionScope: SimAwsAccountRegionScope, tableName: string): SimArn;
+//# sourceMappingURL=sim-dynamodb-table-arn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-table-arn.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-table-arn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAE1F;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,kBAAkB,EAAE,wBAAwB,EAC5C,SAAS,EAAE,MAAM,GAChB,MAAM,CAER"}

package/dist/service/dynamodb/table/sim-dynamodb-table-arn.js

@@ -0,0 +1,10 @@
+/**
+ * The ARN a table has in an Account and Region.
+ *
+ * The table need not exist. CreateTable authorizes against the ARN the table is
+ * about to have, as real IAM does before the service handles the request.
+ */
+export function simDynamoDbTableArn(accountRegionScope, tableName) {
+    return `arn:aws:dynamodb:${accountRegionScope.regionName}:${accountRegionScope.accountId}:table/${tableName}`;
+}
+//# sourceMappingURL=sim-dynamodb-table-arn.js.map

package/dist/service/dynamodb/table/sim-dynamodb-table-arn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-table-arn.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-table-arn.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CACjC,kBAA4C,EAC5C,SAAiB;IAEjB,OAAO,oBAAoB,kBAAkB,CAAC,UAAU,IAAI,kBAAkB,CAAC,SAAS,UAAU,SAAS,EAAE,CAAC;AAChH,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-table-billing.d.ts

@@ -0,0 +1,40 @@
+import type { SimDynamoDbBillingMode, SimDynamoDbBillingModeSummary, SimDynamoDbProvisionedThroughput, SimDynamoDbProvisionedThroughputDescription } from "../command/table/table.types.js";
+interface SimDynamoDbTableBillingInput {
+    readonly BillingMode?: string | undefined;
+    readonly ProvisionedThroughput?: SimDynamoDbProvisionedThroughput | undefined;
+}
+/**
+ * How a simulated table is billed, and what it is provisioned for.
+ *
+ * `BillingMode` defaults to `PROVISIONED`, which is what makes
+ * `ProvisionedThroughput` required on a request that leaves it out.
+ */
+export declare class SimDynamoDbTableBilling {
+    readonly mode: SimDynamoDbBillingMode;
+    private readonly throughput;
+    private readonly requestedMode;
+    private constructor();
+    /**
+     * Read the billing mode and throughput a CreateTable request carries.
+     */
+    static fromInput(input: SimDynamoDbTableBillingInput): SimDynamoDbTableBilling;
+    /**
+     * This billing with the capacity an UpdateTable request names.
+     *
+     * A request carrying capacity and no `BillingMode` is asking to reprovision
+     * the table rather than to bill it another way, so the mode is kept. Whether
+     * the table reports a `BillingModeSummary` is kept too, since that says
+     * whether the request that made it named a mode, and this request did not.
+     */
+    withThroughput(throughput: SimDynamoDbProvisionedThroughput | undefined): SimDynamoDbTableBilling;
+    /**
+     * How the table reports its throughput.
+     */
+    throughputDescription(): SimDynamoDbProvisionedThroughputDescription;
+    /**
+     * How the table reports its billing mode, when the request named one.
+     */
+    summary(): SimDynamoDbBillingModeSummary | undefined;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-table-billing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-table-billing.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-table-billing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,6BAA6B,EAC7B,gCAAgC,EAChC,2CAA2C,EAC5C,MAAM,iCAAiC,CAAC;AAIzC,UAAU,4BAA4B;IACpC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,qBAAqB,CAAC,EAAE,gCAAgC,GAAG,SAAS,CAAC;CAC/E;AA2DD;;;;;GAKG;AACH,qBAAa,uBAAuB;IAClC,SAAgB,IAAI,EAAE,sBAAsB,CAAC;IAE7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAU;IAExC,OAAO,eAIN;IAED;;OAEG;IACH,MAAM,CAAC,SAAS,CACd,KAAK,EAAE,4BAA4B,GAClC,uBAAuB,CAQzB;IAED;;;;;;;OAOG;IACH,cAAc,CACZ,UAAU,EAAE,gCAAgC,GAAG,SAAS,GACvD,uBAAuB,CAQzB;IAED;;OAEG;IACH,qBAAqB,IAAI,2CAA2C,CAEnE;IAED;;OAEG;IACH,OAAO,IAAI,6BAA6B,GAAG,SAAS,CAMnD;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-table-billing.js

@@ -0,0 +1,97 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+import { SimDynamoDbTableThroughput } from "./sim-dynamodb-table-throughput.js";
+const billingModes = new Set([
+    "PROVISIONED",
+    "PAY_PER_REQUEST",
+]);
+/**
+ * Read the billing mode a request names, defaulting to the one AWS defaults to.
+ */
+function readBillingMode(requested) {
+    if (requested === undefined) {
+        return "PROVISIONED";
+    }
+    if (!billingModes.has(requested)) {
+        throw new SimDynamoDbValidationException(`BillingMode '${requested}' is invalid. It is one of PROVISIONED or ` +
+            `PAY_PER_REQUEST.`);
+    }
+    return requested;
+}
+/**
+ * Read the capacity that goes with a billing mode.
+ *
+ * The two contradict each other in both directions. A provisioned table has to
+ * say what it is provisioned with, and an on-demand table has nothing to
+ * provision, so naming a throughput for one is refused.
+ */
+function readThroughput(mode, input) {
+    if (mode === "PROVISIONED") {
+        return SimDynamoDbTableThroughput.required(input.ProvisionedThroughput);
+    }
+    if (input.ProvisionedThroughput !== undefined) {
+        throw new SimDynamoDbValidationException("One or more parameter values were invalid: Neither ReadCapacityUnits " +
+            "nor WriteCapacityUnits can be specified when BillingMode is " +
+            "PAY_PER_REQUEST");
+    }
+    return SimDynamoDbTableThroughput.none();
+}
+/**
+ * How a simulated table is billed, and what it is provisioned for.
+ *
+ * `BillingMode` defaults to `PROVISIONED`, which is what makes
+ * `ProvisionedThroughput` required on a request that leaves it out.
+ */
+export class SimDynamoDbTableBilling {
+    mode;
+    throughput;
+    requestedMode;
+    constructor(properties) {
+        this.mode = properties.mode;
+        this.throughput = properties.throughput;
+        this.requestedMode = properties.requestedMode;
+    }
+    /**
+     * Read the billing mode and throughput a CreateTable request carries.
+     */
+    static fromInput(input) {
+        const mode = readBillingMode(input.BillingMode);
+        return new this({
+            mode,
+            throughput: readThroughput(mode, input),
+            requestedMode: input.BillingMode !== undefined,
+        });
+    }
+    /**
+     * This billing with the capacity an UpdateTable request names.
+     *
+     * A request carrying capacity and no `BillingMode` is asking to reprovision
+     * the table rather than to bill it another way, so the mode is kept. Whether
+     * the table reports a `BillingModeSummary` is kept too, since that says
+     * whether the request that made it named a mode, and this request did not.
+     */
+    withThroughput(throughput) {
+        return new SimDynamoDbTableBilling({
+            mode: this.mode,
+            throughput: readThroughput(this.mode, {
+                ProvisionedThroughput: throughput,
+            }),
+            requestedMode: this.requestedMode,
+        });
+    }
+    /**
+     * How the table reports its throughput.
+     */
+    throughputDescription() {
+        return this.throughput.toDescription();
+    }
+    /**
+     * How the table reports its billing mode, when the request named one.
+     */
+    summary() {
+        if (!this.requestedMode) {
+            return undefined;
+        }
+        return { BillingMode: this.mode };
+    }
+}
+//# sourceMappingURL=sim-dynamodb-table-billing.js.map

package/dist/service/dynamodb/table/sim-dynamodb-table-billing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-table-billing.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-table-billing.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAahF,MAAM,YAAY,GAAwB,IAAI,GAAG,CAAC;IAChD,aAAa;IACb,iBAAiB;CAClB,CAAC,CAAC;AAEH;;GAEG;AACH,SAAS,eAAe,CACtB,SAA6B;IAE7B,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,8BAA8B,CACtC,gBAAgB,SAAS,4CAA4C;YACnE,kBAAkB,CACrB,CAAC;IACJ,CAAC;IAED,OAAO,SAAmC,CAAC;AAC7C,CAAC;AAED;;;;;;GAMG;AACH,SAAS,cAAc,CACrB,IAA4B,EAC5B,KAAmC;IAEnC,IAAI,IAAI,KAAK,aAAa,EAAE,CAAC;QAC3B,OAAO,0BAA0B,CAAC,QAAQ,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;IAC1E,CAAC;IAED,IAAI,KAAK,CAAC,qBAAqB,KAAK,SAAS,EAAE,CAAC;QAC9C,MAAM,IAAI,8BAA8B,CACtC,uEAAuE;YACrE,8DAA8D;YAC9D,iBAAiB,CACpB,CAAC;IACJ,CAAC;IAED,OAAO,0BAA0B,CAAC,IAAI,EAAE,CAAC;AAC3C,CAAC;AAED;;;;;GAKG;AACH,MAAM,OAAO,uBAAuB;IAClB,IAAI,CAAyB;IAE5B,UAAU,CAA6B;IACvC,aAAa,CAAU;IAExC,YAAoB,UAA6C;QAC/D,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAC5B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;QACxC,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,SAAS,CACd,KAAmC;QAEnC,MAAM,IAAI,GAAG,eAAe,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAEhD,OAAO,IAAI,IAAI,CAAC;YACd,IAAI;YACJ,UAAU,EAAE,cAAc,CAAC,IAAI,EAAE,KAAK,CAAC;YACvC,aAAa,EAAE,KAAK,CAAC,WAAW,KAAK,SAAS;SAC/C,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACH,cAAc,CACZ,UAAwD;QAExD,OAAO,IAAI,uBAAuB,CAAC;YACjC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,UAAU,EAAE,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE;gBACpC,qBAAqB,EAAE,UAAU;aAClC,CAAC;YACF,aAAa,EAAE,IAAI,CAAC,aAAa;SAClC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,qBAAqB;QACnB,OAAO,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,OAAO;QACL,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;IACpC,CAAC;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-table-class.d.ts

@@ -0,0 +1,10 @@
+import type { SimDynamoDbTableClass } from "../command/table/table.types.js";
+/**
+ * Read the table class a request names, if it names one.
+ *
+ * A table with no class named is a STANDARD table. It is kept as undefined
+ * rather than filled in, because a table only reports a class here when the
+ * request that made it asked for one.
+ */
+export declare function readSimDynamoDbTableClass(value: string | undefined): SimDynamoDbTableClass | undefined;
+//# sourceMappingURL=sim-dynamodb-table-class.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-table-class.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-table-class.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAQ7E;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,qBAAqB,GAAG,SAAS,CAanC"}

package/dist/service/dynamodb/table/sim-dynamodb-table-class.js

@@ -0,0 +1,23 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+const tableClasses = new Set([
+    "STANDARD",
+    "STANDARD_INFREQUENT_ACCESS",
+]);
+/**
+ * Read the table class a request names, if it names one.
+ *
+ * A table with no class named is a STANDARD table. It is kept as undefined
+ * rather than filled in, because a table only reports a class here when the
+ * request that made it asked for one.
+ */
+export function readSimDynamoDbTableClass(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!tableClasses.has(value)) {
+        throw new SimDynamoDbValidationException(`TableClass '${value}' is invalid. It is one of STANDARD or ` +
+            `STANDARD_INFREQUENT_ACCESS.`);
+    }
+    return value;
+}
+//# sourceMappingURL=sim-dynamodb-table-class.js.map

package/dist/service/dynamodb/table/sim-dynamodb-table-class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-table-class.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-table-class.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAE5E,MAAM,YAAY,GAAwB,IAAI,GAAG,CAAC;IAChD,UAAU;IACV,4BAA4B;CAC7B,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,yBAAyB,CACvC,KAAyB;IAEzB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,8BAA8B,CACtC,eAAe,KAAK,yCAAyC;YAC3D,6BAA6B,CAChC,CAAC;IACJ,CAAC;IAED,OAAO,KAA8B,CAAC;AACxC,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-table-definition.d.ts

@@ -0,0 +1,53 @@
+import type { SimDynamoDbTableClass } from "../command/table/table.types.js";
+import type { SimDynamoDbAttributeDefinitions } from "./sim-dynamodb-attribute-definitions.js";
+import { SimDynamoDbItemKey } from "./sim-dynamodb-item-key.js";
+import type { SimDynamoDbKeySchema } from "./sim-dynamodb-key-schema.js";
+import type { SimDynamoDbTableBilling } from "./sim-dynamodb-table-billing.js";
+import type { SimDynamoDbTableUpdate } from "./sim-dynamodb-table-update.js";
+interface SimDynamoDbTableDefinitionProperties {
+    readonly keySchema: SimDynamoDbKeySchema;
+    readonly attributeDefinitions: SimDynamoDbAttributeDefinitions;
+    readonly billing: SimDynamoDbTableBilling;
+    readonly tableClass: SimDynamoDbTableClass | undefined;
+}
+/**
+ * What a table is, as far as UpdateTable can change it.
+ *
+ * A table's key schema is fixed for its whole life, and everything here is not:
+ * the attributes its keys are made of grow when an index is added, and how it is
+ * billed and which class it is stored under can both be changed. Holding them
+ * together is what lets an update replace them in one step, while everything
+ * already holding the table goes on reading the table.
+ */
+export declare class SimDynamoDbTableDefinition {
+    #private;
+    readonly keySchema: SimDynamoDbKeySchema;
+    constructor(properties: SimDynamoDbTableDefinitionProperties);
+    /**
+     * The attributes the table's keys are made of, its own and its indexes'.
+     */
+    get attributeDefinitions(): SimDynamoDbAttributeDefinitions;
+    /**
+     * How the table is billed, and what it is provisioned for.
+     */
+    get billing(): SimDynamoDbTableBilling;
+    /**
+     * The class the table is stored under, when it was given one.
+     */
+    get tableClass(): SimDynamoDbTableClass | undefined;
+    /**
+     * How the table reads the primary key of an item.
+     */
+    get itemKey(): SimDynamoDbItemKey;
+    /**
+     * Take the part of an UpdateTable that changes what the table is.
+     *
+     * The attribute definitions always come through, since an update that added
+     * none gives back the set the table already had. The item key is rebuilt from
+     * them, so a key attribute is still checked against the type the table
+     * declares for it.
+     */
+    apply(update: SimDynamoDbTableUpdate): void;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-table-definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-table-definition.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-table-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC7E,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,yCAAyC,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAE7E,UAAU,oCAAoC;IAC5C,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,QAAQ,CAAC,oBAAoB,EAAE,+BAA+B,CAAC;IAC/D,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,qBAAqB,GAAG,SAAS,CAAC;CACxD;AAED;;;;;;;;GAQG;AACH,qBAAa,0BAA0B;;IACrC,SAAgB,SAAS,EAAE,oBAAoB,CAAC;IAOhD,YAAY,UAAU,EAAE,oCAAoC,EAS3D;IAED;;OAEG;IACH,IAAI,oBAAoB,IAAI,+BAA+B,CAE1D;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,uBAAuB,CAErC;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,qBAAqB,GAAG,SAAS,CAElD;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,kBAAkB,CAEhC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI,CAQ1C;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-table-definition.js

@@ -0,0 +1,63 @@
+import { SimDynamoDbItemKey } from "./sim-dynamodb-item-key.js";
+/**
+ * What a table is, as far as UpdateTable can change it.
+ *
+ * A table's key schema is fixed for its whole life, and everything here is not:
+ * the attributes its keys are made of grow when an index is added, and how it is
+ * billed and which class it is stored under can both be changed. Holding them
+ * together is what lets an update replace them in one step, while everything
+ * already holding the table goes on reading the table.
+ */
+export class SimDynamoDbTableDefinition {
+    keySchema;
+    #attributeDefinitions;
+    #billing;
+    #tableClass;
+    #itemKey;
+    constructor(properties) {
+        this.keySchema = properties.keySchema;
+        this.#attributeDefinitions = properties.attributeDefinitions;
+        this.#billing = properties.billing;
+        this.#tableClass = properties.tableClass;
+        this.#itemKey = new SimDynamoDbItemKey(properties.keySchema, properties.attributeDefinitions);
+    }
+    /**
+     * The attributes the table's keys are made of, its own and its indexes'.
+     */
+    get attributeDefinitions() {
+        return this.#attributeDefinitions;
+    }
+    /**
+     * How the table is billed, and what it is provisioned for.
+     */
+    get billing() {
+        return this.#billing;
+    }
+    /**
+     * The class the table is stored under, when it was given one.
+     */
+    get tableClass() {
+        return this.#tableClass;
+    }
+    /**
+     * How the table reads the primary key of an item.
+     */
+    get itemKey() {
+        return this.#itemKey;
+    }
+    /**
+     * Take the part of an UpdateTable that changes what the table is.
+     *
+     * The attribute definitions always come through, since an update that added
+     * none gives back the set the table already had. The item key is rebuilt from
+     * them, so a key attribute is still checked against the type the table
+     * declares for it.
+     */
+    apply(update) {
+        this.#attributeDefinitions = update.attributeDefinitions;
+        this.#itemKey = new SimDynamoDbItemKey(this.keySchema, update.attributeDefinitions);
+        this.#billing = update.billing ?? this.#billing;
+        this.#tableClass = update.tableClass ?? this.#tableClass;
+    }
+}
+//# sourceMappingURL=sim-dynamodb-table-definition.js.map