Merge branch 'master' of github.com:hitz-group/dynamo-helper

oolio-group · Aug 10, 2020 · 1837bc6 · 1837bc6
2 parents e1b199d + c962e1a
commit 1837bc6
Show file tree

Hide file tree

Showing 9 changed files with 131 additions and 140 deletions.
diff --git a/README.md b/README.md
@@ -13,8 +13,7 @@ Import DynamoHelper
 ```typescript
 import { DynamoHelper } from '@hitz-group/dynamo-helper';
 
-const { DynamoHelper} = require('@hitz-group/dynamo-helper');
-
+const { DynamoHelper } = require('@hitz-group/dynamo-helper');
 ```
 
 Use constructor to create the DynamoHelper instance
@@ -41,34 +40,35 @@ export interface TableConfig {
 import { DynamoHelper } from '@hitz-group/dynamo-helper';
 
 const table = {
- name: 'my-ddb-table',
- indexes: {
-   default: {
-     partitionKeyName: 'pk',
-     sortKeyName: 'sk',
-   }
- }
+  name: 'my-ddb-table',
+  indexes: {
+    default: {
+      partitionKeyName: 'pk',
+      sortKeyName: 'sk',
+    },
+  },
 };
 const client = new DynamoHelper(table, 'ap-south-1');
 
-await client.getItem('library#books', 'book-123');
+await client.getItem({ id: 'book-123' });
+await client.getItem({ pk: 'library#books', sk: 'book-123' });
+
 await client.query({
   where: {
     pk: 'library#books',
     publishedAt: {
-      between: [15550000, 15800000]
-    }
-  }
+      between: [15550000, 15800000],
+    },
+  },
 });
-
 ```
 
 ### buildQueryTableParams
 
 ```typescript
 import { buildQueryTableParams } from '@hitz-group/dynamo-helper';
 
-const { buildQueryTableParams} = require('@hitz-group/dynamo-helper');
+const { buildQueryTableParams } = require('@hitz-group/dynamo-helper');
 ```
 
 This method generates DynamoDB query input params from given filter object of type `Filter<T>`
@@ -175,12 +175,25 @@ const products = await dynamoHelper.query<ProductModel>({
 ### getItem
 
 Fetch an item using pk and sk combination. Returns item if found or returns null
+`getItem<T>(key: DocumentClient.Key, fields: Array<keyof T>)`
+
+#### key
+
+Required, at least partition key values must be provided.
+
+#### fields
+
+Optional, specify fields to project
 
 ```typescript
 import { getItem } from '@hitz-group/dynamo-helper';
 
 // Get a single product matching the key
-const product = await dynamoHelper.getItem<ProductModel>('org_uuid', 'product_xxx');
+await dynamoHelper.getItem<ProductModel>({ pk: 'org_uuid', sk: 'product_xxx' });
+await dynamoHelper.getItem<ProductModel>({ id: 'product_xxx' }, [
+  'id',
+  'isActive',
+]);
 ```
 
 ### batchGetItems
@@ -205,7 +218,7 @@ Check if an item exists in the database with the keys provided. Returns a boolea
 import { exists } from '@hitz-group/dynamo-helper';
 
 // Check if product already exists
-if (await dynamoHelper.exists('x', 1)) {
+if (await dynamoHelper.exists({ id: 'x' })) {
   console.log('exists');
 }
 ```
@@ -232,7 +245,7 @@ Remove an item from database matching the key provided if it exists
 import { deleteItem } from '@hitz-group/dynamo-helper';
 
 // delete product
