Merge pull request #180 from shiftcode/#179-various

#179 write requests execFullResponse does not map items

Author: michaelwittwer

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

@@ -1,6 +1,7 @@
 import * as DynamoDB from 'aws-sdk/clients/dynamodb'
 import { ComplexModel, SimpleWithPartitionKeyModel } from '../../../../test/models'
 import { updateDynamoEasyConfig } from '../../../config/update-config.function'
+import { DynamoDbWrapper } from '../../dynamo-db-wrapper'
 import { DeleteRequest } from './delete.request'
 
 describe('delete request', () => {
@@ -72,4 +73,28 @@ describe('delete request', () => {
       expect(logInfoData.includes(sampleResponse)).toBeTruthy()
     })
   })
+
+  describe('typings', () => {
+    // tests basically only exists to be not valid when typings would be wrong
+    let req: DeleteRequest<SimpleWithPartitionKeyModel>
+    let dynamoDbWrapperMock: DynamoDbWrapper
+
+    beforeEach(() => {
+      dynamoDbWrapperMock = <any>{
+        deleteItem: () =>
+          Promise.resolve({
+            Attributes: {
+              id: { S: 'myId' },
+              age: { N: '20' },
+            },
+          }),
+      }
+      req = new DeleteRequest(<any>dynamoDbWrapperMock, SimpleWithPartitionKeyModel, 'myKey')
+    })
+
+    it('exec, ALL_OLD', async () => {
+      const result: SimpleWithPartitionKeyModel = await req.returnValues('ALL_OLD').exec()
+      expect(result).toEqual({ id: 'myId', age: 20 })
+    })
+  })
 })

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

@@ -1,15 +1,21 @@
 import * as DynamoDB from 'aws-sdk/clients/dynamodb'
-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'
+import { DeleteResponse } from './delete.response'
 
-type DeleteRequestReturnT<T> = Omit<DeleteRequest<T>, 'exec'> & { exec(): Promise<T> }
+type DeleteRequestReturnT<T> = Omit<Omit<DeleteRequest<T>, 'exec'>,'execFullResponse'> & {
+  exec(): Promise<T>
+  execFullResponse(): Promise<DeleteResponse<T>>
+}
 
-export class DeleteRequest<T> extends WriteRequest<T, DynamoDB.DeleteItemInput, DeleteRequest<T>> {
+/**
+ * Request class for the DeleteItem operation.
+ */
+export class DeleteRequest<T> extends WriteRequest<T, DynamoDB.DeleteItemInput, DynamoDB.DeleteItemOutput, DeleteRequest<T>> {
   protected readonly logger: Logger
 
   constructor(dynamoDBWrapper: DynamoDbWrapper, modelClazz: ModelConstructor<T>, partitionKey: any, sortKey?: any) {
@@ -26,20 +32,7 @@ export class DeleteRequest<T> extends WriteRequest<T, DynamoDB.DeleteItemInput,
     return this
   }
 
-  /*
-   * kind a hacky - this is just for typing reasons so Promise<void> is the default return type when not defining a
-   * returnValues other than NONE
-   *
-   * const valueVoid = new DeleteRequest(...).exec()
-   * const valueMyModel = new DeleteRequest(...).returnValues('ALL_OLD').exec()
-   */
-  exec(): Promise<void> {
-    return <Promise<void>>super.exec()
-  }
-
-  execFullResponse(): Promise<DynamoDB.DeleteItemOutput> {
-    this.logger.debug('request', this.params)
-    return this.dynamoDBWrapper.deleteItem(this.params)
-      .then(promiseTap(response => this.logger.debug('response', response)))
+  protected doRequest(params: DynamoDB.DeleteItemInput): Promise<DynamoDB.DeleteItemOutput> {
+    return this.dynamoDBWrapper.deleteItem(params)
   }
 }

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

@@ -0,0 +1,8 @@
+import * as DynamoDB from 'aws-sdk/clients/dynamodb'
+
+export interface DeleteResponse<T> {
+  ConsumedCapacity?: DynamoDB.ConsumedCapacity
+  ItemCollectionMetrics?: DynamoDB.ItemCollectionMetrics
+  Item: T
+}
+

src/dynamo/request/public-api.ts

@@ -1,12 +1,15 @@
 export * from './delete/delete.request'
+export * from './delete/delete.response'
 export * from './get/get.request'
 export * from './get/get.response'
 export * from './put/put.request'
+export * from './put/put.response'
 export * from './query/query.request'
 export * from './query/query.response'
 export * from './scan/scan.request'
 export * from './scan/scan.response'
 export * from './update/update.request'
+export * from './update/update.response'
 export * from './batchgetsingletable/batch-get-single-table.request'
 export * from './batchgetsingletable/batch-get-single-table.response'
 export * from './read-many.request'

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

@@ -1,6 +1,7 @@
 import * as DynamoDB from 'aws-sdk/clients/dynamodb'
 import { SimpleWithPartitionKeyModel } from '../../../../test/models'
 import { updateDynamoEasyConfig } from '../../../config/update-config.function'
+import { DynamoDbWrapper } from '../../dynamo-db-wrapper'
 import { PutRequest } from './put.request'
 
 describe('put request', () => {
@@ -67,4 +68,28 @@ describe('put request', () => {
       expect(logInfoData.includes(sampleResponse)).toBeTruthy()
     })
   })
+
+  describe('typings', () => {
+    // tests basically only exists to be not valid when typings would be wrong
+    let req: PutRequest<SimpleWithPartitionKeyModel>
+    let dynamoDbWrapperMock: DynamoDbWrapper
+
+    beforeEach(() => {
+      dynamoDbWrapperMock = <any>{
+        putItem: () =>
+          Promise.resolve({
+            Attributes: {
+              id: { S: 'myId' },
+              age: { N: '20' },
+            },
+          }),
+      }
+      req = new PutRequest(<any>dynamoDbWrapperMock, SimpleWithPartitionKeyModel, { id: 'myKey', age: 20 })
+    })
+
+    it('exec, ALL_OLD', async () => {
+      const result: SimpleWithPartitionKeyModel = await req.returnValues('ALL_OLD').exec()
+      expect(result).toEqual({ id: 'myId', age: 20 })
+    })
+  })
 })

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

