feat(updateRequest): add support for fluent condition expression api in update request

Author: michaelwittwer

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

@@ -10,8 +10,8 @@ import { isFunctionOperator } from './functions/is-function-operator.function'
 import { isNoParamFunctionOperator } from './functions/is-no-param-function-operator.function'
 import { operatorParameterArity } from './functions/operator-parameter-arity.function'
 import { uniqAttributeValueName } from './functions/unique-attribute-value-name.function'
-import { ConditionExpression } from './type/condition-expression.type'
 import { ConditionOperator } from './type/condition-operator.type'
+import { Expression } from './type/expression.type'
 
 /**
  * TODO complete doc
@@ -27,15 +27,15 @@ export class ConditionExpressionBuilder {
    * @param {any[]} values Depending on the operator the amount of values differs
    * @param {string[]} existingValueNames If provided the existing names are used to make sure we have a unique name for the current attributePath
    * @param {Metadata<any>} metadata If provided we use the metadata to define the attribute name and use it to map the given value(s) to attributeValue(s)
-   * @returns {ConditionExpression}
+   * @returns {Expression}
    */
   static buildFilterExpression(
     attributePath: string,
     operator: ConditionOperator,
     values: any[],
     existingValueNames: string[] | undefined,
     metadata: Metadata<any> | undefined
-  ): ConditionExpression {
+  ): Expression {
     // TODO investigate is there a use case for undefined desired to be a value
     // get rid of undefined values
     values = values.filter(value => value !== undefined)
@@ -94,7 +94,7 @@ export class ConditionExpressionBuilder {
    * @param {string[]} values
    * @param {string[]} existingValueNames
    * @param {PropertyMetadata<any>} propertyMetadata
-   * @returns {ConditionExpression}
+   * @returns {Expression}
    */
   private static buildInConditionExpression(
     attributePath: string,
@@ -104,7 +104,7 @@ export class ConditionExpressionBuilder {
     values: any[],
     existingValueNames: string[] | undefined,
     propertyMetadata: PropertyMetadata<any> | undefined
-  ): ConditionExpression {
+  ): Expression {
     const mappedValues = Mapper.toDbOne(values[0], propertyMetadata)
 
     const attributeValues: AttributeMap = {}
@@ -125,7 +125,7 @@ export class ConditionExpressionBuilder {
     values: string[],
     existingValueNames: string[] | undefined,
     propertyMetadata: PropertyMetadata<any> | undefined
-  ): ConditionExpression {
+  ): Expression {
     const attributeValues: AttributeMap = {}
     const mappedValue1 = Mapper.toDbOne(values[0], propertyMetadata)
     const mappedValue2 = Mapper.toDbOne(values[1], propertyMetadata)
@@ -156,7 +156,7 @@ export class ConditionExpressionBuilder {
     existingValueNames: string[] | undefined,
     propertyMetadata: PropertyMetadata<any> | undefined,
     operator: ConditionOperator
-  ): ConditionExpression {
+  ): Expression {
     let statement: string
     let hasValue = true
     if (isFunctionOperator(operator)) {

src/dynamo/expression/logical-operator/and.function.ts

@@ -1,5 +1,5 @@
 import { ConditionExpressionDefinitionFunction } from '../type/condition-expression-definition-function'
-import { ConditionExpression } from '../type/condition-expression.type'
+import { Expression } from '../type/expression.type'
 import { mergeConditions } from './merge-conditions.function'
 
 export function and(

src/dynamo/expression/logical-operator/attribute.function.ts

@@ -1,17 +1,14 @@
-import { ExpressionAttributeValueMap } from 'aws-sdk/clients/dynamodb'
-import { curry } from 'lodash'
-import { Metadata } from '../../../decorator/metadata/metadata'
-import { PropertyMetadata } from '../../../decorator/metadata/property-metadata.model'
-import { AttributeType } from '../../../mapper/type/attribute.type'
-import { ConditionExpressionBuilder } from '../condition-expression-builder'
 import { RequestExpressionBuilder } from '../request-expression-builder'
-import { ConditionExpressionChain } from '../type/condition-expression-chain'
 import { ConditionExpressionDefinitionChain } from '../type/condition-expression-definition-chain'
-import { ConditionExpressionDefinitionFunction } from '../type/condition-expression-definition-function'
-import { ConditionExpression } from '../type/condition-expression.type'
-import { ConditionOperator } from '../type/condition-operator.type'
 
+/**
+ * Use this method when accesing a top level attribute of a model
+ */
 export function attribute<T>(attributePath: keyof T): ConditionExpressionDefinitionChain
+
+/**
+ * Use this method when accessing a nested attribute of a model
+ */
 export function attribute(attributePath: string): ConditionExpressionDefinitionChain
 
 export function attribute<T>(attributePath: keyof T): ConditionExpressionDefinitionChain {

src/dynamo/expression/logical-operator/merge-conditions.function.ts

@@ -3,17 +3,14 @@ import { Metadata } from '../../../decorator/metadata/metadata'
 import { ConditionExpressionBuilder } from '../condition-expression-builder'
 import { uniqAttributeValueName } from '../functions/unique-attribute-value-name.function'
 import { ConditionExpressionDefinitionFunction } from '../type/condition-expression-definition-function'
-import { ConditionExpression } from '../type/condition-expression.type'
+import { Expression } from '../type/expression.type'
 
 export function mergeConditions(
   operator: 'AND' | 'OR',
   conditionDefinitionFns: ConditionExpressionDefinitionFunction[]
 ): ConditionExpressionDefinitionFunction {
-  return (
-    expressionAttributeValues: string[] | undefined,
-    metadata: Metadata<any> | undefined
-  ): ConditionExpression => {
-    const mergedCondition: ConditionExpression = {
+  return (expressionAttributeValues: string[] | undefined, metadata: Metadata<any> | undefined): Expression => {
+    const mergedCondition: Expression = {
       statement: '',
       attributeNames: {},
       attributeValues: {},

src/dynamo/expression/logical-operator/not.function.ts

@@ -1,15 +1,12 @@
 import { Metadata } from '../../../decorator/metadata/metadata'
 import { ConditionExpressionDefinitionFunction } from '../type/condition-expression-definition-function'
-import { ConditionExpression } from '../type/condition-expression.type'
+import { Expression } from '../type/expression.type'
 import { mergeConditions } from './merge-conditions.function'
 
 export function not(
   conditionDefinitionFn: ConditionExpressionDefinitionFunction
 ): ConditionExpressionDefinitionFunction {
-  return (
-    expressionAttributeValues: string[] | undefined,
-    metadata: Metadata<any> | undefined
-  ): ConditionExpression => {
+  return (expressionAttributeValues: string[] | undefined, metadata: Metadata<any> | undefined): Expression => {
     const condition = conditionDefinitionFn(expressionAttributeValues, metadata)
     condition.statement = `NOT ${condition.statement}`
     return condition

src/dynamo/expression/logical-operator/or.function.ts

@@ -1,5 +1,5 @@
 import { ConditionExpressionDefinitionFunction } from '../type/condition-expression-definition-function'
-import { ConditionExpression } from '../type/condition-expression.type'
+import { Expression } from '../type/expression.type'
 import { mergeConditions } from './merge-conditions.function'
 
 export function or(

src/dynamo/expression/logical-operator/update.function.ts

@@ -0,0 +1,16 @@
+/**
+ * Use this method when accesing a top level attribute of a model
+ */
+import { RequestExpressionBuilder } from '../request-expression-builder'
+import { UpdateExpressionDefinitionChain } from '../type/update-expression-definition-chain'
+
+export function update<T>(attributePath: keyof T): UpdateExpressionDefinitionChain
+
+/**
+ * Use this method when accessing a nested attribute of a model
+ */
+export function update(attributePath: string): UpdateExpressionDefinitionChain
+
+export function update<T>(attributePath: keyof T): UpdateExpressionDefinitionChain {
+  return RequestExpressionBuilder.updateDefinitionFunction<T>(attributePath)
+}

src/dynamo/expression/param-util.ts

@@ -3,14 +3,16 @@ import {
   ExpressionAttributeValueMap,
   QueryInput,
   ScanInput,
+  UpdateItemInput,
 } from 'aws-sdk/clients/dynamodb'
 import { isEmpty, isString } from 'lodash'
-import { ConditionExpression } from './type/condition-expression.type'
+import { UpdateRequest } from '../request/update/update.request'
+import { Expression } from './type/expression.type'
 
 export class ParamUtil {
   static addExpression(
     expressionType: 'ConditionExpression' | 'KeyConditionExpression' | 'FilterExpression',
-    condition: ConditionExpression,
+    condition: Expression,
     params: QueryInput | ScanInput
   ) {
     const expressionAttributeNames = <ExpressionAttributeNameMap>{
@@ -41,4 +43,35 @@ export class ParamUtil {
       ;(<any>params)[expressionType] = condition.statement
     }
   }
+
+  static addUpdateExpression(updateExpression: Expression, params: UpdateItemInput) {
+    const expressionType = 'UpdateExpression'
+    // FIXME refactor remove duplicate code
+    const expressionAttributeNames = <ExpressionAttributeNameMap>{
+      ...updateExpression.attributeNames,
+      ...params.ExpressionAttributeNames,
+    }
+
+    const expressionAttributeValues = <ExpressionAttributeValueMap>{
+      ...updateExpression.attributeValues,
+      ...params.ExpressionAttributeValues,
+    }
+
+    if (!isEmpty(expressionAttributeNames)) {
+      params.ExpressionAttributeNames = expressionAttributeNames
+    }
+
+    if (!isEmpty(expressionAttributeValues)) {
+      params.ExpressionAttributeValues = expressionAttributeValues
+    }
+
+    const expression = Reflect.get(params, expressionType)
+    if (isString(expression) && expression !== '') {
+      throw new Error(
+        'params.UpdateExpression is not empty, please use the UpdateRequest.operations() method to define all the update operations'
+      )
+    } else {
+      ;(<any>params)[expressionType] = updateExpression.statement
+    }
+  }
 }

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

@@ -1,18 +1,22 @@
 import { curry } from 'lodash'
 import { Metadata } from '../../decorator/metadata/metadata'
-import { PropertyMetadata } from '../../decorator/metadata/property-metadata.model'
 import { BaseRequest } from '../request/base.request'
 import { ConditionExpressionBuilder } from './condition-expression-builder'
 import { ParamUtil } from './param-util'
 import { ConditionExpressionDefinitionChain } from './type/condition-expression-definition-chain'
 import { ConditionExpressionDefinitionFunction } from './type/condition-expression-definition-function'
-import { ConditionExpression } from './type/condition-expression.type'
 import { OperatorAlias } from './type/condition-operator-alias.type'
 import { OPERATOR_TO_ALIAS_MAP } from './type/condition-operator-to-alias-map.const'
 import { ConditionOperator } from './type/condition-operator.type'
 import { ExpressionType } from './type/expression-type.type'
+import { Expression } from './type/expression.type'
 import { RequestConditionFunction } from './type/request-condition-function'
 import { RequestSortKeyConditionFunction } from './type/sort-key-condition-function'
+import { UpdateAction, UpdateActionDef } from './type/update-action.type'
+import { UpdateExpressionDefinitionChain } from './type/update-expression-definition-chain'
+import { UpdateExpressionDefinitionFunction } from './type/update-expression-definition-function'
+import { UpdateExpression } from './type/update-expression.type'
+import { UpdateExpressionBuilder } from './update-expression-builder'
 
 /**
  *
@@ -98,11 +102,35 @@ export class RequestExpressionBuilder {
     return RequestExpressionBuilder.addSortKeyCondition(keyName, request, metadata).equals(keyValue)
   }
 
+  // FIXME attributePath could also be a simple string for nested paths
+  static updateDefinitionFunction(attributePath: string): UpdateExpressionDefinitionChain
+  static updateDefinitionFunction<T>(attributePath: keyof T): UpdateExpressionDefinitionChain
+
+  static updateDefinitionFunction<T>(attributePath: keyof T): UpdateExpressionDefinitionChain {
+    const f = (operation: UpdateActionDef) => {
+      return (...values: any[]): UpdateExpressionDefinitionFunction => {
+        const copy = [...values]
+        const curried = curry<
+          string,
+          UpdateActionDef,
+          any[],
+          string[] | undefined,
+          Metadata<any> | undefined,
+          UpdateExpression
+        >(UpdateExpressionBuilder.buildUpdateExpression)
+
+        return curried(attributePath, operation, copy)
+      }
+    }
+
+    return RequestExpressionBuilder.createUpdateFunctions<UpdateExpressionDefinitionChain>(f)
+  }
+
   static propertyDefinitionFunction<T>(attributePath: keyof T): ConditionExpressionDefinitionChain {
     const f = (operator: ConditionOperator) => {
       return (...values: any[]): ConditionExpressionDefinitionFunction => {
         const copy = [...values]
-        const curried = curry<string, ConditionOperator, any[], string[], Metadata<any>, ConditionExpression>(
+        const curried = curry<string, ConditionOperator, any[], string[], Metadata<any>, Expression>(
           ConditionExpressionBuilder.buildFilterExpression
         )
         return curried(attributePath, operator, copy)
@@ -112,6 +140,30 @@ export class RequestExpressionBuilder {
     return RequestExpressionBuilder.createConditionFunctions<ConditionExpressionDefinitionChain>(f)
   }
 
+  /**
+   * Creates an object which contains callable functions for all update operations defined in update-operation type
+   * for all the values included in operators
+   *
+   * @param {(operator: ConditionOperator) => any} impl The function which is called with the operator and returns a function which expects the value
+   * for the condition. when executed the implementation defines what todo with the condition, just return it for example or add the condition to the request
+   * parameters as another example
+   */
+  private static createUpdateFunctions<T>(impl: (operation: UpdateActionDef) => any): T {
+    // FIXME add all operators
+    return <T>[
+      new UpdateActionDef('SET', 'incrementBy'),
+      new UpdateActionDef('SET', 'decrementBy'),
+      new UpdateActionDef('SET', 'set'),
+    ].reduce(
+      (result: T, updateActionDef: UpdateActionDef) => {
+        Reflect.set(<any>result, updateActionDef.action, impl(updateActionDef))
+
+        return result
+      },
+      <T>{}
+    )
+  }
+
   /**
    * Creates an object which contains callable functions for all aliases defined in CONDITION_OPERATOR_ALIAS or if operators parameter is defined,
    * for all the values included in operators

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

@@ -1,20 +1,20 @@
 import { AttributeType } from '../../../mapper/type/attribute.type'
-import { ConditionExpression } from './condition-expression.type'
+import { Expression } from './expression.type'
 
 export interface ConditionExpressionChain {
-  equals: (value: any) => ConditionExpression
-  eq: (value: any) => ConditionExpression
-  ne: (value: any) => ConditionExpression
-  lte: (value: any) => ConditionExpression
-  lt: (value: any) => ConditionExpression
-  gte: (value: any) => ConditionExpression
-  gt: (value: any) => ConditionExpression
-  null: () => ConditionExpression
-  notNull: () => ConditionExpression
-  contains: (value: any) => ConditionExpression
-  notContains: (value: any) => ConditionExpression
-  type: (value: AttributeType) => ConditionExpression
-  in: (value: any[]) => ConditionExpression
-  beginsWith: (value: any) => ConditionExpression
-  between: (value1: any, value2: any) => ConditionExpression
+  equals: (value: any) => Expression
+  eq: (value: any) => Expression
+  ne: (value: any) => Expression
+  lte: (value: any) => Expression
+  lt: (value: any) => Expression
+  gte: (value: any) => Expression
+  gt: (value: any) => Expression
+  null: () => Expression
+  notNull: () => Expression
+  contains: (value: any) => Expression
+  notContains: (value: any) => Expression
+  type: (value: AttributeType) => Expression
+  in: (value: any[]) => Expression
+  beginsWith: (value: any) => Expression
+  between: (value1: any, value2: any) => Expression
 }