feat(batchGet): add support for batch get item request

there are two possible scenarios for batchGetItem, one asking for multiple items of the same table
and one asking for multiple items in different tables. the first scenario can be achived using the
dynamoStore.batchGet() operation the other one by creating a new batchGet request

Author: michaelwittwer

src/dynamo/batchget/batch-get.request.spec.ts

@@ -0,0 +1,23 @@
+import { Organization } from '../../../../test/models/organization.model'
+import { BatchGetRequest } from './batch-get.request'
+
+describe('batch get', () => {
+  let request: BatchGetRequest
+
+  beforeEach(() => {
+    request = new BatchGetRequest()
+  })
+
+  it('base params', () => {
+    const params = request.params
+    expect(params).toEqual({ RequestItems: {} })
+  })
+
+  it('key', () => {
+    request.forModel(Organization, ['idValue'])
+    const params = request.params
+    expect(params.RequestItems).toBeDefined()
+    expect(params.RequestItems['Organization']).toBeDefined()
+    expect(params.RequestItems['Organization']).toEqual({ Keys: [{ id: { S: 'idValue' } }] })
+  })
+})

src/dynamo/batchget/batch-get.request.ts

@@ -0,0 +1,127 @@
+import { AttributeMap, BatchGetItemInput } from 'aws-sdk/clients/dynamodb'
+import { isObject } from 'lodash'
+import { Observable } from 'rxjs/Observable'
+import { MetadataHelper } from '../../decorator/metadata/metadata-helper'
+import { Mapper } from '../../mapper/mapper'
+import { ModelConstructor } from '../../model/model-constructor'
+import { DEFAULT_SESSION_VALIDITY_ENSURER } from '../default-session-validity-ensurer.const'
+import { DEFAULT_TABLE_NAME_RESOLVER } from '../default-table-name-resolver.const'
+import { DynamoRx } from '../dynamo-rx'
+import { REGEX_TABLE_NAME } from '../request/regex'
+import { SessionValidityEnsurer } from '../session-validity-ensurer.type'
+import { TableNameResolver } from '../table-name-resolver.type'
+
+interface TableConfig<T> {
+  tableName: string
+  modelClazz: ModelConstructor<T>
+  keys: any[]
+}
+
+// tslint:disable-next-line:interface-over-type-literal
+export type BatchGetItemResponse = { [tableName: string]: any[] }
+
+export class BatchGetRequest {
+  private readonly dynamoRx: DynamoRx
+
+  private tables: Map<string, TableConfig<any>> = new Map()
+  readonly params: BatchGetItemInput
+
+  constructor(
+    private tableNameResolver: TableNameResolver = DEFAULT_TABLE_NAME_RESOLVER,
+    sessionValidityEnsurer: SessionValidityEnsurer = DEFAULT_SESSION_VALIDITY_ENSURER
+  ) {
+    this.dynamoRx = new DynamoRx(sessionValidityEnsurer)
+    this.params = <BatchGetItemInput>{
+      RequestItems: {},
+    }
+  }
+
+  /**
+   * @param {ModelConstructor<T>} modelClazz
+   * @param {any[]} keys either a simple string for partition key or an object with partitionKey and sortKey
+   * @returns {BatchGetSingleTableRequest}
+   */
+  forModel<T>(modelClazz: ModelConstructor<T>, keys: any[]): BatchGetRequest {
+    const tableName = this.getTableName(modelClazz, this.tableNameResolver)
+    if (this.tables.has(tableName)) {
+      throw new Error('table name already exists, please provide all the keys for the same table at once')
+    }
+
+    const metadata = MetadataHelper.get(modelClazz)
+    const attributeMaps: AttributeMap[] = []
+
+    // loop over all the keys
+    keys.forEach(key => {
+      const idOb: AttributeMap = {}
+
+      if (isObject(key)) {
+        // TODO add some more checks
+        // got a composite primary key
+
+        // partition key
+        const mappedPartitionKey = Mapper.toDbOne(key.partitionKey)
+        if (mappedPartitionKey === null) {
+          throw Error('please provide an actual value for partition key')
+        }
+        idOb[metadata.getPartitionKey()] = mappedPartitionKey
+
+        // sort key
+        const mappedSortKey = Mapper.toDbOne(key.sortKey)
+        if (mappedSortKey === null) {
+          throw Error('please provide an actual value for partition key')
+        }
+
+        idOb[metadata.getSortKey()!] = mappedSortKey
+      } else {
+        // got a simple primary key
+        const value = Mapper.toDbOne(key)
+        if (value === null) {
+          throw Error('please provide an actual value for partition key')
+        }
+
+        idOb[metadata.getPartitionKey()] = value
+      }
+
+      attributeMaps.push(idOb)
+    })
+
+    this.params.RequestItems[tableName] = {
+      Keys: attributeMaps,
+    }
+    return this
+  }
+
+  execFullResponse() {}
+
+  // TODO fix any
+  // TODO add support for indexes
+  exec(): Observable<BatchGetItemResponse> {
+    return this.dynamoRx.batchGetItems(this.params).map(response => {
+      const r = <BatchGetItemResponse>{}
+      if (response.Responses && Object.keys(response.Responses).length) {
+        const responses: { [key: string]: AttributeMap } = {}
+        Object.keys(response.Responses).forEach(tableName => {
+          const mapped = response.Responses![tableName].map(attributeMap =>
+            Mapper.fromDb(attributeMap, this.tables.get(tableName)!.modelClazz)
+          )
+          r[tableName] = mapped
+        })
+
+        return r
+      } else {
+        return {}
+      }
+    })
+  }
+
+  private getTableName(modelClazz: ModelConstructor<any>, tableNameResolver: TableNameResolver) {
+    const tableName = tableNameResolver(MetadataHelper.get(modelClazz).modelOptions.tableName)
+    if (!REGEX_TABLE_NAME.test(tableName)) {
+      throw new Error(
+        'make sure the table name only contains these characters «a-z A-Z 0-9 - _ .» and is between 3 and 255 characters long'
+      )
+    }
+
+    return tableName
+  }
+}

