@moicky/dynamodb 2.2.0 → 2.3.0

package/dist/lib/defaultArguments.d.ts

@@ -1,19 +1,21 @@
-import { deleteItem, deleteItems, getAllItems, getItem, getItems, itemExists, putItem, putItems, query, queryAllItems, queryItems, queryPaginatedItems, removeAttributes, updateItem } from "../operations";
+import { deleteItem, deleteItems, getAllItems, getItem, getItems, itemExists, putItem, putItems, query, queryAllItems, queryItems, queryPaginatedItems, removeAttributes, transactGetItems, transactWriteItems, updateItem } from "../operations";
 export interface OperationArguments {
     deleteItem?: Parameters<typeof deleteItem>[1];
     deleteItems?: Parameters<typeof deleteItems>[1];
     getItem?: Parameters<typeof getItem>[1];
     getItems?: Parameters<typeof getItems>[1];
     getAllItems?: Parameters<typeof getAllItems>[0];
-    queryPaginatedItems?: Parameters<typeof queryPaginatedItems>[2];
     itemExists?: Parameters<typeof itemExists>[1];
     putItem?: Parameters<typeof putItem>[1];
     putItems?: Parameters<typeof putItems>[1];
     query?: Parameters<typeof query>[2];
     queryItems?: Parameters<typeof queryItems>[2];
     queryAllItems?: Parameters<typeof queryAllItems>[2];
+    queryPaginatedItems?: Parameters<typeof queryPaginatedItems>[2];
     updateItem?: Parameters<typeof updateItem>[2];
     removeAttributes?: Parameters<typeof removeAttributes>[2];
+    transactGetItems?: Parameters<typeof transactGetItems>[1];
+    transactWriteItems?: Parameters<typeof transactWriteItems>[1];
 }
 /**
  * Initializes the default arguments to use for all operations.
@@ -25,13 +27,13 @@ export interface OperationArguments {
  * initDefaultArguments({
  *   getItem: { ConsistentRead: true },
  *   getAllItems: { ConsistentRead: true },
- *   queryPaginatedItems: { ConsistentRead: true, pageSize: 100 },
  *
  *   itemExists: { ConsistentRead: true },
  *
  *   query: { ConsistentRead: true },
  *   queryItems: { ConsistentRead: true },
  *   queryAllItems: { ConsistentRead: true },
+ *   queryPaginatedItems: { ConsistentRead: true, pageSize: 100 },
  * });
  * ```
  */

package/dist/lib/defaultArguments.js

@@ -12,13 +12,13 @@ let defaultArguments = {};
  * initDefaultArguments({
  *   getItem: { ConsistentRead: true },
  *   getAllItems: { ConsistentRead: true },
- *   queryPaginatedItems: { ConsistentRead: true, pageSize: 100 },
  *
  *   itemExists: { ConsistentRead: true },
  *
  *   query: { ConsistentRead: true },
  *   queryItems: { ConsistentRead: true },
  *   queryAllItems: { ConsistentRead: true },
+ *   queryPaginatedItems: { ConsistentRead: true, pageSize: 100 },
  * });
  * ```
  */

package/dist/lib/helpers.d.ts

@@ -1,7 +1,7 @@
 export declare function stripKey(key: any, args?: {
     TableName?: string;
-}): Record<string, any>;
+}): Record<string, import("@aws-sdk/client-dynamodb").AttributeValue>;
 export declare function splitEvery<T>(items: T[], limit?: number): T[][];
-export declare function getAttributeValues(key: any, attributesToGet?: string[]): Record<string, any>;
+export declare function getAttributeValues(key: any, attributesToGet?: string[]): Record<string, import("@aws-sdk/client-dynamodb").AttributeValue>;
 export declare function getAttributeNames(key: any, attributesToGet?: string[]): Record<string, string>;
 export declare function getAttributesFromExpression(expression: string, prefix?: string): string[];

package/dist/operations/delete.d.ts

@@ -26,7 +26,7 @@ import { BatchWriteItemCommandInput, DeleteItemCommandInput, DeleteItemCommandOu
  * );
  * ```
  */
