feat(projection-expression): add support for projection expression

- add projection expression support for bacth-get-single-table.request and read-many.request
- also fix issue where attribute name was not mapped to correct dynamoDB attribute name if metadata was specified

Author: michaelwittwer

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

@@ -3,7 +3,11 @@ import * as DynamoDB from 'aws-sdk/clients/dynamodb'
 // tslint:disable:no-unused-expression
 // tslint:disable:no-non-null-assertion
 import { resetDynamoEasyConfig } from '../../../../test/helper/resetDynamoEasyConfig.function'
-import { SimpleWithCompositePartitionKeyModel, SimpleWithPartitionKeyModel } from '../../../../test/models'
+import {
+  ComplexModel,
+  SimpleWithCompositePartitionKeyModel,
+  SimpleWithPartitionKeyModel,
+} from '../../../../test/models'
 import { updateDynamoEasyConfig } from '../../../config/update-config.function'
 import { getTableName } from '../../get-table-name.function'
 import { BatchGetSingleTableRequest } from './batch-get-single-table.request'
@@ -60,7 +64,7 @@ describe('batch get', () => {
       })
     })
 
-    it('ConsistentRead', () => {
+    it('consistent read', () => {
       const request = new BatchGetSingleTableRequest<any>(<any>null, SimpleWithPartitionKeyModel, [{ id: 'myId' }])
       request.consistentRead()
       expect(request.params.RequestItems).toBeDefined()
@@ -78,6 +82,19 @@ describe('batch get', () => {
         '#name': 'name',
       })
     })
+
+    it('projection expression (custom db attribute name)', () => {
+      const request = new BatchGetSingleTableRequest<ComplexModel>(<any>null, ComplexModel, [
+        { id: 'myId', creationDate: new Date() },
+      ])
+      request.projectionExpression('active')
+      expect(request.params.RequestItems).toBeDefined()
+      expect(request.params.RequestItems[getTableName(ComplexModel)]).toBeDefined()
+      expect(request.params.RequestItems[getTableName(ComplexModel)].ProjectionExpression).toBe('#active')
+      expect(request.params.RequestItems[getTableName(ComplexModel)].ExpressionAttributeNames).toEqual({
+        '#active': 'isActive',
+      })
+    })
   })
 
   describe('should return appropriate value', () => {

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

@@ -11,8 +11,8 @@ import { ModelConstructor } from '../../../model/model-constructor'
 import { batchGetItemsFetchAll } from '../../batchget/batch-get-utils'
 import { BATCH_GET_DEFAULT_TIME_SLOT, BATCH_GET_MAX_REQUEST_ITEM_COUNT } from '../../batchget/batch-get.const'
 import { DynamoDbWrapper } from '../../dynamo-db-wrapper'
-import { resolveAttributeNames } from '../../expression/functions/attribute-names.function'
 import { BaseRequest } from '../base.request'
+import { addProjectionExpressionParam } from '../helper/add-projection-expression-param.function'
 import { BatchGetSingleTableResponse } from './batch-get-single-table.response'
 
 /**
@@ -49,19 +49,11 @@ export class BatchGetSingleTableRequest<T> extends BaseRequest<
   }
 
   /**
-   * Specifies the list of document attributes to be returned from the table instead of returning the entire document
-   * @param attributesToGet List of document attributes to be returned
+   * Specifies the list of model attributes to be returned from the table instead of returning the entire document
+   * @param attributesToGet List of model attributes to be returned
    */
-  projectionExpression(...attributesToGet: string[]): BatchGetSingleTableRequest<T> {
-    // tslint:disable-next-line:no-unnecessary-callback-wrapper
-    const resolved = attributesToGet.map(a => resolveAttributeNames(a))
-    this.params.RequestItems[this.tableName].ProjectionExpression = resolved.map(attr => attr.placeholder).join(', ')
-    Object.values(resolved).forEach(r => {
-      this.params.RequestItems[this.tableName].ExpressionAttributeNames = {
-        ...this.params.RequestItems[this.tableName].ExpressionAttributeNames,
-        ...r.attributeNames,
-      }
-    })
+  projectionExpression(...attributesToGet: Array<keyof T | string>): BatchGetSingleTableRequest<T> {
+    addProjectionExpressionParam(attributesToGet, this.params.RequestItems[this.tableName], this.metadata)
     return this
   }
 

src/dynamo/request/get/get.request.spec.ts

@@ -1,6 +1,10 @@
 // tslint:disable:no-unused-expression
 import * as DynamoDB from 'aws-sdk/clients/dynamodb'
-import { SimpleWithCompositePartitionKeyModel, SimpleWithPartitionKeyModel } from '../../../../test/models'
+import {
+  ComplexModel,
+  SimpleWithCompositePartitionKeyModel,
+  SimpleWithPartitionKeyModel,
+} from '../../../../test/models'
 import { updateDynamoEasyConfig } from '../../../config/update-config.function'
 import { Attributes } from '../../../mapper/type/attribute.type'
 import { getTableName } from '../../get-table-name.function'
@@ -19,7 +23,7 @@ describe('GetRequest', () => {
     })
   })
 
-  describe('correct params', () => {
+  describe('correct params (simple model)', () => {
     let request: GetRequest<SimpleWithPartitionKeyModel>
 
     beforeEach(() => {
@@ -53,6 +57,23 @@ describe('GetRequest', () => {
     })
   })
 
+  describe('correct params (complex model)', () => {
+    let request: GetRequest<ComplexModel>
+
+    beforeEach(() => {
+      request = new GetRequest(<any>null, ComplexModel, 'partitionKeyValue', new Date())
+    })
+
+    it('projection expression', () => {
+      request.projectionExpression('active')
+
+      const params = request.params
+      expect(params.ProjectionExpression).toBe('#active')
+      expect(params.ExpressionAttributeNames).toEqual({ '#active': 'isActive' })
+      expect(Object.keys(params).length).toBe(4)
+    })
+  })
+
   describe('maps response item', () => {
     const jsItem: SimpleWithPartitionKeyModel = { age: 20, id: 'my-id' }
     const dbItem: Attributes<SimpleWithPartitionKeyModel> = { age: { N: '20' }, id: { S: 'my-id' } }

src/dynamo/request/get/get.request.ts

@@ -8,10 +8,16 @@ import { createKeyAttributes, fromDb } from '../../../mapper/mapper'
 import { Attributes } from '../../../mapper/type/attribute.type'
 import { ModelConstructor } from '../../../model/model-constructor'
 import { DynamoDbWrapper } from '../../dynamo-db-wrapper'
-import { resolveAttributeNames } from '../../expression/functions/attribute-names.function'
+import { addProjectionExpressionParam } from '../helper/add-projection-expression-param.function'
 import { StandardRequest } from '../standard.request'
 import { GetResponse } from './get.response'
 
+export interface GetRequestProjected<T>
+  extends StandardRequest<Partial<T>, DynamoDB.GetItemInput, GetRequest<Partial<T>>> {
+  execFullResponse(): Promise<GetResponse<Partial<T>>>
+  exec(): Promise<Partial<T> | null>
+}
+
 /**
  * Request class for the GetItem operation.
  */
@@ -33,17 +39,12 @@ export class GetRequest<T> extends StandardRequest<T, DynamoDB.GetItemInput, Get
   }
 
   /**
-   * Specifies the list of document attributes to be returned from the table instead of returning the entire document
-   * @param attributesToGet List of document attributes to be returned
+   * Specifies the list of model attributes to be returned from the table instead of returning the entire document
+   * @param attributesToGet List of model attributes to be returned
    */
-  projectionExpression(...attributesToGet: string[]): GetRequest<T> {
-    // tslint:disable-next-line:no-unnecessary-callback-wrapper
-    const resolved = attributesToGet.map(a => resolveAttributeNames(a))
-    this.params.ProjectionExpression = resolved.map(attr => attr.placeholder).join(', ')
-    Object.values(resolved).forEach(r => {
-      this.params.ExpressionAttributeNames = { ...this.params.ExpressionAttributeNames, ...r.attributeNames }
-    })
-    return this
+  projectionExpression(...attributesToGet: Array<keyof T | string>): GetRequestProjected<T> {
+    addProjectionExpressionParam(attributesToGet, this.params, this.metadata)
+    return <GetRequestProjected<T>>(<any>this)
   }
 
   execFullResponse(): Promise<GetResponse<T>> {

src/dynamo/request/helper/add-projection-expression-param.function.ts

@@ -0,0 +1,18 @@
+import * as DynamoDB from 'aws-sdk/clients/dynamodb'
+import { Metadata } from '../../../decorator/metadata/metadata'
+import { resolveAttributeNames } from '../../expression/functions/attribute-names.function'
+
+/**
+ * Adds ProjectionExpression param and expressionAttributeNames to the params object
+ */
+export function addProjectionExpressionParam<T>(
+  attributesToGet: Array<keyof T | string>,
+  params: DynamoDB.QueryInput | DynamoDB.ScanInput | DynamoDB.GetItemInput | DynamoDB.KeysAndAttributes,
+  metadata?: Metadata<T>,
+): void {
+  const resolved = attributesToGet.map(attributeToGet => resolveAttributeNames(<string>attributeToGet, metadata))
+  params.ProjectionExpression = resolved.map(attr => attr.placeholder).join(', ')
+  resolved.forEach(r => {
+    params.ExpressionAttributeNames = { ...params.ExpressionAttributeNames, ...r.attributeNames }
+  })
+}

src/dynamo/request/query/query.response.ts

@@ -9,7 +9,7 @@ import * as DynamoDB from 'aws-sdk/clients/dynamodb'
  */
 export interface QueryResponse<T> {
   /**
-   * An array of item attributes that match the query criteria. Each element in this array consists of an attribute name and the value for that attribute, as specified by ProjectionExpression.
+   * An array of item attributes that match the query criteria. Each element in this array consists of an attribute name and the value for that attribute (subset of attributes if ProjectionExpression was defined).
    */
   Items: T[]
   /**

src/dynamo/request/read-many.request.spec.ts

@@ -1,5 +1,6 @@
 import * as DynamoDB from 'aws-sdk/clients/dynamodb'
 import {
+  ComplexModel,
   ModelWithABunchOfIndexes,
   SimpleWithCompositePartitionKeyModel,
   SimpleWithPartitionKeyModel,
@@ -124,6 +125,23 @@ describe('ReadManyRequest', () => {
     })
   })
 
+  describe('projectionExpression', () => {
+    beforeEach(() => {
+      request = new TestRequest(ComplexModel)
+    })
+
+    it('should set param for projection expression', () => {
+      request.projectionExpression('active', 'lastUpdated')
+      expect(request.params.ProjectionExpression).toBe('#active, #lastUpdated')
+      expect(request.params.ExpressionAttributeNames).toEqual({ '#active': 'isActive', '#lastUpdated': 'lastUpdated' })
+    })
+
+    it('should return instance', () => {
+      const r = request.projectionExpression('active')
+      expect(r).toBe(request)
+    })
+  })
+
   describe('conditions functions', () => {
     beforeEach(() => {
       request = new TestRequest(SimpleWithPartitionKeyModel)

src/dynamo/request/read-many.request.ts

@@ -10,7 +10,6 @@ import { fromDb } from '../../mapper/mapper'
 import { Attributes } from '../../mapper/type/attribute.type'
 import { ModelConstructor } from '../../model/model-constructor'
 import { DynamoDbWrapper } from '../dynamo-db-wrapper'
-import { resolveAttributeNames } from '../expression/functions/attribute-names.function'
 import { and } from '../expression/logical-operator/and.function'
 import { addExpression } from '../expression/param-util'
 import { addCondition } from '../expression/request-expression-builder'
@@ -19,6 +18,7 @@ import {
   RequestConditionFunctionTyped,
 } from '../expression/type/condition-expression-definition-chain'
 import { ConditionExpressionDefinitionFunction } from '../expression/type/condition-expression-definition-function'
+import { addProjectionExpressionParam } from './helper/add-projection-expression-param.function'
 import { QueryRequest } from './query/query.request'
 import { QueryResponse } from './query/query.response'
 import { ScanRequest } from './scan/scan.request'
@@ -108,16 +108,11 @@ export abstract class ReadManyRequest<
   }
 
   /**
-   * Specifies the list of document attributes to be returned from the table instead of returning the entire document
-   * @param attributesToGet List of document attributes to be returned
+   * Specifies the list of model attributes to be returned from the table instead of returning the entire document
+   * @param attributesToGet List of model attributes to be returned
    */
-  projectionExpression(...attributesToGet: string[]): R {
-    // tslint:disable-next-line:no-unnecessary-callback-wrapper
-    const resolved = attributesToGet.map(a => resolveAttributeNames(a))
-    this.params.ProjectionExpression = resolved.map(attr => attr.placeholder).join(', ')
-    Object.values(resolved).forEach(r => {
-      this.params.ExpressionAttributeNames = { ...this.params.ExpressionAttributeNames, ...r.attributeNames }
-    })
+  projectionExpression(...attributesToGet: Array<keyof T | string>): R {
+    addProjectionExpressionParam(attributesToGet, this.params, this.metadata)
     return <any>this
   }
 

src/dynamo/request/scan/scan.response.ts

@@ -5,7 +5,7 @@ import * as DynamoDB from 'aws-sdk/clients/dynamodb'
 
 export interface ScanResponse<T> {
   /**
-   * An array of item attributes that match the scan criteria. Each element in this array consists of an attribute name and the value for that attribute, as specified by ProjectionExpression.
+   * An array of item attributes that match the scan criteria. Each element in this array consists of an attribute name and the value for that attribute (subset of attributes if ProjectionExpression was defined).
    */
   Items: T[]
   /**