@squiz/db-lib 1.71.3 → 1.73.0

package/lib/dynamodb/AbstractDynamoDbRepository.spec.js

@@ -193,13 +193,11 @@ describe('AbstractRepository', () => {
                 },
                 ConditionExpression: `attribute_exists(pk)`,
             };
-            const partialItemWithKeyFields = {
-                name: 'foo',
-            };
             const updateItem = {
+                name: 'foo',
                 country: 'au-updated',
             };
-            const result = await repository.updateItem(partialItemWithKeyFields, updateItem);
+            const result = await repository.updateItem(updateItem);
             expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.UpdateCommand, input);
             expect(result).toEqual(new TestItem({
                 name: 'foo',
@@ -208,19 +206,43 @@ describe('AbstractRepository', () => {
                 data: {},
             }));
         });
-        it('should undefined if item does does not exist', async () => {
+        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({
                 $metadata: {
                     httpStatusCode: 200,
                 },
+                Item: {
+                    name: 'foo',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                },
             });
-            const partialItemWithKeyFields = {
+            ddbClientMock.on(lib_dynamodb_1.UpdateCommand).rejects(new Error('updateItem() called when not expected'));
+            // update input attributes are same as in the existing item
+            const updateItem = {
                 name: 'foo',
+                country: 'au',
             };
+            const result = await repository.updateItem(updateItem);
+            expect(result).toEqual(new TestItem({
+                name: 'foo',
+                age: 99,
+                country: 'au',
+                data: {},
+            }));
+        });
+        it('should return undefined if item does does not exist', async () => {
+            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
             const updateItem = {
+                name: 'foo',
                 country: 'au-updated',
             };
-            const result = await repository.updateItem(partialItemWithKeyFields, updateItem);
+            const result = await repository.updateItem(updateItem);
             expect(result).toEqual(undefined);
         });
         it('should return undefined if update cmd conditional check fails', async () => {
@@ -239,13 +261,11 @@ describe('AbstractRepository', () => {
                 $metadata: {},
                 message: 'not found',
             }));
-            const partialItemWithKeyFields = {
-                name: 'foo',
-            };
             const updateItem = {
+                name: 'foo',
                 country: 'au-updated',
             };
-            const result = await repository.updateItem(partialItemWithKeyFields, updateItem);
+            const result = await repository.updateItem(updateItem);
             expect(result).toEqual(undefined);
         });
         it('should throw error update data has invalid data', async () => {
@@ -260,13 +280,11 @@ describe('AbstractRepository', () => {
                     data: {},
                 },
             });
-            const partialItemWithKeyFields = {
-                name: 'foo',
-            };
             const updateItem = {
+                name: 'foo',
                 country: 61, // should be "string" type
             };
-            await expect(repository.updateItem(partialItemWithKeyFields, updateItem)).rejects.toEqual(new Error('Invalid "country"'));
+            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({
@@ -280,23 +298,19 @@ describe('AbstractRepository', () => {
                     data: {},
                 },
             });
-            const partialItemWithKeyFields = {
-                name: 'foo',
-            };
             const updateItem = {
+                name: 'foo',
                 country: 'au-updated',
                 extra: '',
             };
-            await expect(repository.updateItem(partialItemWithKeyFields, updateItem)).rejects.toEqual(new __1.InvalidDbSchemaError('Excess properties in entity test-item-entity: extra'));
+            await expect(repository.updateItem(updateItem)).rejects.toEqual(new __1.InvalidDbSchemaError('Excess properties in entity test-item-entity: extra'));
         });
         it('should throw error if input does not includes key field(s)', async () => {
-            const partialItemWithKeyFields = {
-                age: 99,
-            };
             const updateItem = {
+                age: 99,
                 country: 'au-updated', // should be "string" type
             };
-            await expect(repository.updateItem(partialItemWithKeyFields, updateItem)).rejects.toEqual(new __1.MissingKeyValuesError('Key field "name" must be specified in the input item in entity test-item-entity'));
+            await expect(repository.updateItem(updateItem)).rejects.toEqual(new __1.MissingKeyValuesError('Key field "name" must be specified in the input item in entity test-item-entity'));
         });
     });
     describe('getItem()', () => {
@@ -385,6 +399,435 @@ describe('AbstractRepository', () => {
             await expect(repository.getItem(partialItem)).rejects.toEqual(new InvalidDataFormatError_1.InvalidDataFormatError(`Field 'data2' defined as JSON String has a non-string data`));
         });
     });
