Merge pull request #171 from shiftcode/#162-write-request-exec

#162 write request exec

Author: michaelwittwer

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

@@ -35,6 +35,11 @@ describe('batch get', () => {
         },
       ])
     })
+
+    it('returnConsumedCapacity', () => {
+      request.returnConsumedCapacity('TOTAL')
+      expect(request.params.ReturnConsumedCapacity).toBe('TOTAL')
+    })
   })
 
   describe('forModel', () => {

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

@@ -24,6 +24,11 @@ export class BatchGetRequest {
     }
   }
 
+  returnConsumedCapacity(level: DynamoDB.ReturnConsumedCapacity): BatchGetRequest {
+    this.params.ReturnConsumedCapacity = level
+    return this
+  }
+
   /**
    * @param {ModelConstructor<T>} modelClazz
    * @param {Partial<T>[]} keys a partial of T that contains Partition key and SortKey (if necessary). Throws if missing.

src/dynamo/request/delete/delete.request.spec.ts

@@ -35,6 +35,12 @@ describe('delete request', () => {
     it('should throw for no sort key value', () => {
       expect(() => new DeleteRequest(<any>null, ComplexModel, 'myId')).toThrowError()
     })
+
+    it('returnValues', () => {
+      const request = new DeleteRequest(<any>null, SimpleWithPartitionKeyModel, 'myId')
+      const req = request.returnValues('ALL_OLD')
+      expect(req.params.ReturnValues).toEqual('ALL_OLD')
+    })
   })
 
   describe('logger', () => {

src/dynamo/request/delete/delete.request.ts

@@ -3,21 +3,33 @@ import { promiseTap } from '../../../helper/promise-tap.function'
 import { createLogger, Logger } from '../../../logger/logger'
 import { createKeyAttributes } from '../../../mapper/mapper'
 import { ModelConstructor } from '../../../model/model-constructor'
+import { Omit } from '../../../model/omit.type'
 import { DynamoDbWrapper } from '../../dynamo-db-wrapper'
 import { WriteRequest } from '../write.request'
 
+type DeleteRequestReturnT<T> = Omit<DeleteRequest<T>, 'exec'> & { exec(): Promise<T> }
+
 export class DeleteRequest<T> extends WriteRequest<T, DynamoDB.DeleteItemInput, DeleteRequest<T>> {
-  private readonly logger: Logger
+  protected readonly logger: Logger
 
   constructor(dynamoDBWrapper: DynamoDbWrapper, modelClazz: ModelConstructor<T>, partitionKey: any, sortKey?: any) {
     super(dynamoDBWrapper, modelClazz)
     this.logger = createLogger('dynamo.request.DeleteRequest', modelClazz)
     this.params.Key = createKeyAttributes(this.metadata, partitionKey, sortKey)
   }
 
+
+  returnValues(returnValues: 'ALL_OLD'): DeleteRequestReturnT<T>
+  returnValues(returnValues: 'NONE'): DeleteRequest<T>
+  returnValues(returnValues: 'ALL_OLD' | 'NONE'): DeleteRequest<T> | DeleteRequestReturnT<T> {
+    this.params.ReturnValues = returnValues
+    return this
+  }
+
   execFullResponse(): Promise<DynamoDB.DeleteItemOutput> {
     this.logger.debug('request', this.params)
     return this.dynamoDBWrapper.deleteItem(this.params)
       .then(promiseTap(response => this.logger.debug('response', response)))
   }
 }
+

src/dynamo/request/put/put.request.spec.ts

@@ -26,6 +26,11 @@ describe('put request', () => {
       expect(params.ExpressionAttributeNames).toEqual({ '#id': 'id' })
       expect(params.ExpressionAttributeValues).toBeUndefined()
     })
+
+    it('returnValues', () => {
+      const req = request.returnValues('ALL_OLD')
+      expect(req.params.ReturnValues).toEqual('ALL_OLD')
+    })
   })
 
   describe('logger', () => {

src/dynamo/request/put/put.request.ts

@@ -3,12 +3,16 @@ import { promiseTap } from '../../../helper/promise-tap.function'
 import { createLogger, Logger } from '../../../logger/logger'
 import { toDb } from '../../../mapper/mapper'
 import { ModelConstructor } from '../../../model/model-constructor'
+import { Omit } from '../../../model/omit.type'
 import { DynamoDbWrapper } from '../../dynamo-db-wrapper'
 import { createIfNotExistsCondition } from '../../expression/create-if-not-exists-condition.function'
 import { WriteRequest } from '../write.request'
 
+type PutRequestReturnT<T> = Omit<PutRequest<T>, 'exec'> & { exec(): Promise<DynamoDB.AttributeMap> }
+
+
 export class PutRequest<T> extends WriteRequest<T, DynamoDB.PutItemInput, PutRequest<T>> {
-  private readonly logger: Logger
+  protected readonly logger: Logger
 
   constructor(dynamoDBWrapper: DynamoDbWrapper, modelClazz: ModelConstructor<T>, item: T) {
     super(dynamoDBWrapper, modelClazz)
@@ -27,6 +31,13 @@ export class PutRequest<T> extends WriteRequest<T, DynamoDB.PutItemInput, PutReq
     return this
   }
 
+  returnValues(returnValues: 'ALL_OLD'): PutRequestReturnT<T>
+  returnValues(returnValues: 'NONE'): PutRequest<T>
+  returnValues(returnValues: 'ALL_OLD' | 'NONE'): PutRequest<T> | PutRequestReturnT<T> {
+    this.params.ReturnValues = returnValues
+    return this
+  }
+
   execFullResponse(): Promise<DynamoDB.PutItemOutput> {
     this.logger.debug('request', this.params)
     return this.dynamoDBWrapper.putItem(this.params)

src/dynamo/request/update/update.request.spec.ts

@@ -44,6 +44,12 @@ describe('update request', () => {
       expect(() => new UpdateRequest(<any>null, SimpleWithCompositePartitionKeyModel, 'myId')).toThrow()
     })
 
+    it('returnValues', () => {
+      const request = new UpdateRequest(<any>null, SimpleWithPartitionKeyModel, 'myId')
+      const req = request.returnValues('UPDATED_OLD')
+      expect(req.params.ReturnValues).toEqual('UPDATED_OLD')
+    })
+
     it('should add operations', () => {
       const now = new Date()
       const request = new UpdateRequest(<any>null, UpdateModel, 'myId')

src/dynamo/request/update/update.request.ts

@@ -3,15 +3,19 @@ import { promiseTap } from '../../../helper/promise-tap.function'
 import { createLogger, Logger } from '../../../logger/logger'
 import { createKeyAttributes } from '../../../mapper/mapper'
 import { ModelConstructor } from '../../../model/model-constructor'
+import { Omit } from '../../../model/omit.type'
 import { DynamoDbWrapper } from '../../dynamo-db-wrapper'
 import { prepareAndAddUpdateExpressions } from '../../expression/prepare-and-add-update-expressions.function'
 import { addUpdate } from '../../expression/request-expression-builder'
 import { RequestUpdateFunction } from '../../expression/type/update-expression-definition-chain'
 import { UpdateExpressionDefinitionFunction } from '../../expression/type/update-expression-definition-function'
 import { WriteRequest } from '../write.request'
 
+type UpdateRequestReturnT<T> = Omit<UpdateRequest<T>, 'exec'> & { exec(): Promise<T> }
+type UpdateRequestReturnPartialT<T> = Omit<UpdateRequest<T>, 'exec'> & { exec(): Promise<Partial<T>> }
+
 export class UpdateRequest<T> extends WriteRequest<T, DynamoDB.UpdateItemInput, UpdateRequest<T>> {
-  private readonly logger: Logger
+  protected readonly logger: Logger
 
   constructor(dynamoDBWrapper: DynamoDbWrapper, modelClazz: ModelConstructor<T>, partitionKey: any, sortKey?: any) {
     super(dynamoDBWrapper, modelClazz)
@@ -28,6 +32,14 @@ export class UpdateRequest<T> extends WriteRequest<T, DynamoDB.UpdateItemInput,
     return this
   }
 
+  returnValues(returnValues: 'ALL_OLD' | 'ALL_NEW'): UpdateRequestReturnT<T>
+  returnValues(returnValues: 'UPDATED_OLD' | 'UPDATED_NEW'): UpdateRequestReturnPartialT<T>
+  returnValues(returnValues: 'NONE'): UpdateRequest<T>
+  returnValues(returnValues: 'ALL_OLD' | 'ALL_NEW' | 'UPDATED_OLD' | 'UPDATED_NEW' | 'NONE'): UpdateRequest<T> | UpdateRequestReturnT<T> | UpdateRequestReturnPartialT<T> {
+    this.params.ReturnValues = returnValues
+    return this
+  }
+
   execFullResponse(): Promise<DynamoDB.UpdateItemOutput> {
     this.logger.debug('request', this.params)
     return this.dynamoDBWrapper.updateItem(this.params)

src/dynamo/request/write.request.spec.ts

@@ -1,15 +1,19 @@
 import { SimpleWithPartitionKeyModel } from '../../../test/models'
+import { createLogger, Logger } from '../../logger/logger'
+import { Attributes } from '../../mapper/type/attribute.type'
 import { ModelConstructor } from '../../model/model-constructor'
 import { attribute } from '../expression/logical-operator/attribute.function'
 import { or } from '../expression/logical-operator/public.api'
 import { WriteRequest } from './write.request'
 
 describe('write request', () => {
   class TestWriteRequest<T> extends WriteRequest<T, any, TestWriteRequest<T>> {
+    protected readonly logger: Logger
     readonly params: any = {}
 
     constructor(modelClazz: ModelConstructor<T>) {
       super(<any>null, modelClazz)
+      this.logger = createLogger('dynamo.request.PutRequest', modelClazz)
     }
 
     execFullResponse() {
@@ -19,7 +23,7 @@ describe('write request', () => {
 
   let req: TestWriteRequest<SimpleWithPartitionKeyModel>
 
-  describe('exec', () => {
+  describe('exec [ReturnValues = NONE]', () => {
     let execFullResponseSpy: jasmine.Spy
     beforeEach(() => {
       req = new TestWriteRequest(SimpleWithPartitionKeyModel)
@@ -37,6 +41,18 @@ describe('write request', () => {
     })
   })
 
+  describe('exec [ReturnValues = ALL_OLD]', () => {
+    beforeEach(() => {
+      req = new TestWriteRequest(SimpleWithPartitionKeyModel)
+      const returnValues: Attributes<SimpleWithPartitionKeyModel> = { id: { S: 'myId' }, age: { N: '20' } }
+      spyOn(req, 'execFullResponse').and.returnValue(Promise.resolve({ Attributes: returnValues }))
+    })
+    it('should map result if Attributes return values(s)', async () => {
+      const result = await req.exec()
+      expect(result).toEqual({ id: 'myId', age: 20 })
+    })
+  })
+
   describe('params', () => {
     beforeEach(() => {
       req = new TestWriteRequest(SimpleWithPartitionKeyModel)
@@ -47,11 +63,6 @@ describe('write request', () => {
       expect(req.params.ReturnItemCollectionMetrics).toBe('SIZE')
     })
 
-    it('should set returnValues', () => {
-      req.returnValues('ALL_OLD')
-      expect(req.params.ReturnValues).toBe('ALL_OLD')
-    })
-
     it('[onlyIfAttribute] should set condition', () => {
       req.onlyIfAttribute('age').gt(20)
       expect(req.params.ConditionExpression).toEqual('#age > :age')

src/dynamo/request/write.request.ts

@@ -1,4 +1,8 @@
 import * as DynamoDB from 'aws-sdk/clients/dynamodb'
+import { promiseTap } from '../../helper/promise-tap.function'
+import { Logger } from '../../logger/logger'
+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 { and } from '../expression/logical-operator/public.api'
@@ -14,6 +18,10 @@ import { StandardRequest } from './standard.request'
 export abstract class WriteRequest<T,
   I extends DynamoDB.DeleteItemInput | DynamoDB.PutItemInput | DynamoDB.UpdateItemInput,
   R extends WriteRequest<T, I, R>> extends StandardRequest<T, I, R> {
+
+  protected abstract readonly logger: Logger
+
+
   protected constructor(dynamoDBWrapper: DynamoDbWrapper, modelClazz: ModelConstructor<T>) {
     super(dynamoDBWrapper, modelClazz)
   }
@@ -28,7 +36,6 @@ export abstract class WriteRequest<T,
   }
 
   /**
-   * @param conditionDefFns
    * @example writeRequest.onlyIf( attribute('age').eq(23) )
    * @example writeRequest.onlyIf( or( attribute('age').lt(18), attribute('age').gt(65) ) )
    */
@@ -38,17 +45,23 @@ export abstract class WriteRequest<T,
     return <any>this
   }
 
-  /*
-   * The ReturnValues parameter is used by several DynamoDB operations; however,
-   * DeleteItem/PutItem/UpdateItem does not recognize any values other than NONE or ALL_OLD.
+  /**
+   * @returns { void } if no ReturnValues are requested, { T } if the requested ReturnValues are ALL_OLD|ALL_NEW or {Partial<T>} if the requested ReturnValues are UPDATED_OLD|UPDATED_NEW
    */
-  returnValues(returnValues: 'NONE' | 'ALL_OLD'): R {
-    this.params.ReturnValues = returnValues
-    return <R>(<any>this)
-  }
-
-  exec(): Promise<void> {
+  exec(): Promise<T | undefined> {
     return this.execFullResponse()
-      .then(response => {return})
+      .then(response => {
+        if ('Attributes' in response && typeof response.Attributes === 'object' && response.Attributes !== null) {
+          return fromDb(<Attributes<T>>response.Attributes, this.modelClazz)
+        }
+        return
+      })
+      .then(promiseTap(item => {
+        if (item) {
+          this.logger.debug('mapped item', item)
+        } else {
+          this.logger.debug('no return values to map')
+        }
+      }))
   }
 }