cmp-aws-database 1.7.1-dev.27 → 1.7.1-dev.28

package/dist/base-dynamoose-dao.d.ts

@@ -12,15 +12,32 @@ type DynamooseModelLike = {
 export declare class GenericDynamooseDAO<T extends BaseDynamooseModel> {
     protected readonly model: DynamooseModelLike;
     protected readonly primaryKeyName: keyof T & string;
+    protected readonly sortKeyName?: (keyof T & string) | undefined;
     /**
      * @param model Dynamoose model instance for the target table.
      * @param primaryKeyName Attribute name used as the table hash key.
      */
-    constructor(model: DynamooseModelLike, primaryKeyName: keyof T & string);
+    constructor(model: DynamooseModelLike, primaryKeyName: keyof T & string, sortKeyName?: (keyof T & string) | undefined);
     /**
      * Builds a DynamoDB key object from a single primary key value.
      */
-    protected getKeyObject(primaryKeyValue: string): DynamoKey;
+    protected getKeyObject(primaryKeyValue: string, sortKeyValue?: string): DynamoKey;
+    /**
+     * Extracts and validates string primary key value from an item.
+     */
+    protected getPrimaryKeyValueFromItem(item: T): string;
+    /**
+     * Extracts and validates sort key value from an item when sort key is configured.
+     */
+    protected getSortKeyValueFromItem(item: T): string | undefined;
+    /**
+     * Builds complete key object (hash + optional sort) from an item.
+     */
+    protected getItemKeyObject(item: T): DynamoKey;
+    /**
+     * Serializes key object for stable set/map comparisons.
+     */
+    protected serializeKey(key: DynamoKey): string;
     /**
      * Creates a new record and automatically stamps created audit fields.
      */
@@ -28,23 +45,32 @@ export declare class GenericDynamooseDAO<T extends BaseDynamooseModel> {
     /**
      * Updates an existing record and automatically stamps updated audit fields.
      */
-    update(primaryKeyValue: string, updates: Partial<T>, authContext?: AuthContext): Promise<T>;
+    update(primaryKeyValue: string, updates: Partial<T>, authContext?: AuthContext, sortKeyValue?: string): Promise<T>;
     /**
      * Deletes one record by primary key.
      */
-    delete(primaryKeyValue: string): Promise<T | undefined>;
+    delete(primaryKeyValue: string, sortKeyValue?: string): Promise<T | undefined>;
     /**
      * Fetches one record by primary key. Returns null when not found.
      */
-    get(primaryKeyValue: string): Promise<T | null>;
+    get(primaryKeyValue: string, sortKeyValue?: string): Promise<T | null>;
     /**
      * Writes multiple records in a batch and throws if any item is left unprocessed.
      */
     batchSave(items: T[], authContext?: AuthContext): Promise<T[]>;
+    /**
+     * Upserts multiple records by primary key.
+     * New keys are created (created_* fields), existing keys are updated (updated_* fields).
+     */
+    batchUpsert(items: T[], authContext?: AuthContext): Promise<T[]>;
     /**
      * Fetches multiple records by primary keys.
      */
     batchGet(primaryKeyValues: string[]): Promise<T[]>;
+    /**
+     * Fetches multiple records by key objects (supports hash + optional sort key).
+     */
+    batchGetByKeys(keys: DynamoKey[]): Promise<T[]>;
     /**
      * Decodes a base64 continuation token into DynamoDB last evaluated key.
      */

package/dist/base-dynamoose-dao.js

@@ -6,15 +6,65 @@ class GenericDynamooseDAO {
      * @param model Dynamoose model instance for the target table.
      * @param primaryKeyName Attribute name used as the table hash key.
      */
-    constructor(model, primaryKeyName) {
+    constructor(model, primaryKeyName, sortKeyName) {
         this.model = model;
         this.primaryKeyName = primaryKeyName;
+        this.sortKeyName = sortKeyName;
     }
     /**
      * Builds a DynamoDB key object from a single primary key value.
      */
-    getKeyObject(primaryKeyValue) {
-        return { [this.primaryKeyName]: primaryKeyValue };
+    getKeyObject(primaryKeyValue, sortKeyValue) {
+        const keyObject = { [this.primaryKeyName]: primaryKeyValue };
+        if (this.sortKeyName) {
+            if (!sortKeyValue) {
+                throw new Error(`Missing sort key value for '${this.sortKeyName}'`);
+            }
+            keyObject[this.sortKeyName] = sortKeyValue;
+        }
+        return keyObject;
+    }
+    /**
+     * Extracts and validates string primary key value from an item.
+     */
+    getPrimaryKeyValueFromItem(item) {
+        const keyRecord = item;
+        const keyValue = keyRecord[this.primaryKeyName];
+        if (typeof keyValue !== "string" || keyValue.length === 0) {
+            throw new Error(`Missing or invalid primary key value for '${this.primaryKeyName}'`);
+        }
+        return keyValue;
+    }
+    /**
+     * Extracts and validates sort key value from an item when sort key is configured.
+     */
+    getSortKeyValueFromItem(item) {
+        if (!this.sortKeyName) {
+            return undefined;
+        }
+        const keyRecord = item;
+        const keyValue = keyRecord[this.sortKeyName];
+        if (typeof keyValue !== "string" || keyValue.length === 0) {
+            throw new Error(`Missing or invalid sort key value for '${this.sortKeyName}'`);
+        }
+        return keyValue;
+    }
+    /**
+     * Builds complete key object (hash + optional sort) from an item.
+     */
+    getItemKeyObject(item) {
+        const primaryKeyValue = this.getPrimaryKeyValueFromItem(item);
+        const sortKeyValue = this.getSortKeyValueFromItem(item);
+        return this.getKeyObject(primaryKeyValue, sortKeyValue);
+    }
+    /**
+     * Serializes key object for stable set/map comparisons.
+     */
+    serializeKey(key) {
+        if (!this.sortKeyName) {
+            return `${key[this.primaryKeyName]}`;
+        }
+        return `${key[this.primaryKeyName]}#${key[this.sortKeyName]}`;
     }
     /**
      * Creates a new record and automatically stamps created audit fields.
@@ -31,9 +81,9 @@ class GenericDynamooseDAO {
     /**
      * Updates an existing record and automatically stamps updated audit fields.
      */
-    async update(primaryKeyValue, updates, authContext) {
+    async update(primaryKeyValue, updates, authContext, sortKeyValue) {
         const updateFn = this.model.update;
-        const updated = await updateFn(this.getKeyObject(primaryKeyValue), {
+        const updated = await updateFn(this.getKeyObject(primaryKeyValue, sortKeyValue), {
             ...updates,
             updated_time: new Date(),
             updated_user: authContext?.userSub
@@ -43,17 +93,17 @@ class GenericDynamooseDAO {
     /**
      * Deletes one record by primary key.
      */
-    async delete(primaryKeyValue) {
+    async delete(primaryKeyValue, sortKeyValue) {
         const deleteFn = this.model.delete;
-        const deleted = await deleteFn(this.getKeyObject(primaryKeyValue));
+        const deleted = await deleteFn(this.getKeyObject(primaryKeyValue, sortKeyValue));
         return deleted;
     }
     /**
      * Fetches one record by primary key. Returns null when not found.
      */
-    async get(primaryKeyValue) {
+    async get(primaryKeyValue, sortKeyValue) {
         const getFn = this.model.get;
-        const item = await getFn(this.getKeyObject(primaryKeyValue));
+        const item = await getFn(this.getKeyObject(primaryKeyValue, sortKeyValue));
         return item ?? null;
     }
     /**
@@ -73,11 +123,48 @@ class GenericDynamooseDAO {
         }
         return inputItems;
     }
+    /**
+     * Upserts multiple records by primary key.
+     * New keys are created (created_* fields), existing keys are updated (updated_* fields).
+     */
+    async batchUpsert(items, authContext) {
+        const now = new Date();
+        const keys = items.map((item) => this.getItemKeyObject(item));
+        const existingItems = await this.batchGetByKeys(keys);
+        const existingKeySet = new Set(existingItems.map((item) => this.serializeKey(this.getItemKeyObject(item))));
+        const upsertItems = items.map((item) => {
+            const itemKey = this.getItemKeyObject(item);
+            if (existingKeySet.has(this.serializeKey(itemKey))) {
+                return {
+                    ...item,
+                    updated_time: now,
+                    updated_user: authContext?.userSub
+                };
+            }
+            return {
+                ...item,
+                created_time: now,
+                created_user: authContext?.userSub
+            };
+        });
+        const batchPutFn = this.model.batchPut;
+        const result = await batchPutFn(upsertItems);
+        if (result.unprocessedItems.length > 0) {
+            throw new Error(`Batch upsert partially failed. Unprocessed items: ${result.unprocessedItems.length}`);
+        }
+        return upsertItems;
+    }
     /**
      * Fetches multiple records by primary keys.
      */
     async batchGet(primaryKeyValues) {
         const keys = primaryKeyValues.map((value) => this.getKeyObject(value));
+        return this.batchGetByKeys(keys);
+    }
+    /**
+     * Fetches multiple records by key objects (supports hash + optional sort key).
+     */
+    async batchGetByKeys(keys) {
         const batchGetFn = this.model.batchGet;
         const items = await batchGetFn(keys);
         return items;
@@ -107,4 +194,4 @@ class GenericDynamooseDAO {
     }
 }
 exports.GenericDynamooseDAO = GenericDynamooseDAO;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-dynamoose-dao.js","sourceRoot":"","sources":["../src/base-dynamoose-dao.ts"],"names":[],"mappings":";;;AAyBA,MAAa,mBAAmB;IAC5B;;;OAGG;IACH,YACuB,KAAyB,EACzB,cAAgC;QADhC,UAAK,GAAL,KAAK,CAAoB;QACzB,mBAAc,GAAd,cAAc,CAAkB;IACnD,CAAC;IAEL;;OAEG;IACO,YAAY,CAAC,eAAuB;QAC1C,OAAO,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,eAAe,EAAE,CAAC;IACtD,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAI,CAAC,IAAO,EAAE,WAAyB;QACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,MAAqB,CAAC;QAClD,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC;YAC3B,GAAG,IAAI;YACP,YAAY,EAAE,IAAI,IAAI,EAAE;YACxB,YAAY,EAAE,WAAW,EAAE,OAAO;SACrC,CAAC,CAAC;QACH,OAAO,OAAY,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,eAAuB,EAAE,OAAmB,EAAE,WAAyB;QAChF,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,MAAqB,CAAC;QAClD,MAAM,OAAO,GAAG,MAAM,QAAQ,CAC1B,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,EAClC;YACI,GAAG,OAAO;YACV,YAAY,EAAE,IAAI,IAAI,EAAE;YACxB,YAAY,EAAE,WAAW,EAAE,OAAO;SACrC,CACJ,CAAC;QACF,OAAO,OAAY,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,eAAuB;QAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,MAAkB,CAAC;QAC/C,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAC;QACnE,OAAO,OAAwB,CAAC;IACpC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CAAC,eAAuB;QAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAY,CAAC;QACtC,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAAC;QAC7D,OAAQ,IAAsB,IAAI,IAAI,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,KAAU,EAAE,WAAyB;QACjD,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACpC,GAAG,IAAI;YACP,YAAY,EAAE,GAAG;YACjB,YAAY,EAAE,WAAW,EAAE,OAAO;SACrC,CAAC,CAAQ,CAAC;QAEX,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,QAAyB,CAAC;QACxD,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,UAAU,CAAC,CAAC;QAC5C,IAAI,MAAM,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,mDAAmD,MAAM,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC;QACzG,CAAC;QAED,OAAO,UAAU,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,QAAQ,CAAC,gBAA0B;QACrC,MAAM,IAAI,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;QACvE,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,QAAsB,CAAC;QACrD,MAAM,KAAK,GAAG,MAAM,UAAU,CAAC,IAAI,CAAC,CAAC;QACrC,OAAO,KAAY,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,iBAAqC;QACxC,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACrB,OAAO,SAAS,CAAC;QACrB,CAAC;QAED,IAAI,CAAC;YACD,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,iBAAiB,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAc,CAAC;QAC9F,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QACjD,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,gBAAuC;QAChD,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACpB,OAAO,SAAS,CAAC;QACrB,CAAC;QAED,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC5E,CAAC;CACJ;AAvHD,kDAuHC","sourcesContent":["import { BaseDynamooseModel, AuthContext } from \"./base-dynamoose-model\";\n\ntype DynamoKeyValue = string | number | boolean | null;\nexport type DynamoKey = Record<string, DynamoKeyValue>;\n\ntype BatchPutResponse<T> = {\n    unprocessedItems: Partial<T>[];\n};\n\ntype CreateFn<T> = (item: Partial<T>) => Promise<object>;\ntype UpdateFn<T> = (key: DynamoKey, update: Partial<T>) => Promise<object>;\ntype DeleteFn = (key: DynamoKey) => Promise<object | undefined>;\ntype GetFn = (key: DynamoKey) => Promise<object | undefined>;\ntype BatchPutFn<T> = (items: Partial<T>[]) => Promise<BatchPutResponse<T>>;\ntype BatchGetFn = (keys: DynamoKey[]) => Promise<object[]>;\n\ntype DynamooseModelLike = {\n    create: Function;\n    update: Function;\n    get: Function;\n    delete: Function;\n    batchPut: Function;\n    batchGet: Function;\n};\n\nexport class GenericDynamooseDAO<T extends BaseDynamooseModel> {\n    /**\n     * @param model Dynamoose model instance for the target table.\n     * @param primaryKeyName Attribute name used as the table hash key.\n     */\n    constructor(\n        protected readonly model: DynamooseModelLike,\n        protected readonly primaryKeyName: keyof T & string\n    ) { }\n\n    /**\n     * Builds a DynamoDB key object from a single primary key value.\n     */\n    protected getKeyObject(primaryKeyValue: string): DynamoKey {\n        return { [this.primaryKeyName]: primaryKeyValue };\n    }\n\n    /**\n     * Creates a new record and automatically stamps created audit fields.\n     */\n    async save(item: T, authContext?: AuthContext): Promise<T> {\n        const createFn = this.model.create as CreateFn<T>;\n        const created = await createFn({\n            ...item,\n            created_time: new Date(),\n            created_user: authContext?.userSub\n        });\n        return created as T;\n    }\n\n    /**\n     * Updates an existing record and automatically stamps updated audit fields.\n     */\n    async update(primaryKeyValue: string, updates: Partial<T>, authContext?: AuthContext): Promise<T> {\n        const updateFn = this.model.update as UpdateFn<T>;\n        const updated = await updateFn(\n            this.getKeyObject(primaryKeyValue),\n            {\n                ...updates,\n                updated_time: new Date(),\n                updated_user: authContext?.userSub\n            }\n        );\n        return updated as T;\n    }\n\n    /**\n     * Deletes one record by primary key.\n     */\n    async delete(primaryKeyValue: string): Promise<T | undefined> {\n        const deleteFn = this.model.delete as DeleteFn;\n        const deleted = await deleteFn(this.getKeyObject(primaryKeyValue));\n        return deleted as T | undefined;\n    }\n\n    /**\n     * Fetches one record by primary key. Returns null when not found.\n     */\n    async get(primaryKeyValue: string): Promise<T | null> {\n        const getFn = this.model.get as GetFn;\n        const item = await getFn(this.getKeyObject(primaryKeyValue));\n        return (item as T | undefined) ?? null;\n    }\n\n    /**\n     * Writes multiple records in a batch and throws if any item is left unprocessed.\n     */\n    async batchSave(items: T[], authContext?: AuthContext): Promise<T[]> {\n        const now = new Date();\n        const inputItems = items.map((item) => ({\n            ...item,\n            created_time: now,\n            created_user: authContext?.userSub\n        })) as T[];\n\n        const batchPutFn = this.model.batchPut as BatchPutFn<T>;\n        const result = await batchPutFn(inputItems);\n        if (result.unprocessedItems.length > 0) {\n            throw new Error(`Batch save partially failed. Unprocessed items: ${result.unprocessedItems.length}`);\n        }\n\n        return inputItems;\n    }\n\n    /**\n     * Fetches multiple records by primary keys.\n     */\n    async batchGet(primaryKeyValues: string[]): Promise<T[]> {\n        const keys = primaryKeyValues.map((value) => this.getKeyObject(value));\n        const batchGetFn = this.model.batchGet as BatchGetFn;\n        const items = await batchGetFn(keys);\n        return items as T[];\n    }\n\n    /**\n     * Decodes a base64 continuation token into DynamoDB last evaluated key.\n     */\n    decode(continuationToken: string | undefined): DynamoKey | undefined {\n        if (!continuationToken) {\n            return undefined;\n        }\n\n        try {\n            return JSON.parse(Buffer.from(continuationToken, \"base64\").toString(\"utf8\")) as DynamoKey;\n        } catch (error) {\n            throw new Error(\"Invalid continuationToken\");\n        }\n    }\n\n    /**\n     * Encodes DynamoDB last evaluated key into a base64 continuation token.\n     */\n    async encode(lastEvaluatedKey: DynamoKey | undefined): Promise<string | undefined> {\n        if (!lastEvaluatedKey) {\n            return undefined;\n        }\n\n        return Buffer.from(JSON.stringify(lastEvaluatedKey)).toString(\"base64\");\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-dynamoose-dao.js","sourceRoot":"","sources":["../src/base-dynamoose-dao.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseDynamooseModel, AuthContext } from \"./base-dynamoose-model\";\n\ntype DynamoKeyValue = string | number | boolean | null;\nexport type DynamoKey = Record<string, DynamoKeyValue>;\n\ntype BatchPutResponse<T> = {\n    unprocessedItems: Partial<T>[];\n};\n\ntype CreateFn<T> = (item: Partial<T>) => Promise<object>;\ntype UpdateFn<T> = (key: DynamoKey, update: Partial<T>) => Promise<object>;\ntype DeleteFn = (key: DynamoKey) => Promise<object | undefined>;\ntype GetFn = (key: DynamoKey) => Promise<object | undefined>;\ntype BatchPutFn<T> = (items: Partial<T>[]) => Promise<BatchPutResponse<T>>;\ntype BatchGetFn = (keys: DynamoKey[]) => Promise<object[]>;\n\ntype DynamooseModelLike = {\n    create: Function;\n    update: Function;\n    get: Function;\n    delete: Function;\n    batchPut: Function;\n    batchGet: Function;\n};\n\nexport class GenericDynamooseDAO<T extends BaseDynamooseModel> {\n    /**\n     * @param model Dynamoose model instance for the target table.\n     * @param primaryKeyName Attribute name used as the table hash key.\n     */\n    constructor(\n        protected readonly model: DynamooseModelLike,\n        protected readonly primaryKeyName: keyof T & string,\n        protected readonly sortKeyName?: keyof T & string\n    ) { }\n\n    /**\n     * Builds a DynamoDB key object from a single primary key value.\n     */\n    protected getKeyObject(primaryKeyValue: string, sortKeyValue?: string): DynamoKey {\n        const keyObject: DynamoKey = { [this.primaryKeyName]: primaryKeyValue };\n        if (this.sortKeyName) {\n            if (!sortKeyValue) {\n                throw new Error(`Missing sort key value for '${this.sortKeyName}'`);\n            }\n            keyObject[this.sortKeyName] = sortKeyValue;\n        }\n        return keyObject;\n    }\n\n    /**\n     * Extracts and validates string primary key value from an item.\n     */\n    protected getPrimaryKeyValueFromItem(item: T): string {\n        const keyRecord = item as unknown as Record<string, DynamoKeyValue | undefined>;\n        const keyValue = keyRecord[this.primaryKeyName];\n        if (typeof keyValue !== \"string\" || keyValue.length === 0) {\n            throw new Error(`Missing or invalid primary key value for '${this.primaryKeyName}'`);\n        }\n        return keyValue;\n    }\n\n    /**\n     * Extracts and validates sort key value from an item when sort key is configured.\n     */\n    protected getSortKeyValueFromItem(item: T): string | undefined {\n        if (!this.sortKeyName) {\n            return undefined;\n        }\n        const keyRecord = item as unknown as Record<string, DynamoKeyValue | undefined>;\n        const keyValue = keyRecord[this.sortKeyName];\n        if (typeof keyValue !== \"string\" || keyValue.length === 0) {\n            throw new Error(`Missing or invalid sort key value for '${this.sortKeyName}'`);\n        }\n        return keyValue;\n    }\n\n    /**\n     * Builds complete key object (hash + optional sort) from an item.\n     */\n    protected getItemKeyObject(item: T): DynamoKey {\n        const primaryKeyValue = this.getPrimaryKeyValueFromItem(item);\n        const sortKeyValue = this.getSortKeyValueFromItem(item);\n        return this.getKeyObject(primaryKeyValue, sortKeyValue);\n    }\n\n    /**\n     * Serializes key object for stable set/map comparisons.\n     */\n    protected serializeKey(key: DynamoKey): string {\n        if (!this.sortKeyName) {\n            return `${key[this.primaryKeyName]}`;\n        }\n        return `${key[this.primaryKeyName]}#${key[this.sortKeyName]}`;\n    }\n\n    /**\n     * Creates a new record and automatically stamps created audit fields.\n     */\n    async save(item: T, authContext?: AuthContext): Promise<T> {\n        const createFn = this.model.create as CreateFn<T>;\n        const created = await createFn({\n            ...item,\n            created_time: new Date(),\n            created_user: authContext?.userSub\n        });\n        return created as T;\n    }\n\n    /**\n     * Updates an existing record and automatically stamps updated audit fields.\n     */\n    async update(primaryKeyValue: string, updates: Partial<T>, authContext?: AuthContext, sortKeyValue?: string): Promise<T> {\n        const updateFn = this.model.update as UpdateFn<T>;\n        const updated = await updateFn(\n            this.getKeyObject(primaryKeyValue, sortKeyValue),\n            {\n                ...updates,\n                updated_time: new Date(),\n                updated_user: authContext?.userSub\n            }\n        );\n        return updated as T;\n    }\n\n    /**\n     * Deletes one record by primary key.\n     */\n    async delete(primaryKeyValue: string, sortKeyValue?: string): Promise<T | undefined> {\n        const deleteFn = this.model.delete as DeleteFn;\n        const deleted = await deleteFn(this.getKeyObject(primaryKeyValue, sortKeyValue));\n        return deleted as T | undefined;\n    }\n\n    /**\n     * Fetches one record by primary key. Returns null when not found.\n     */\n    async get(primaryKeyValue: string, sortKeyValue?: string): Promise<T | null> {\n        const getFn = this.model.get as GetFn;\n        const item = await getFn(this.getKeyObject(primaryKeyValue, sortKeyValue));\n        return (item as T | undefined) ?? null;\n    }\n\n    /**\n     * Writes multiple records in a batch and throws if any item is left unprocessed.\n     */\n    async batchSave(items: T[], authContext?: AuthContext): Promise<T[]> {\n        const now = new Date();\n        const inputItems = items.map((item) => ({\n            ...item,\n            created_time: now,\n            created_user: authContext?.userSub\n        })) as T[];\n\n        const batchPutFn = this.model.batchPut as BatchPutFn<T>;\n        const result = await batchPutFn(inputItems);\n        if (result.unprocessedItems.length > 0) {\n            throw new Error(`Batch save partially failed. Unprocessed items: ${result.unprocessedItems.length}`);\n        }\n\n        return inputItems;\n    }\n\n    /**\n     * Upserts multiple records by primary key.\n     * New keys are created (created_* fields), existing keys are updated (updated_* fields).\n     */\n    async batchUpsert(items: T[], authContext?: AuthContext): Promise<T[]> {\n        const now = new Date();\n        const keys = items.map((item) => this.getItemKeyObject(item));\n        const existingItems = await this.batchGetByKeys(keys);\n\n        const existingKeySet = new Set(\n            existingItems.map((item) => this.serializeKey(this.getItemKeyObject(item)))\n        );\n\n        const upsertItems = items.map((item) => {\n            const itemKey = this.getItemKeyObject(item);\n            if (existingKeySet.has(this.serializeKey(itemKey))) {\n                return {\n                    ...item,\n                    updated_time: now,\n                    updated_user: authContext?.userSub\n                };\n            }\n\n            return {\n                ...item,\n                created_time: now,\n                created_user: authContext?.userSub\n            };\n        }) as T[];\n\n        const batchPutFn = this.model.batchPut as BatchPutFn<T>;\n        const result = await batchPutFn(upsertItems);\n        if (result.unprocessedItems.length > 0) {\n            throw new Error(`Batch upsert partially failed. Unprocessed items: ${result.unprocessedItems.length}`);\n        }\n\n        return upsertItems;\n    }\n\n    /**\n     * Fetches multiple records by primary keys.\n     */\n    async batchGet(primaryKeyValues: string[]): Promise<T[]> {\n        const keys = primaryKeyValues.map((value) => this.getKeyObject(value));\n        return this.batchGetByKeys(keys);\n    }\n\n    /**\n     * Fetches multiple records by key objects (supports hash + optional sort key).\n     */\n    async batchGetByKeys(keys: DynamoKey[]): Promise<T[]> {\n        const batchGetFn = this.model.batchGet as BatchGetFn;\n        const items = await batchGetFn(keys);\n        return items as T[];\n    }\n\n    /**\n     * Decodes a base64 continuation token into DynamoDB last evaluated key.\n     */\n    decode(continuationToken: string | undefined): DynamoKey | undefined {\n        if (!continuationToken) {\n            return undefined;\n        }\n\n        try {\n            return JSON.parse(Buffer.from(continuationToken, \"base64\").toString(\"utf8\")) as DynamoKey;\n        } catch (error) {\n            throw new Error(\"Invalid continuationToken\");\n        }\n    }\n\n    /**\n     * Encodes DynamoDB last evaluated key into a base64 continuation token.\n     */\n    async encode(lastEvaluatedKey: DynamoKey | undefined): Promise<string | undefined> {\n        if (!lastEvaluatedKey) {\n            return undefined;\n        }\n\n        return Buffer.from(JSON.stringify(lastEvaluatedKey)).toString(\"base64\");\n    }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cmp-aws-database",
-  "version": "1.7.1-dev.27",
+  "version": "1.7.1-dev.28",
   "bin": {
     "craft-my-plate-database": "bin/craft-my-plate-database.js"
   },