+    describe('getItems()', () => {
+        it('should use BatchGetItem to get result', async () => {
+            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Responses: {
+                    [TABLE_NAME]: [
+                        {
+                            name: 'foo',
+                            age: 99,
+                            country: 'au',
+                            data: {},
+                            data2: '{"foo":"bar","num":123}',
+                        },
+                        {
+                            name: 'foo2',
+                            age: 999,
+                            country: 'au',
+                            data: {},
+                            data2: '{"foo":"bar","num":123}',
+                        },
+                    ],
+                },
+            });
+            const input = {
+                RequestItems: {
+                    [TABLE_NAME]: {
+                        Keys: [
+                            { pk: 'test_item#foo', sk: '#meta' },
+                            { pk: 'test_item#foo2', sk: '#meta' },
+                        ],
+                    },
+                },
+            };
+            const requestItems = [{ name: 'foo' }, { name: 'foo2' }];
+            const result = await repository.getItems(requestItems);
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.BatchGetCommand, input);
+            expect(result).toEqual([
+                new TestItem({
+                    name: 'foo',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                    data2: {
+                        foo: 'bar',
+                        num: 123,
+                    },
+                }),
+                new TestItem({
+                    name: 'foo2',
+                    age: 999,
+                    country: 'au',
+                    data: {},
+                    data2: {
+                        foo: 'bar',
+                        num: 123,
+                    },
+                }),
+            ]);
+        });
+        it('should retry if unprocessed keys returned', async () => {
+            const input1 = {
+                RequestItems: {
+                    [TABLE_NAME]: {
+                        Keys: [
+                            { pk: 'test_item#foo', sk: '#meta' },
+                            { pk: 'test_item#foo2', sk: '#meta' },
+                        ],
+                    },
+                },
+            };
+            const input2 = {
+                RequestItems: {
+                    [TABLE_NAME]: {
+                        Keys: [{ pk: 'test_item#foo2', sk: '#meta' }],
+                    },
+                },
+            };
+            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand, input1).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Responses: {
+                    [TABLE_NAME]: [
+                        {
+                            name: 'foo',
+                            age: 99,
+                            country: 'au',
+                            data: {},
+                            data2: '{"foo":"bar","num":123}',
+                        },
+                    ],
+                },
+                UnprocessedKeys: {
+                    [TABLE_NAME]: {
+                        Keys: [{ pk: 'test_item#foo2', sk: '#meta' }],
+                    },
+                },
+            });
+            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand, input2).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Responses: {
+                    [TABLE_NAME]: [
+                        {
+                            name: 'foo2',
+                            age: 999,
+                            country: 'au',
+                            data: {},
+                            data2: '{"foo":"bar","num":123}',
+                        },
+                    ],
+                },
+                UnprocessedKeys: {},
+            });
+            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(result).toEqual([
+                new TestItem({
+                    name: 'foo',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                    data2: {
+                        foo: 'bar',
+                        num: 123,
+                    },
+                }),
+                new TestItem({
+                    name: 'foo2',
+                    age: 999,
+                    country: 'au',
+                    data: {},
+                    data2: {
+                        foo: 'bar',
+                        num: 123,
+                    },
+                }),
+            ]);
+        });
+        it('should fail after max retries for unprocessed keys', async () => {
+            const input1 = {
+                RequestItems: {
+                    [TABLE_NAME]: {
+                        Keys: [
+                            { pk: 'test_item#foo', sk: '#meta' },
+                            { pk: 'test_item#foo2', sk: '#meta' },
+                        ],
+                    },
+                },
+            };
+            const input2 = {
+                RequestItems: {
+                    [TABLE_NAME]: {
+                        Keys: [{ pk: 'test_item#foo2', sk: '#meta' }],
+                    },
+                },
+            };
+            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand, input1).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Responses: {
+                    [TABLE_NAME]: [
+                        {
+                            name: 'foo',
+                            age: 99,
+                            country: 'au',
+                            data: {},
+                            data2: '{"foo":"bar","num":123}',
+                        },
+                    ],
+                },
+                UnprocessedKeys: {
+                    [TABLE_NAME]: {
+                        Keys: [{ pk: 'test_item#foo2', sk: '#meta' }],
+                    },
+                },
+            });
+            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand, input2).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Responses: {},
+                UnprocessedKeys: {
+                    [TABLE_NAME]: {
+                        Keys: [{ pk: 'test_item#foo2', sk: '#meta' }],
+                    },
+                },
+            });
+            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);
+        });
+        it('should request BatchGetItem in batch of 100 items to get result', async () => {
+            ddbClientMock.on(lib_dynamodb_1.BatchGetCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const requestItems = [];
+            for (let i = 0; i < 120; i++) {
+                requestItems.push({ name: `foo${i}` });
+            }
+            // keys for first batch request
+            const keys1 = [];
+            for (let i = 0; i < 100; i++) {
+                keys1.push({ pk: `test_item#foo${i}`, sk: '#meta' });
+            }
+            // keys for second batch request
+            const keys2 = [];
+            for (let i = 100; i < 120; i++) {
+                keys2.push({ pk: `test_item#foo${i}`, sk: '#meta' });
+            }
+            const input1 = {
+                RequestItems: {
+                    [TABLE_NAME]: {
+                        Keys: keys1,
+                    },
+                },
+            };
+            const input2 = {
+                RequestItems: {
+                    [TABLE_NAME]: {
+                        Keys: keys2,
+                    },
+                },
+            };
+            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);
+        });
+        it('should throw error if any input item does not includes key field(s)', async () => {
+            const requestItems = [{ name: 'foo' }, { age: 22 }];
+            await expect(repository.getItems(requestItems)).rejects.toEqual(new __1.MissingKeyValuesError('Key field "name" must be specified in the input item in entity test-item-entity'));
+        });
+    });
+    describe('deleteItems()', () => {
+        it('should use batchWrite() to get result', async () => {
+            ddbClientMock.on(lib_dynamodb_1.BatchWriteCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                ItemCollectionMetrics: {
+                    [TABLE_NAME]: [{}],
+                },
+            });
+            const input = {
+                RequestItems: {
+                    [TABLE_NAME]: [
+                        {
+                            DeleteRequest: {
+                                Key: { pk: 'test_item#foo', sk: '#meta' },
+                            },
+                        },
+                        {
+                            DeleteRequest: {
+                                Key: { pk: 'test_item#foo2', sk: '#meta' },
+                            },
+                        },
+                    ],
+                },
+            };
+            const requestItems = [{ name: 'foo' }, { name: 'foo2' }];
+            await repository.deleteItems(requestItems);
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.BatchWriteCommand, input);
+        });
+        it('should use re-try if unprocessed items returned', async () => {
+            const input1 = {
+                RequestItems: {
+                    [TABLE_NAME]: [
+                        {
+                            DeleteRequest: {
+                                Key: { pk: 'test_item#foo', sk: '#meta' },
+                            },
+                        },
+                        {
+                            DeleteRequest: {
+                                Key: { pk: 'test_item#foo2', sk: '#meta' },
+                            },
+                        },
+                    ],
+                },
+            };
+            const input2 = {
+                RequestItems: {
+                    [TABLE_NAME]: [
+                        {
+                            DeleteRequest: {
+                                Key: { pk: 'test_item#foo2', sk: '#meta' },
+                            },
+                        },
+                    ],
+                },
+            };
+            ddbClientMock.on(lib_dynamodb_1.BatchWriteCommand, input1).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                UnprocessedItems: {
+                    [TABLE_NAME]: [
+                        {
+                            DeleteRequest: {
+                                Key: { pk: 'test_item#foo2', sk: '#meta' },
+                            },
+                        },
+                    ],
+                },
+            });
+            ddbClientMock.on(lib_dynamodb_1.BatchWriteCommand, input2).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                UnprocessedItems: {},
+            });
+            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);
+        });
+        it('should fail after max number of retries', async () => {
+            const input1 = {
+                RequestItems: {
+                    [TABLE_NAME]: [
+                        {
+                            DeleteRequest: {
+                                Key: { pk: 'test_item#foo', sk: '#meta' },
+                            },
+                        },
+                        {
+                            DeleteRequest: {
+                                Key: { pk: 'test_item#foo2', sk: '#meta' },
+                            },
+                        },
+                    ],
+                },
+            };
+            const input2 = {
+                RequestItems: {
+                    [TABLE_NAME]: [
+                        {
+                            DeleteRequest: {
+                                Key: { pk: 'test_item#foo2', sk: '#meta' },
+                            },
+                        },
+                    ],
+                },
+            };
+            ddbClientMock.on(lib_dynamodb_1.BatchWriteCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                UnprocessedItems: {
+                    [TABLE_NAME]: [
+                        {
+                            DeleteRequest: {
+                                Key: { pk: 'test_item#foo2', sk: '#meta' },
+                            },
+                        },
+                    ],
+                },
+            });
+            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);
+        });
+        it('should request batchWrite in batch of 25 items to get result', async () => {
+            ddbClientMock.on(lib_dynamodb_1.BatchWriteCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const requestItems = [];
+            for (let i = 0; i < 30; i++) {
+                requestItems.push({ name: `foo${i}` });
+            }
+            // keys for first batch request
+            const keys1 = [];
+            for (let i = 0; i < 25; i++) {
+                keys1.push({ pk: `test_item#foo${i}`, sk: '#meta' });
+            }
+            // keys for second batch request
+            const keys2 = [];
+            for (let i = 25; i < 30; i++) {
+                keys2.push({ pk: `test_item#foo${i}`, sk: '#meta' });
+            }
+            const input1 = {
+                RequestItems: {
+                    [TABLE_NAME]: keys1.map((key) => {
+                        return {
+                            DeleteRequest: {
+                                Key: key,
+                            },
+                        };
+                    }),
+                },
+            };
+            const input2 = {
+                RequestItems: {
+                    [TABLE_NAME]: keys2.map((key) => {
+                        return {
+                            DeleteRequest: {
+                                Key: key,
+                            },
+                        };
+                    }),
+                },
+            };
+            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);
+        });
+        it('should throw error if any input item does not includes key field(s)', async () => {
+            const requestItems = [{ name: 'foo' }, { age: 22 }];
+            await expect(repository.deleteItems(requestItems)).rejects.toEqual(new __1.MissingKeyValuesError('Key field "name" must be specified in the input item in entity test-item-entity'));
+        });
+    });
     describe('queryItems()', () => {
         it('should return the items if found', async () => {
             ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
@@ -462,8 +905,7 @@ describe('AbstractRepository', () => {
                 },
             };
             const partialItem = { name: 'foo' };
-            const useSortKey = true;
-            const _result = await repository.queryItems(partialItem, useSortKey);
+            const _result = await repository.queryItems(partialItem, { useSortKey: true });
             expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
         });
         it('should return the items if found when using gsi index', async () => {
@@ -500,7 +942,7 @@ describe('AbstractRepository', () => {
             };
             const partialItem = { country: 'au' };
             const useSortKey = false;
-            const result = await repository.queryItems(partialItem, useSortKey, index);
+            const result = await repository.queryItems(partialItem, { useSortKey, index });
             expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
             expect(result).toEqual([
                 new TestItem({
@@ -539,13 +981,122 @@ describe('AbstractRepository', () => {
             };
             const partialItem = { age: 99, country: 'au' };
             const useSortKey = true;
-            const _result = await repository.queryItems(partialItem, useSortKey, index);
+            const _result = await repository.queryItems(partialItem, { useSortKey, index });
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+        });
+        it('should set input query correctly when "filter - begins_with" query option is set', async () => {
+            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const input = {
+                TableName: TABLE_NAME,
+                KeyConditionExpression: '#pkName = :pkValue AND begins_with(#skName, :skValue)',
+                ExpressionAttributeNames: {
+                    '#pkName': 'pk',
+                    '#skName': 'sk',
+                },
+                ExpressionAttributeValues: {
+                    ':pkValue': 'test_item#foo',
+                    ':skValue': 'keyword-x',
+                },
+            };
+            const partialItem = { name: 'foo' };
+            const queryOptions = {
+                filter: {
+                    type: 'begins_with',
+                    keyword: 'keyword-x',
+                },
+            };
+            await repository.queryItems(partialItem, queryOptions);
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+        });
+        it('should throw error invalid "filter" query option is set', async () => {
+            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const partialItem = { name: 'foo' };
+            const queryOptions = {
+                filter: {
+                    type: 'invalid-type',
+                    keyword: 'keyword-x',
+                },
+            };
+            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({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const input = {
+                TableName: TABLE_NAME,
+                KeyConditionExpression: '#pkName = :pkValue',
+                ExpressionAttributeNames: {
+                    '#pkName': 'pk',
+                },
+                ExpressionAttributeValues: {
+                    ':pkValue': 'test_item#foo',
+                },
+                Limit: 33,
+            };
+            const partialItem = { name: 'foo' };
+            const queryOptions = { limit: 33 };
+            await repository.queryItems(partialItem, queryOptions);
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+        });
+        it('should set input query correctly when "order asc" query option is set', async () => {
+            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const input = {
+                TableName: TABLE_NAME,
+                KeyConditionExpression: '#pkName = :pkValue',
+                ExpressionAttributeNames: {
+                    '#pkName': 'pk',
+                },
+                ExpressionAttributeValues: {
+                    ':pkValue': 'test_item#foo',
+                },
+                ScanIndexForward: true,
+            };
+            const partialItem = { name: 'foo' };
+            const queryOptions = { order: 'asc' };
+            await repository.queryItems(partialItem, queryOptions);
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+        });
+        it('should set input query correctly when "order desc" query option is set', async () => {
+            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const input = {
+                TableName: TABLE_NAME,
+                KeyConditionExpression: '#pkName = :pkValue',
+                ExpressionAttributeNames: {
+                    '#pkName': 'pk',
+                },
+                ExpressionAttributeValues: {
+                    ':pkValue': 'test_item#foo',
+                },
+                ScanIndexForward: false,
+            };
+            const partialItem = { name: 'foo' };
+            const queryOptions = { order: 'desc' };
+            await repository.queryItems(partialItem, queryOptions);
             expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
         });
         it('should throw error for invalid index query', async () => {
             const index = 'undefined-index';
             const partialItem = { age: 99, country: 'au' };
-            await expect(repository.queryItems(partialItem, false, index)).rejects.toEqual(new __1.MissingKeyValuesError(`Table index '${index}' not defined on entity test-item-entity`));
+            await expect(repository.queryItems(partialItem, { index })).rejects.toEqual(new __1.MissingKeyValuesError(`Table index '${index}' not defined on entity test-item-entity`));
         });
         it('should throw error for missing key fields', async () => {
             const partialItem = { age: 99, country: 'au' };
@@ -555,13 +1106,13 @@ describe('AbstractRepository', () => {
             const partialItem = { name: 'foo' };
             const useSortKey = false;
             const index = 'gsi1_pk-gsi1_sk-index';
-            await expect(repository.queryItems(partialItem, useSortKey, index)).rejects.toEqual(new __1.MissingKeyValuesError(`Key field "country" must be specified in the input item in entity test-item-entity`));
+            await expect(repository.queryItems(partialItem, { useSortKey, index })).rejects.toEqual(new __1.MissingKeyValuesError(`Key field "country" must be specified in the input item in entity test-item-entity`));
         });
         it('should throw error for missing key fields with  "useSortKey" param  true when using index', async () => {
             const partialItem = { country: 'au' };
             const useSortKey = true;
             const index = 'gsi1_pk-gsi1_sk-index';
-            await expect(repository.queryItems(partialItem, useSortKey, index)).rejects.toEqual(new __1.MissingKeyValuesError(`Key field "age" must be specified in the input item in entity test-item-entity`));
+            await expect(repository.queryItems(partialItem, { useSortKey, index })).rejects.toEqual(new __1.MissingKeyValuesError(`Key field "age" must be specified in the input item in entity test-item-entity`));
         });
     });
     describe('deleteItem()', () => {
@@ -628,7 +1179,6 @@ describe('AbstractRepository', () => {
                 await repository.deleteItem({ name: 'foo' }, transaction);
                 await repository.updateItem({
                     name: 'foo2',
-                }, {
                     age: 55,
                 }, transaction);
                 return await repository.createItem({