@squiz/db-lib 1.64.0 → 1.66.0

package/src/dynamodb/AbstractDynamoDbRepository.spec.ts

@@ -0,0 +1,804 @@
+import { AbstractDynamoDbRepository } from './AbstractDynamoDbRepository';
+import {
+  DeleteCommand,
+  DeleteCommandInput,
+  DynamoDBDocument,
+  DynamoDBDocumentClient,
+  GetCommand,
+  GetCommandInput,
+  PutCommand,
+  PutCommandInput,
+  QueryCommand,
+  QueryCommandInput,
+  UpdateCommand,
+  UpdateCommandInput,
+  TransactWriteCommand,
+  TransactWriteCommandInput,
+} from '@aws-sdk/lib-dynamodb';
+import { ConditionalCheckFailedException } from '@aws-sdk/client-dynamodb';
+import { DynamoDbManager, Transaction } from './DynamoDbManager';
+import { MissingKeyValuesError, InvalidDbSchemaError } from '..';
+
+import { mockClient } from 'aws-sdk-client-mock';
+import 'aws-sdk-client-mock-jest';
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { DuplicateItemError } from '../error/DuplicateItemError';
+import crypto from 'crypto';
+
+const ddbClientMock = mockClient(DynamoDBDocumentClient);
+const ddbDoc = DynamoDBDocument.from(new DynamoDB({}));
+
+interface ITestItem {
+  name: string;
+  age: number;
+  country: string;
+  data?: object;
+}
+
+class TestItem implements ITestItem {
+  public name: string;
+  public age: number;
+  public country: string;
+  public data: object;
+
+  constructor(data: Partial<ITestItem> = {}) {
+    this.name = data.name ?? 'default name';
+    this.age = data.age ?? 0;
+    this.country = data.country ?? 'default country';
+    this.data = data.data ?? {};
+
+    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"');
+    }
+  }
+}
+
+export type TestRepositories = {
+  testItem: TestItemRepository;
+};
+export type TestDbManager = DynamoDbManager<TestRepositories>;
+
+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',
+      },
+    },
+  },
+};
+
+class TestItemRepository extends AbstractDynamoDbRepository<ITestItem, TestItem> {
+  constructor(tableName: string, dbManager: TestDbManager) {
+    super(tableName, dbManager, TEST_ITEM_ENTITY_NAME, TEST_ITEM_ENTITY_DEFINITION, TestItem);
+  }
+}
+
+const ddbManager = new DynamoDbManager<TestRepositories>(ddbDoc, (dbManager: TestDbManager) => {
+  return {
+    testItem: new TestItemRepository(TABLE_NAME, dbManager),
+  };
+});
+
+// Test start ////////////////////////////////////
+
+describe('AbstractRepository', () => {
+  let repository: TestItemRepository;
+  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(PutCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+      const input: PutCommandInput = {
+        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: {},
+        },
+        ConditionExpression: `attribute_not_exists(pk)`,
+      };
+
+      const item = {
+        name: 'foo',
+        age: 99,
+        country: 'au',
+        data: {},
+      };
+      const result = await repository.createItem(item);
+      expect(ddbClientMock).toHaveReceivedCommandWith(PutCommand, input);
+      expect(result).toEqual(
+        new TestItem({
+          name: 'foo',
+          age: 99,
+          country: 'au',
+          data: {},
+        }),
+      );
+    });
+
+    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 item already exists input', async () => {
+      ddbClientMock.on(PutCommand).rejects(
+        new ConditionalCheckFailedException({
+          $metadata: {},
+          message: 'already exists',
+        }),
+      );
+
+      const item = {
+        name: 'foo',
+        age: 99,
+        country: 'au',
+        data: {},
+      };
+      await expect(repository.createItem(item)).rejects.toEqual(new DuplicateItemError('Item already exists'));
+    });
+
+    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 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 as unknown as TestItem)).rejects.toEqual(
+        new 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(GetCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+        Item: {
+          name: 'foo',
+          age: 99,
+          country: 'au',
+          data: {},
+        },
+      });
+      ddbClientMock.on(UpdateCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+        Attributes: {
+          name: 'foo',
+          age: 99,
+          country: 'au-updated',
+          data: {},
+        },
+      });
+      const input: UpdateCommandInput = {
+        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 partialItemWithKeyFields = {
+        name: 'foo',
+      };
+      const updateItem = {
+        country: 'au-updated',
+      };
+      const result = await repository.updateItem(partialItemWithKeyFields, updateItem);
+      expect(ddbClientMock).toHaveReceivedNthCommandWith(2, UpdateCommand, input);
+      expect(result).toEqual(
+        new TestItem({
+          name: 'foo',
+          age: 99,
+          country: 'au-updated',
+          data: {},
+        }),
+      );
+    });
+
+    it('should undefined if item does does not exist', async () => {
+      ddbClientMock.on(GetCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+
+      const partialItemWithKeyFields = {
+        name: 'foo',
+      };
+      const updateItem = {
+        country: 'au-updated',
+      };
+      const result = await repository.updateItem(partialItemWithKeyFields, updateItem);
+      expect(result).toEqual(undefined);
+    });
+
+    it('should return undefined if update cmd conditional check fails', async () => {
+      ddbClientMock.on(GetCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+        Item: {
+          name: 'foo',
+          age: 99,
+          country: 'au',
+          data: {},
+        },
+      });
+
+      ddbClientMock.on(UpdateCommand).rejects(
+        new ConditionalCheckFailedException({
+          $metadata: {},
+          message: 'not found',
+        }),
+      );
+
+      const partialItemWithKeyFields = {
+        name: 'foo',
+      };
+      const updateItem = {
+        country: 'au-updated',
+      };
+      const result = await repository.updateItem(partialItemWithKeyFields, updateItem);
+      expect(result).toEqual(undefined);
+    });
+
+    it('should throw error update data has invalid data', async () => {
+      ddbClientMock.on(GetCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+        Item: {
+          name: 'foo',
+          age: 99,
+          country: 'au',
+          data: {},
+        },
+      });
+
+      const partialItemWithKeyFields = {
+        name: 'foo',
+      };
+      const updateItem = {
+        country: 61, // should be "string" type
+      };
+      await expect(
+        repository.updateItem(partialItemWithKeyFields, updateItem as unknown as Partial<TestItem>),
+      ).rejects.toEqual(new Error('Invalid "country"'));
+    });
+
+    it('should throw error if excess column in input', async () => {
+      ddbClientMock.on(GetCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+        Item: {
+          name: 'foo',
+          age: 99,
+          country: 'au',
+          data: {},
+        },
+      });
+
+      const partialItemWithKeyFields = {
+        name: 'foo',
+      };
+      const updateItem = {
+        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'));
+    });
+
+    it('should throw error if input does not includes key field(s)', async () => {
+      const partialItemWithKeyFields = {
+        age: 99,
+      };
+      const updateItem = {
+        country: 'au-updated', // should be "string" type
+      };
+      await expect(repository.updateItem(partialItemWithKeyFields, updateItem)).rejects.toEqual(
+        new 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(GetCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+        Item: {
+          name: 'foo',
+          age: 99,
+          country: 'au',
+          data: {},
+        },
+      });
+      const input: GetCommandInput = {
+        TableName: TABLE_NAME,
+        Key: { pk: 'test_item#foo', sk: '#meta' },
+      };
+
+      const partialItem = { name: 'foo' };
+      const result = await repository.getItem(partialItem);
+      expect(ddbClientMock).toHaveReceivedCommandWith(GetCommand, input);
+      expect(result).toEqual(
+        new TestItem({
+          name: 'foo',
+          age: 99,
+          country: 'au',
+          data: {},
+        }),
+      );
+    });
+
+    it('should return undefined if item not found', async () => {
+      ddbClientMock.on(GetCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+      const input: GetCommandInput = {
+        TableName: TABLE_NAME,
+        Key: { pk: 'test_item#foo', sk: '#meta' },
+      };
+
+      const partialItem = { name: 'foo' };
+      const result = await repository.getItem(partialItem);
+      expect(ddbClientMock).toHaveReceivedCommandWith(GetCommand, input);
+      expect(result).toEqual(undefined);
+    });
+
+    it('should throw error if item schema validation fails', async () => {
+      ddbClientMock.on(GetCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+        Item: {
+          name: 'foo',
+          age: '99', // should be number
+          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 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({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+        Items: [
+          {
+            name: 'foo',
+            age: 99,
+            country: 'au',
+            data: {},
+          },
+        ],
+      });
+      const input: QueryCommandInput = {
+        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(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(QueryCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+      const input: QueryCommandInput = {
+        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(QueryCommand, input);
+      expect(result).toEqual([]);
+    });
+
+    it('should use sort key in query if "useSortKey" param is true', async () => {
+      ddbClientMock.on(QueryCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+      const input: QueryCommandInput = {
+        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 useSortKey = true;
+      const _result = await repository.queryItems(partialItem, useSortKey);
+      expect(ddbClientMock).toHaveReceivedCommandWith(QueryCommand, input);
+    });
+
+    it('should return the items if found when using gsi index', async () => {
+      ddbClientMock.on(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: QueryCommandInput = {
+        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(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(QueryCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+      const index = 'gsi1_pk-gsi1_sk-index';
+      const input: QueryCommandInput = {
+        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(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 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 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 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 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(DeleteCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+      const input: DeleteCommandInput = {
+        TableName: TABLE_NAME,
+        Key: { pk: 'test_item#foo', sk: '#meta' },
+      };
+
+      const partialItem = { name: 'foo' };
+      const result = await repository.deleteItem(partialItem);
+      expect(ddbClientMock).toHaveReceivedCommandWith(DeleteCommand, input);
+      expect(result).toBe(1);
+    });
+
+    it('should return 0 when item is not found', async () => {
+      ddbClientMock.on(DeleteCommand).rejects(
+        new ConditionalCheckFailedException({
+          $metadata: {},
+          message: 'not found',
+        }),
+      );
+      const input: DeleteCommandInput = {
+        TableName: TABLE_NAME,
+        Key: { pk: 'test_item#foo', sk: '#meta' },
+      };
+
+      const partialItem = { name: 'foo' };
+      const result = await repository.deleteItem(partialItem);
+      expect(ddbClientMock).toHaveReceivedCommandWith(DeleteCommand, input);
+      expect(result).toBe(0);
+    });
+
+    it('should throw error if request fails', async () => {
+      const partialItem = { name: 'foo' };
+      ddbClientMock.on(DeleteCommand).rejects('some other error');
+      await expect(repository.deleteItem(partialItem)).rejects.toEqual(new Error('some other error'));
+    });
+
+    it('should throw error if input does not includes key field(s)', async () => {
+      const partialItem = { age: 99 };
+      await expect(repository.deleteItem(partialItem)).rejects.toEqual(
+        new 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, 'randomUUID');
+      spy.mockImplementation(() => 'some-token' as any);
+
+      ddbClientMock.on(GetCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+        Item: {
+          name: 'foo2',
+          age: 99,
+          country: 'au',
+          data: {},
+        },
+      });
+
+      ddbClientMock.on(TransactWriteCommand).resolves({
+        $metadata: {
+          httpStatusCode: 200,
+        },
+      });
+
+      const result = await ddbManager.executeInTransaction(async (transaction: 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: TransactWriteCommandInput = {
+        ClientRequestToken: 'some-token',
+        TransactItems: [
+          {
+            Delete: {
+              ConditionExpression: 'attribute_exists(pk)',
+              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, TransactWriteCommand, input);
+      expect(result).toEqual({
+        name: 'foo3',
+        age: 11,
+        country: 'au',
+        data: {},
+      });
+    });
+  });
+});