@jzhuo3/dynamodb-lib 0.1.0 → 0.1.2

package/dist/esm/index.d.ts

@@ -135,6 +135,20 @@ export declare function ListPrepend(attribute: string, value: Array<any>, upsert
 export declare function Remove(attribute: string): DynamoDBExpression;
 export declare function SetAdd(attribute: string, value: Set<any>): DynamoDBExpression;
 export declare function SetDelete(attribute: string, value: Set<any>): DynamoDBExpression;
+/** JSON-compatible value used by expression descriptions. */
+export type DynamoDBExpressionSerializedValue = null | boolean | number | string | DynamoDBExpressionSerializedValue[] | {
+    [key: string]: DynamoDBExpressionSerializedValue;
+};
+export type DynamoDBExpressionDescription = {
+    /** DynamoDB expression string, e.g. `#attr0 = :val0`. */
+    expression: string;
+    /** Placeholder -> attribute name (e.g. `#attr0` -> `VersionStamp`). */
+    expressionAttributeNames: Record<string, string>;
+    /** Placeholder -> JSON-compatible value; native non-JSON values use explicit `$type` tags. */
+    expressionAttributeValues: Record<string, DynamoDBExpressionSerializedValue>;
+    /** Which update clause the expression belongs to (SET/REMOVE/ADD/DELETE). */
+    updateExpressionGroup?: 'SET' | 'REMOVE' | 'ADD' | 'DELETE';
+};
 export declare class DynamoDBExpression {
     expressionAttributeNameMap: Map<string, string>;
     expressionAttributeValueMap: Map<string, any> | null;
@@ -143,6 +157,14 @@ export declare class DynamoDBExpression {
     constructor(expressionAttributeNameMap?: Map<string, string>, // e.g. #attr0 -> attribute
     expressionAttributeValueMap?: Map<string, any> | null, // e.g. :val0 -> value
     expression?: string, updateExpressionGroup?: "SET" | "REMOVE" | "ADD" | "DELETE" | undefined);
+    /**
+     * Detached, JSON-serializable description of the expression. Intended for logging,
+     * debugging, and unit tests that need to assert on a built expression
+     * without reaching into the internal Maps.
+     * Sets, bigint, binary, Maps, NumberValue, undefined and non-finite numbers
+     * use explicit `$type` tags. Circular and unsupported values throw TypeError.
+     */
+    describe(): DynamoDBExpressionDescription;
 }
 export declare enum DynamoDBTransactionMode {
     READ = "READ",

package/dist/esm/index.js

@@ -1,6 +1,6 @@
 import { Agent } from 'https';
 import { DynamoDBClient, ReturnConsumedCapacity, } from '@aws-sdk/client-dynamodb';
-import { DynamoDBDocumentClient, GetCommand, BatchGetCommand, QueryCommand, PutCommand, BatchWriteCommand, UpdateCommand, DeleteCommand, TransactGetCommand, TransactWriteCommand, } from '@aws-sdk/lib-dynamodb';
+import { DynamoDBDocumentClient, NumberValue, GetCommand, BatchGetCommand, QueryCommand, PutCommand, BatchWriteCommand, UpdateCommand, DeleteCommand, TransactGetCommand, TransactWriteCommand, } from '@aws-sdk/lib-dynamodb';
 import { diff, camel, snake } from 'radash';
 const silentLogger = { debug() { }, warn() { }, error() { } };
 export class DynamoDBError extends Error {
@@ -324,6 +324,55 @@ export function SetDelete(attribute, value) {
     const expression = `${path} :val0`;
     return new DynamoDBExpression(expressionAttributeNameMap, expressionAttributeValueMap, expression, 'DELETE');
 }
+function serializeExpressionValue(value, ancestors = new Set()) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : { $type: 'Number', value: String(value) };
+    }
+    if (typeof value === 'bigint')
+        return { $type: 'BigInt', value: value.toString() };
+    if (value === undefined)
+        return { $type: 'Undefined' };
+    if (typeof value !== 'object') {
+        throw new TypeError(`Cannot describe expression value of type ${typeof value}`);
+    }
+    if (ancestors.has(value))
+        throw new TypeError('Cannot describe circular expression value');
+    ancestors.add(value);
+    try {
+        if (value instanceof NumberValue)
+            return { $type: 'NumberValue', value: value.toString() };
+        if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+            const bytes = value instanceof ArrayBuffer
+                ? Buffer.from(value)
+                : Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+            return { $type: 'Binary', encoding: 'base64', value: bytes.toString('base64') };
+        }
+        if (value instanceof Set) {
+            return { $type: 'Set', values: Array.from(value, item => serializeExpressionValue(item, ancestors)) };
+        }
+        if (Array.isArray(value))
+            return Array.from(value, item => serializeExpressionValue(item, ancestors));
+        if (value instanceof Map) {
+            return { $type: 'Map', entries: Array.from(value, ([key, item]) => [
+                    serializeExpressionValue(key, ancestors), serializeExpressionValue(item, ancestors),
+                ]) };
+        }
+        if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+            throw new TypeError('Cannot describe unsupported expression value object');
+        }
+        if (Object.getOwnPropertySymbols(value).some(key => Object.prototype.propertyIsEnumerable.call(value, key))) {
+            throw new TypeError('Cannot describe expression value with symbol keys');
+        }
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key, serializeExpressionValue(item, ancestors),
+        ]));
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
 export class DynamoDBExpression {
     expressionAttributeNameMap;
     expressionAttributeValueMap;
@@ -337,6 +386,27 @@ export class DynamoDBExpression {
         this.expression = expression;
         this.updateExpressionGroup = updateExpressionGroup;
     }
+    /**
+     * Detached, JSON-serializable description of the expression. Intended for logging,
+     * debugging, and unit tests that need to assert on a built expression
+     * without reaching into the internal Maps.
+     * Sets, bigint, binary, Maps, NumberValue, undefined and non-finite numbers
+     * use explicit `$type` tags. Circular and unsupported values throw TypeError.
+     */
+    describe() {
+        return {
+            expression: this.expression,
+            expressionAttributeNames: Object.fromEntries(this.expressionAttributeNameMap),
+            expressionAttributeValues: this.expressionAttributeValueMap
+                ? Object.fromEntries(Array.from(this.expressionAttributeValueMap, ([key, value]) => [
+                    key, serializeExpressionValue(value),
+                ]))
+                : {},
+            ...(this.updateExpressionGroup !== undefined
+                ? { updateExpressionGroup: this.updateExpressionGroup }
+                : {}),
+        };
+    }
 }
 export var DynamoDBTransactionMode;
 (function (DynamoDBTransactionMode) {
@@ -388,6 +458,7 @@ export class DynamoDBTransaction {
                     if (i === retries - 1) {
                         throw error;
                     }
+                    this.logger.warn('DynamoDB retrying transaction conflict', { mode: this.mode, attempt: i + 1, maxAttempts: retries, delayMs: delay * (i + 1) });
                     await new Promise(resolve => setTimeout(resolve, delay * (i + 1)));
                 }
                 else {
@@ -636,10 +707,6 @@ export class DynamoDBTransaction {
             }
             ExpressionAttributeValues[attributeValueVariable] = value;
         });
-        this.logger.debug('Update Expression: %s', UpdateExpression);
-        this.logger.debug('Condition Expression: %s', ConditionExpression);
-        this.logger.debug('Expression Attribute Names: %o', ExpressionAttributeNames);
-        this.logger.debug('Expression Attribute Values: %o', ExpressionAttributeValues);
         this.transactWriteItems.push({
             Update: {
                 TableName: table.name,
@@ -715,6 +782,7 @@ export class DynamoDBTransaction {
         const result = {
             numberOfTransactItems: 0,
         };
+        this.logger.debug('DynamoDB transaction started', { mode: this.mode, itemCount: this.mode === DynamoDBTransactionMode.READ ? this.transactGetItems.length : this.transactWriteItems.length });
         switch (this.mode) {
             case DynamoDBTransactionMode.READ:
                 command = new TransactGetCommand({
@@ -726,21 +794,21 @@ export class DynamoDBTransaction {
                 const { Responses } = (await this.txConflictRetryWrapper(command, this.txRetryLimit, this.txRetryDelay).catch((e) => {
                     this._cleanup();
                     if (isTransactionConflictError(e)) {
-                        this.logger.error('Transaction conflict due to TransactionConflict');
+                        this.logger.error('DynamoDB transaction conflict retry limit reached', { errorName: e.name });
                         throw new DynamoDBError(409, {
                             message: e.message,
                             cause: e,
                         });
                     }
                     else if (e.name === 'TransactionCanceledException') {
-                        this.logger.error(e.message);
+                        this.logger.error('DynamoDB transaction canceled', { errorName: e.name });
                         throw new DynamoDBError(400, {
                             message: e.message,
                             cause: e,
                         });
                     }
                     else {
-                        this.logger.error('Transaction failed due to %s', e.message);
+                        this.logger.error('Transaction failed', { errorName: e.name });
                         throw new DynamoDBError(500, {
                             message: e.message,
                             cause: e,
@@ -789,28 +857,28 @@ export class DynamoDBTransaction {
                 await this.txConflictRetryWrapper(command, this.txRetryLimit, this.txRetryDelay).catch((e) => {
                     this._cleanup();
                     if (isTransactionConflictError(e)) {
-                        this.logger.error('Transaction conflict due to TransactionConflict');
+                        this.logger.error('DynamoDB transaction conflict retry limit reached', { errorName: e.name });
                         throw new DynamoDBError(409, {
                             message: e.message,
                             cause: e,
                         });
                     }
                     else if (e.name === 'TransactionCanceledException') {
-                        this.logger.error(e.message);
+                        this.logger.error('DynamoDB transaction canceled', { errorName: e.name });
                         throw new DynamoDBError(400, {
                             message: e.message,
                             cause: e,
                         });
                     }
                     else if (e.name === 'ValidationException') {
-                        this.logger.error('The request parameters are invalid with error: %s', e.message);
+                        this.logger.error('The request parameters are invalid', { errorName: e.name });
                         throw new DynamoDBError(400, {
                             message: 'Invalid request parameters',
                             cause: e,
                         });
                     }
                     else {
-                        this.logger.error('Transaction failed due to %s', e.message);
+                        this.logger.error('Transaction failed', { errorName: e.name });
                         throw new DynamoDBError(500, {
                             message: e.message,
                             cause: e,
@@ -823,6 +891,7 @@ export class DynamoDBTransaction {
             default:
                 throw new Error('Invalid transaction mode');
         }
+        this.logger.debug('DynamoDB transaction completed', { mode: this.mode, itemCount: result.numberOfTransactItems });
         return result;
     }
 }
@@ -891,8 +960,7 @@ export default class DynamoDBService {
                 ExpressionAttributeNames[attributeNameVariable] = attributeName;
             });
         }
-        this.logger.debug('Projection Expression: %s', ProjectionExpression);
-        this.logger.debug('Expression Attribute Names: %o', ExpressionAttributeNames);
+        this.logger.debug('DynamoDB request started', { operation: 'getOne', tableKey });
         const getCommand = new GetCommand({
             TableName: table.name,
             Key: keys,
@@ -907,22 +975,14 @@ export default class DynamoDBService {
             .send(getCommand)
             .catch((e) => {
             if (e.name === 'ValidationException') {
-                this.logger.error('The request parameters are invalid with error: %s', e.message, {
-                    tableKey,
-                    primaryKey,
-                    opts,
-                });
+                this.logger.error('The request parameters are invalid', { errorName: e.name, tableKey });
                 throw new DynamoDBError(400, {
                     message: 'Invalid request parameters',
                     cause: e,
                 });
             }
             else {
-                this.logger.error('Failed to get item with error: %s', e.message, {
-                    tableKey,
-                    primaryKey,
-                    opts,
-                });
+                this.logger.error('Failed to get item', { errorName: e.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to get item',
                     cause: e,
@@ -933,6 +993,7 @@ export default class DynamoDBService {
         if (item && table.timeToLiveAttribute && item[table.timeToLiveAttribute] !== undefined) {
             const now = getUnixTime(new Date());
             if (item[table.timeToLiveAttribute] <= now) {
+                this.logger.debug('DynamoDB getOne completed', { tableKey, outcome: 'expired' });
                 return null;
             }
             // Delete the time to live attribute from the item if not requested
@@ -940,6 +1001,7 @@ export default class DynamoDBService {
                 delete item[table.timeToLiveAttribute];
             }
         }
+        this.logger.debug('DynamoDB getOne completed', { tableKey, outcome: item ? 'found' : 'not-found' });
         // Item will be undefined if not found
         // Convert keys back to camelCase if camelOrSnake is 'camel' or to snake_case if camelOrSnake is 'snake'
         if (item) {
@@ -973,7 +1035,6 @@ export default class DynamoDBService {
         const keys = primaryKeys.map((primaryKey, indx) => {
             const isArrayOfKeys = Array.isArray(primaryKey);
             const pkStr = serializeKey(primaryKey);
-            this.logger.debug('Primary Key: %s', pkStr);
             if (pkIndexMap.has(pkStr)) {
                 throw new Error(`Duplicate primary key: ${pkStr}`);
             }
@@ -1022,13 +1083,12 @@ export default class DynamoDBService {
                 ExpressionAttributeNames[attributeNameVariable] = attributeName;
             });
         }
-        this.logger.debug('Projection Expression: %s', ProjectionExpression);
-        this.logger.debug('Expression Attribute Names: %o', ExpressionAttributeNames);
         const results = new Array(primaryKeys.length).fill(null);
         const now = getUnixTime(new Date());
         let unprocessedAttempt = 0;
         while (keys.length > 0) {
             const batch = keys.splice(0, 100);
+            this.logger.debug('DynamoDB batch request started', { operation: 'getMany', tableKey, itemCount: batch.length });
             const batchGetCommand = new BatchGetCommand({
                 RequestItems: {
                     [table.name]: {
@@ -1042,19 +1102,23 @@ export default class DynamoDBService {
                 },
                 ReturnConsumedCapacity: opts.returnConsumedCapacity ?? ReturnConsumedCapacity.NONE,
             });
-            const { Responses: responses, UnprocessedKeys: rawUnprocessedKeys } = await this.ddbDocClient.send(batchGetCommand);
+            const { Responses: responses, UnprocessedKeys: rawUnprocessedKeys } = await this.ddbDocClient.send(batchGetCommand).catch((error) => {
+                this.logger.error('Failed to get items', { tableKey, errorName: error.name });
+                throw error;
+            });
             const items = responses && responses[table.name] ? responses[table.name] : [];
             const unprocessedKeys = (rawUnprocessedKeys && rawUnprocessedKeys[table.name]?.Keys) || [];
-            this.logger.debug(`GetMany Responsed Items: %o`, items);
-            this.logger.debug('Now: %d', now);
             if (unprocessedKeys.length > 0) {
                 if (unprocessedAttempt >= MAX_UNPROCESSED_ATTEMPTS) {
+                    this.logger.error('DynamoDB batch retry limit reached', { operation: 'getMany', tableKey, retryCount: unprocessedAttempt });
                     throw new DynamoDBError(500, {
                         message: 'Failed to retrieve items after multiple attempts',
                         cause: new Error('Too many unprocessed items'),
                     });
                 }
-                await sleep(backoffDelayMs(unprocessedAttempt));
+                const delayMs = backoffDelayMs(unprocessedAttempt);
+                this.logger.warn('DynamoDB retrying unprocessed batch items', { operation: 'getMany', tableKey, itemCount: unprocessedKeys.length, attempt: unprocessedAttempt + 1, delayMs });
+                await sleep(delayMs);
                 unprocessedAttempt += 1;
             }
             else {
@@ -1077,7 +1141,6 @@ export default class DynamoDBService {
                 const pkStr = serializeKey(table.sortKey
                     ? [item[table.partitionKey], item[table.sortKey]]
                     : item[table.partitionKey]);
-                this.logger.debug('Primary Key: %s', pkStr);
                 //  Delete the primary key values from the item if not requested
                 if (optIncludePartitionKey === false) {
                     delete item[table.partitionKey];
@@ -1104,6 +1167,7 @@ export default class DynamoDBService {
                 }
             });
         }
+        this.logger.debug('DynamoDB getMany completed', { tableKey, requestedCount: primaryKeys.length, returnedCount: results.filter(item => item !== null).length });
         return results;
     }
     async find(tableKey, keyCondition, filter = null, opts = {}, camelOrSnake = 'camel') {
@@ -1266,7 +1330,6 @@ export default class DynamoDBService {
                             indexName: indexToScan.indexName,
                             projectionType: indexToScan
                                 .projectionType,
-                            projectionFields,
                         });
                     }
                     break;
@@ -1296,12 +1359,11 @@ export default class DynamoDBService {
                             ]).length > 0;
                     }
                     if (hasFieldNotInsideGSIProjection) {
-                        this.logger.error('Some of the projection fields are not included in the GSI projection, which may cause additional read cost', {
+                        this.logger.error('Some of the projection fields are not included in the GSI projection, so the query cannot be executed', {
                             tableKey,
                             indexName: indexToScan.indexName,
                             projectionType: indexToScan
                                 .projectionType,
-                            projectionFields,
                         });
                         throw new Error('All projection fields must be included in the GSI projection');
                     }
@@ -1358,11 +1420,6 @@ export default class DynamoDBService {
             }
             ExpressionAttributeValues[attributeValueVariable] = value;
         });
-        this.logger.debug('Projection Expression: %s', ProjectionExpression);
-        this.logger.debug('Expression Attribute Names: %o', ExpressionAttributeNames);
-        this.logger.debug('Expression Attribute Values: %o', ExpressionAttributeValues);
-        this.logger.debug('Key Condition Expression: %s', KeyConditionExpression);
-        this.logger.debug('Filter Expression: %s', FilterExpression);
         const numOfNeededItems = opts.limit; // May be undefined then no limit
         const result = {
             items: [],
@@ -1424,32 +1481,24 @@ export default class DynamoDBService {
                 : {}),
         };
         while (true) {
+            this.logger.debug('DynamoDB query page requested', { tableKey, hasCursor: !!params.ExclusiveStartKey, hasFilter: !!params.FilterExpression });
             const { Items, LastEvaluatedKey } = await this.ddbDocClient
                 .send(new QueryCommand(params))
                 .catch((e) => {
                 if (e.name === 'ValidationException') {
-                    this.logger.error('The request parameters are invalid with error: %s', e.message, {
-                        tableKey,
-                        keyCondition,
-                        filter,
-                        opts,
-                    });
+                    this.logger.error('The request parameters are invalid', { errorName: e.name, tableKey });
                     throw new DynamoDBError(400, {
                         message: 'Invalid request parameters',
                         cause: e,
                     });
                 }
-                this.logger.error('Failed to query items with error: %s', e.message, {
-                    tableKey,
-                    keyCondition,
-                    filter,
-                    opts,
-                });
+                this.logger.error('Failed to query items', { errorName: e.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to query items',
                     cause: e,
                 });
             });
+            this.logger.debug('DynamoDB query page received', { tableKey, itemCount: Items?.length ?? 0, hasMore: !!LastEvaluatedKey });
             if (LastEvaluatedKey) {
                 params.ExclusiveStartKey = LastEvaluatedKey;
             }
@@ -1594,6 +1643,7 @@ export default class DynamoDBService {
                 ExpressionAttributeNames[key] = value;
             });
         }
+        this.logger.debug('DynamoDB request started', { operation: 'createOne', tableKey });
         const putCommand = new PutCommand({
             TableName: table.name,
             Item: normalizedItem,
@@ -1646,22 +1696,18 @@ export default class DynamoDBService {
             const error = e;
             if (error.name === 'ConditionalCheckFailedException' &&
                 opts.onConflict === 'ignore') {
-                this.logger.debug('Item %s already exists', normalizedItem[table.partitionKey] +
-                    (table.sortKey ? `:${normalizedItem[table.sortKey]}` : ''));
+                this.logger.debug('DynamoDB create skipped: item already exists', { tableKey });
                 result.created = false;
             }
             else {
-                this.logger.error('Failed to create item with error: %s', error.message, {
-                    tableKey,
-                    item: normalizedItem,
-                    opts,
-                });
+                this.logger.error('Failed to create item', { errorName: error.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to create item',
                     cause: error,
                 });
             }
         }
+        this.logger.debug('DynamoDB createOne completed', { tableKey, created: result.created });
         return result;
     }
     async createMany(tableKey, primaryKeys, items, opts = {}) {
@@ -1706,6 +1752,7 @@ export default class DynamoDBService {
         let unprocessedAttempt = 0;
         while (normalizedItems.length > 0) {
             const batch = normalizedItems.splice(0, 25);
+            this.logger.debug('DynamoDB batch request started', { operation: 'createMany', tableKey, itemCount: batch.length });
             const batchWriteCommand = new BatchWriteCommand({
                 RequestItems: {
                     [table.name]: batch.map(item => ({
@@ -1719,11 +1766,7 @@ export default class DynamoDBService {
             const { UnprocessedItems } = await this.ddbDocClient
                 .send(batchWriteCommand)
                 .catch((e) => {
-                this.logger.error('Failed to create items with error: %s', e.message, {
-                    tableKey,
-                    items: batch,
-                    opts,
-                });
+                this.logger.error('Failed to create items', { errorName: e.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to create items',
                     cause: e,
@@ -1732,12 +1775,15 @@ export default class DynamoDBService {
             const unprocessedItems = UnprocessedItems?.[table.name];
             if (unprocessedItems !== undefined && unprocessedItems.length > 0) {
                 if (unprocessedAttempt >= MAX_UNPROCESSED_ATTEMPTS) {
+                    this.logger.error('DynamoDB batch retry limit reached', { operation: 'createMany', tableKey, retryCount: unprocessedAttempt });
                     throw new DynamoDBError(500, {
                         message: 'Failed to create items after multiple attempts',
                         cause: new Error('Too many unprocessed items'),
                     });
                 }
-                await sleep(backoffDelayMs(unprocessedAttempt));
+                const delayMs = backoffDelayMs(unprocessedAttempt);
+                this.logger.warn('DynamoDB retrying unprocessed batch items', { operation: 'createMany', tableKey, itemCount: unprocessedItems.length, attempt: unprocessedAttempt + 1, delayMs });
+                await sleep(delayMs);
                 unprocessedAttempt += 1;
                 normalizedItems.push(...unprocessedItems
                     .map(item => item.PutRequest?.Item)
@@ -1747,6 +1793,7 @@ export default class DynamoDBService {
                 unprocessedAttempt = 0;
             }
         }
+        this.logger.debug('DynamoDB createMany completed', { tableKey, itemCount: result.numberOfItems });
         return result;
     }
     async update(tableKey, primaryKey, commands, condition = null, opts = {}, camelOrSnake = 'camel') {
@@ -1822,10 +1869,7 @@ export default class DynamoDBService {
             }
             ExpressionAttributeValues[attributeValueVariable] = value;
         });
-        this.logger.debug('Update Expression: %s', UpdateExpression);
-        this.logger.debug('Condition Expression: %s', ConditionExpression);
-        this.logger.debug('Expression Attribute Names: %o', ExpressionAttributeNames);
-        this.logger.debug('Expression Attribute Values: %o', ExpressionAttributeValues);
+        this.logger.debug('DynamoDB request started', { operation: 'update', tableKey });
         const updateCommand = new UpdateCommand({
             TableName: table.name,
             Key: keys,
@@ -1859,29 +1903,17 @@ export default class DynamoDBService {
         catch (e) {
             const error = e;
             if (error.name === 'ValidationException') {
-                this.logger.error('The request parameters are invalid with error: %s', error.message, {
-                    tableKey,
-                    primaryKey,
-                    commands,
-                    condition,
-                    opts,
-                });
+                this.logger.error('The request parameters are invalid', { errorName: error.name, tableKey });
                 throw new DynamoDBError(400, {
                     message: 'Invalid request parameters',
                     cause: e,
                 });
             }
             else if (error.name === 'ConditionalCheckFailedException') {
-                this.logger.debug('Condition failed to update item %s', primaryKey.toString());
+                this.logger.debug('DynamoDB update skipped: condition not met', { tableKey });
             }
             else {
-                this.logger.error('Failed to update item with error: %s', error.message, {
-                    tableKey,
-                    primaryKey,
-                    commands,
-                    condition,
-                    opts,
-                });
+                this.logger.error('Failed to update item', { errorName: error.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to update item',
                     cause: e,
@@ -1907,6 +1939,7 @@ export default class DynamoDBService {
                 result.item = newItem;
             }
         }
+        this.logger.debug('DynamoDB update completed', { tableKey, updatedOrCreated: result.updatedOrCreated });
         return result;
     }
     async deleteOne(tableKey, primaryKey, condition = null, opts = {}, camelOrSnake = 'camel') {
@@ -1942,6 +1975,7 @@ export default class DynamoDBService {
             }
             ConditionExpression = condition.expression;
         }
+        this.logger.debug('DynamoDB request started', { operation: 'deleteOne', tableKey });
         const deleteCommand = new DeleteCommand({
             TableName: table.name,
             Key: keys,
@@ -1969,27 +2003,17 @@ export default class DynamoDBService {
         catch (e) {
             const error = e;
             if (error.name === 'ValidationException') {
-                this.logger.error('The request parameters are invalid with error: %s', error.message, {
-                    tableKey,
-                    primaryKey,
-                    condition,
-                    opts,
-                });
+                this.logger.error('The request parameters are invalid', { errorName: error.name, tableKey });
                 throw new DynamoDBError(400, {
                     message: 'Invalid request parameters',
                     cause: e,
                 });
             }
             else if (error.name === 'ConditionalCheckFailedException') {
-                this.logger.debug('Condition failed to delete item %s', primaryKey.toString());
+                this.logger.debug('DynamoDB delete skipped: condition not met', { tableKey });
             }
             else {
-                this.logger.error('Failed to delete item with error: %s', error.message, {
-                    tableKey,
-                    primaryKey,
-                    condition,
-                    opts,
-                });
+                this.logger.error('Failed to delete item', { errorName: error.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to delete item',
                     cause: e,
@@ -2015,6 +2039,7 @@ export default class DynamoDBService {
                 result.item = newItem;
             }
         }
+        this.logger.debug('DynamoDB deleteOne completed', { tableKey, deleted: result.deleted });
         return result;
     }
     async deleteMany(tableKey, primaryKeys, opts = {}) {
@@ -2039,6 +2064,7 @@ export default class DynamoDBService {
         let unprocessedAttempt = 0;
         while (keys.length > 0) {
             const batch = keys.splice(0, 25);
+            this.logger.debug('DynamoDB batch request started', { operation: 'deleteMany', tableKey, itemCount: batch.length });
             const batchWriteCommand = new BatchWriteCommand({
                 RequestItems: {
                     [table.name]: batch.map(key => ({
@@ -2052,11 +2078,7 @@ export default class DynamoDBService {
             const { UnprocessedItems } = await this.ddbDocClient
                 .send(batchWriteCommand)
                 .catch((e) => {
-                this.logger.error('Failed to delete items with error: %s', e.message, {
-                    tableKey,
-                    keys: batch,
-                    opts,
-                });
+                this.logger.error('Failed to delete items', { errorName: e.name, tableKey });
                 throw new DynamoDBError(500, {
                     message: 'Failed to delete items',
                     cause: e,
@@ -2065,12 +2087,15 @@ export default class DynamoDBService {
             const unprocessedItems = UnprocessedItems?.[table.name];
             if (unprocessedItems !== undefined && unprocessedItems.length > 0) {
                 if (unprocessedAttempt >= MAX_UNPROCESSED_ATTEMPTS) {
+                    this.logger.error('DynamoDB batch retry limit reached', { operation: 'deleteMany', tableKey, retryCount: unprocessedAttempt });
                     throw new DynamoDBError(500, {
                         message: 'Failed to delete items after multiple attempts',
                         cause: new Error('Too many unprocessed items'),
                     });
                 }
-                await sleep(backoffDelayMs(unprocessedAttempt));
+                const delayMs = backoffDelayMs(unprocessedAttempt);
+                this.logger.warn('DynamoDB retrying unprocessed batch items', { operation: 'deleteMany', tableKey, itemCount: unprocessedItems.length, attempt: unprocessedAttempt + 1, delayMs });
+                await sleep(delayMs);
                 unprocessedAttempt += 1;
                 keys.push(...unprocessedItems
                     .map(item => item.DeleteRequest?.Key)
@@ -2080,6 +2105,7 @@ export default class DynamoDBService {
                 unprocessedAttempt = 0;
             }
         }
+        this.logger.debug('DynamoDB deleteMany completed', { tableKey, itemCount: result.numberOfItems });
         return result;
     }
     transaction(opts) {