-export declare function deleteItem(key: any, args?: Partial<DeleteItemCommandInput>): Promise<DeleteItemCommandOutput>;
+export declare function deleteItem(key: Record<string, any>, args?: Partial<DeleteItemCommandInput>): Promise<DeleteItemCommandOutput>;
 type DeleteItemsArgs = Partial<BatchWriteItemCommandInput & {
     TableName?: string;
 }>;
@@ -62,5 +62,5 @@ type DeleteItemsArgs = Partial<BatchWriteItemCommandInput & {
  * );
  * ```
  */
-export declare function deleteItems(keys: any[], args?: DeleteItemsArgs, retry?: number): Promise<void>;
+export declare function deleteItems(keys: Record<string, any>[], args?: DeleteItemsArgs, retry?: number): Promise<void>;
 export {};

package/dist/operations/delete.js

@@ -101,7 +101,7 @@ async function deleteItems(keys, args = {}, retry = 0) {
                 if (res?.UnprocessedItems?.[table]?.length) {
                     if (retry + 1 > 3)
                         return reject(res);
-                    return deleteItems(res.UnprocessedItems[table], args, retry + 1);
+                    return deleteItems(res.UnprocessedItems[table].map((d) => d?.DeleteRequest?.Key), { ...args, TableName: table }, retry + 1);
                 }
             })
                 .catch(reject);

package/dist/operations/get.d.ts

@@ -25,7 +25,7 @@ import { BatchGetItemCommandInput, GetItemCommandInput, ScanCommandInput } from
  * );
  * ```
  */
-export declare function getItem(key: any, args?: Partial<GetItemCommandInput>): Promise<Record<string, any> | undefined>;
+export declare function getItem(key: Record<string, any>, args?: Partial<GetItemCommandInput>): Promise<Record<string, any> | undefined>;
 type GetItemsArgs = Partial<BatchGetItemCommandInput & {
     TableName?: string;
 }>;
@@ -58,7 +58,7 @@ type GetItemsArgs = Partial<BatchGetItemCommandInput & {
  * );
  * ```
  */
-export declare function getItems(keys: any[], args?: GetItemsArgs, retry?: number): Promise<Record<string, any>[]>;
+export declare function getItems(keys: Record<string, any>[], args?: GetItemsArgs, retry?: number): Promise<Record<string, any>[]>;
 /**
  * Retrieves all items from the DynamoDB table.
  * @param args - The additional arguments to override or specify for {@link ScanCommandInput}

package/dist/operations/index.d.ts

@@ -4,3 +4,5 @@ export * from "./misc";
 export * from "./put";
 export * from "./query";
 export * from "./update";
+export * from "./transactGetItems";
+export * from "./transactWriteItems";

package/dist/operations/index.js

@@ -20,3 +20,5 @@ __exportStar(require("./misc"), exports);
 __exportStar(require("./put"), exports);
 __exportStar(require("./query"), exports);
 __exportStar(require("./update"), exports);
+__exportStar(require("./transactGetItems"), exports);
+__exportStar(require("./transactWriteItems"), exports);

package/dist/operations/misc.d.ts

@@ -12,7 +12,7 @@ import { GetItemCommandInput } from "@aws-sdk/client-dynamodb";
  * console.log(exists); // true / false
  * ```
  */
