@squiz/db-lib 1.71.2 → 1.72.0

package/lib/dynamodb/AbstractDynamoDbRepository.spec.js

@@ -0,0 +1,924 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractDynamoDbRepository_1 = require("./AbstractDynamoDbRepository");
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const DynamoDbManager_1 = require("./DynamoDbManager");
+const __1 = require("..");
+const aws_sdk_client_mock_1 = require("aws-sdk-client-mock");
+require("aws-sdk-client-mock-jest");
+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 ddbDoc = lib_dynamodb_1.DynamoDBDocument.from(new client_dynamodb_2.DynamoDB({}));
+class TestItem {
+    constructor(data = {}) {
+        var _a, _b, _c, _d, _e;
+        this.name = (_a = data.name) !== null && _a !== void 0 ? _a : 'default name';
+        this.age = (_b = data.age) !== null && _b !== void 0 ? _b : 0;
+        this.country = (_c = data.country) !== null && _c !== void 0 ? _c : 'default country';
+        this.data = (_d = data.data) !== null && _d !== void 0 ? _d : {};
+        this.data2 = (_e = data.data2) !== null && _e !== void 0 ? _e : {};
+        if (typeof this.name !== 'string') {
+            throw Error('Invalid "name"');
+        }
+        if (typeof this.age !== 'number') {
+            throw Error('Invalid "age"');
+        }
+        if (typeof this.country !== 'string') {
+            throw Error('Invalid "country"');
+        }
+        if (typeof this.data !== 'object' || Array.isArray(this.data)) {
+            throw Error('Invalid "data"');
+        }
+    }
+}
+const TABLE_NAME = 'test-table';
+const TEST_ITEM_ENTITY_NAME = 'test-item-entity';
+const TEST_ITEM_ENTITY_DEFINITION = {
+    keys: {
+        pk: {
+            format: 'test_item#{name}',
+            attributeName: 'pk',
+        },
+        sk: {
+            format: '#meta',
+            attributeName: 'sk',
+        },
+    },
+    indexes: {
+        'gsi1_pk-gsi1_sk-index': {
+            pk: {
+                format: 'country#{country}',
+                attributeName: 'gsi1_pk',
+            },
+            sk: {
+                format: 'age#{age}',
+                attributeName: 'gsi1_sk',
+            },
+        },
+    },
+    // field to be stored as JSON string
+    fieldsAsJsonString: ['data2'],
+};
+class TestItemRepository extends AbstractDynamoDbRepository_1.AbstractDynamoDbRepository {
+    constructor(tableName, dbManager) {
+        super(tableName, dbManager, TEST_ITEM_ENTITY_NAME, TEST_ITEM_ENTITY_DEFINITION, TestItem);
+    }
+}
+const ddbManager = new DynamoDbManager_1.DynamoDbManager(ddbDoc, (dbManager) => {
+    return {
+        testItem: new TestItemRepository(TABLE_NAME, dbManager),
+    };
+});
+// Test start ////////////////////////////////////
+describe('AbstractRepository', () => {
+    let repository;
+    beforeEach(() => {
+        ddbClientMock.reset();
+        repository = new TestItemRepository(TABLE_NAME, ddbManager);
+    });
+    describe('createItem()', () => {
+        it('should create and return the item object if valid input', async () => {
+            ddbClientMock.on(lib_dynamodb_1.PutCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const input = {
+                TableName: TABLE_NAME,
+                Item: {
+                    pk: 'test_item#foo',
+                    sk: '#meta',
+                    gsi1_pk: 'country#au',
+                    gsi1_sk: 'age#99',
+                    name: 'foo',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                    // "data2" property is defined to be stored as JSON string
+                    data2: '{"foo":"bar","num":123}',
+                },
+                ConditionExpression: `attribute_not_exists(pk)`,
+            };
+            const item = {
+                name: 'foo',
+                age: 99,
+                country: 'au',
+                data: {},
+                data2: {
+                    foo: 'bar',
+                    num: 123,
+                },
+            };
+            const result = await repository.createItem(item);
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.PutCommand, input);
+            expect(result).toEqual(new TestItem({
+                name: 'foo',
+                age: 99,
+                country: 'au',
+                data: {},
+                data2: {
+                    foo: 'bar',
+                    num: 123,
+                },
+            }));
+        });
+        it('should throw error if invalid input', async () => {
+            const item = {
+                name: 'foo',
+                age: 99,
+                country: 'au',
+                data: [], // should be non-array object
+            };
+            await expect(repository.createItem(item)).rejects.toEqual(new Error('Invalid "data"'));
+        });
+        it('should throw error if excess column in input', async () => {
+            const item = {
+                name: 'foo',
+                age: 99,
+                country: 'au',
+                data: {},
+                extraColumn: '123',
+                extraColumn2: '',
+            };
+            await expect(repository.createItem(item)).rejects.toEqual(new __1.InvalidDbSchemaError('Excess properties in entity test-item-entity: extraColumn, extraColumn2'));
+        });
+        it('should throw error if input does not includes key field(s)', async () => {
+            const partialItem = {
+                age: 99,
+                country: 'au',
+                data: {},
+            };
+            await expect(repository.createItem(partialItem)).rejects.toEqual(new __1.MissingKeyValuesError('Key field "name" must be specified in the input item in entity test-item-entity'));
+        });
+    });
+    describe('updateItem()', () => {
+        it('should update and return the item object if valid input', async () => {
+            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Item: {
+                    name: 'foo',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                },
+            });
+            ddbClientMock.on(lib_dynamodb_1.UpdateCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Attributes: {
+                    name: 'foo',
+                    age: 99,
+                    country: 'au-updated',
+                    data: {},
+                },
+            });
+            const input = {
+                TableName: TABLE_NAME,
+                Key: { pk: 'test_item#foo', sk: '#meta' },
+                UpdateExpression: 'SET #country = :country',
+                ExpressionAttributeNames: {
+                    '#country': 'country',
+                },
+                ExpressionAttributeValues: {
+                    ':country': 'au-updated',
+                },
+                ConditionExpression: `attribute_exists(pk)`,
+            };
+            const updateItem = {
+                name: 'foo',
+                country: 'au-updated',
+            };
+            const result = await repository.updateItem(updateItem);
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.UpdateCommand, input);
+            expect(result).toEqual(new TestItem({
+                name: 'foo',
+                age: 99,
+                country: 'au-updated',
+                data: {},
+            }));
+        });
+        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: {},
+                },
+            });
+            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(updateItem);
+            expect(result).toEqual(undefined);
+        });
+        it('should return undefined if update cmd conditional check fails', async () => {
+            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Item: {
+                    name: 'foo',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                },
+            });
+            ddbClientMock.on(lib_dynamodb_1.UpdateCommand).rejects(new client_dynamodb_1.ConditionalCheckFailedException({
+                $metadata: {},
+                message: 'not found',
+            }));
+            const updateItem = {
+                name: 'foo',
+                country: 'au-updated',
+            };
+            const result = await repository.updateItem(updateItem);
+            expect(result).toEqual(undefined);
+        });
+        it('should throw error update data has invalid data', async () => {
+            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Item: {
+                    name: 'foo',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                },
+            });
+            const updateItem = {
+                name: 'foo',
+                country: 61, // should be "string" type
+            };
+            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({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Item: {
+                    name: 'foo',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                },
+            });
+            const updateItem = {
+                name: 'foo',
+                country: 'au-updated',
+                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 updateItem = {
+                age: 99,
+                country: 'au-updated', // should be "string" type
+            };
+            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()', () => {
+        it('should return the item object if found', async () => {
+            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Item: {
+                    name: 'foo',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                    data2: '{"foo":"bar","num":123}',
+                },
+            });
+            const input = {
+                TableName: TABLE_NAME,
+                Key: { pk: 'test_item#foo', sk: '#meta' },
+            };
+            const partialItem = { name: 'foo' };
+            const result = await repository.getItem(partialItem);
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.GetCommand, input);
+            expect(result).toEqual(new TestItem({
+                name: 'foo',
+                age: 99,
+                country: 'au',
+                data: {},
+                data2: {
+                    foo: 'bar',
+                    num: 123,
+                },
+            }));
+        });
+        it('should return undefined if item not found', async () => {
+            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const input = {
+                TableName: TABLE_NAME,
+                Key: { pk: 'test_item#foo', sk: '#meta' },
+            };
+            const partialItem = { name: 'foo' };
+            const result = await repository.getItem(partialItem);
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.GetCommand, input);
+            expect(result).toEqual(undefined);
+        });
+        it('should throw error if item schema validation fails', async () => {
+            ddbClientMock.on(lib_dynamodb_1.GetCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Item: {
+                    name: 'foo',
+                    age: '99',
+                    country: 'au',
+                    data: {},
+                },
+            });
+            const partialItem = { name: 'foo' };
+            await expect(repository.getItem(partialItem)).rejects.toEqual(new Error('Invalid "age"'));
+        });
+        it('should throw error if input does not includes key field(s)', async () => {
+            const partialItem = { age: 99 };
+            await expect(repository.getItem(partialItem)).rejects.toEqual(new __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({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Item: {
+                    name: 'foo',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                    data2: {
+                        foo: 'bar',
+                        num: 123,
+                    },
+                },
+            });
+            const partialItem = { name: 'foo' };
+            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 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('queryItems()', () => {
+        it('should return the items if found', async () => {
+            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Items: [
+                    {
+                        name: 'foo',
+                        age: 99,
+                        country: 'au',
+                        data: {},
+                    },
+                ],
+            });
+            const input = {
+                TableName: TABLE_NAME,
+                KeyConditionExpression: '#pkName = :pkValue',
+                ExpressionAttributeNames: {
+                    '#pkName': 'pk',
+                },
+                ExpressionAttributeValues: {
+                    ':pkValue': 'test_item#foo',
+                },
+            };
+            const partialItem = { name: 'foo' };
+            const result = await repository.queryItems(partialItem);
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+            expect(result).toEqual([
+                new TestItem({
+                    name: 'foo',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                }),
+            ]);
+        });
+        it('should return empty array if no items found', 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',
+                },
+            };
+            const partialItem = { name: 'foo' };
+            const result = await repository.queryItems(partialItem);
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.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({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const input = {
+                TableName: TABLE_NAME,
+                KeyConditionExpression: '#pkName = :pkValue AND #skName = :skValue',
+                ExpressionAttributeNames: {
+                    '#pkName': 'pk',
+                    '#skName': 'sk',
+                },
+                ExpressionAttributeValues: {
+                    ':pkValue': 'test_item#foo',
+                    ':skValue': '#meta',
+                },
+            };
+            const partialItem = { name: 'foo' };
+            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 () => {
+            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Items: [
+                    {
+                        name: 'foo',
+                        age: 99,
+                        country: 'au',
+                        data: {},
+                    },
+                    {
+                        name: 'fox',
+                        age: 11,
+                        country: 'au',
+                        data: {},
+                    },
+                ],
+            });
+            const index = 'gsi1_pk-gsi1_sk-index';
+            const input = {
+                TableName: TABLE_NAME,
+                IndexName: index,
+                KeyConditionExpression: '#pkName = :pkValue',
+                ExpressionAttributeNames: {
+                    '#pkName': 'gsi1_pk',
+                },
+                ExpressionAttributeValues: {
+                    ':pkValue': 'country#au',
+                },
+            };
+            const partialItem = { country: 'au' };
+            const useSortKey = false;
+            const result = await repository.queryItems(partialItem, { useSortKey, index });
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.QueryCommand, input);
+            expect(result).toEqual([
+                new TestItem({
+                    name: 'foo',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                }),
+                new TestItem({
+                    name: 'fox',
+                    age: 11,
+                    country: 'au',
+                    data: {},
+                }),
+            ]);
+        });
+        it('should use sort key  in query if "useSortKey" param is true when using gsi index', async () => {
+            ddbClientMock.on(lib_dynamodb_1.QueryCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const index = 'gsi1_pk-gsi1_sk-index';
+            const input = {
+                TableName: TABLE_NAME,
+                IndexName: index,
+                KeyConditionExpression: '#pkName = :pkValue AND #skName = :skValue',
+                ExpressionAttributeNames: {
+                    '#pkName': 'gsi1_pk',
+                    '#skName': 'gsi1_sk',
+                },
+                ExpressionAttributeValues: {
+                    ':pkValue': 'country#au',
+                    ':skValue': 'age#99',
+                },
+            };
+            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);
+        });
+        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, { 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' };
+            await expect(repository.queryItems(partialItem)).rejects.toEqual(new __1.MissingKeyValuesError(`Key field "name" must be specified in the input item in entity test-item-entity`));
+        });
+        it('should throw error for missing key fields when using index', async () => {
+            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`));
+        });
+        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`));
+        });
+    });
+    describe('deleteItem()', () => {
+        it('should return 1 when item is found and deleted', async () => {
+            ddbClientMock.on(lib_dynamodb_1.DeleteCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const input = {
+                TableName: TABLE_NAME,
+                Key: { pk: 'test_item#foo', sk: '#meta' },
+            };
+            const partialItem = { name: 'foo' };
+            const result = await repository.deleteItem(partialItem);
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.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({
+                $metadata: {},
+                message: 'not found',
+            }));
+            const input = {
+                TableName: TABLE_NAME,
+                Key: { pk: 'test_item#foo', sk: '#meta' },
+            };
+            const partialItem = { name: 'foo' };
+            const result = await repository.deleteItem(partialItem);
+            expect(ddbClientMock).toHaveReceivedCommandWith(lib_dynamodb_1.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');
+            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 () => {
+            const partialItem = { age: 99 };
+            await expect(repository.deleteItem(partialItem)).rejects.toEqual(new __1.MissingKeyValuesError('Key field "name" must be specified in the input item in entity test-item-entity'));
+        });
+    });
+    describe('Writer fns with transaction - DynamoDbManager', () => {
+        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({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+                Item: {
+                    name: 'foo2',
+                    age: 99,
+                    country: 'au',
+                    data: {},
+                },
+            });
+            ddbClientMock.on(lib_dynamodb_1.TransactWriteCommand).resolves({
+                $metadata: {
+                    httpStatusCode: 200,
+                },
+            });
+            const result = await ddbManager.executeInTransaction(async (transaction) => {
+                await repository.deleteItem({ name: 'foo' }, transaction);
+                await repository.updateItem({
+                    name: 'foo2',
+                    age: 55,
+                }, transaction);
+                return await repository.createItem({
+                    name: 'foo3',
+                    age: 11,
+                    country: 'au',
+                    data: {},
+                }, transaction);
+            });
+            const input = {
+                ClientRequestToken: 'some-token',
+                TransactItems: [
+                    {
+                        Delete: {
+                            Key: {
+                                pk: 'test_item#foo',
+                                sk: '#meta',
+                            },
+                            TableName: 'test-table',
+                        },
+                    },
+                    {
+                        Update: {
+                            ConditionExpression: 'attribute_exists(pk)',
+                            ExpressionAttributeNames: {
+                                '#age': 'age',
+                            },
+                            ExpressionAttributeValues: {
+                                ':age': 55,
+                            },
+                            Key: {
+                                pk: 'test_item#foo2',
+                                sk: '#meta',
+                            },
+                            TableName: 'test-table',
+                            UpdateExpression: 'SET #age = :age',
+                        },
+                    },
+                    {
+                        Put: {
+                            ConditionExpression: 'attribute_not_exists(pk)',
+                            Item: {
+                                age: 11,
+                                country: 'au',
+                                data: {},
+                                gsi1_pk: 'country#au',
+                                gsi1_sk: 'age#11',
+                                name: 'foo3',
+                                pk: 'test_item#foo3',
+                                sk: '#meta',
+                            },
+                            TableName: 'test-table',
+                        },
+                    },
+                ],
+            };
+            expect(ddbClientMock).toHaveReceivedNthCommandWith(2, lib_dynamodb_1.TransactWriteCommand, input);
+            expect(result).toEqual({
+                name: 'foo3',
+                age: 11,
+                country: 'au',
+                data: {},
+            });
+        });
+    });
+});
+//# sourceMappingURL=AbstractDynamoDbRepository.spec.js.map