refactor(dynamo): for easier reading, prefer return type this

also made some needless casts

Author: mumenthalers

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

@@ -34,7 +34,7 @@ export class UpdateRequest<T, T2 = void> extends WriteRequest<
    * 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, T2>, T, K> {
+  updateAttribute<K extends keyof T>(attributePath: K): RequestUpdateFunction<this, T, K> {
     return addUpdate(attributePath, this, this.metadata)
   }
 

src/dynamo/request/write.request.ts

@@ -45,29 +45,29 @@ export abstract class WriteRequest<
   /**
    * return item collection metrics.
    */
-  returnItemCollectionMetrics(returnItemCollectionMetrics: DynamoDB.ReturnItemCollectionMetrics): R {
+  returnItemCollectionMetrics(returnItemCollectionMetrics: DynamoDB.ReturnItemCollectionMetrics): this {
     this.params.ReturnItemCollectionMetrics = returnItemCollectionMetrics
-    return <R>(<any>this)
+    return this
   }
 
   /**
    * add a condition for propertyPath
    * @param attributePath
    */
-  onlyIfAttribute<K extends keyof T>(attributePath: K): RequestConditionFunctionTyped<R, T, K>
-  onlyIfAttribute(attributePath: string): RequestConditionFunction<R, T>
-  onlyIfAttribute<K extends keyof T>(attributePath: K | string): RequestConditionFunctionTyped<R, T, K> {
-    return addCondition<R, T, any>('ConditionExpression', attributePath, <any>this, this.metadata)
+  onlyIfAttribute<K extends keyof T>(attributePath: K): RequestConditionFunctionTyped<this, T, K>
+  onlyIfAttribute(attributePath: string): RequestConditionFunction<this, T>
+  onlyIfAttribute<K extends keyof T>(attributePath: K | string): RequestConditionFunctionTyped<this, T, K> {
+    return addCondition<this, T, any>('ConditionExpression', attributePath, <any>this, this.metadata)
   }
 
   /**
    * @example writeRequest.onlyIf( attribute('age').eq(23) )
    * @example writeRequest.onlyIf( or( attribute('age').lt(18), attribute('age').gt(65) ) )
    */
-  onlyIf(...conditionDefFns: ConditionExpressionDefinitionFunction[]): R {
+  onlyIf(...conditionDefFns: ConditionExpressionDefinitionFunction[]): this {
     const condition = and(...conditionDefFns)(undefined, this.metadata)
     addExpression('ConditionExpression', condition, this.params)
-    return <any>this
+    return this
   }
 
   /**

src/dynamo/transactwrite/transact-base-operation.ts

@@ -50,29 +50,29 @@ export abstract class TransactBaseOperation<
    * create a condition on given attributePath
    * @example req.onlyIfAttribute('age').lt(10)
    */
-  onlyIfAttribute<K extends keyof T>(attributePath: K): RequestConditionFunctionTyped<R, T, K>
-  onlyIfAttribute(attributePath: string): RequestConditionFunction<R, T>
+  onlyIfAttribute<K extends keyof T>(attributePath: K): RequestConditionFunctionTyped<this, T, K>
+  onlyIfAttribute(attributePath: string): RequestConditionFunction<this, T>
   onlyIfAttribute<K extends keyof T>(
     attributePath: string | K,
-  ): RequestConditionFunction<R, T> | RequestConditionFunctionTyped<R, T, K> {
-    return addCondition<R, T, any>('ConditionExpression', attributePath, <R>(<any>this), this.metadata)
+  ): RequestConditionFunction<this, T> | RequestConditionFunctionTyped<this, T, K> {
+    return addCondition<this, T, any>('ConditionExpression', attributePath, this, this.metadata)
   }
 
   /**
    * add a condition necessary for the transaction to succeed
    * @example req.onlyIf(or(attribute('age').lt(10), attribute('age').gt(20)))
    */
-  onlyIf(...conditionDefFns: ConditionExpressionDefinitionFunction[]): R {
+  onlyIf(...conditionDefFns: ConditionExpressionDefinitionFunction[]): this {
     const condition = and(...conditionDefFns)(undefined, this.metadata)
     addExpression('ConditionExpression', condition, this.params)
-    return <R>(<any>this)
+    return this
   }
 
   /**
    * get the item attributes if the condition fails
    */
-  returnValuesOnConditionCheckFailure(value: DynamoDB.ReturnValuesOnConditionCheckFailure): R {
+  returnValuesOnConditionCheckFailure(value: DynamoDB.ReturnValuesOnConditionCheckFailure): this {
     this.params.ReturnValuesOnConditionCheckFailure = value
-    return <R>(<any>this)
+    return this
   }
 }

src/dynamo/transactwrite/transact-put.ts

@@ -16,7 +16,10 @@ export class TransactPut<T> extends TransactBaseOperation<T, DynamoDB.Put, Trans
     this.params.Item = toDb(item, this.modelClazz)
   }
 
-  ifNotExists(predicate: boolean = true): TransactPut<T> {
+  /**
+   * 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): this {
     if (predicate) {
       this.onlyIf(...createIfNotExistsCondition(this.metadata))
     }

src/dynamo/transactwrite/transact-update.ts

@@ -23,15 +23,15 @@ export class TransactUpdate<T> extends TransactBaseOperation<T, DynamoDB.Update,
    * create and add a single update operation
    * @example updtTrans.updateAttribute('path.to.attr').set('newVal')
    */
-  updateAttribute<K extends keyof T>(attributePath: K): RequestUpdateFunction<TransactUpdate<T>, T, K> {
+  updateAttribute<K extends keyof T>(attributePath: K): RequestUpdateFunction<this, T, K> {
     return addUpdate(attributePath, this, this.metadata)
   }
 
   /**
    * add multiple update ops
    * @example updtTrans.operations(update('path.to.attr).set('newVal'), ... )
    */
-  operations(...updateDefFns: UpdateExpressionDefinitionFunction[]): TransactUpdate<T> {
+  operations(...updateDefFns: UpdateExpressionDefinitionFunction[]): this {
     prepareAndAddUpdateExpressions(this.metadata, this.params, updateDefFns)
     return this
   }

src/dynamo/transactwrite/transact-write.request.ts

@@ -23,20 +23,28 @@ export class TransactWriteRequest {
     }
   }
 
-  returnConsumedCapacity(level: DynamoDB.ReturnConsumedCapacity): TransactWriteRequest {
+  /**
+   * return ConsumedCapacity of the corresponding table(s) in the response
+   */
+  returnConsumedCapacity(level: DynamoDB.ReturnConsumedCapacity): this {
     this.params.ReturnConsumedCapacity = level
     return this
   }
 
   /**
    * return item collection metrics.
    */
-  returnItemCollectionMetrics(returnItemCollectionMetrics: DynamoDB.ReturnItemCollectionMetrics): TransactWriteRequest {
+  returnItemCollectionMetrics(returnItemCollectionMetrics: DynamoDB.ReturnItemCollectionMetrics): this {
     this.params.ReturnItemCollectionMetrics = returnItemCollectionMetrics
     return this
   }
 
-  transact(...writeOperations: TransactOperation[]): TransactWriteRequest {
+  /**
+   * add up to 10 transaction operations
+   * create the operations with:
+   * {@link TransactConditionCheck}, {@link TransactDelete}, {@link TransactPut}, {@link TransactUpdate}
+   */
+  transact(...writeOperations: TransactOperation[]): this {
     if (!writeOperations || writeOperations.length === 0) {
       throw new Error('at least one transaction operation must be added')
     }