@moicky/dynamodb 2.6.3 → 3.0.0

package/dist/lib/client.js

@@ -2,38 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getClient = exports.initClient = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const oidc_1 = require("@vercel/functions/oidc");
 const schemas_1 = require("./schemas");
-const authTypes = {
-    vercel: () => {
-        if (!process.env.AWS_ROLE_ARN)
-            return {};
-        return {
-            credentials: import("@vercel/functions/oidc").then(({ awsCredentialsProvider }) => ({
-                credentials: awsCredentialsProvider({
-                    roleArn: process.env.AWS_ROLE_ARN,
-                    roleSessionName: "moicky-dynamodb",
-                }),
-            })),
-        };
-    },
-    assumeRole: () => {
-        if (!process.env.DYNAMODB_ASSUME_ROLE)
-            return {};
-        return {
-            credentials: import("@aws-sdk/credential-providers").then(({ fromTemporaryCredentials }) => fromTemporaryCredentials({
-                params: {
-                    RoleArn: process.env.DYNAMODB_ASSUME_ROLE,
-                    RoleSessionName: "moicky-dynamodb",
-                },
-            })),
-        };
-    },
-};
-const _authType = process.env.MOICKY_DYNAMODB_AWS_ROLE;
-const authType = authTypes[_authType];
+const authType = process.env.MOICKY_DYNAMODB_AWS_ROLE;
+const roleArn = process.env.AWS_ROLE_ARN;
 let client = new client_dynamodb_1.DynamoDBClient({
     region: process.env.AWS_REGION || "eu-central-1",
-    ...(authType && authType()),
+    ...(authType === "vercel" &&
+        roleArn && { credentials: (0, oidc_1.awsCredentialsProvider)({ roleArn }) }),
 });
 const defaultTable = process.env.DYNAMODB_TABLE;
 if (defaultTable) {

package/dist/lib/config.d.ts

@@ -0,0 +1,78 @@
+import { QueryCommandInput, ScanCommandInput } from "@aws-sdk/client-dynamodb";
+import { marshall, marshallOptions, unmarshall, unmarshallOptions } from "@aws-sdk/util-dynamodb";
+import { DynamoDBItem } from "../types";
+/**
+ * DynamoDBConfig is a collection of fixes or configurations for DynamoDB and this package.
+ * @property disableConsistantReadWhenUsingIndexes - Disables ConsistentRead when using indexes.
+ * @property marshallOptions - Options to pass to the [marshall](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/interfaces/_aws_sdk_util_dynamodb.marshallOptions.html) function.
+ * @property unmarshallOptions - Options to pass to the [unmarshall](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/interfaces/_aws_sdk_util_dynamodb.unmarshallOptions.html) function.
+ * @property splitTransactionsIfAboveLimit - Splits a transaction into multiple, if more than [100 operations](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html) are provided.
+ * @property itemModificationTimestamp - A function that returns the value of the `createdAt` and `updatedAt` attributes for an item when it is created or updated.
+ * @example
+ * ```javascript
+ * initConfig({
+ *   disableConsistantReadWhenUsingIndexes: {
+ *     enabled: true, // default,
+ *
+ *     // Won't disable ConsistantRead if IndexName is specified here.
+ *     stillUseOnLocalIndexes: ["localIndexName1", "localIndexName1"],
+ *   },
+ * });
+ * ```
+ */
+export declare interface DynamoDBConfig {
+    disableConsistantReadWhenUsingIndexes?: {
+        enabled: boolean;
+        stillUseOnLocalIndexes?: string[];
+    };
+    marshallOptions?: marshallOptions;
+    unmarshallOptions?: unmarshallOptions;
+    splitTransactionsIfAboveLimit?: boolean;
+    itemModificationTimestamp?: (field: "createdAt" | "updatedAt") => any;
+}
+/**
+ * Initializes the {@link DynamoDBConfig} to use for all operations.
+ * @param newConfig - The new {@link DynamoDBConfig} to use, will be merged with the default config.
+ * @returns void
+ */
+export declare const initConfig: (newConfig: DynamoDBConfig) => void;
+/**
+ * Returns the current {@link DynamoDBConfig} used for all operations.
+ * @returns The current {@link DynamoDBConfig}
+ * @private
+ */
+export declare const getConfig: () => DynamoDBConfig;
+/**
+ * Applies fixes & configurations for the arguments for Query/Scan operations.
+ * @param args - The arguments to override the default arguments with
+ * @returns The merged arguments
+ * @private
+ */
+export declare const withConfig: (args: Partial<QueryCommandInput> | Partial<ScanCommandInput>) => Partial<QueryCommandInput> | Partial<ScanCommandInput>;
+/**
+ * Returns the default {@link DynamoDBConfig} used for all operations.
+ * @returns The current {@link DynamoDBConfig}
+ * @private
+ */
+export declare const getDefaultConfig: () => DynamoDBConfig;
+/**
+ * Marshalls the input using {@link marshall} with the global options.
+ * @param input - The input to marshall
+ * @returns The marshalled input
+ * @private
+ */
+export declare const marshallWithOptions: (input: Parameters<typeof marshall>[0]) => Record<string, import("@aws-sdk/client-dynamodb").AttributeValue>;
+/**
+ * Unmarshalls the input using {@link unmarshall} with the global options.
+ * @param input - The input to unmarshall
+ * @returns The unmarshalled input
+ * @private
+ */
+export declare const unmarshallWithOptions: <T extends DynamoDBItem = DynamoDBItem>(input: Parameters<typeof unmarshall>[0]) => T;
+/**
+ * Returns the timestamp for the item modification field.
+ * @param field - The field to get the timestamp for
+ * @returns The timestamp
+ * @private
+ */
+export declare const getItemModificationTimestamp: (field: "createdAt" | "updatedAt") => any;

package/dist/lib/config.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getItemModificationTimestamp = exports.unmarshallWithOptions = exports.marshallWithOptions = exports.getDefaultConfig = exports.withConfig = exports.getConfig = exports.initConfig = void 0;
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const defaultConfig = Object.freeze({
+    disableConsistantReadWhenUsingIndexes: {
+        enabled: true,
+    },
+    itemModificationTimestamp: (_) => Date.now(),
+});
+let config = defaultConfig;
+/**
+ * Initializes the {@link DynamoDBConfig} to use for all operations.
+ * @param newConfig - The new {@link DynamoDBConfig} to use, will be merged with the default config.
+ * @returns void
+ */
+const initConfig = (newConfig) => {
+    config = { ...defaultConfig, ...newConfig };
+};
+exports.initConfig = initConfig;
+/**
+ * Returns the current {@link DynamoDBConfig} used for all operations.
+ * @returns The current {@link DynamoDBConfig}
+ * @private
+ */
+const getConfig = () => config;
+exports.getConfig = getConfig;
+const handleIndex = (args) => {
+    if (config?.disableConsistantReadWhenUsingIndexes?.enabled &&
+        args?.IndexName &&
+        args?.ConsistentRead &&
+        !config?.disableConsistantReadWhenUsingIndexes?.stillUseOnLocalIndexes?.includes(args?.IndexName)) {
+        args.ConsistentRead = false;
+    }
+};
+/**
+ * Applies fixes & configurations for the arguments for Query/Scan operations.
+ * @param args - The arguments to override the default arguments with
+ * @returns The merged arguments
+ * @private
+ */
+const withConfig = (args) => {
+    handleIndex(args);
+    return args;
+};
+exports.withConfig = withConfig;
+/**
+ * Returns the default {@link DynamoDBConfig} used for all operations.
+ * @returns The current {@link DynamoDBConfig}
+ * @private
+ */
+const getDefaultConfig = () => defaultConfig;
+exports.getDefaultConfig = getDefaultConfig;
+/**
+ * Marshalls the input using {@link marshall} with the global options.
+ * @param input - The input to marshall
+ * @returns The marshalled input
+ * @private
+ */
+const marshallWithOptions = (input) => (0, util_dynamodb_1.marshall)(input, config.marshallOptions);
+exports.marshallWithOptions = marshallWithOptions;
+/**
+ * Unmarshalls the input using {@link unmarshall} with the global options.
+ * @param input - The input to unmarshall
+ * @returns The unmarshalled input
+ * @private
+ */
+const unmarshallWithOptions = (input) => (0, util_dynamodb_1.unmarshall)(input, config.unmarshallOptions);
+exports.unmarshallWithOptions = unmarshallWithOptions;
+/**
+ * Returns the timestamp for the item modification field.
+ * @param field - The field to get the timestamp for
+ * @returns The timestamp
+ * @private
+ */
+const getItemModificationTimestamp = (field) => config.itemModificationTimestamp?.(field) ?? Date.now();
+exports.getItemModificationTimestamp = getItemModificationTimestamp;

package/dist/lib/helpers.d.ts

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

package/dist/lib/helpers.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getItemKey = exports.ExpressionAttributes = exports.getAttributesFromExpression = exports.getAttributeNames = exports.getAttributeValues = exports.splitEvery = exports.stripKey = void 0;
-const fixes_1 = require("./fixes");
+const config_1 = require("./config");
 const schemas_1 = require("./schemas");
 // Since dynamo only accepts key atrtributes which are described in table schema
 // we remove any other attributes from the item if they are present and passed as
 // key parameter to any of the functions below (getItem, updateItem, deleteItem...)
 function stripKey(key, args) {
     const { hash, range } = (0, schemas_1.getTableSchema)(args?.TableName);
-    return (0, fixes_1.marshallWithOptions)({
+    return (0, config_1.marshallWithOptions)({
         [hash]: key[hash],
         ...(range && { [range]: key[range] }),
     });
 }
 exports.stripKey = stripKey;
-function splitEvery(items, limit = 25) {
+function splitEvery(items, limit) {
     const batches = [];
     for (let i = 0; i < items.length; i += limit) {
         batches.push(items.slice(i, i + limit));
@@ -23,7 +23,7 @@ function splitEvery(items, limit = 25) {
 }
 exports.splitEvery = splitEvery;
 function getAttributeValues(key, { attributesToGet, prefix = ":", } = {}) {
-    return (0, fixes_1.marshallWithOptions)((attributesToGet || Object.keys(key)).reduce((acc, keyName) => {
+    return (0, config_1.marshallWithOptions)((attributesToGet || Object.keys(key)).reduce((acc, keyName) => {
         acc[`${prefix}${keyName}`] = key[keyName];
         return acc;
     }, {}));
@@ -77,7 +77,7 @@ class ExpressionAttributes {
         this.appendValues(values);
     }
     getAttributes() {
-        const marshalled = (0, fixes_1.marshallWithOptions)(this.ExpressionAttributeValues);
+        const marshalled = (0, config_1.marshallWithOptions)(this.ExpressionAttributeValues);
         return {
             ExpressionAttributeNames: this.ExpressionAttributeNames,
             ...(Object.keys(marshalled).length > 0 && {

package/dist/lib/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./client";
+export * from "./config";
 export * from "./defaultArguments";
-export * from "./fixes";
 export * from "./helpers";
 export * from "./schemas";

package/dist/lib/index.js

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./client"), exports);
+__exportStar(require("./config"), exports);
 __exportStar(require("./defaultArguments"), exports);
-__exportStar(require("./fixes"), exports);
 __exportStar(require("./helpers"), exports);
 __exportStar(require("./schemas"), exports);

package/dist/lib/schemas.js

@@ -37,14 +37,14 @@ const validateSchema = (schema) => {
     tables.forEach((table) => {
         const { hash } = schema[table];
         if (!hash) {
-            throw new Error(`No hash key provided for table ${table}`);
+            throw new Error(`[@moicky/dynamodb]: No hash key provided for table ${table}`);
         }
         if (typeof hash !== "string") {
-            throw new Error(`Invalid hash key provided for table ${table}`);
+            throw new Error(`[@moicky/dynamodb]: Invalid hash key provided for table ${table}`);
         }
         const { range } = schema[table];
         if (range && typeof range !== "string") {
-            throw new Error(`Invalid range key provided for table ${table}`);
+            throw new Error(`[@moicky/dynamodb]: Invalid range key provided for table ${table}`);
         }
     });
     return true;

package/dist/operations/delete.js

@@ -81,7 +81,7 @@ async function deleteItems(keys, args = {}, retry = 0) {
         return acc;
     }, {}));
     return new Promise(async (resolve, reject) => {
-        const batches = (0, lib_1.splitEvery)(uniqueKeys);
+        const batches = (0, lib_1.splitEvery)(uniqueKeys, 25);
         if (retry > 3)
             return;
         const table = args?.TableName || (0, lib_1.getDefaultTable)();

package/dist/operations/get.js

@@ -142,7 +142,7 @@ exports.getItems = getItems;
  * ```
  */
 async function getAllItems(args = {}) {
-    args = (0, lib_1.withFixes)((0, lib_1.withDefaults)(args, "getAllItems"));
+    args = (0, lib_1.withConfig)((0, lib_1.withDefaults)(args, "getAllItems"));
     let items = [];
     let lastEvaluatedKey;
     do {

package/dist/operations/put.js

@@ -6,7 +6,7 @@ const lib_1 = require("../lib");
 async function putItem(item, args) {
     const argsWithDefaults = (0, lib_1.withDefaults)(args || {}, "putItem");
     if (!Object.keys(item).includes("createdAt")) {
-        item = { ...item, createdAt: Date.now() };
+        item = { ...item, createdAt: (0, lib_1.getItemModificationTimestamp)("createdAt") };
     }
     const { ReturnValues, ...otherArgs } = argsWithDefaults;
     return (0, lib_1.getClient)()
@@ -49,11 +49,11 @@ async function putItems(items, args = {}, retry = 0) {
         return;
     args = (0, lib_1.withDefaults)(args, "putItems");
     return new Promise(async (resolve, reject) => {
-        const now = Date.now();
+        const createdAt = (0, lib_1.getItemModificationTimestamp)("createdAt");
         const batches = (0, lib_1.splitEvery)(items.map((item) => ({
             ...item,
-            createdAt: item?.createdAt ?? now,
-        })));
+            createdAt: item?.createdAt ?? createdAt,
+        })), 25);
         const results = [];
         const table = args?.TableName || (0, lib_1.getDefaultTable)();
         for (const batch of batches) {

package/dist/operations/query.js

@@ -12,7 +12,7 @@ const lib_1 = require("../lib");
  * @private
  */
 async function _query(keyCondition, key, args = {}) {
-    args = (0, lib_1.withFixes)(args);
+    args = (0, lib_1.withConfig)(args);
     return (0, lib_1.getClient)().send(new client_dynamodb_1.QueryCommand({
         KeyConditionExpression: keyCondition,
         ExpressionAttributeValues: (0, lib_1.getAttributeValues)(key, {

package/dist/operations/transactWriteItems.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transactWriteItems = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 const lib_1 = require("../lib");
+// https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html
+const OPERATIONS_LIMIT = 100;
 /**
  * Performs a TransactWriteItems operation against DynamoDB. This allows you to perform multiple write operations in a single transaction.
  * @param transactItems - Array of items to transact. Each item can be a Put, Update, Delete, or ConditionCheck operation.
@@ -50,48 +52,59 @@ 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 });
+        const shouldSplitTransactions = (0, lib_1.getConfig)().splitTransactionsIfAboveLimit ?? false;
+        if (transactItems.length === 0 ||
+            (transactItems.length > OPERATIONS_LIMIT && !shouldSplitTransactions)) {
+            reject(new Error("[@moicky/dynamodb]: Invalid number of operations"));
+        }
+        const conditionCheckItems = transactItems
+            .filter((item) => item.ConditionCheck)
+            .map((item) => handleConditionCheck(item.ConditionCheck, { table }));
+        let createdAt = null;
+        let updatedAt = null;
+        const operationItems = transactItems
+            .filter((item) => !item.ConditionCheck)
+            .map((item) => {
+            if (item.Put) {
+                createdAt ??= (0, lib_1.getItemModificationTimestamp)("createdAt");
+                return handlePutItem(item.Put, { createdAt, table });
             }
             else if (item.Delete) {
-                return handleDeleteItem(item.Delete, { now, table });
+                return handleDeleteItem(item.Delete, { table });
             }
             else if (item.Update) {
-                return handleUpdateItem(item.Update, { now, table });
+                updatedAt ??= (0, lib_1.getItemModificationTimestamp)("updatedAt");
+                return handleUpdateItem(item.Update, { updatedAt, table });
             }
             else {
-                throw new Error("[@moicky/dynamodb]: Invalid TransactItem: " + JSON.stringify(item));
+                reject(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);
+        const availableSlots = OPERATIONS_LIMIT - conditionCheckItems.length;
+        const batches = (0, lib_1.splitEvery)(operationItems, availableSlots);
+        const results = {};
+        for (const batch of operationItems?.length ? batches : [[]]) {
+            const populatedItems = [...conditionCheckItems, ...batch];
+            await (0, lib_1.getClient)()
+                .send(new client_dynamodb_1.TransactWriteItemsCommand({
+                TransactItems: populatedItems,
+                ...args,
+            }))
+                .then((res) => {
+                Object.entries(res.ItemCollectionMetrics || {}).forEach(([tableName, metrics]) => {
+                    const unmarshalledMetrics = metrics.map((metric) => ({
+                        Key: (0, lib_1.unmarshallWithOptions)(metric.ItemCollectionKey || {}),
+                        SizeEstimateRangeGB: metric.SizeEstimateRangeGB,
+                    }));
+                    results[tableName] ??= [];
+                    results[tableName].push(...unmarshalledMetrics);
+                });
+            })
+                .catch(reject);
+        }
+        return resolve(results);
     });
 }
 exports.transactWriteItems = transactWriteItems;
@@ -118,7 +131,9 @@ function handleConditionCheck(params, args) {
 }
 function handlePutItem(params, args) {
     const populatedData = structuredClone(params.item);
-    populatedData.createdAt ??= args.now;
+    if (!Object.keys(populatedData).includes("createdAt")) {
+        populatedData.createdAt = args.createdAt;
+    }
     const { item, conditionData, ...rest } = params;
     return {
         Put: {
@@ -143,7 +158,9 @@ function handleDeleteItem(params, args) {
 function handleUpdateItem(params, args) {
     const { key, updateData, conditionData, ...rest } = params;
     const populatedData = structuredClone(updateData);
-    populatedData.updatedAt ??= args.now;
+    if (!Object.keys(populatedData).includes("updatedAt")) {
+        populatedData.updatedAt = args.updatedAt;
+    }
     const mergedData = { ...populatedData, ...conditionData };
     const UpdateExpression = "SET " +
         Object.keys(populatedData)

package/dist/operations/update.js

@@ -6,7 +6,7 @@ const lib_1 = require("../lib");
 async function updateItem(key, data, args) {
     const argsWithDefaults = (0, lib_1.withDefaults)(args || {}, "updateItem");
     if (!Object.keys(data).includes("updatedAt")) {
-        data = { ...data, updatedAt: Date.now() };
+        data = { ...data, updatedAt: (0, lib_1.getItemModificationTimestamp)("updatedAt") };
     }
     const valuesInCondition = (0, lib_1.getAttributesFromExpression)(argsWithDefaults?.ConditionExpression || "", ":");
     const namesInCondition = (0, lib_1.getAttributesFromExpression)(argsWithDefaults?.ConditionExpression || "");

package/dist/transactions/index.d.ts

@@ -1,14 +1,19 @@
-import { TransactWriteItemsCommandInput } from "@aws-sdk/client-dynamodb";
+import { ItemCollectionMetrics, TransactWriteItemsCommandInput } from "@aws-sdk/client-dynamodb";
 import { ConditionOperations, CreateOperations, UpdateOperations } from "./operations";
 import { WithoutReferences } from "./references/types";
 import { ConditionOperation, CreateOperation, DeleteOperation, DynamoDBItemKey, ItemWithKey, OnlyKey, UpdateOperation } from "./types";
+type ResponseItem = Pick<ItemCollectionMetrics, "SizeEstimateRangeGB"> & {
+    Key: Record<string, any>;
+};
 export declare class Transaction {
     private tableName;
-    private timestamp;
+    private createdAt;
+    private updatedAt;
     private operations;
-    constructor({ tableName, timestamp, }?: {
+    constructor({ tableName, createdAt, updatedAt, }?: {
         tableName?: string;
-        timestamp?: number;
+        createdAt?: any;
+        updatedAt?: any;
     });
     private getItemKey;
     create<T extends ItemWithKey>(item: WithoutReferences<T>, args?: CreateOperation["args"]): CreateOperations<T>;
@@ -16,5 +21,6 @@ export declare class Transaction {
     delete(item: DynamoDBItemKey, args?: DeleteOperation["args"]): void;
     addConditionFor<T extends DynamoDBItemKey>(item: T, args?: Partial<ConditionOperation["args"]>): ConditionOperations<T>;
     private handleOperation;
-    execute(args?: Partial<Omit<TransactWriteItemsCommandInput, "TransactItems">>): Promise<import("@aws-sdk/client-dynamodb").TransactWriteItemsCommandOutput>;
+    execute(args?: Partial<Omit<TransactWriteItemsCommandInput, "TransactItems">>): Promise<Record<string, ResponseItem[]>>;
 }
+export {};

package/dist/transactions/index.js

@@ -8,11 +8,13 @@ const operations_1 = require("./operations");
 const OPERATIONS_LIMIT = 100;
 class Transaction {
     tableName;
-    timestamp = Date.now();
+    createdAt;
+    updatedAt;
     operations = {};
-    constructor({ tableName = (0, __1.getDefaultTable)(), timestamp = Date.now(), } = {}) {
+    constructor({ tableName = (0, __1.getDefaultTable)(), createdAt = (0, __1.getItemModificationTimestamp)("createdAt"), updatedAt = (0, __1.getItemModificationTimestamp)("updatedAt"), } = {}) {
         this.tableName = tableName;
-        this.timestamp = timestamp;
+        this.createdAt = createdAt ?? (0, __1.getItemModificationTimestamp)("createdAt");
+        this.updatedAt = updatedAt ?? (0, __1.getItemModificationTimestamp)("updatedAt");
     }
     getItemKey(item, tableName) {
         return (0, __1.getItemKey)(item, { TableName: tableName || this.tableName });
@@ -32,7 +34,7 @@ class Transaction {
         const updateOperation = {
             _type: "update",
             item,
-            actions: [{ _type: "set", values: { updatedAt: this.timestamp } }],
+            actions: [{ _type: "set", values: { updatedAt: this.updatedAt } }],
             args: { TableName: this.tableName, ...args },
         };
         this.operations[itemKey] = updateOperation;
@@ -58,7 +60,7 @@ class Transaction {
                 const { item, args } = operation;
                 return {
                     Put: {
-                        Item: (0, __1.marshallWithOptions)({ createdAt: this.timestamp, ...item }),
+                        Item: (0, __1.marshallWithOptions)({ createdAt: this.createdAt, ...item }),
                         ...args,
                     },
                 };
@@ -123,15 +125,44 @@ class Transaction {
         }
     }
     async execute(args) {
-        const operations = Object.values(this.operations).map((op) => this.handleOperation(op));
-        if (operations.length === 0 || operations.length > OPERATIONS_LIMIT) {
-            throw new Error("Invalid number of operations");
-        }
-        const input = {
-            TransactItems: operations,
-            ...args,
-        };
-        return (0, __1.getClient)().send(new client_dynamodb_1.TransactWriteItemsCommand(input));
+        args = (0, __1.withDefaults)(args, "transactWriteItems");
+        return new Promise(async (resolve, reject) => {
+            const shouldSplitTransactions = (0, __1.getConfig)().splitTransactionsIfAboveLimit ?? false;
+            const operations = Object.values(this.operations);
+            if (operations.length === 0 ||
+                (operations.length > OPERATIONS_LIMIT && !shouldSplitTransactions)) {
+                reject(new Error("[@moicky/dynamodb]: Invalid number of operations"));
+            }
+            const conditionCheckItems = operations
+                .filter((op) => op._type === "condition")
+                .map((op) => this.handleOperation(op));
+            const operationItems = operations
+                .filter((op) => op._type !== "condition")
+                .map((op) => this.handleOperation(op));
+            const availableSlots = OPERATIONS_LIMIT - conditionCheckItems.length;
+            const batches = (0, __1.splitEvery)(operationItems, availableSlots);
+            const results = {};
+            for (const batch of operationItems?.length ? batches : [[]]) {
+                const populatedItems = [...conditionCheckItems, ...batch];
+                await (0, __1.getClient)()
+                    .send(new client_dynamodb_1.TransactWriteItemsCommand({
+                    TransactItems: populatedItems,
+                    ...args,
+                }))
+                    .then((res) => {
+                    Object.entries(res.ItemCollectionMetrics || {}).forEach(([tableName, metrics]) => {
+                        const unmarshalledMetrics = metrics.map((metric) => ({
+                            Key: (0, __1.unmarshallWithOptions)(metric.ItemCollectionKey || {}),
+                            SizeEstimateRangeGB: metric.SizeEstimateRangeGB,
+                        }));
+                        results[tableName] ??= [];
+                        results[tableName].push(...unmarshalledMetrics);
+                    });
+                })
+                    .catch(reject);
+            }
+            return resolve(results);
+        });
     }
 }
 exports.Transaction = Transaction;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
 export type DynamoDBItem = Record<string, any> & {
-    createdAt?: number;
-    updatedAt?: number;
+    createdAt?: any;
+    updatedAt?: any;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moicky/dynamodb",
-  "version": "2.6.3",
+  "version": "3.0.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "Contains a collection of convenience functions for working with AWS DynamoDB",
@@ -28,10 +28,9 @@
     "aws-crt": "^1.15.20"
   },
   "devDependencies": {
-    "@aws-sdk/credential-providers": "^3.744.0",
-    "@vercel/functions": "^2.0.0",
     "@types/jest": "^29.5.1",
     "@types/node": "^20.2.4",
+    "@vercel/functions": "^2.0.0",
     "dotenv": "^16.0.3",
     "jest": "^29.5.0",
     "typescript": "^5.0.4"

package/readme.md

@@ -14,9 +14,11 @@ Contains convenience functions for all major dynamodb operations. Requires very
 - 🔒 When specifying an item using its keySchema, all additional attributes (apart from keySchema attributes from `initSchema` or `PK` & `SK` as default) will be removed to avoid errors
 - 👻 Will **use placeholders** to avoid colliding with [reserved words](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html) if applicable
 - 🌎 Supports globally defined default arguments for each operation ([example](#configuring-global-defaults))
-- 🔨 Supports fixes for several issues with dynamodb ([example](#applying-fixes))
+- 🔨 Supports configuration for several dynamodb behaviors and fixes ([example](#configuration))
 - 📖 Offers a convenient way to use pagination with queries ([example](#paginated-items))
 - 🗂️ Supports **transactGetItems** & **transactWriteItems**
+- ⚙️ Customizable timestamp generation for `createdAt` and `updatedAt` attributes
+- 🔄 Automatic transaction splitting for operations exceeding the 100-item limit (disabled by default)
 
 ## Installation
 
@@ -290,6 +292,9 @@ console.log(id4); // "00000010"
 import { transactWriteItems } from "@moicky/dynamodb";
 
 // Perform a TransactWriteItems operation
+// Note: By default, transactions are limited to 100 operations (AWS limit).
+// Enable automatic splitting via initConfig({ splitTransactionsIfAboveLimit: true })
+// to handle larger transactions automatically. (note that this is not recommended for transactional updates)
 const response = await transactWriteItems([
   {
     Put: {
@@ -368,14 +373,18 @@ const itemWithoutConsistentRead = await getItem(
 );
 ```
 
-## Applying fixes
+## Configuration
 
-Arguments which are passed to [marshall](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/interfaces/_aws_sdk_util_dynamodb.marshallOptions.html) and [unmarshall](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/interfaces/_aws_sdk_util_dynamodb.unmarshallOptions.html) from `@aws-sdk/util-dynamodb` can be configured using
+The package provides a unified configuration system through `initConfig` that allows you to customize various behaviors and fixes for DynamoDB operations.
+
+### Marshall/Unmarshall Options
+
+Arguments which are passed to [marshall](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/interfaces/_aws_sdk_util_dynamodb.marshallOptions.html) and [unmarshall](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/interfaces/_aws_sdk_util_dynamodb.unmarshallOptions.html) from `@aws-sdk/util-dynamodb` can be configured using:
 
 ```ts
-import { initFixes } from "@moicky/dynamodb";
+import { initConfig } from "@moicky/dynamodb";
 
-initFixes({
+initConfig({
   marshallOptions: {
     removeUndefinedValues: true,
   },
@@ -385,22 +394,55 @@ initFixes({
 });
 ```
 
-When using `GlobalSecondaryIndexes`, DynamoDb does not support using `ConsistantRead`. This is fixed by default (`ConsistantRead` is turned off) and can be configured using:
+### Consistent Read with Indexes
+
+When using `GlobalSecondaryIndexes`, DynamoDB does not support using `ConsistentRead`. This is fixed by default (`ConsistentRead` is turned off) and can be configured using:
 
 ```ts
-import { initFixes } from "@moicky/dynamodb";
+import { initConfig } from "@moicky/dynamodb";
 
-initFixes({
+initConfig({
   disableConsistantReadWhenUsingIndexes: {
-    enabled: true, // default,
+    enabled: true, // default
 
-    // Won't disable ConsistantRead if IndexName is specified here.
-    // This works because DynamoDB supports ConsistantRead on LocalSecondaryIndexes
+    // Won't disable ConsistentRead if IndexName is specified here.
+    // This works because DynamoDB supports ConsistentRead on LocalSecondaryIndexes
     stillUseOnLocalIndexes: ["localIndexName1", "localIndexName2"],
   },
 });
 ```
 
+### Custom Timestamp Generation
+
+You can customize how `createdAt` and `updatedAt` timestamps are generated for items:
+
+```ts
+import { initConfig } from "@moicky/dynamodb";
+
+initConfig({
+  itemModificationTimestamp: (field) => {
+    if (field === "createdAt") {
+      return new Date().toISOString();
+    }
+    return Date.now();
+  },
+});
+```
+
+### Transaction Splitting
+
+By default, `transactWriteItems` will reject transactions with more than 100 operations (AWS limit). You can enable automatic splitting to handle larger transactions:
+
+```ts
+import { initConfig } from "@moicky/dynamodb";
+
+initConfig({
+  splitTransactionsIfAboveLimit: true,
+});
+```
+
+When enabled, transactions exceeding 100 operations will be automatically split into multiple batches, with condition checks preserved across all batches.
+
 ## What are the benefits and why should I use it?
 
 Generally it makes it easier to interact with the dynamodb from AWS. Here are some before and after examples using the new aws-sdk v3: