@squiz/db-lib 1.71.3 → 1.73.0

package/src/dynamodb/AbstractDynamoDbRepository.spec.ts

@@ -1,4 +1,4 @@
-import { AbstractDynamoDbRepository } from './AbstractDynamoDbRepository';
+import { AbstractDynamoDbRepository, QueryOptions } from './AbstractDynamoDbRepository';
 import {
   DeleteCommand,
   DeleteCommandInput,
@@ -14,6 +14,10 @@ import {
   UpdateCommandInput,
   TransactWriteCommand,
   TransactWriteCommandInput,
+  BatchGetCommand,
+  BatchGetCommandInput,
+  BatchWriteCommand,
+  BatchWriteCommandInput,
 } from '@aws-sdk/lib-dynamodb';
 import { ConditionalCheckFailedException } from '@aws-sdk/client-dynamodb';
 import { DynamoDbManager, Transaction } from './DynamoDbManager';
@@ -245,13 +249,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, UpdateCommand, input);
       expect(result).toEqual(
         new TestItem({
@@ -263,20 +265,49 @@ describe('AbstractRepository', () => {
       );
     });
 
-    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(GetCommand).resolves({
         $metadata: {
           httpStatusCode: 200,
         },
+        Item: {
+          name: 'foo',
+          age: 99,
+          country: 'au',
+          data: {},
+        },
       });
+      ddbClientMock.on(UpdateCommand).rejects(new Error('updateItem() called when not expected'));
 
-      const partialItemWithKeyFields = {
+      // 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(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);
     });
 
@@ -300,13 +331,11 @@ describe('AbstractRepository', () => {
         }),
       );
 
-      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);
     });
 
@@ -323,15 +352,13 @@ describe('AbstractRepository', () => {
         },
       });
 
-      const partialItemWithKeyFields = {
-        name: 'foo',
-      };
       const updateItem = {
+        name: 'foo',
         country: 61, // should be "string" type
       };
-      await expect(
-        repository.updateItem(partialItemWithKeyFields, updateItem as unknown as Partial<TestItem>),
-      ).rejects.toEqual(new Error('Invalid "country"'));
+      await expect(repository.updateItem(updateItem as unknown as Partial<TestItem>)).rejects.toEqual(
+        new Error('Invalid "country"'),
+      );
     });
 
     it('should throw error if excess column in input', async () => {
@@ -347,26 +374,22 @@ describe('AbstractRepository', () => {
         },
       });
 
-      const partialItemWithKeyFields = {
-        name: 'foo',
-      };
       const updateItem = {
+        name: 'foo',
         country: 'au-updated',
         extra: '',
       };
-      await expect(
-        repository.updateItem(partialItemWithKeyFields, updateItem as unknown as Partial<TestItem>),
-      ).rejects.toEqual(new InvalidDbSchemaError('Excess properties in entity test-item-entity: extra'));
+      await expect(repository.updateItem(updateItem as unknown as Partial<TestItem>)).rejects.toEqual(
+        new 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(
+      await expect(repository.updateItem(updateItem)).rejects.toEqual(
         new MissingKeyValuesError('Key field "name" must be specified in the input item in entity test-item-entity'),
       );
     });
@@ -473,6 +496,471 @@ describe('AbstractRepository', () => {
     });
   });
 
+  describe('getItems()', () => {
+    it('should use BatchGetItem to get result', async () => {
+      ddbClientMock.on(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: BatchGetCommandInput = {
+        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(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: BatchGetCommandInput = {
+        RequestItems: {
+          [TABLE_NAME]: {
+            Keys: [
+              { pk: 'test_item#foo', sk: '#meta' },
+              { pk: 'test_item#foo2', sk: '#meta' },
+            ],
+          },
+        },
+      };
+      const input2: BatchGetCommandInput = {
+        RequestItems: {
+          [TABLE_NAME]: {
+            Keys: [{ pk: 'test_item#foo2', sk: '#meta' }],
+          },
+        },
+      };
+
+      ddbClientMock.on(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(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, BatchGetCommand, input1);
+      expect(ddbClientMock).toHaveReceivedNthCommandWith(2, 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: BatchGetCommandInput = {
+        RequestItems: {
+          [TABLE_NAME]: {
+            Keys: [
+              { pk: 'test_item#foo', sk: '#meta' },
+              { pk: 'test_item#foo2', sk: '#meta' },
+            ],
+          },
+        },
+      };
+      const input2: BatchGetCommandInput = {
+        RequestItems: {
+          [TABLE_NAME]: {
+            Keys: [{ pk: 'test_item#foo2', sk: '#meta' }],
+          },
+        },
+      };
+
+      ddbClientMock.on(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(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, 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(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: BatchGetCommandInput = {
+        RequestItems: {
+          [TABLE_NAME]: {
+            Keys: keys1,
+          },
+        },
+      };
+      const input2: BatchGetCommandInput = {
+        RequestItems: {
+          [TABLE_NAME]: {
+            Keys: keys2,
+          },
+        },
+      };
+
+      await repository.getItems(requestItems);
+      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 }];
+      await expect(repository.getItems(requestItems)).rejects.toEqual(
+        new 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(BatchWriteCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+        ItemCollectionMetrics: {
+          [TABLE_NAME]: [{}],
+        },
+      });
+      const input: BatchWriteCommandInput = {
+        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(BatchWriteCommand, input);
+    });
+
+    it('should use re-try if unprocessed items returned', async () => {
+      const input1: BatchWriteCommandInput = {
+        RequestItems: {
+          [TABLE_NAME]: [
+            {
+              DeleteRequest: {
+                Key: { pk: 'test_item#foo', sk: '#meta' },
+              },
+            },
+            {
+              DeleteRequest: {
+                Key: { pk: 'test_item#foo2', sk: '#meta' },
+              },
+            },
+          ],
+        },
+      };
+      const input2: BatchWriteCommandInput = {
+        RequestItems: {
+          [TABLE_NAME]: [
+            {
+              DeleteRequest: {
+                Key: { pk: 'test_item#foo2', sk: '#meta' },
+              },
+            },
+          ],
+        },
+      };
+
+      ddbClientMock.on(BatchWriteCommand, input1).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+        UnprocessedItems: {
+          [TABLE_NAME]: [
+            {
+              DeleteRequest: {
+                Key: { pk: 'test_item#foo2', sk: '#meta' },
+              },
+            },
+          ],
+        },
+      });
+      ddbClientMock.on(BatchWriteCommand, input2).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+        UnprocessedItems: {},
+      });
+
+      const requestItems = [{ name: 'foo' }, { name: 'foo2' }];
+      await repository.deleteItems(requestItems);
+      expect(ddbClientMock).toHaveReceivedNthCommandWith(1, BatchWriteCommand, input1);
+      expect(ddbClientMock).toHaveReceivedNthCommandWith(2, BatchWriteCommand, input2);
+    });
+
+    it('should fail after max number of retries', async () => {
+      const input1: BatchWriteCommandInput = {
+        RequestItems: {
+          [TABLE_NAME]: [
+            {
+              DeleteRequest: {
+                Key: { pk: 'test_item#foo', sk: '#meta' },
+              },
+            },
+            {
+              DeleteRequest: {
+                Key: { pk: 'test_item#foo2', sk: '#meta' },
+              },
+            },
+          ],
+        },
+      };
+      const input2: BatchWriteCommandInput = {
+        RequestItems: {
+          [TABLE_NAME]: [
+            {
+              DeleteRequest: {
+                Key: { pk: 'test_item#foo2', sk: '#meta' },
+              },
+            },
+          ],
+        },
+      };
+
+      ddbClientMock.on(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, 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(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: BatchWriteCommandInput = {
+        RequestItems: {
+          [TABLE_NAME]: keys1.map((key) => {
+            return {
+              DeleteRequest: {
+                Key: key,
+              },
+            };
+          }),
+        },
+      };
+      const input2: BatchWriteCommandInput = {
+        RequestItems: {
+          [TABLE_NAME]: keys2.map((key) => {
+            return {
+              DeleteRequest: {
+                Key: key,
+              },
+            };
+          }),
+        },
+      };
+
+      await repository.deleteItems(requestItems);
+      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 }];
+      await expect(repository.deleteItems(requestItems)).rejects.toEqual(
+        new 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(QueryCommand).resolves({
@@ -555,8 +1043,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(QueryCommand, input);
     });
 
@@ -595,7 +1082,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(QueryCommand, input);
       expect(result).toEqual([
         new TestItem({
@@ -636,14 +1123,134 @@ 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(QueryCommand, input);
+    });
+
+    it('should set input query correctly when "filter - begins_with" query option is set', async () => {
+      ddbClientMock.on(QueryCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+      const input: QueryCommandInput = {
+        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: QueryOptions = {
+        filter: {
+          type: 'begins_with',
+          keyword: 'keyword-x',
+        },
+      };
+      await repository.queryItems(partialItem, queryOptions);
+      expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
+    });
+
+    it('should throw error invalid "filter" query option is set', async () => {
+      ddbClientMock.on(QueryCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+      const partialItem = { name: 'foo' };
+      const queryOptions = {
+        filter: {
+          type: 'invalid-type',
+          keyword: 'keyword-x',
+        },
+      } as unknown as QueryOptions;
+      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(QueryCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+      const input: QueryCommandInput = {
+        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(QueryCommand, input);
+    });
+
+    it('should set input query correctly when "order asc" query option is set', async () => {
+      ddbClientMock.on(QueryCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+      const input: QueryCommandInput = {
+        TableName: TABLE_NAME,
+        KeyConditionExpression: '#pkName = :pkValue',
+        ExpressionAttributeNames: {
+          '#pkName': 'pk',
+        },
+        ExpressionAttributeValues: {
+          ':pkValue': 'test_item#foo',
+        },
+        ScanIndexForward: true,
+      };
+
+      const partialItem = { name: 'foo' };
+      const queryOptions = { order: 'asc' } as unknown as QueryOptions;
+      await repository.queryItems(partialItem, queryOptions);
+      expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
+    });
+
+    it('should set input query correctly when "order desc" query option is set', async () => {
+      ddbClientMock.on(QueryCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+      const input: QueryCommandInput = {
+        TableName: TABLE_NAME,
+        KeyConditionExpression: '#pkName = :pkValue',
+        ExpressionAttributeNames: {
+          '#pkName': 'pk',
+        },
+        ExpressionAttributeValues: {
+          ':pkValue': 'test_item#foo',
+        },
+        ScanIndexForward: false,
+      };
+
+      const partialItem = { name: 'foo' };
+      const queryOptions = { order: 'desc' } as unknown as QueryOptions;
+      await repository.queryItems(partialItem, queryOptions);
       expect(ddbClientMock).toHaveReceivedCommandWith(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(
+      await expect(repository.queryItems(partialItem, { index })).rejects.toEqual(
         new MissingKeyValuesError(`Table index '${index}' not defined on entity test-item-entity`),
       );
     });
@@ -659,7 +1266,7 @@ 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(
+      await expect(repository.queryItems(partialItem, { useSortKey, index })).rejects.toEqual(
         new MissingKeyValuesError(`Key field "country" must be specified in the input item in entity test-item-entity`),
       );
     });
@@ -668,7 +1275,7 @@ describe('AbstractRepository', () => {
       const partialItem = { country: 'au' };
       const useSortKey = true;
       const index = 'gsi1_pk-gsi1_sk-index';
-      await expect(repository.queryItems(partialItem, useSortKey, index)).rejects.toEqual(
+      await expect(repository.queryItems(partialItem, { useSortKey, index })).rejects.toEqual(
         new MissingKeyValuesError(`Key field "age" must be specified in the input item in entity test-item-entity`),
       );
     });
@@ -752,8 +1359,6 @@ describe('AbstractRepository', () => {
         await repository.updateItem(
           {
             name: 'foo2',
-          },
-          {
             age: 55,
           },
           transaction,