-await dynamoHelper.deleteItem('x', '1'});
+await dynamoHelper.deleteItem({ id: '1' });
 ```
 
 ### transactPutItems

diff --git a/src/DynamoHelper.ts b/src/DynamoHelper.ts
@@ -45,11 +45,10 @@ export class DynamoHelper {
   }
 
   async getItem<T extends AnyObject>(
-    pk: string,
-    sk: string,
+    key: DocumentClient.Key,
     fields?: Array<keyof T>,
   ): Promise<T> {
-    return getItem(this.dbClient, this.table, pk, sk, fields);
+    return getItem(this.dbClient, this.table, key, fields);
   }
 
   async batchGetItems(
@@ -60,8 +59,8 @@ export class DynamoHelper {
     return batchGetItems(this.dbClient, this.table, keys, fields);
   }
 
-  async exists(pk: string, sk: string): Promise<boolean> {
-    return exists(this.dbClient, this.table, pk, sk);
+  async exists(key: DocumentClient.Key): Promise<boolean> {
+    return exists(this.dbClient, this.table, key);
   }
 
   async batchExists(
@@ -71,10 +70,9 @@ export class DynamoHelper {
   }
 
   async deleteItem(
-    pk: string,
-    sk: string,
+    key: DocumentClient.Key,
   ): Promise<PromiseResult<DeleteItemOutput, AWSError>> {
-    return deleteItem(this.dbClient, this.table, pk, sk);
+    return deleteItem(this.dbClient, this.table, key);
   }
 
   async batchDeleteItems(

diff --git a/src/mutation/deleteItem.spec.ts b/src/mutation/deleteItem.spec.ts
@@ -22,16 +22,48 @@ describe('deleteItem', () => {
     expect(typeof deleteItem).toBe('function');
   });
 
+  test('argument validation', async () => {
+    await expect(deleteItem(undefined)).rejects.toThrowError(
+      'Expected key to be of type object and not empty',
+    );
+    await expect(deleteItem(null)).rejects.toThrowError(
+      'Expected key to be of type object and not empty',
+    );
+    await expect(deleteItem('null')).rejects.toThrowError(
+      'Expected key to be of type object and not empty',
+    );
+    await expect(deleteItem(2 as never, '')).rejects.toThrowError(
+      'Expected key to be of type object and not empty',
+    );
+  });
+
+  test('key validation', async () => {
+    await expect(deleteItem({ id: 'string' })).rejects.toThrowError(
+      'Invalid key: expected key to contain at least partition key',
+    );
+    await expect(deleteItem({ pk: 'string' })).resolves.not.toThrow();
+    // Custom partition key name in table config
+    await expect(
+      deleteItemMethod(
+        testClient,
+        { ...testTableConf, indexes: { default: { partitionKeyName: 'id' } } },
+        { id: 'string' },
+      ),
+    ).resolves.not.toThrow();
+  });
+
   test('promise rejection', async () => {
     spy.mockReturnValue({
       promise: jest.fn().mockRejectedValue([]),
     });
 
-    await expect(deleteItem('xxxx', 'yyyy')).rejects.toStrictEqual([]);
+    await expect(deleteItem({ pk: 'xxxx', sk: 'yyyy' })).rejects.toStrictEqual(
+      [],
+    );
   });
 
   test('uses delete correctly', async () => {
-    await deleteItem('xxxx', 'yyyy');
+    await deleteItem({ pk: 'xxxx', sk: 'yyyy' });
     expect(spy).toHaveBeenCalledWith({
       TableName: testTableConf.name,
       Key: {
@@ -40,32 +72,4 @@ describe('deleteItem', () => {
       },
     } as DeleteItemInput);
   });
-
-  test('uses key names from table index configuration', async () => {
-    spy.mockReturnValue({
-      promise: jest.fn().mockResolvedValue({ Item: { id: 'xxxx' } }),
-    });
-
-    await deleteItemMethod(
-      testClient,
-      {
-        ...testTableConf,
-        indexes: {
-          default: {
-            partitionKeyName: 'key1',
-            sortKeyName: 'key2',
-          },
-        },
-      },
-      'xxxx',
-      'yyyy',
-    );
-    expect(testClient.delete).toHaveBeenCalledWith({
-      TableName: testTableConf.name,
-      Key: {
-        key1: 'xxxx',
-        key2: 'yyyy',
-      },
-    });
-  });
 });
diff --git a/src/mutation/deleteItem.ts b/src/mutation/deleteItem.ts
@@ -11,18 +11,24 @@ import { TableConfig } from '../types';
 export async function deleteItem(
   dbClient: DocumentClient,
   table: TableConfig,
-  pk: string,
-  sk: string,
+  key: DocumentClient.Key,
 ): Promise<PromiseResult<DocumentClient.DeleteItemOutput, AWSError>> {
   const index = table.indexes.default;
 
+  if (!key || typeof key !== 'object' || Object.keys(key).length === 0) {
+    throw new Error('Expected key to be of type object and not empty');
+  }
+
+  if (!key[index.partitionKeyName]) {
+    throw new Error(
+      'Invalid key: expected key to contain at least partition key',
+    );
+  }
+
   return dbClient
     .delete({
       TableName: table.name,
-      Key: {
-        [index.partitionKeyName]: pk,
-        [index.sortKeyName]: sk,
-      },
+      Key: key,
     })
     .promise();
 }
diff --git a/src/query/exists.spec.ts b/src/query/exists.spec.ts
@@ -12,35 +12,29 @@ describe('exists', () => {
   });
 
   test('validates arguments', async () => {
-    await expect(exists(undefined, undefined)).rejects.toThrowError(
-      'Expected two arguments of type string, string received undefined, undefined',
+    await expect(exists(undefined)).rejects.toThrowError(
+      'Expected key to be of type object and not empty',
     );
-    await expect(exists(null, null)).rejects.toThrowError(
-      'Expected two arguments of type string, string received object, object',
+    await expect(exists(null)).rejects.toThrowError(
+      'Expected key to be of type object and not empty',
     );
-    await expect(exists('null', null)).rejects.toThrowError(
-      'Expected two arguments of type string, string received string, object',
-    );
-    await expect(exists(undefined, '')).rejects.toThrowError(
-      'Expected two arguments of type string, string received undefined, string',
+    await expect(exists('null')).rejects.toThrowError(
+      'Expected key to be of type object and not empty',
     );
     await expect(exists(2 as never, '')).rejects.toThrowError(
-      'Expected two arguments of type string, string received number, string',
-    );
-    await expect(exists('', '')).rejects.toThrowError(
-      'Expected both arguments to have length greater than 0',
+      'Expected key to be of type object and not empty',
     );
   });
 
   test('returns boolean value', async () => {
     // No results found, hence empty list.
     // getItem will return null in this case
-    await expect(exists('xxxx', 'yyyy')).resolves.toBe(false);
+    await expect(exists({ pk: 'xxxx', sk: 'yyyy' })).resolves.toBe(false);
 
     spy.mockReturnValue({
       promise: jest.fn().mockResolvedValue({ Item: { id: 'xxxx' } }),
     });
 
-    await expect(exists('xxxx', 'yyyy')).resolves.toBe(true);
+    await expect(exists({ pk: 'xxxx', sk: 'yyyy' })).resolves.toBe(true);
   });
 });
diff --git a/src/query/exists.ts b/src/query/exists.ts
@@ -11,9 +11,8 @@ import { TableConfig } from '../types';
 export async function exists(
   dbClient: DocumentClient,
   table: TableConfig,
-  pk: string,
-  sk: string
+  key: DocumentClient.Key,
 ): Promise<boolean> {
-  const item = await getItem(dbClient, table, pk, sk, ['id']);
+  const item = await getItem(dbClient, table, key, ['id']);
   return item ? true : false;
 }