-export declare function itemExists(key: any, args?: Partial<GetItemCommandInput>): Promise<boolean>;
+export declare function itemExists(key: Record<string, any>, args?: Partial<GetItemCommandInput>): Promise<boolean>;
 /**
  * Generate an ascending ID for an item in the DynamoDB table using the key schema.
  * @param params - An object containing key schema information and optional ID length and TableName

package/dist/operations/put.d.ts

@@ -1,7 +1,7 @@
 import { BatchWriteItemCommandInput, BatchWriteItemCommandOutput, PutItemCommandInput, PutItemCommandOutput } from "@aws-sdk/client-dynamodb";
 /**
  * Inserts an item into the DynamoDB table.
- * @param data - The item to insert into the table.
+ * @param item - The item to insert into the table.
  * @param args - The additional arguments to override or specify for {@link PutItemCommandInput}
  * @returns A promise that resolves to the output of {@link PutItemCommandOutput} or the unmarshalled attributes if 'ReturnValues' is specified in 'args'.
  *
@@ -17,7 +17,7 @@ import { BatchWriteItemCommandInput, BatchWriteItemCommandOutput, PutItemCommand
  * });
  * ```
  */
-export declare function putItem(data: any, args?: Partial<PutItemCommandInput>): Promise<PutItemCommandOutput | Record<string, any>>;
+export declare function putItem(item: Record<string, any>, args?: Partial<PutItemCommandInput>): Promise<PutItemCommandOutput | Record<string, any>>;
 type PutItemsArgs = Partial<BatchWriteItemCommandInput & {
     TableName?: string;
 }>;
@@ -42,5 +42,5 @@ type PutItemsArgs = Partial<BatchWriteItemCommandInput & {
  * ]);
  * ```
  */
-export declare function putItems(items: any[], args?: PutItemsArgs): Promise<BatchWriteItemCommandOutput[]>;
+export declare function putItems(items: Record<string, any>[], args?: PutItemsArgs, retry?: number): Promise<BatchWriteItemCommandOutput[]>;
 export {};

package/dist/operations/put.js

@@ -5,7 +5,7 @@ const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 const lib_1 = require("../lib");
 /**
  * Inserts an item into the DynamoDB table.
- * @param data - The item to insert into the table.
+ * @param item - The item to insert into the table.
  * @param args - The additional arguments to override or specify for {@link PutItemCommandInput}
  * @returns A promise that resolves to the output of {@link PutItemCommandOutput} or the unmarshalled attributes if 'ReturnValues' is specified in 'args'.
  *
@@ -21,14 +21,14 @@ const lib_1 = require("../lib");
  * });
  * ```
  */
