@moicky/dynamodb 3.0.4 → 3.1.0

package/dist/transactions/index.d.ts

@@ -11,6 +11,7 @@ export declare class Transaction {
     private updatedAt;
     private operations;
     private shouldSplitTransactions;
+    private hasBeenExecuted;
     constructor({ tableName, createdAt, updatedAt, shouldSplitTransactions, }?: {
         tableName?: string;
         createdAt?: any;
@@ -19,8 +20,8 @@ export declare class Transaction {
     });
     private getItemKey;
     create<T extends ItemWithKey>(item: WithoutReferences<T>, args?: CreateOperation["args"]): CreateOperations<T>;
-    update<T extends DynamoDBItemKey>(item: OnlyKey<T>, args?: UpdateOperation["args"]): UpdateOperations<T>;
-    delete(item: DynamoDBItemKey, args?: DeleteOperation["args"]): void;
+    update<T extends DynamoDBItemKey>(item: T extends any ? OnlyKey<T> : T, args?: UpdateOperation["args"]): UpdateOperations<T>;
+    delete(item: DynamoDBItemKey, args?: DeleteOperation["args"]): this;
     addConditionFor<T extends DynamoDBItemKey>(item: T, args?: Partial<ConditionOperation["args"]>): ConditionOperations<T>;
     private handleOperation;
     execute(args?: Partial<Omit<TransactWriteItemsCommandInput, "TransactItems">>): Promise<Record<string, ResponseItem[]>>;

package/dist/transactions/index.js

@@ -12,6 +12,7 @@ class Transaction {
     updatedAt;
     operations = {};
     shouldSplitTransactions;
+    hasBeenExecuted = false;
     constructor({ tableName, createdAt, updatedAt, shouldSplitTransactions, } = {}) {
         this.tableName = tableName ?? (0, __1.getDefaultTable)();
         this.createdAt = createdAt ?? (0, __1.getItemModificationTimestamp)("createdAt");
@@ -25,6 +26,9 @@ class Transaction {
         return (0, __1.getItemKey)(item, { TableName: tableName || this.tableName });
     }
     create(item, args) {
+        if (this.hasBeenExecuted) {
+            throw new Error("[@moicky/dynamodb]: Transaction has already been executed");
+        }
         const itemKey = this.getItemKey(item, args?.TableName);
         const createOperation = {
             _type: "create",
@@ -35,26 +39,41 @@ class Transaction {
         return new operations_1.CreateOperations(createOperation, this);
     }
     update(item, args) {
+        if (this.hasBeenExecuted) {
+            throw new Error("[@moicky/dynamodb]: Transaction has already been executed");
+        }
         const itemKey = this.getItemKey(item, args?.TableName);
+        const actions = [];
+        const existingOperation = this.operations[itemKey];
+        if (existingOperation && existingOperation._type === "update") {
+            actions.push(...existingOperation.actions);
+        }
         const updateOperation = {
             _type: "update",
             item,
-            actions: [{ _type: "set", values: { updatedAt: this.updatedAt } }],
+            actions,
             args: { TableName: this.tableName, ...args },
         };
         this.operations[itemKey] = updateOperation;
         return new operations_1.UpdateOperations(updateOperation, this);
     }
     delete(item, args) {
+        if (this.hasBeenExecuted) {
+            throw new Error("[@moicky/dynamodb]: Transaction has already been executed");
+        }
         const itemKey = this.getItemKey(item, args?.TableName);
         this.operations[itemKey] = {
             _type: "delete",
             item,
             args: { TableName: this.tableName, ...args },
         };
+        return this;
     }
     addConditionFor(item, args) {
-        return new operations_1.ConditionOperations(this.operations, item, {
+        if (this.hasBeenExecuted) {
+            throw new Error("[@moicky/dynamodb]: Transaction has already been executed");
+        }
+        return new operations_1.ConditionOperations(this, this.operations, item, {
             TableName: this.tableName,
             ...args,
         });
@@ -80,32 +99,49 @@ class Transaction {
                 };
                 const { ExpressionAttributeValues, ExpressionAttributeNames, ...otherArgs } = args;
                 const attr = new __1.ExpressionAttributes(ExpressionAttributeValues, ExpressionAttributeNames);
+                let hasSetUpdatedAt = false;
                 actions.forEach((action) => {
                     switch (action._type) {
                         case "set":
                             attr.appendBoth(action.values);
+                            if ("updatedAt" in action.values) {
+                                hasSetUpdatedAt = true;
+                            }
                             expressions.set.push(Object.keys(action.values)
                                 .map((key) => `${attr.getName(key)} = ${attr.getValue(key)}`)
                                 .join(", "));
                             break;
                         case "remove":
                             attr.appendNames(action.attributes);
+                            if (action.attributes.includes("updatedAt")) {
+                                hasSetUpdatedAt = true;
+                            }
                             expressions.remove.push(action.attributes.map((key) => attr.getName(key)).join(", "));
                             break;
                         case "add":
                             attr.appendBoth(action.values);
+                            if ("updatedAt" in action.values) {
+                                hasSetUpdatedAt = true;
+                            }
                             expressions.add.push(Object.keys(action.values)
                                 .map((key) => `${attr.getName(key)} ${attr.getValue(key)}`)
                                 .join(", "));
                             break;
                         case "delete":
                             attr.appendBoth(action.values);
+                            if ("updatedAt" in action.values) {
+                                hasSetUpdatedAt = true;
+                            }
                             expressions.delete.push(Object.keys(action.values)
                                 .map((key) => `${attr.getName(key)} ${attr.getValue(key)}`)
                                 .join(", "));
                             break;
                     }
                 });
+                if (!hasSetUpdatedAt) {
+                    attr.appendBoth({ updatedAt: this.updatedAt });
+                    expressions.set.push(`${attr.getName("updatedAt")} = ${attr.getValue("updatedAt")}`);
+                }
                 const joinedExpressions = Object.entries(expressions)
                     .filter(([, value]) => value?.length)
                     .reduce((acc, [t, v]) => [...acc, `${t.toUpperCase()} ${v.join(", ")}`], [])
@@ -132,6 +168,10 @@ class Transaction {
     async execute(args) {
         args = (0, __1.withDefaults)(args, "transactWriteItems");
         return new Promise(async (resolve, reject) => {
+            if (this.hasBeenExecuted) {
+                reject(new Error("[@moicky/dynamodb]: Transaction has already been executed"));
+            }
+            this.hasBeenExecuted = true;
             const operations = Object.values(this.operations);
             if (operations.length === 0 ||
                 (operations.length > OPERATIONS_LIMIT &&

package/dist/transactions/operations.d.ts

@@ -1,3 +1,4 @@
+import { TransactWriteItemsCommandInput } from "@aws-sdk/client-dynamodb";
 import { Transaction } from ".";
 import { DynamoDBItem } from "../types";
 import { DynamoDBReference } from "./references/types";
@@ -7,6 +8,9 @@ export declare class CreateOperations<U extends ItemWithKey> {
     private transaction;
     constructor(operation: CreateOperation, transaction: Transaction);
     setReferences(refs: SetReferencesParams<U>): void;
+    execute(args?: Partial<Omit<TransactWriteItemsCommandInput, "TransactItems">>): Promise<Record<string, (Pick<import("@aws-sdk/client-dynamodb").ItemCollectionMetrics, "SizeEstimateRangeGB"> & {
+        Key: Record<string, any>;
+    })[]>>;
 }
 export declare class UpdateOperations<U extends DynamoDBItem> {
     private operation;
@@ -15,25 +19,32 @@ export declare class UpdateOperations<U extends DynamoDBItem> {
     setReferences(refs: SetReferencesParams<U>): void;
     set(values: WithoutKey<Partial<U>> & NestedParams): this;
     adjustNumber(values: Prettify<StrictDeepNumberUpdates<U>>): this;
-    removeAttributes(...attributes: string[]): this;
+    removeAttributes(...attributes: Array<Exclude<Extract<keyof U, string>, keyof DynamoDBItemKey> | `${string}.${string}` | `${string}.${string}.${string}`>): UpdateOperations<U>;
     addItemsToSet(values: Prettify<DeepSetUpdates<U>>): this;
     deleteItemsFromSet(values: Prettify<DeepSetUpdates<U>>): this;
     onCondition({ expression, values, }: {
         expression: string;
         values: Partial<U> & Record<string, any>;
     }): void;
+    execute(args?: Partial<Omit<TransactWriteItemsCommandInput, "TransactItems">>): Promise<Record<string, (Pick<import("@aws-sdk/client-dynamodb").ItemCollectionMetrics, "SizeEstimateRangeGB"> & {
+        Key: Record<string, any>;
+    })[]>>;
 }
 export declare class ConditionOperations<U extends DynamoDBItem> {
+    private transaction;
     private operations;
     private item;
     private args;
-    constructor(operations: Transaction["operations"], item: DynamoDBItemKey, args: Partial<ConditionOperation["args"]> & {
+    constructor(transaction: Transaction, operations: Transaction["operations"], item: DynamoDBItemKey, args: Partial<ConditionOperation["args"]> & {
         TableName: string;
     });
     matches({ expression, values, }: {
         expression: string;
         values: Partial<U> & Record<string, any>;
     }): void;
+    execute(args?: Partial<Omit<TransactWriteItemsCommandInput, "TransactItems">>): Promise<Record<string, (Pick<import("@aws-sdk/client-dynamodb").ItemCollectionMetrics, "SizeEstimateRangeGB"> & {
+        Key: Record<string, any>;
+    })[]>>;
 }
 type SetReferencesParams<U extends DynamoDBItem> = TypedParams<U, DynamoDBReference, DynamoDBItemKey> & TypedParams<U, Set<DynamoDBReference>, DynamoDBItemKey[] | Set<DynamoDBItemKey>> & NestedParams<DynamoDBItemKey | DynamoDBItemKey[] | Set<DynamoDBItemKey>>;
 export {};

package/dist/transactions/operations.js

@@ -19,7 +19,7 @@ class CreateOperations {
                 onAttribute: attributeName,
             };
             const refData = ref instanceof Set
-                ? [...ref].map((references) => (0, references_1.createReference)({ references, ...refArgs }, this.transaction))
+                ? Array.from(ref).map((references) => (0, references_1.createReference)({ references, ...refArgs }, this.transaction))
                 : (0, references_1.createReference)({ references: ref, ...refArgs }, this.transaction);
             const parts = attributeName.split(".");
             parts.reduce((acc, part, index) => {
@@ -33,6 +33,9 @@ class CreateOperations {
             }, this.operation.item);
         });
     }
+    execute(args) {
+        return this.transaction.execute(args);
+    }
 }
 exports.CreateOperations = CreateOperations;
 class UpdateOperations {
@@ -54,7 +57,7 @@ class UpdateOperations {
                 _type: "set",
                 values: {
                     [attributeName]: ref instanceof Set
-                        ? [...ref].map((references) => (0, references_1.createReference)({ references, ...refArgs }, this.transaction))
+                        ? Array.from(ref).map((references) => (0, references_1.createReference)({ references, ...refArgs }, this.transaction))
                         : (0, references_1.createReference)({ references: ref, ...refArgs }, this.transaction),
                 },
             });
@@ -75,7 +78,10 @@ class UpdateOperations {
     removeAttributes(...attributes) {
         if (attributes.length === 0)
             return this;
-        this.operation.actions.push({ _type: "remove", attributes });
+        this.operation.actions.push({
+            _type: "remove",
+            attributes: attributes.map(String),
+        });
         return this;
     }
     addItemsToSet(values) {
@@ -109,13 +115,18 @@ class UpdateOperations {
             }, {}),
         };
     }
+    execute(args) {
+        return this.transaction.execute(args);
+    }
 }
 exports.UpdateOperations = UpdateOperations;
 class ConditionOperations {
+    transaction;
     operations;
     item;
     args;
-    constructor(operations, item, args) {
+    constructor(transaction, operations, item, args) {
+        this.transaction = transaction;
         this.operations = operations;
         this.item = item;
         this.args = args;
@@ -136,6 +147,9 @@ class ConditionOperations {
             },
         };
     }
+    execute(args) {
+        return this.transaction.execute(args);
+    }
 }
 exports.ConditionOperations = ConditionOperations;
 const arraysToSets = (values) => {

package/dist/transactions/references/index.js

@@ -39,13 +39,15 @@ const getRefsToResolve = (item) => {
     for (const value of Object.values(item)) {
         if (typeof value === "object") {
             if (value instanceof Set || Array.isArray(value)) {
-                refs.push(...[...value].map((v) => getRefsToResolve(v)).flat());
+                refs.push(...Array.from(value)
+                    .map((v) => getRefsToResolve(v))
+                    .flat());
             }
             else if (value?._type === "dynamodb:reference") {
                 refs.push(value?._target);
             }
             else {
-                refs.push(...getRefsToResolve(value));
+                refs.push(...getRefsToResolve(value).flat());
             }
         }
     }
@@ -62,7 +64,7 @@ const injectRefs = (item, refs) => {
     for (const [key, value] of Object.entries(item)) {
         if (typeof value === "object") {
             if (value instanceof Set || Array.isArray(value)) {
-                item[key] = new Set([...value].map((v) => injectRefs(v, refs)));
+                item[key] = new Set(Array.from(value).map((v) => injectRefs(v, refs)));
             }
             else if (value?._type === "dynamodb:reference") {
                 item[key] = refs[itemToStringKey(value._target)];

package/dist/transactions/types.d.ts

@@ -51,10 +51,6 @@ export type TypedParams<T extends DynamoDBItem, ValueType, ParamType = ValueType
 export type NestedParams<T = any> = Record<`${string}.${string}`, T>;
 export type NestedTypedParams<T extends DynamoDBItem, ValueType, ParamType = ValueType> = TypedParams<T, ValueType, ParamType> & NestedParams<ParamType>;
 type Prev = [never, 0, 1, 2, 3];
-type PathEntry = {
-    path: string;
-    type: any;
-};
 type DeepNumberPathEntries<T, Prefix extends string = "", D extends number = 3> = [D] extends [never] ? never : {
     [K in keyof T & string]-?: NonNullable<T[K]> extends number ? {
         path: `${Prefix}${K}`;
@@ -62,7 +58,11 @@ type DeepNumberPathEntries<T, Prefix extends string = "", D extends number = 3>
     } : NonNullable<T[K]> extends any[] | Set<any> | Date | Function | Uint8Array ? never : NonNullable<T[K]> extends object ? DeepNumberPathEntries<NonNullable<T[K]>, `${Prefix}${K}.`, Prev[D]> : never;
 }[keyof T & string];
 export type StrictDeepNumberUpdates<T> = {
-    [Entry in DeepNumberPathEntries<T> & PathEntry as Entry["path"]]?: Entry["type"];
+    [E in DeepNumberPathEntries<T> as E extends {
+        path: string;
+    } ? E["path"] : never]?: E extends {
+        type: infer V;
+    } ? V : never;
 };
 type DeepSetPathEntries<T, Prefix extends string = "", D extends number = 3> = [
     D
@@ -73,6 +73,10 @@ type DeepSetPathEntries<T, Prefix extends string = "", D extends number = 3> = [
     } : NonNullable<T[K]> extends Date | Function | Uint8Array ? never : NonNullable<T[K]> extends object ? DeepSetPathEntries<NonNullable<T[K]>, `${Prefix}${K}.`, Prev[D]> : never;
 }[keyof T & string];
 export type DeepSetUpdates<T> = {
-    [Entry in DeepSetPathEntries<T> & PathEntry as Entry["path"]]?: Entry["type"][] | Set<Entry["type"]>;
+    [E in DeepSetPathEntries<T> as E extends {
+        path: string;
+    } ? E["path"] : never]?: E extends {
+        type: infer V;
+    } ? V[] | Set<V> : never;
 };
 export {};

package/package.json

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