@@ -1,17 +1,22 @@
 import * as DynamoDB from 'aws-sdk/clients/dynamodb'
-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'
+import { PutResponse } from './put.response'
 
-type PutRequestReturnT<T> = Omit<PutRequest<T>, 'exec'> & { exec(): Promise<DynamoDB.AttributeMap> }
-
+type PutRequestReturnT<T> = Omit<Omit<PutRequest<T>, 'exec'>, 'execFullResponse'> & {
+  exec(): Promise<T>
+  execFullResponse(): Promise<PutResponse<T>>
+}
 
-export class PutRequest<T> extends WriteRequest<T, DynamoDB.PutItemInput, PutRequest<T>> {
+/**
+ * Request class for the PutItem operation.
+ */
+export class PutRequest<T> extends WriteRequest<T, DynamoDB.PutItemInput, DynamoDB.PutItemOutput, PutRequest<T>> {
   protected readonly logger: Logger
 
   constructor(dynamoDBWrapper: DynamoDbWrapper, modelClazz: ModelConstructor<T>, item: T) {
@@ -22,7 +27,6 @@ export class PutRequest<T> extends WriteRequest<T, DynamoDB.PutItemInput, PutReq
 
   /**
    * Adds a condition expression to the request, which makes sure the item will only be saved if the id does not exist
-   * @returns {PutRequest<T>}
    */
   ifNotExists(predicate: boolean = true): PutRequest<T> {
     if (predicate) {
@@ -38,20 +42,7 @@ export class PutRequest<T> extends WriteRequest<T, DynamoDB.PutItemInput, PutReq
     return this
   }
 
-  /*
-   * kind a hacky - this is just for typing reasons so Promise<void> is the default return type when not defining a
-   * returnValues other than NONE
-   *
-   * const valueVoid = new DeleteRequest(...).exec()
-   * const valueMyModel = new DeleteRequest(...).returnValues('ALL_OLD').exec()
-   */
-  exec(): Promise<void> {
-    return <Promise<void>>super.exec()
-  }
-
-  execFullResponse(): Promise<DynamoDB.PutItemOutput> {
-    this.logger.debug('request', this.params)
-    return this.dynamoDBWrapper.putItem(this.params)
-      .then(promiseTap(response => this.logger.debug('response', response)))
+  protected doRequest(params: DynamoDB.PutItemInput): Promise<DynamoDB.PutItemOutput> {
+    return this.dynamoDBWrapper.putItem(params)
   }
 }

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

@@ -0,0 +1,8 @@
+import * as DynamoDB from 'aws-sdk/clients/dynamodb'
+
+export interface PutResponse<T> {
+  ConsumedCapacity?: DynamoDB.ConsumedCapacity
+  ItemCollectionMetrics?: DynamoDB.ItemCollectionMetrics
+  Item: T
+}
+

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

@@ -10,6 +10,7 @@ import { Duration } from '../../../../test/models/duration.model'
 import { SpecialCasesModel } from '../../../../test/models/special-cases-model.model'
 import { updateDynamoEasyConfig } from '../../../config/update-config.function'
 import { dateToStringMapper } from '../../../mapper/custom/date-to-string.mapper'
+import { DynamoDbWrapper } from '../../dynamo-db-wrapper'
 import { update, update2 } from '../../expression/logical-operator/update.function'
 import { UpdateRequest } from './update.request'
 
@@ -220,4 +221,33 @@ describe('update request', () => {
       expect(logInfoData.includes(sampleResponse)).toBeTruthy()
     })
   })
+
+  describe('typings', () => {
+    // tests basically only exists to be not valid when typings would be wrong
+    let req: UpdateRequest<SimpleWithPartitionKeyModel>
+    let dynamoDbWrapperMock: DynamoDbWrapper
+
+    beforeEach(() => {
+      dynamoDbWrapperMock = <any>{
+        updateItem: () =>
+          Promise.resolve({
+            Attributes: {
+              id: { S: 'myId' },
+              age: { N: '20' },
+            },
+          }),
+      }
+      req = new UpdateRequest(<any>dynamoDbWrapperMock, SimpleWithPartitionKeyModel, 'myKey')
+    })
+
+    it('exec, ALL_OLD', async () => {
+      const result: SimpleWithPartitionKeyModel = await req.returnValues('ALL_OLD').exec()
+      expect(result).toEqual({ id: 'myId', age: 20 })
+    })
+
+    it('exec, UPDATED_OLD', async () => {
+      const result: Partial<SimpleWithPartitionKeyModel> = await req.returnValues('UPDATED_OLD').exec()
+      expect(result).toEqual({ id: 'myId', age: 20 })
+    })
+  })
 })

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

