fix(requests): allow attributePath for onlyIfAttribute, whereAttribute

Author: mumenthalers

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

@@ -8,7 +8,7 @@ import { prepareAndAddUpdateExpressions } from './prepare-and-add-update-express
 import {
   ConditionExpressionDefinitionChain,
   ConditionExpressionDefinitionChainTyped,
-  RequestConditionFunction,
+  RequestConditionFunctionTyped,
 } from './type/condition-expression-definition-chain'
 import { ConditionExpressionDefinitionFunction } from './type/condition-expression-definition-function'
 import { OperatorAlias } from './type/condition-operator-alias.type'
@@ -66,24 +66,21 @@ export function addUpdate<R extends UpdateParamsHost, T, K extends keyof T>(
 /**
  * return the condition-functions which then can apply a conditionDefinition to the given request.params
  * and afterwards will return the request object (which allows chaining)
- * @param attributePath
- * @param request
- * @param metadata
  */
 export function addCondition<R extends ConditionalParamsHost, T, K extends keyof T>(
   expressionType: ExpressionType,
   attributePath: K,
   request: R,
   metadata?: Metadata<T>,
-): RequestConditionFunction<R, T, K> {
+): RequestConditionFunctionTyped<R, T, K> {
   // f the function to create the condition functions
   const f = (operator: ConditionOperator) => {
     // return the function the user will call in the end
     return (...values: any[]): R => {
       return doAddCondition(expressionType, <string>attributePath, request, metadata, operator, ...values)
     }
   }
-  return createConditionFunctions<RequestConditionFunction<R, T, K>>(f)
+  return createConditionFunctions<RequestConditionFunctionTyped<R, T, K>>(f)
 }
 
 export function addSortKeyCondition<R extends ConditionalParamsHost>(

src/dynamo/expression/type/condition-expression-definition-chain.ts

@@ -28,12 +28,8 @@ interface ConditionFunctions<T, R> {
 
 export type ConditionExpressionDefinitionChain = ConditionFunctions<any, ConditionExpressionDefinitionFunction>
 
-export type ConditionExpressionDefinitionChainTyped<T, K extends keyof T> = ConditionFunctions<
-  T[K],
-  ConditionExpressionDefinitionFunction
->
+export type ConditionExpressionDefinitionChainTyped<T, K extends keyof T> = ConditionFunctions<T[K],
+  ConditionExpressionDefinitionFunction>
 
-export type RequestConditionFunction<R extends ConditionalParamsHost, T, K extends keyof T> = ConditionFunctions<
-  T[K],
-  R
->
+export type RequestConditionFunctionTyped<R extends ConditionalParamsHost, T, K extends keyof T> = ConditionFunctions<T[K], R>
+export type RequestConditionFunction<R extends ConditionalParamsHost, T> = ConditionFunctions<any, R>

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

@@ -10,7 +10,10 @@ import { DynamoDbWrapper } from '../dynamo-db-wrapper'
 import { and } from '../expression/logical-operator/and.function'
 import { addExpression } from '../expression/param-util'
 import { addCondition } from '../expression/request-expression-builder'
-import { RequestConditionFunction } from '../expression/type/condition-expression-definition-chain'
+import {
+  RequestConditionFunction,
+  RequestConditionFunctionTyped,
+} from '../expression/type/condition-expression-definition-chain'
 import { ConditionExpressionDefinitionFunction } from '../expression/type/condition-expression-definition-function'
 import { QueryRequest } from './query/query.request'
 import { QueryResponse } from './query/query.response'
@@ -86,8 +89,17 @@ export abstract class ReadManyRequest<T,
     return <any>this
   }
 
-  whereAttribute<K extends keyof T>(attributePath: K): RequestConditionFunction<R, T, K> {
-    return addCondition('FilterExpression', attributePath, <any>this, this.metadata)
+
+  /**
+   * add a condition for propertyPath
+   * @param attributePath
+   */
+  whereAttribute<K extends keyof T>(attributePath: K): RequestConditionFunctionTyped<R, T, K>
+  whereAttribute(attributePath: string): RequestConditionFunction<R, T>
+  whereAttribute<K extends keyof T>(attributePath: string | K): RequestConditionFunction<R, T> | RequestConditionFunctionTyped<R, T, K>
+
+  {
+    return addCondition<R, T, any>('FilterExpression', attributePath, <any>this, this.metadata)
   }
 
   where(...conditionDefFns: ConditionExpressionDefinitionFunction[]): R {

src/dynamo/request/write.request.ts

@@ -8,7 +8,10 @@ import { DynamoDbWrapper } from '../dynamo-db-wrapper'
 import { and } from '../expression/logical-operator/public.api'
 import { addExpression } from '../expression/param-util'
 import { addCondition } from '../expression/request-expression-builder'
-import { RequestConditionFunction } from '../expression/type/condition-expression-definition-chain'
+import {
+  RequestConditionFunction,
+  RequestConditionFunctionTyped,
+} from '../expression/type/condition-expression-definition-chain'
 import { ConditionExpressionDefinitionFunction } from '../expression/type/condition-expression-definition-function'
 import { StandardRequest } from './standard.request'
 
@@ -31,8 +34,14 @@ export abstract class WriteRequest<T,
     return <R>(<any>this)
   }
 
-  onlyIfAttribute<K extends keyof T>(attributePath: K): RequestConditionFunction<R, T, K> {
-    return addCondition<R, T, K>('ConditionExpression', attributePath, <any>this, this.metadata)
+  /**
+   * 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)
   }
 
   /**

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

@@ -5,16 +5,17 @@ import { ModelConstructor } from '../../model/model-constructor'
 import { and } from '../expression/logical-operator/and.function'
 import { addExpression } from '../expression/param-util'
 import { addCondition } from '../expression/request-expression-builder'
-import { RequestConditionFunction } from '../expression/type/condition-expression-definition-chain'
+import {
+  RequestConditionFunction,
+  RequestConditionFunctionTyped,
+} from '../expression/type/condition-expression-definition-chain'
 import { ConditionExpressionDefinitionFunction } from '../expression/type/condition-expression-definition-function'
 import { getTableName } from '../get-table-name.function'
 import { ConditionalParamsHost } from '../operation-params.type'
 
-export abstract class TransactBaseOperation<
-  T,
+export abstract class TransactBaseOperation<T,
   I extends DynamoDB.ConditionCheck | DynamoDB.Put | DynamoDB.Update | DynamoDB.Delete,
-  R extends TransactBaseOperation<T, I, any>
-> implements ConditionalParamsHost {
+  R extends TransactBaseOperation<T, I, any>> implements ConditionalParamsHost {
   readonly params: I
   readonly metadata: Metadata<T>
   readonly modelClazz: ModelConstructor<T>
@@ -37,8 +38,10 @@ export abstract class TransactBaseOperation<
     }
   }
 
-  onlyIfAttribute<K extends keyof T>(attributePath: K): RequestConditionFunction<R, T, K> {
-    return addCondition('ConditionExpression', attributePath, <R>(<any>this), this.metadata)
+  onlyIfAttribute<K extends keyof T>(attributePath: K): RequestConditionFunctionTyped<R, T, K>
+  onlyIfAttribute(attributePath: string): RequestConditionFunction<R, 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)
   }
 
   onlyIf(...conditionDefFns: ConditionExpressionDefinitionFunction[]): R {