feat(typing): more advanced typing for return types

more advanced typing for cases which need to manipulate the return type of exec() (or similar), before the update update().returnValues('ALL_NEW').exec() returned `T` but when another command was added to the chain the type went back to `void` when using `this` as return type the information will be prevented.

Author: michaelwittwer

src/dynamo/expression/request-expression-builder.ts

@@ -151,18 +151,18 @@ export function doAddCondition<T, R extends ConditionalParamsHost>(
 /**
  * @hidden
  */
-export function addPartitionKeyCondition<R extends StandardRequest<any, any, any>>(
+export function addPartitionKeyCondition<R extends StandardRequest<any, any, any, any>>(
   keyName: keyof any,
   keyValue: any,
   request: R,
 ): R
-export function addPartitionKeyCondition<T, R extends StandardRequest<T, any, any>>(
+export function addPartitionKeyCondition<T, R extends StandardRequest<T, any, any, any>>(
   keyName: keyof T,
   keyValue: any,
   request: R,
   metadata: Metadata<T>,
 ): R
-export function addPartitionKeyCondition<T, R extends StandardRequest<T, any, any>>(
+export function addPartitionKeyCondition<T, R extends StandardRequest<T, any, any, any>>(
   keyName: keyof T,
   keyValue: any,
   request: R,

src/dynamo/request/base.request.ts

@@ -15,6 +15,7 @@ import { getTableName } from '../get-table-name.function'
  */
 export abstract class BaseRequest<
   T,
+  T2,
   I extends
     | DynamoDB.DeleteItemInput
     | DynamoDB.GetItemInput
@@ -26,7 +27,7 @@ export abstract class BaseRequest<
     | DynamoDB.BatchWriteItemInput
     | DynamoDB.TransactGetItemsInput
     | DynamoDB.TransactWriteItemsInput,
-  R extends BaseRequest<T, I, any>
+  R extends BaseRequest<T, T2, I, any>
 > {
   readonly dynamoDBWrapper: DynamoDbWrapper
 
@@ -86,5 +87,5 @@ export abstract class BaseRequest<
   /**
    * execute request and return the parsed item(s) or void if none were requested.
    */
-  abstract exec(): Promise<T | T[] | void | null>
+  abstract exec(): Promise<T2 | T2[] | void | null>
 }

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

@@ -18,10 +18,11 @@ import { BatchGetSingleTableResponse } from './batch-get-single-table.response'
 /**
  * Request class for BatchGetItem operation which supports a single model class only.
  */
-export class BatchGetSingleTableRequest<T> extends BaseRequest<
+export class BatchGetSingleTableRequest<T, T2 = T> extends BaseRequest<
   T,
+  T2,
   DynamoDB.BatchGetItemInput,
-  BatchGetSingleTableRequest<T>
+  BatchGetSingleTableRequest<T, T2>
 > {
   private readonly logger: Logger
 
@@ -43,7 +44,7 @@ export class BatchGetSingleTableRequest<T> extends BaseRequest<
   /**
    * Determines the read consistency model: If set to true, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads.
    */
-  consistentRead(value: boolean = true): BatchGetSingleTableRequest<T> {
+  consistentRead(value: boolean = true): this {
     this.params.RequestItems[this.tableName].ConsistentRead = value
     return this
   }
@@ -52,7 +53,7 @@ export class BatchGetSingleTableRequest<T> extends BaseRequest<
    * 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: Array<keyof T | string>): BatchGetSingleTableRequest<T> {
+  projectionExpression(...attributesToGet: Array<keyof T | string>): BatchGetSingleTableRequest<T, Partial<T>> {
     addProjectionExpressionParam(attributesToGet, this.params.RequestItems[this.tableName], this.metadata)
     return this
   }
@@ -77,7 +78,7 @@ export class BatchGetSingleTableRequest<T> extends BaseRequest<
   execFullResponse(
     backoffTimer = randomExponentialBackoffTimer,
     throttleTimeSlot = BATCH_GET_DEFAULT_TIME_SLOT,
-  ): Promise<BatchGetSingleTableResponse<T>> {
+  ): Promise<BatchGetSingleTableResponse<T2>> {
     return this.fetch(backoffTimer, throttleTimeSlot)
       .then(this.mapResponse)
       .then(promiseTap(response => this.logger.debug('mapped items', response.Items)))
@@ -88,18 +89,18 @@ export class BatchGetSingleTableRequest<T> extends BaseRequest<
    * @param backoffTimer when unprocessed keys are returned the next value of backoffTimer is used to determine how many time slots to wait before doing the next request
    * @param throttleTimeSlot the duration of a time slot in ms
    */
-  exec(backoffTimer = randomExponentialBackoffTimer, throttleTimeSlot = BATCH_GET_DEFAULT_TIME_SLOT): Promise<T[]> {
+  exec(backoffTimer = randomExponentialBackoffTimer, throttleTimeSlot = BATCH_GET_DEFAULT_TIME_SLOT): Promise<T2[]> {
     return this.fetch(backoffTimer, throttleTimeSlot)
       .then(this.mapResponse)
       .then(r => r.Items)
       .then(promiseTap(items => this.logger.debug('mapped items', items)))
   }
 
   private mapResponse = (response: DynamoDB.BatchGetItemOutput) => {
-    let items: T[] = []
+    let items: T2[] = []
     if (response.Responses && Object.keys(response.Responses).length && response.Responses[this.tableName]) {
-      const mapped: T[] = response.Responses[this.tableName].map(attributeMap =>
-        fromDb(<Attributes<T>>attributeMap, this.modelClazz),
+      const mapped: T2[] = response.Responses[this.tableName].map(attributeMap =>
+        fromDb(<Attributes<T2>>attributeMap, <any>this.modelClazz),
       )
       items = mapped
     }

src/dynamo/request/batchwritesingletable/batch-write-single-table.request.ts

@@ -14,10 +14,11 @@ import { BaseRequest } from '../base.request'
 /**
  * Request class for BatchWriteItem operation which supports a single model class only.
  */
-export class BatchWriteSingleTableRequest<T> extends BaseRequest<
+export class BatchWriteSingleTableRequest<T, T2 = T> extends BaseRequest<
   T,
+  T2,
   DynamoDB.BatchWriteItemInput,
-  BatchWriteSingleTableRequest<T>
+  BatchWriteSingleTableRequest<T, T2>
 > {
   private readonly logger: Logger
   private toKey = createToKeyFn(this.modelClazz)
@@ -37,15 +38,15 @@ export class BatchWriteSingleTableRequest<T> extends BaseRequest<
     this.params.ReturnItemCollectionMetrics = value
   }
 
-  delete(items: Array<Partial<T>>): BatchWriteSingleTableRequest<T> {
+  delete(items: Array<Partial<T>>): this {
     if (this.params.RequestItems[this.tableName].length + items.length > BATCH_WRITE_MAX_REQUEST_ITEM_COUNT) {
       throw new Error(`batch write takes at max ${BATCH_WRITE_MAX_REQUEST_ITEM_COUNT} items`)
     }
     this.params.RequestItems[this.tableName].push(...items.map(this.createDeleteRequest))
     return this
   }
 
-  put(items: T[]): BatchWriteSingleTableRequest<T> {
+  put(items: T[]): this {
     if (this.params.RequestItems[this.tableName].length + items.length > BATCH_WRITE_MAX_REQUEST_ITEM_COUNT) {
       throw new Error(`batch write takes at max ${BATCH_WRITE_MAX_REQUEST_ITEM_COUNT} items`)
     }

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

@@ -5,24 +5,18 @@ import * as DynamoDB from 'aws-sdk/clients/dynamodb'
 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<Omit<DeleteRequest<T>, 'exec'>, 'execFullResponse'> & {
-  exec(): Promise<T>
-  execFullResponse(): Promise<DeleteResponse<T>>
-}
 
 /**
  * Request class for the DeleteItem operation.
  */
-export class DeleteRequest<T> extends WriteRequest<
+export class DeleteRequest<T, T2 = T> extends WriteRequest<
   T,
+  T2,
   DynamoDB.DeleteItemInput,
   DynamoDB.DeleteItemOutput,
-  DeleteRequest<T>
+  DeleteRequest<T, T2>
 > {
   protected readonly logger: Logger
 
@@ -32,11 +26,11 @@ export class DeleteRequest<T> extends WriteRequest<
     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> {
+  returnValues(returnValues: 'ALL_OLD'): DeleteRequest<T, T>
+  returnValues(returnValues: 'NONE'): DeleteRequest<T, void>
+  returnValues(returnValues: 'ALL_OLD' | 'NONE'): DeleteRequest<T, T | void> {
     this.params.ReturnValues = returnValues
-    return this
+    return <any>this
   }
 
   protected doRequest(params: DynamoDB.DeleteItemInput): Promise<DynamoDB.DeleteItemOutput> {

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

@@ -34,8 +34,11 @@ describe('GetRequest', () => {
     })
 
     it('projection expression', () => {
+      // const item = await request.consistentRead().exec()
+      // const item = await request.consistentRead().projectionExpression('age').exec()
+      // const item2 = await request.projectionExpression('age').exec()
+      // const item3 = await request.projectionExpression('age').consistentRead().exec()
       request.projectionExpression('age')
-
       const params = request.params
       expect(params.ProjectionExpression).toBe('#age')
       expect(params.ExpressionAttributeNames).toEqual({ '#age': 'age' })

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

@@ -15,7 +15,7 @@ import { GetResponse } from './get.response'
 /**
  * Request class for the GetItem operation.
  */
-export class GetRequest<T> extends StandardRequest<T, DynamoDB.GetItemInput, GetRequest<T>> {
+export class GetRequest<T, T2 = T> extends StandardRequest<T, T2, DynamoDB.GetItemInput, GetRequest<T, T2>> {
   private readonly logger: Logger
 
   constructor(dynamoDBWrapper: DynamoDbWrapper, modelClazz: ModelConstructor<T>, partitionKey: any, sortKey?: any) {
@@ -27,7 +27,7 @@ export class GetRequest<T> extends StandardRequest<T, DynamoDB.GetItemInput, Get
   /**
    * Determines the read consistency model: If set to true, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads.
    */
-  consistentRead(consistentRead: boolean = true): GetRequest<T> {
+  consistentRead(consistentRead: boolean = true): this {
     this.params.ConsistentRead = consistentRead
     return this
   }
@@ -36,21 +36,21 @@ export class GetRequest<T> extends StandardRequest<T, DynamoDB.GetItemInput, Get
    * 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: Array<keyof T | string>): GetRequest<T> {
+  projectionExpression(...attributesToGet: Array<keyof T | string>): GetRequest<T, Partial<T>> {
     addProjectionExpressionParam(attributesToGet, this.params, this.metadata)
     return this
   }
 
-  execFullResponse(): Promise<GetResponse<T>> {
+  execFullResponse(): Promise<GetResponse<T2>> {
     this.logger.debug('request', this.params)
     return this.dynamoDBWrapper
       .getItem(this.params)
       .then(promiseTap(response => this.logger.debug('response', response)))
       .then(getItemResponse => {
-        const response: GetResponse<T> = <any>{ ...getItemResponse }
+        const response: GetResponse<T2> = <any>{ ...getItemResponse }
 
         if (getItemResponse.Item) {
-          response.Item = fromDb(<Attributes<T>>getItemResponse.Item, this.modelClazz)
+          response.Item = fromDb(<Attributes<T2>>getItemResponse.Item, <any>this.modelClazz)
         } else {
           response.Item = null
         }
@@ -63,14 +63,14 @@ export class GetRequest<T> extends StandardRequest<T, DynamoDB.GetItemInput, Get
   /**
    * execute request and return the parsed item
    */
-  exec(): Promise<T | null> {
+  exec(): Promise<T2 | null> {
     this.logger.debug('request', this.params)
     return this.dynamoDBWrapper
       .getItem(this.params)
       .then(promiseTap(response => this.logger.debug('response', response)))
       .then(response => {
         if (response.Item) {
-          return fromDb(<Attributes<T>>response.Item, this.modelClazz)
+          return fromDb(<Attributes<T2>>response.Item, <any>this.modelClazz)
         } else {
           return null
         }

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

@@ -5,21 +5,20 @@ import * as DynamoDB from 'aws-sdk/clients/dynamodb'
 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<Omit<PutRequest<T>, 'exec'>, 'execFullResponse'> & {
-  exec(): Promise<T>
-  execFullResponse(): Promise<PutResponse<T>>
-}
 
 /**
  * Request class for the PutItem operation.
  */
-export class PutRequest<T> extends WriteRequest<T, DynamoDB.PutItemInput, DynamoDB.PutItemOutput, PutRequest<T>> {
+export class PutRequest<T, T2 = void> extends WriteRequest<
+  T,
+  T2,
+  DynamoDB.PutItemInput,
+  DynamoDB.PutItemOutput,
+  PutRequest<T, T2>
+> {
   protected readonly logger: Logger
 
   constructor(dynamoDBWrapper: DynamoDbWrapper, modelClazz: ModelConstructor<T>, item: T) {
@@ -31,18 +30,19 @@ export class PutRequest<T> extends WriteRequest<T, DynamoDB.PutItemInput, Dynamo
   /**
    * Adds a condition expression to the request, which makes sure the item will only be saved if the id does not exist
    */
-  ifNotExists(predicate: boolean = true): PutRequest<T> {
+  ifNotExists(predicate: boolean = true): this {
     if (predicate) {
       this.onlyIf(...createIfNotExistsCondition(this.metadata))
     }
+
     return this
   }
 
-  returnValues(returnValues: 'ALL_OLD'): PutRequestReturnT<T>
-  returnValues(returnValues: 'NONE'): PutRequest<T>
-  returnValues(returnValues: 'ALL_OLD' | 'NONE'): PutRequest<T> | PutRequestReturnT<T> {
+  returnValues(returnValues: 'ALL_OLD'): PutRequest<T, T>
+  returnValues(returnValues: 'NONE'): PutRequest<T, void>
+  returnValues(returnValues: 'ALL_OLD' | 'NONE'): PutRequest<T, T | void> {
     this.params.ReturnValues = returnValues
-    return this
+    return <any>this
   }
 
   protected doRequest(params: DynamoDB.PutItemInput): Promise<DynamoDB.PutItemOutput> {

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

@@ -13,12 +13,13 @@ import { QueryResponse } from './query.response'
 /**
  * Request class for the Query operation.
  */
-export class QueryRequest<T> extends ReadManyRequest<
+export class QueryRequest<T, T2 = T> extends ReadManyRequest<
   T,
+  T2,
   DynamoDB.QueryInput,
   DynamoDB.QueryOutput,
-  QueryResponse<T>,
-  QueryRequest<T>
+  QueryResponse<T2>,
+  QueryRequest<T2>
 > {
   protected readonly logger: Logger
 
@@ -27,10 +28,7 @@ export class QueryRequest<T> extends ReadManyRequest<
     this.logger = createLogger('dynamo.request.QueryRequest', modelClazz)
   }
 
-  /**
-   *
-   */
-  wherePartitionKey(partitionKeyValue: any): QueryRequest<T> {
+  wherePartitionKey(partitionKeyValue: any): this {
     let partitionKey: keyof T
     if (this.secondaryIndex) {
       if (!this.secondaryIndex.partitionKey) {
@@ -47,7 +45,7 @@ export class QueryRequest<T> extends ReadManyRequest<
   /**
    * used to define some condition for the sort key, use the secondary index to query based on a custom index
    */
-  whereSortKey(): SortKeyConditionFunction<QueryRequest<T>> {
+  whereSortKey(): SortKeyConditionFunction<QueryRequest<T, T2>> {
     let sortKey: keyof T | null
     if (this.secondaryIndex) {
       if (!this.secondaryIndex.sortKey) {
@@ -65,12 +63,12 @@ export class QueryRequest<T> extends ReadManyRequest<
     return addSortKeyCondition(sortKey, this, this.metadata)
   }
 
-  ascending(): QueryRequest<T> {
+  ascending(): this {
     this.params.ScanIndexForward = true
     return this
   }
 
-  descending(): QueryRequest<T> {
+  descending(): this {
     this.params.ScanIndexForward = false
     return this
   }