-async function putItem(data, args = {}) {
+async function putItem(item, args = {}) {
     args = (0, lib_1.withDefaults)(args, "putItem");
-    if (!Object.keys(data).includes("createdAt")) {
-        data.createdAt = Date.now();
+    if (!Object.keys(item).includes("createdAt")) {
+        item.createdAt = Date.now();
     }
     return (0, lib_1.getClient)()
         .send(new client_dynamodb_1.PutItemCommand({
-        Item: (0, lib_1.marshallWithOptions)(data),
+        Item: (0, lib_1.marshallWithOptions)(item),
         ...args,
         TableName: args?.TableName || (0, lib_1.getDefaultTable)(),
     }))
@@ -56,7 +56,9 @@ exports.putItem = putItem;
  * ]);
  * ```
  */
-async function putItems(items, args = {}) {
+async function putItems(items, args = {}, retry = 0) {
+    if (retry > 3)
+        return;
     args = (0, lib_1.withDefaults)(args, "putItems");
     return new Promise(async (resolve, reject) => {
         const now = Date.now();
@@ -78,7 +80,16 @@ async function putItems(items, args = {}) {
                 },
                 ...args,
             }))
-                .then((res) => results.push(res))
+                .then((res) => {
+                results.push(res);
+                if (res?.UnprocessedItems?.[table]?.length) {
+                    if (retry + 1 < 3) {
+                        reject(res);
+                        return;
+                    }
+                    return putItems(res.UnprocessedItems[table].map((item) => (0, lib_1.unmarshallWithOptions)(item.PutRequest.Item)), { ...args, TableName: table }, retry + 1);
+                }
+            })
                 .catch(reject);
         }
         resolve(results);

package/dist/operations/query.d.ts

@@ -15,7 +15,7 @@ import { QueryCommandInput, QueryCommandOutput } from "@aws-sdk/client-dynamodb"
  * });
  * ```
  */
-export declare function query(keyCondition: string, key: any, args?: Partial<QueryCommandInput>): Promise<QueryCommandOutput>;
+export declare function query(keyCondition: string, key: Record<string, any>, args?: Partial<QueryCommandInput>): Promise<QueryCommandOutput>;
 /**
  * Query multiple items from the DynamoDB table using a key condition and unmarshalls the result.
  * @param keyCondition - The condition for the key in DynamoDB QueryCommand.
@@ -32,7 +32,7 @@ export declare function query(keyCondition: string, key: any, args?: Partial<Que
  * });
  * ```
  */
-export declare function queryItems(keyCondition: string, key: any, args?: Partial<QueryCommandInput>): Promise<Record<string, any>[]>;
+export declare function queryItems(keyCondition: string, key: Record<string, any>, args?: Partial<QueryCommandInput>): Promise<Record<string, any>[]>;
 /**
  * Query all items from the DynamoDB table using a key condition and unmarshalls the result.
  * This function retries until all items are retrieved due to the AWS limit of 1MB per query.
@@ -62,7 +62,7 @@ export declare function queryItems(keyCondition: string, key: any, args?: Partia
  * );
  * ```
  */
-export declare function queryAllItems(keyCondition: string, key: any, args?: Partial<QueryCommandInput>): Promise<Record<string, any>[]>;
+export declare function queryAllItems(keyCondition: string, key: Record<string, any>, args?: Partial<QueryCommandInput>): Promise<Record<string, any>[]>;
 /**
  * The structure for the PaginationPage type.
  * @property number - The page number. Cannot be set manually.
@@ -125,4 +125,4 @@ export interface PaginationArgs extends Partial<Omit<QueryCommandInput, "Limit">
  * // currentPage: { number: 2, firstKey: { ... }, lastKey: { ... } }
  * ```
  */
-export declare function queryPaginatedItems(keyCondition: string, key: any, args: PaginationArgs): Promise<PaginationResult>;
+export declare function queryPaginatedItems(keyCondition: string, key: Record<string, any>, args: PaginationArgs): Promise<PaginationResult>;

package/dist/operations/transactGetItems.d.ts

@@ -0,0 +1,42 @@
+import { Get, TransactGetItemsCommandInput } from "@aws-sdk/client-dynamodb";
+/**
+ * Performs a TransactGetItems operation against DynamoDB. This allows you to retrieve many items at once.
+ * @param keys - Array of items to retrieve. Each item requires a `key` property, with at least the partition and the sort key (according to the table definition).
+ * @param args - The additional arguments to override or specify for {@link TransactGetItemsCommandInput}
+ * @returns A promise that resolves to an unmarshalled items array
+ *
+ * @example
+ * Get items from the default-table
+ * ```javascript
+ * const items = await transactGetItems([
+ *    { key: { PK: "User/1", SK: "Book/1", title: "The Great Gatsby", released: 1925 }},
+ *    { key: { PK: "User/1", SK: "Book/2" }},
+ *    { key: { PK: "User/1", SK: "Book/3" }},
+ * ]);
+ * ```
+ * @example
+ * Get items from a different tables
+ * ```javascript
+ * const items = await transactGetItems([
+ *    { TableName: "yourTable", key: { PK: "User/1", SK: "Book/2" }},
+ *    { TableName: "yourOtherTable", key: { PK: "User/1", SK: "Book/3" }},
+ * ]);
+ * ```
+ * @example
+ * Get all items from a non-default table
+ * ```javascript
+ * const items = await transactGetItems(
+ *   [
+ *     { key: { PK: "User/1", SK: "Book/2" } },
+ *     { key: { PK: "User/1", SK: "Book/3" } },
+ *   ],
+ *   { TableName: "yourTable" }
+ * );
+ * ```
+ */
+export declare function transactGetItems(keys: Array<Omit<Get, "TableName" | "Key"> & {
+    key: Record<string, any>;
+    TableName?: string;
+}>, args?: Partial<TransactGetItemsCommandInput & {
+    TableName?: string;
+}>): Promise<Array<Record<string, any> | undefined>>;

package/dist/operations/transactGetItems.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactGetItems = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const lib_1 = require("../lib");
+/**
+ * Performs a TransactGetItems operation against DynamoDB. This allows you to retrieve many items at once.
+ * @param keys - Array of items to retrieve. Each item requires a `key` property, with at least the partition and the sort key (according to the table definition).
+ * @param args - The additional arguments to override or specify for {@link TransactGetItemsCommandInput}
+ * @returns A promise that resolves to an unmarshalled items array
+ *
+ * @example
+ * Get items from the default-table
+ * ```javascript
+ * const items = await transactGetItems([
+ *    { key: { PK: "User/1", SK: "Book/1", title: "The Great Gatsby", released: 1925 }},
+ *    { key: { PK: "User/1", SK: "Book/2" }},
+ *    { key: { PK: "User/1", SK: "Book/3" }},
+ * ]);
+ * ```
+ * @example
+ * Get items from a different tables
+ * ```javascript
+ * const items = await transactGetItems([
+ *    { TableName: "yourTable", key: { PK: "User/1", SK: "Book/2" }},
+ *    { TableName: "yourOtherTable", key: { PK: "User/1", SK: "Book/3" }},
+ * ]);
+ * ```
+ * @example
+ * Get all items from a non-default table
+ * ```javascript
+ * const items = await transactGetItems(
+ *   [
+ *     { key: { PK: "User/1", SK: "Book/2" } },
+ *     { key: { PK: "User/1", SK: "Book/3" } },
+ *   ],
+ *   { TableName: "yourTable" }
+ * );
+ * ```
+ */
+function transactGetItems(keys, args) {
+    return new Promise(async (resolve, reject) => {
+        args = (0, lib_1.withDefaults)(args, "transactGetItems");
+        const { TableName, ...otherArgs } = args;
+        const defaultTable = TableName || (0, lib_1.getDefaultTable)();
+        const batches = (0, lib_1.splitEvery)(keys, 100);
+        const results = [];
+        for (const batch of batches) {
+            await (0, lib_1.getClient)()
+                .send(new client_dynamodb_1.TransactGetItemsCommand({
+                TransactItems: batch.map((item) => {
+                    const table = item.TableName || defaultTable;
+                    return {
+                        Get: {
+                            Key: (0, lib_1.stripKey)(item.key, { TableName: table }),
+                            TableName: table,
+                            ExpressionAttributeNames: item.ExpressionAttributeNames,
+                            ProjectionExpression: item.ProjectionExpression,
+                        },
+                    };
+                }),
+                ...otherArgs,
+            }))
+                .then((res) => results.push(res))
+                .catch(reject);
+        }
+        resolve(results.flatMap((result) => result.Responses?.map((item) => item?.Item ? (0, lib_1.unmarshallWithOptions)(item.Item) : undefined) || []));
+    });
+}
+exports.transactGetItems = transactGetItems;

package/dist/operations/transactWriteItems.d.ts

@@ -0,0 +1,33 @@
+import { ConditionCheck, Delete, ItemCollectionMetrics, Put, TransactWriteItem, TransactWriteItemsCommandInput, Update } from "@aws-sdk/client-dynamodb";
+type TransactItem = {
+    ConditionCheck?: Omit<ConditionCheck, "Key" | "TableName"> & {
+        key: Record<string, any>;
+        conditionData: Record<string, any>;
+        TableName?: string;
+    };
+    Put?: Omit<Put, "Item" | "TableName"> & {
+        item: Record<string, any>;
+        TableName?: string;
+        conditionData?: Record<string, any>;
+    };
+    Delete?: Omit<Delete, "Key" | "TableName"> & {
+        key: Record<string, any>;
+        conditionData?: Record<string, any>;
+        TableName?: string;
+    };
+    Update?: Omit<Update, "Key" | "TableName"> & {
+        key: Record<string, any>;
+        updateData: Record<string, any>;
+        conditionData?: Record<string, any>;
+        TableName?: string;
+    };
+};
+type TransactWriteItemsInput = Partial<Omit<TransactWriteItemsCommandInput, "TransactItems">> & {
+    TransactItems?: TransactWriteItem[];
+    TableName?: string;
+};
+type ResponseItem = Pick<ItemCollectionMetrics, "SizeEstimateRangeGB"> & {
+    Key: Record<string, any>;
+};
+export declare function transactWriteItems(transactItems: TransactItem[], args?: TransactWriteItemsInput): Promise<Record<string, ResponseItem[]>>;
+export {};

package/dist/operations/transactWriteItems.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactWriteItems = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const lib_1 = require("../lib");
+async function transactWriteItems(transactItems, args = {}) {
+    return new Promise(async (resolve, reject) => {
+        args = (0, lib_1.withDefaults)(args, "transactWriteItems");
+        if (transactItems.length > 100) {
+            throw new Error("[@moicky/dynamodb]: TransactWriteItems can only handle up to 100 items");
+        }
+        const now = Date.now();
+        const table = args.TableName || (0, lib_1.getDefaultTable)();
+        const populatedItems = transactItems.map((item) => {
+            if (item.ConditionCheck) {
+                return handleConditionCheck(item.ConditionCheck, { now, table });
+            }
+            else if (item.Put) {
+                return handlePutItem(item.Put, { now, table });
+            }
+            else if (item.Delete) {
+                return handleDeleteItem(item.Delete, { now, table });
+            }
+            else if (item.Update) {
+                return handleUpdateItem(item.Update, { now, table });
+            }
+            else {
+                throw new Error("[@moicky/dynamodb]: Invalid TransactItem: " + JSON.stringify(item));
+            }
+        });
+        return (0, lib_1.getClient)()
+            .send(new client_dynamodb_1.TransactWriteItemsCommand({
+            TransactItems: populatedItems,
+            ...args,
+        }))
+            .then((res) => {
+            const results = {};
+            Object.entries(res.ItemCollectionMetrics || {}).forEach(([tableName, metrics]) => {
+                const unmarshalledMetrics = metrics.map((metric) => ({
+                    Key: (0, lib_1.unmarshallWithOptions)(metric.ItemCollectionKey || {}),
+                    SizeEstimateRangeGB: metric.SizeEstimateRangeGB,
+                }));
+                if (!results[tableName]) {
+                    results[tableName] = [];
+                }
+                results[tableName].push(...unmarshalledMetrics);
+            });
+            resolve(results);
+        })
+            .catch(reject);
+    });
+}
+exports.transactWriteItems = transactWriteItems;
+function handleExpressionAttributes(rest, data) {
+    return {
+        ExpressionAttributeValues: (0, lib_1.getAttributeValues)(data || {}, (0, lib_1.getAttributesFromExpression)(rest.ConditionExpression || "", ":")),
+        ExpressionAttributeNames: (0, lib_1.getAttributeNames)(data || {}, (0, lib_1.getAttributesFromExpression)(rest.ConditionExpression || "")),
+    };
+}
+function handleConditionCheck(params, args) {
+    const { key, conditionData, ...rest } = params;
+    return {
+        ConditionCheck: {
+            Key: (0, lib_1.stripKey)(key, { TableName: rest.TableName || args.table }),
+            ...handleExpressionAttributes(rest, conditionData),
+            ...rest,
+            TableName: rest.TableName || args.table,
+        },
+    };
+}
+function handlePutItem(params, args) {
+    const populatedData = structuredClone(params.item);
+    populatedData.createdAt ??= args.now;
+    const { item, conditionData, ...rest } = params;
+    return {
+        Put: {
+            Item: (0, lib_1.marshallWithOptions)(populatedData),
+            ...handleExpressionAttributes(rest, conditionData),
+            ...rest,
+            TableName: rest.TableName || args.table,
+        },
+    };
+}
+function handleDeleteItem(params, args) {
+    const { key, conditionData, ...rest } = params;
+    return {
+        Delete: {
+            Key: (0, lib_1.stripKey)(key, { TableName: rest.TableName || args.table }),
+            ...handleExpressionAttributes(rest, conditionData),
+            ...rest,
+            TableName: rest.TableName || args.table,
+        },
+    };
+}
+function handleUpdateItem(params, args) {
+    const { key, updateData, conditionData, ...rest } = params;
+    const populatedData = structuredClone(updateData);
+    populatedData.updatedAt ??= args.now;
+    const mergedData = { ...populatedData, ...conditionData };
+    const UpdateExpression = "SET " +
+        Object.keys(populatedData)
+            .map((key) => `#${key} = :${key}`)
+            .join(", ");
+    return {
+        Update: {
+            Key: (0, lib_1.stripKey)(key, { TableName: rest.TableName || args.table }),
+            UpdateExpression,
+            ExpressionAttributeValues: (0, lib_1.getAttributeValues)(mergedData),
+            ExpressionAttributeNames: (0, lib_1.getAttributeNames)({}, (0, lib_1.getAttributesFromExpression)(rest.ConditionExpression || "").concat(Object.keys(populatedData))),
+            ...rest,
+            TableName: rest.TableName || args.table,
+        },
+    };
+}

package/dist/operations/update.d.ts

@@ -31,7 +31,7 @@ import { UpdateItemCommandInput, UpdateItemCommandOutput } from "@aws-sdk/client
  * console.log(newItem); // { "PK": "User/1", "SK": "Book/1", "released": 2000 }
  * ```
  */
-export declare function updateItem(key: any, data: any, args?: Partial<UpdateItemCommandInput>): Promise<undefined | Record<string, any>>;
+export declare function updateItem(key: Record<string, any>, data: Record<string, any>, args?: Partial<UpdateItemCommandInput>): Promise<undefined | Record<string, any>>;
 /**
  * Removes specified attributes from an item in DynamoDB.
  *
@@ -46,4 +46,4 @@ export declare function updateItem(key: any, data: any, args?: Partial<UpdateIte
  * await removeAttributes({ PK: "User/1", SK: "Book/1" }, ["description"]);
  * ```
  */
-export declare function removeAttributes(key: any, attributes: string[], args?: Partial<UpdateItemCommandInput>): Promise<UpdateItemCommandOutput>;
+export declare function removeAttributes(key: Record<string, any>, attributes: string[], args?: Partial<UpdateItemCommandInput>): Promise<UpdateItemCommandOutput>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moicky/dynamodb",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "Contains a collection of convenience functions for working with AWS DynamoDB",

package/readme.md

@@ -16,6 +16,7 @@ Contains convenience functions for all major dynamodb operations. Requires very
 - 🌎 Supports globally defined default arguments for each operation ([example](#configuring-global-defaults))
 - 🔨 Supports fixes for several issues with dynamodb ([example](#applying-fixes))
 - 📖 Offers a convenient way to use pagination with queries
+- 🔨 Supports transactGetItems & transactWriteItems
 
 ## Installation
 
@@ -324,7 +325,7 @@ initFixes({
     enabled: true, // default,
 
     // Won't disable ConsistantRead if IndexName is specified here.
-    stillUseOnLocalIndexes: ["localIndexName1", "localIndexName1"],
+    stillUseOnLocalIndexes: ["localIndexName1", "localIndexName2"],
   },
 });
 ```