@@ -1,5 +1,4 @@
 import * as DynamoDB from 'aws-sdk/clients/dynamodb'
-import { promiseTap } from '../../../helper/promise-tap.function'
 import { createLogger, Logger } from '../../../logger/logger'
 import { createKeyAttributes } from '../../../mapper/mapper'
 import { ModelConstructor } from '../../../model/model-constructor'
@@ -10,11 +9,22 @@ 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'
+import { UpdateResponse } from './update.response'
 
-type UpdateRequestReturnT<T> = Omit<UpdateRequest<T>, 'exec'> & { exec(): Promise<T> }
-type UpdateRequestReturnPartialT<T> = Omit<UpdateRequest<T>, 'exec'> & { exec(): Promise<Partial<T>> }
+type UpdateRequestReturnT<T> = Omit<Omit<UpdateRequest<T>, 'exec'>, 'execFullResponse'> & {
+  exec(): Promise<T>
+  execFullResponse(): Promise<UpdateResponse<T>>
+}
+type UpdateRequestReturnPartialT<T> = Omit<Omit<UpdateRequest<T>, 'exec'>, 'execFullResponse'> & {
+  exec(): Promise<Partial<T>>
+  execFullResponse(): Promise<UpdateResponse<T>>
+}
+
+/**
+ * Request class for the UpdateItem operation.
+ */
+export class UpdateRequest<T> extends WriteRequest<T, DynamoDB.UpdateItemInput, DynamoDB.UpdateItemOutput, UpdateRequest<T>> {
 
-export class UpdateRequest<T> extends WriteRequest<T, DynamoDB.UpdateItemInput, UpdateRequest<T>> {
   protected readonly logger: Logger
 
   constructor(dynamoDBWrapper: DynamoDbWrapper, modelClazz: ModelConstructor<T>, partitionKey: any, sortKey?: any) {
@@ -23,10 +33,18 @@ export class UpdateRequest<T> extends WriteRequest<T, DynamoDB.UpdateItemInput,
     this.params.Key = createKeyAttributes(this.metadata, partitionKey, sortKey)
   }
 
+  /**
+   * create and add a single update operation
+   * @example req.updateAttribute('path.to.attr').set('newVal')
+   */
   updateAttribute<K extends keyof T>(attributePath: K): RequestUpdateFunction<UpdateRequest<T>, T, K> {
     return addUpdate(attributePath, this, this.metadata)
   }
 
+  /**
+   * add multiple update operations comma separated
+   * @example req.operations(update('path.to.attr).set('newVal'), ... )
+   */
   operations(...updateDefFns: UpdateExpressionDefinitionFunction[]): UpdateRequest<T> {
     prepareAndAddUpdateExpressions(this.metadata, this.params, updateDefFns)
     return this
@@ -40,20 +58,7 @@ export class UpdateRequest<T> extends WriteRequest<T, DynamoDB.UpdateItemInput,
     return this
   }
 
-  /*
-   * kind a hacky - this is just for typing reasons so Promise<void> is the default return type when not defining a
-   * returnValues other than NONE
-   *
-   * const valueVoid = new DeleteRequest(...).exec()
-   * const valueMyModel = new DeleteRequest(...).returnValues('ALL_OLD').exec()
-   */
-  exec(): Promise<void> {
-    return <Promise<void>>super.exec()
-  }
-
-  execFullResponse(): Promise<DynamoDB.UpdateItemOutput> {
-    this.logger.debug('request', this.params)
+  protected doRequest(params: DynamoDB.UpdateItemInput): Promise<DynamoDB.UpdateItemOutput> {
     return this.dynamoDBWrapper.updateItem(this.params)
-      .then(promiseTap(response => this.logger.debug('response', response)))
   }
 }

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

@@ -0,0 +1,8 @@
+import * as DynamoDB from 'aws-sdk/clients/dynamodb'
+
+export interface UpdateResponse<T> {
+  ConsumedCapacity?: DynamoDB.ConsumedCapacity
+  ItemCollectionMetrics?: DynamoDB.ItemCollectionMetrics
+  Item: T
+}
+