src/dynamo/batchget/index.ts

@@ -0,0 +1 @@
+export * from './batch-get.request'

src/dynamo/dynamo-store.ts

@@ -7,32 +7,31 @@ import { DEFAULT_SESSION_VALIDITY_ENSURER } from './default-session-validity-ens
 import { DEFAULT_TABLE_NAME_RESOLVER } from './default-table-name-resolver.const'
 import { DynamoApiOperations } from './dynamo-api-operations.type'
 import { DynamoRx } from './dynamo-rx'
+import { BatchGetSingleTableRequest } from './request/batchgetsingletable/batch-get-single-table.request'
 import { DeleteRequest } from './request/delete/delete.request'
 import { GetRequest } from './request/get/get.request'
 import { PutRequest } from './request/put/put.request'
 import { QueryRequest } from './request/query/query.request'
+import { REGEX_TABLE_NAME } from './request/regex'
 import { ScanRequest } from './request/scan/scan.request'
 import { UpdateRequest } from './request/update/update.request'
 import { SessionValidityEnsurer } from './session-validity-ensurer.type'
 import { TableNameResolver } from './table-name-resolver.type'
 
 export class DynamoStore<T> {
-  /* http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html#limits-naming-rules */
-  private static REGEX_TABLE_NAME = /^[a-zA-Z0-9_\-.]{3,255}$/
-
   private readonly dynamoRx: DynamoRx
   private readonly mapper: Mapper
 
   readonly tableName: string
 
   constructor(
     private modelClazz: ModelConstructor<T>,
-    tableNameResolver: TableNameResolver = DEFAULT_TABLE_NAME_RESOLVER,
+    private tableNameResolver: TableNameResolver = DEFAULT_TABLE_NAME_RESOLVER,
     sessionValidityEnsurer: SessionValidityEnsurer = DEFAULT_SESSION_VALIDITY_ENSURER
   ) {
     this.dynamoRx = new DynamoRx(sessionValidityEnsurer)
     const tableName = tableNameResolver(MetadataHelper.get(this.modelClazz).modelOptions.tableName)
-    if (!DynamoStore.REGEX_TABLE_NAME.test(tableName)) {
+    if (!REGEX_TABLE_NAME.test(tableName)) {
       throw new Error(
         'make sure the table name only contains these characters «a-z A-Z 0-9 - _ .» and is between 3 and 255 characters long'
       )
@@ -69,42 +68,18 @@ export class DynamoStore<T> {
     return new QueryRequest(this.dynamoRx, this.modelClazz, this.tableName)
   }
 
+  /**
+   * This is a special implementation of BatchGetItem request, because it only supports one table, if you wish to retrieve items from multiple tables
+   * get an instance of BatchGetItem request and call it there.
+   */
+  batchGetItem(keys: any[]): BatchGetSingleTableRequest<T> {
+    return new BatchGetSingleTableRequest(this.dynamoRx, this.modelClazz, this.tableName, keys)
+  }
+
   makeRequest<Z>(operation: DynamoApiOperations, params?: { [key: string]: any }): Observable<Z> {
     return this.dynamoRx.makeRequest(operation, params)
   }
 
-  // TODO implement BatchGetItem request (think about support for secondary indexes)
-  // batchGetItems(keys: any[]): Observable<T[]> {
-  //   const requestItems: { [nameDb: string]: { Keys: DynamoDB.AttributeMap[] } } = {}
-  //   const attributeMaps: DynamoDB.AttributeMap[] = []
-  //   keys.forEach(id => {
-  //     const idOb: DynamoDB.AttributeMap = {}
-  //     const value = Mapper.toDbOne(id)
-  //     if (value === null) {
-  //       throw Error('please provide an actual value for partition key')
-  //     }
-  //
-  //     idOb[MetadataHelper.get(this.modelClazz).getPartitionKey()] = value
-  //     attributeMaps.push(idOb)
-  //   })
-  //
-  //   requestItems[this.tableName] = {
-  //     Keys: attributeMaps,
-  //   }
-  //
-  //   const params: DynamoDB.BatchGetItemInput = {
-  //     RequestItems: requestItems,
-  //   }
-  //
-  //   return this.dynamoRx.batchGetItems(params).map(response => {
-  //     if (response.Responses && Object.keys(response.Responses).length) {
-  //       return response.Responses[this.tableName].map(attributeMap => Mapper.fromDb(attributeMap, this.modelClazz))
-  //     } else {
-  //       return []
-  //     }
-  //   })
-  // }
-
   private createBaseParams(): { TableName: string } {
     const params: { TableName: string } = {
       TableName: this.tableName,

src/dynamo/index.ts

@@ -4,3 +4,4 @@ export * from './request'
 export * from './dynamo-rx'
 export * from './dynamo-store'
 export * from './session-validity-ensurer.type'
+export * from './batchget'

src/dynamo/request/base.request.ts

@@ -1,5 +1,6 @@
 import {
   AttributeMap,
+  BatchGetItemInput,
   DeleteItemInput,
   GetItemInput,
   Key,

src/dynamo/request/batchgetsingletable/batch-get-single-table.request.spec.ts

@@ -0,0 +1,43 @@
+import { BatchGetPartitionValueList } from 'aws-sdk/clients/glue'
+import * as moment from 'moment'
+import { getTableName } from '../../../../test/helper/get-table-name.function'
+import { Organization } from '../../../../test/models/organization.model'
+import { BatchGetSingleTableRequest } from './batch-get-single-table.request'
+
+describe('batch get', () => {
+  describe('correct params', () => {
+    it('simple primary key', () => {
+      const request = new BatchGetSingleTableRequest<any>(null, Organization, getTableName(Organization), [
+        'myId',
+        'myId2',
+      ])
+      expect(request.params.RequestItems).toBeDefined()
+      expect(request.params.RequestItems).toEqual({
+        Organization: { Keys: [{ id: { S: 'myId' } }, { id: { S: 'myId2' } }] },
+      })
+    })
+
+    it('composite primary key', () => {
+      const now = moment()
+      const keys = [{ partitionKey: 'myId', sortKey: now }]
+      const request = new BatchGetSingleTableRequest<any>(null, Organization, getTableName(Organization), keys)
+
+      expect(request.params.RequestItems).toBeDefined()
+      expect(request.params.RequestItems).toEqual({
+        Organization: {
+          Keys: [
+            {
+              id: { S: 'myId' },
+              createdAtDate: {
+                S: now
+                  .clone()
+                  .utc()
+                  .format(),
+              },
+            },
+          ],
+        },
+      })
+    })
+  })
+})