@squiz/db-lib 1.77.2 → 1.77.4

package/lib/dynamodb/AbstractDynamoDbRepository.spec.js

@@ -15,6 +15,14 @@ const client_dynamodb_2 = require("@aws-sdk/client-dynamodb");
 const crypto_1 = __importDefault(require("crypto"));
 const InvalidDataFormatError_1 = require("../error/InvalidDataFormatError");
 const ddbClientMock = (0, aws_sdk_client_mock_1.mockClient)(lib_dynamodb_1.DynamoDBDocumentClient);
+const DeleteCommand = lib_dynamodb_1.DeleteCommand;
+const GetCommand = lib_dynamodb_1.GetCommand;
+const PutCommand = lib_dynamodb_1.PutCommand;
+const QueryCommand = lib_dynamodb_1.QueryCommand;
+const UpdateCommand = lib_dynamodb_1.UpdateCommand;
+const TransactWriteCommand = lib_dynamodb_1.TransactWriteCommand;
+const BatchGetCommand = lib_dynamodb_1.BatchGetCommand;
+const BatchWriteCommand = lib_dynamodb_1.BatchWriteCommand;
 const ddbDoc = lib_dynamodb_1.DynamoDBDocument.from(new client_dynamodb_2.DynamoDB({}));
 class TestItem {
     constructor(data = {}) {
@@ -141,7 +149,7 @@ describe('AbstractRepository', () => {
     });
     describe('createItem()', () => {
         it('should create and return the item object if valid input', async () => {
-            ddbClientMock.on(lib_dynamodb_1.PutCommand).resolves({
+            ddbClientMock.on(PutCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -173,7 +181,7 @@ describe('AbstractRepository', () => {
                 },
             };
             const result = await repository.createItem(item);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.PutCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(PutCommand, input);
             expect(result).toEqual(new TestItem({
                 name: 'foo',
                 age: 99,
@@ -186,7 +194,7 @@ describe('AbstractRepository', () => {
             }));
         });
         it('should create and return the item with multiple gsi fields', async () => {
-            ddbClientMock.on(lib_dynamodb_1.PutCommand).resolves({
+            ddbClientMock.on(PutCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -222,7 +230,7 @@ describe('AbstractRepository', () => {
                 email: 'foo@bar.xyz',
             };
             const result = await repository.createItem(item);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.PutCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(PutCommand, input);
             expect(result).toEqual(new TestItem({
                 name: 'foo',
                 age: 99,
@@ -266,7 +274,7 @@ describe('AbstractRepository', () => {
     });
     describe('updateItem()', () => {
         it('should update and return the item object if valid input', async () => {
-            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+            ddbClientMock.on(GetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -277,7 +285,7 @@ describe('AbstractRepository', () => {
                     data: {},
                 },
             });
-            ddbClientMock.on(lib_dynamodb_1.UpdateCommand).resolves({
+            ddbClientMock.on(UpdateCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -309,7 +317,7 @@ describe('AbstractRepository', () => {
                 country: 'au-updated',
             };
             const result = await repository.updateItem(updateItem);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.UpdateCommand, input);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, UpdateCommand, input);
             expect(result).toEqual(new TestItem({
                 name: 'foo',
                 age: 99,
@@ -318,7 +326,7 @@ describe('AbstractRepository', () => {
             }));
         });
         it('should only update the changed attributes', async () => {
-            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+            ddbClientMock.on(GetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -329,7 +337,7 @@ describe('AbstractRepository', () => {
                     data: {},
                 },
             });
-            ddbClientMock.on(lib_dynamodb_1.UpdateCommand).resolves({
+            ddbClientMock.on(UpdateCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -359,7 +367,7 @@ describe('AbstractRepository', () => {
                 data: { active: true },
             };
             const result = await repository.updateItem(updateItem);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.UpdateCommand, input);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, UpdateCommand, input);
             expect(result).toEqual(new TestItem({
                 name: 'foo',
                 age: 99,
@@ -368,7 +376,7 @@ describe('AbstractRepository', () => {
             }));
         });
         it('should not trigger update request if the input attributes are same as in the existing item', async () => {
-            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+            ddbClientMock.on(GetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -379,7 +387,7 @@ describe('AbstractRepository', () => {
                     data: {},
                 },
             });
-            ddbClientMock.on(lib_dynamodb_1.UpdateCommand).rejects(new Error('updateItem() called when not expected'));
+            ddbClientMock.on(UpdateCommand).rejects(new Error('updateItem() called when not expected'));
             // update input attributes are same as in the existing item
             const updateItem = {
                 name: 'foo',
@@ -394,7 +402,7 @@ describe('AbstractRepository', () => {
             }));
         });
         it('should return undefined if item does does not exist', async () => {
-            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+            ddbClientMock.on(GetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -407,7 +415,7 @@ describe('AbstractRepository', () => {
             expect(result).toEqual(undefined);
         });
         it('should return undefined if update cmd conditional check fails', async () => {
-            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+            ddbClientMock.on(GetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -418,7 +426,7 @@ describe('AbstractRepository', () => {
                     data: {},
                 },
             });
-            ddbClientMock.on(lib_dynamodb_1.UpdateCommand).rejects(new client_dynamodb_1.ConditionalCheckFailedException({
+            ddbClientMock.on(UpdateCommand).rejects(new client_dynamodb_1.ConditionalCheckFailedException({
                 $metadata: {},
                 message: 'not found',
             }));
@@ -430,7 +438,7 @@ describe('AbstractRepository', () => {
             expect(result).toEqual(undefined);
         });
         it('should throw error update data has invalid data', async () => {
-            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+            ddbClientMock.on(GetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -448,7 +456,7 @@ describe('AbstractRepository', () => {
             await expect(repository.updateItem(updateItem)).rejects.toEqual(new Error('Invalid "country"'));
         });
         it('should throw error if excess column in input', async () => {
-            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+            ddbClientMock.on(GetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -476,7 +484,7 @@ describe('AbstractRepository', () => {
     });
     describe('getItem()', () => {
         it('should return the item object if found', async () => {
-            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+            ddbClientMock.on(GetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -494,7 +502,7 @@ describe('AbstractRepository', () => {
             };
             const partialItem = { name: 'foo' };
             const result = await repository.getItem(partialItem);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.GetCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(GetCommand, input);
             expect(result).toEqual(new TestItem({
                 name: 'foo',
                 age: 99,
@@ -507,7 +515,7 @@ describe('AbstractRepository', () => {
             }));
         });
         it('should return undefined if item not found', async () => {
-            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+            ddbClientMock.on(GetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -518,11 +526,11 @@ describe('AbstractRepository', () => {
             };
             const partialItem = { name: 'foo' };
             const result = await repository.getItem(partialItem);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.GetCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(GetCommand, input);
             expect(result).toEqual(undefined);
         });
         it('should throw error if item schema validation fails', async () => {
-            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+            ddbClientMock.on(GetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -541,7 +549,7 @@ describe('AbstractRepository', () => {
             await expect(repository.getItem(partialItem)).rejects.toEqual(new MissingKeyValuesError_1.MissingKeyValuesError('Key field "name" must be specified in the input item in entity test-item-entity'));
         });
         it('should throw error if JSON string field has non-string data', async () => {
-            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+            ddbClientMock.on(GetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -562,7 +570,7 @@ describe('AbstractRepository', () => {
     });
     describe('getItems()', () => {
         it('should use BatchGetItem to get result', async () => {
-            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand).resolves({
+            ddbClientMock.on(BatchGetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -597,7 +605,7 @@ describe('AbstractRepository', () => {
             };
             const requestItems = [{ name: 'foo' }, { name: 'foo2' }];
             const result = await repository.getItems(requestItems);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.BatchGetCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(BatchGetCommand, input);
             expect(result).toEqual([
                 new TestItem({
                     name: 'foo',
@@ -622,7 +630,7 @@ describe('AbstractRepository', () => {
             ]);
         });
         it('should remove duplicate items in BatchGetItem request', async () => {
-            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand).resolves({
+            ddbClientMock.on(BatchGetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -657,7 +665,7 @@ describe('AbstractRepository', () => {
             };
             const requestItems = [{ name: 'foo' }, { name: 'foo2' }, { name: 'foo2' }];
             const result = await repository.getItems(requestItems);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.BatchGetCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(BatchGetCommand, input);
             expect(result).toEqual([
                 new TestItem({
                     name: 'foo',
@@ -699,7 +707,7 @@ describe('AbstractRepository', () => {
                     },
                 },
             };
-            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand, input1).resolves({
+            ddbClientMock.on(BatchGetCommand, input1).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -720,7 +728,7 @@ describe('AbstractRepository', () => {
                     },
                 },
             });
-            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand, input2).resolves({
+            ddbClientMock.on(BatchGetCommand, input2).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -739,8 +747,8 @@ describe('AbstractRepository', () => {
             });
             const requestItems = [{ name: 'foo' }, { name: 'foo2' }];
             const result = await repository.getItems(requestItems);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(1, lib_dynamodb_1.BatchGetCommand, input1);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.BatchGetCommand, input2);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(1, BatchGetCommand, input1);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, BatchGetCommand, input2);
             expect(result).toEqual([
                 new TestItem({
                     name: 'foo',
@@ -782,7 +790,7 @@ describe('AbstractRepository', () => {
                     },
                 },
             };
-            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand, input1).resolves({
+            ddbClientMock.on(BatchGetCommand, input1).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -803,7 +811,7 @@ describe('AbstractRepository', () => {
                     },
                 },
             });
-            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand, input2).resolves({
+            ddbClientMock.on(BatchGetCommand, input2).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -816,13 +824,13 @@ describe('AbstractRepository', () => {
             });
             const requestItems = [{ name: 'foo' }, { name: 'foo2' }];
             await expect(repository.getItems(requestItems)).rejects.toEqual(new Error('Maximum allowed retries exceeded for unprocessed items'));
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(1, lib_dynamodb_1.BatchGetCommand, input1);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.BatchGetCommand, input2);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(3, lib_dynamodb_1.BatchGetCommand, input2);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(4, lib_dynamodb_1.BatchGetCommand, input2);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(1, BatchGetCommand, input1);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, BatchGetCommand, input2);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(3, BatchGetCommand, input2);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(4, BatchGetCommand, input2);
         });
         it('should request BatchGetItem in batch of 100 items to get result', async () => {
-            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand).resolves({
+            ddbClientMock.on(BatchGetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -856,9 +864,9 @@ describe('AbstractRepository', () => {
                 },
             };
             await repository.getItems(requestItems);
-            expect(ddbClientMock).toHaveReceivedCommandTimes(lib_dynamodb_1.BatchGetCommand, 2);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(1, lib_dynamodb_1.BatchGetCommand, input1);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.BatchGetCommand, input2);
+            expect(ddbClientMock).toHaveReceivedCommandTimes(BatchGetCommand, 2);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(1, BatchGetCommand, input1);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, BatchGetCommand, input2);
         });
         it('should throw error if any input item does not includes key field(s)', async () => {
             const requestItems = [{ name: 'foo' }, { age: 22 }];
@@ -867,7 +875,7 @@ describe('AbstractRepository', () => {
     });
     describe('deleteItems()', () => {
         it('should use batchWrite() to get result', async () => {
-            ddbClientMock.on(lib_dynamodb_1.BatchWriteCommand).resolves({
+            ddbClientMock.on(BatchWriteCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -893,10 +901,10 @@ describe('AbstractRepository', () => {
             };
             const requestItems = [{ name: 'foo' }, { name: 'foo2' }];
             await repository.deleteItems(requestItems);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.BatchWriteCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(BatchWriteCommand, input);
         });
         it('should remove duplicate items in batchWrite() request', async () => {
-            ddbClientMock.on(lib_dynamodb_1.BatchWriteCommand).resolves({
+            ddbClientMock.on(BatchWriteCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -922,7 +930,7 @@ describe('AbstractRepository', () => {
             };
             const requestItems = [{ name: 'foo' }, { name: 'foo2' }, { name: 'foo2' }, { name: 'foo' }];
             await repository.deleteItems(requestItems);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.BatchWriteCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(BatchWriteCommand, input);
         });
         it('should use re-try if unprocessed items returned', async () => {
             const input1 = {
@@ -952,7 +960,7 @@ describe('AbstractRepository', () => {
                     ],
                 },
             };
-            ddbClientMock.on(lib_dynamodb_1.BatchWriteCommand, input1).resolves({
+            ddbClientMock.on(BatchWriteCommand, input1).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -966,7 +974,7 @@ describe('AbstractRepository', () => {
                     ],
                 },
             });
-            ddbClientMock.on(lib_dynamodb_1.BatchWriteCommand, input2).resolves({
+            ddbClientMock.on(BatchWriteCommand, input2).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -974,8 +982,8 @@ describe('AbstractRepository', () => {
             });
             const requestItems = [{ name: 'foo' }, { name: 'foo2' }];
             await repository.deleteItems(requestItems);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(1, lib_dynamodb_1.BatchWriteCommand, input1);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.BatchWriteCommand, input2);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(1, BatchWriteCommand, input1);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, BatchWriteCommand, input2);
         });
         it('should fail after max number of retries', async () => {
             const input1 = {
@@ -1005,7 +1013,7 @@ describe('AbstractRepository', () => {
                     ],
                 },
             };
-            ddbClientMock.on(lib_dynamodb_1.BatchWriteCommand).resolves({
+            ddbClientMock.on(BatchWriteCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1021,13 +1029,13 @@ describe('AbstractRepository', () => {
             });
             const requestItems = [{ name: 'foo' }, { name: 'foo2' }];
             await expect(repository.deleteItems(requestItems)).rejects.toEqual(new Error('Maximum allowed retries exceeded for unprocessed items'));
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(1, lib_dynamodb_1.BatchWriteCommand, input1);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.BatchWriteCommand, input2);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(3, lib_dynamodb_1.BatchWriteCommand, input2);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(4, lib_dynamodb_1.BatchWriteCommand, input2);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(1, BatchWriteCommand, input1);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, BatchWriteCommand, input2);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(3, BatchWriteCommand, input2);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(4, BatchWriteCommand, input2);
         });
         it('should request batchWrite in batch of 25 items to get result', async () => {
-            ddbClientMock.on(lib_dynamodb_1.BatchWriteCommand).resolves({
+            ddbClientMock.on(BatchWriteCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1069,9 +1077,9 @@ describe('AbstractRepository', () => {
                 },
             };
             await repository.deleteItems(requestItems);
-            expect(ddbClientMock).toHaveReceivedCommandTimes(lib_dynamodb_1.BatchWriteCommand, 2);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(1, lib_dynamodb_1.BatchWriteCommand, input1);
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.BatchWriteCommand, input2);
+            expect(ddbClientMock).toHaveReceivedCommandTimes(BatchWriteCommand, 2);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(1, BatchWriteCommand, input1);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, BatchWriteCommand, input2);
         });
         it('should throw error if any input item does not includes key field(s)', async () => {
             const requestItems = [{ name: 'foo' }, { age: 22 }];
@@ -1080,7 +1088,7 @@ describe('AbstractRepository', () => {
     });
     describe('queryItems()', () => {
         it('should return the items if found', async () => {
-            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+            ddbClientMock.on(QueryCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1105,7 +1113,7 @@ describe('AbstractRepository', () => {
             };
             const partialItem = { name: 'foo' };
             const result = await repository.queryItems(partialItem);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
             expect(result).toEqual([
                 new TestItem({
                     name: 'foo',
@@ -1116,7 +1124,7 @@ describe('AbstractRepository', () => {
             ]);
         });
         it('should return empty array if no items found', async () => {
-            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+            ddbClientMock.on(QueryCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1133,11 +1141,11 @@ describe('AbstractRepository', () => {
             };
             const partialItem = { name: 'foo' };
             const result = await repository.queryItems(partialItem);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
             expect(result).toEqual([]);
         });
         it('should use sort key in query if "useSortKey" param is true', async () => {
-            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+            ddbClientMock.on(QueryCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1156,10 +1164,10 @@ describe('AbstractRepository', () => {
             };
             const partialItem = { name: 'foo' };
             const _result = await repository.queryItems(partialItem, { useSortKey: true });
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
         });
         it('should return the items if found when using gsi index', async () => {
-            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+            ddbClientMock.on(QueryCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1193,7 +1201,7 @@ describe('AbstractRepository', () => {
             const partialItem = { country: 'au' };
             const useSortKey = false;
             const result = await repository.queryItems(partialItem, { useSortKey, index });
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
             expect(result).toEqual([
                 new TestItem({
                     name: 'foo',
@@ -1210,7 +1218,7 @@ describe('AbstractRepository', () => {
             ]);
         });
         it('should use sort key  in query if "useSortKey" param is true when using gsi index', async () => {
-            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+            ddbClientMock.on(QueryCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1232,10 +1240,10 @@ describe('AbstractRepository', () => {
             const partialItem = { age: 99, country: 'au' };
             const useSortKey = true;
             const _result = await repository.queryItems(partialItem, { useSortKey, index });
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
         });
         it('should set input query correctly when "filter - begins_with" query option is set', async () => {
-            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+            ddbClientMock.on(QueryCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1260,10 +1268,10 @@ describe('AbstractRepository', () => {
                 },
             };
             await repository.queryItems(partialItem, queryOptions);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
         });
         it('should throw error invalid "filter" query option is set', async () => {
-            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+            ddbClientMock.on(QueryCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1278,7 +1286,7 @@ describe('AbstractRepository', () => {
             await expect(repository.queryItems(partialItem, queryOptions)).rejects.toEqual(new Error(`Invalid query filter type: invalid-type`));
         });
         it('should set input query correctly when "limit" query option is set', async () => {
-            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+            ddbClientMock.on(QueryCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1299,10 +1307,10 @@ describe('AbstractRepository', () => {
             const partialItem = { name: 'foo' };
             const queryOptions = { limit: 33 };
             await repository.queryItems(partialItem, queryOptions);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
         });
         it('should set input query correctly when "order asc" query option is set', async () => {
-            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+            ddbClientMock.on(QueryCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1321,10 +1329,10 @@ describe('AbstractRepository', () => {
             const partialItem = { name: 'foo' };
             const queryOptions = { order: 'asc' };
             await repository.queryItems(partialItem, queryOptions);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
         });
         it('should set input query correctly when "order desc" query option is set', async () => {
-            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+            ddbClientMock.on(QueryCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1343,7 +1351,7 @@ describe('AbstractRepository', () => {
             const partialItem = { name: 'foo' };
             const queryOptions = { order: 'desc' };
             await repository.queryItems(partialItem, queryOptions);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
         });
         it('should throw error for invalid index query', async () => {
             const index = 'undefined-index';
@@ -1400,7 +1408,7 @@ describe('AbstractRepository', () => {
                 },
             ];
             it('should return all items when there is only 1 page of results', async () => {
-                ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+                ddbClientMock.on(QueryCommand).resolves({
                     Items: [mockItems[0], mockItems[1], mockItems[2]],
                 });
                 const input = {
@@ -1415,14 +1423,14 @@ describe('AbstractRepository', () => {
                 };
                 const partialItem = { name: 'foo' };
                 const result = await repository.queryItems(partialItem);
-                expect(ddbClientMock).toHaveReceivedCommandTimes(lib_dynamodb_1.QueryCommand, 1);
-                expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+                expect(ddbClientMock).toHaveReceivedCommandTimes(QueryCommand, 1);
+                expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
                 expect(result).toEqual([new TestItem(mockItems[0]), new TestItem(mockItems[1]), new TestItem(mockItems[2])]);
             });
             it('should return all items when there are more than 1 page of results', async () => {
                 const mockLastEvaluatedKey = { pk: { S: 'test_item#foo' }, sk: { S: 'name#bar' } };
                 ddbClientMock
-                    .on(lib_dynamodb_1.QueryCommand)
+                    .on(QueryCommand)
                     .resolvesOnce({
                     Items: [mockItems[0], mockItems[1], mockItems[2]],
                     LastEvaluatedKey: mockLastEvaluatedKey,
@@ -1442,9 +1450,9 @@ describe('AbstractRepository', () => {
                 };
                 const partialItem = { name: 'foo' };
                 const result = await repository.queryItems(partialItem);
-                expect(ddbClientMock).toHaveReceivedCommandTimes(lib_dynamodb_1.QueryCommand, 2);
-                expect(ddbClientMock).toHaveReceivedNthCommandWith(1, lib_dynamodb_1.QueryCommand, input);
-                expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.QueryCommand, {
+                expect(ddbClientMock).toHaveReceivedCommandTimes(QueryCommand, 2);
+                expect(ddbClientMock).toHaveReceivedNthCommandWith(1, QueryCommand, input);
+                expect(ddbClientMock).toHaveReceivedNthCommandWith(2, QueryCommand, {
                     ...input,
                     ExclusiveStartKey: mockLastEvaluatedKey,
                 });
@@ -1460,7 +1468,7 @@ describe('AbstractRepository', () => {
                 const mockLimit = 2;
                 const mockLastEvaluatedKey = { pk: { S: 'test_item#foo' }, sk: { S: 'name#bar' } };
                 ddbClientMock
-                    .on(lib_dynamodb_1.QueryCommand)
+                    .on(QueryCommand)
                     .resolvesOnce({
                     Items: [mockItems[0], mockItems[1], mockItems[2]],
                     LastEvaluatedKey: mockLastEvaluatedKey,
@@ -1481,15 +1489,15 @@ describe('AbstractRepository', () => {
                 // Only expect first two items from the first page of results.
                 const partialItem = { name: 'foo' };
                 const result = await repository.queryItems(partialItem, { limit: mockLimit });
-                expect(ddbClientMock).toHaveReceivedCommandTimes(lib_dynamodb_1.QueryCommand, 1);
-                expect(ddbClientMock).toHaveReceivedNthCommandWith(1, lib_dynamodb_1.QueryCommand, input);
+                expect(ddbClientMock).toHaveReceivedCommandTimes(QueryCommand, 1);
+                expect(ddbClientMock).toHaveReceivedNthCommandWith(1, QueryCommand, input);
                 expect(result).toEqual([new TestItem(mockItems[0]), new TestItem(mockItems[1])]);
             });
             it('should return items up to the limit when limit spans multiple pages', async () => {
                 const mockLimit = 4;
                 const mockLastEvaluatedKey = { pk: { S: 'test_item#foo' }, sk: { S: 'name#bar' } };
                 ddbClientMock
-                    .on(lib_dynamodb_1.QueryCommand)
+                    .on(QueryCommand)
                     .resolvesOnce({
                     Items: [mockItems[0], mockItems[1], mockItems[2]],
                     LastEvaluatedKey: mockLastEvaluatedKey,
@@ -1511,9 +1519,9 @@ describe('AbstractRepository', () => {
                 // Expect all 3 results from first page, but only 1 result from second page.
                 const partialItem = { name: 'foo' };
                 const result = await repository.queryItems(partialItem, { limit: mockLimit });
-                expect(ddbClientMock).toHaveReceivedCommandTimes(lib_dynamodb_1.QueryCommand, 2);
-                expect(ddbClientMock).toHaveReceivedNthCommandWith(1, lib_dynamodb_1.QueryCommand, input);
-                expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.QueryCommand, {
+                expect(ddbClientMock).toHaveReceivedCommandTimes(QueryCommand, 2);
+                expect(ddbClientMock).toHaveReceivedNthCommandWith(1, QueryCommand, input);
+                expect(ddbClientMock).toHaveReceivedNthCommandWith(2, QueryCommand, {
                     ...input,
                     ExclusiveStartKey: mockLastEvaluatedKey,
                 });
@@ -1528,7 +1536,7 @@ describe('AbstractRepository', () => {
     });
     describe('deleteItem()', () => {
         it('should return 1 when item is found and deleted', async () => {
-            ddbClientMock.on(lib_dynamodb_1.DeleteCommand).resolves({
+            ddbClientMock.on(DeleteCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1539,11 +1547,11 @@ describe('AbstractRepository', () => {
             };
             const partialItem = { name: 'foo' };
             const result = await repository.deleteItem(partialItem);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.DeleteCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(DeleteCommand, input);
             expect(result).toBe(1);
         });
         it('should return 0 when item is not found', async () => {
-            ddbClientMock.on(lib_dynamodb_1.DeleteCommand).rejects(new client_dynamodb_1.ConditionalCheckFailedException({
+            ddbClientMock.on(DeleteCommand).rejects(new client_dynamodb_1.ConditionalCheckFailedException({
                 $metadata: {},
                 message: 'not found',
             }));
@@ -1553,12 +1561,12 @@ describe('AbstractRepository', () => {
             };
             const partialItem = { name: 'foo' };
             const result = await repository.deleteItem(partialItem);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.DeleteCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(DeleteCommand, input);
             expect(result).toBe(0);
         });
         it('should throw error if request fails', async () => {
             const partialItem = { name: 'foo' };
-            ddbClientMock.on(lib_dynamodb_1.DeleteCommand).rejects('some other error');
+            ddbClientMock.on(DeleteCommand).rejects('some other error');
             await expect(repository.deleteItem(partialItem)).rejects.toEqual(new Error('some other error'));
         });
         it('should throw error if input does not includes key field(s)', async () => {
@@ -1570,7 +1578,7 @@ describe('AbstractRepository', () => {
         it('should execute the multiple transaction write request in a single request', async () => {
             const spy = jest.spyOn(crypto_1.default, 'randomUUID');
             spy.mockImplementation(() => 'some-token');
-            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+            ddbClientMock.on(GetCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1581,7 +1589,7 @@ describe('AbstractRepository', () => {
                     data: {},
                 },
             });
-            ddbClientMock.on(lib_dynamodb_1.TransactWriteCommand).resolves({
+            ddbClientMock.on(TransactWriteCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1648,7 +1656,7 @@ describe('AbstractRepository', () => {
                     },
                 ],
             };
-            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.TransactWriteCommand, input);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, TransactWriteCommand, input);
             expect(result).toEqual({
                 name: 'foo3',
                 age: 11,
@@ -1660,7 +1668,7 @@ describe('AbstractRepository', () => {
     describe('Entity definitions having keys with the object properties', () => {
         it('should use the correct keys in the request', async () => {
             const repository = new TestItem2Repository(TABLE_NAME, ddbManager);
-            ddbClientMock.on(lib_dynamodb_1.PutCommand).resolves({
+            ddbClientMock.on(PutCommand).resolves({
                 $metadata: {
                     httpStatusCode: 200,
                 },
@@ -1698,7 +1706,7 @@ describe('AbstractRepository', () => {
                 },
             };
             const result = await repository.createItem(item);
-            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.PutCommand, input);
+            expect(ddbClientMock).toHaveReceivedCommandWith(PutCommand, input);
             expect(result).toEqual(new TestItem2({
                 date: '2025-02-26',
                 info: {