add ability to refrence context on right hand side of expressions (#21)

regevbr · web-flow · commit 5ad068ee6e86 · 2022-08-29T14:32:14.000+03:00
diff --git a/README.md b/README.md
@@ -37,6 +37,7 @@ interface IExampleContext {
     date: Moment;
     nested: {
         value: number | null;
+        value4: number;
         nested2: {
             value2?: number;
             value3: boolean;
@@ -58,6 +59,7 @@ const context: IExampleContext = {
     date: moment(),
     nested: {
         value: null,
+        value4: 5,
         nested2: {
             value3: true,
         },
@@ -71,6 +73,7 @@ const validationContext: ValidationContext<IExampleContext, IExampleContextIgnor
     date: moment(),
     nested: {
         value: 5,
+        value4: 6,
         nested2: {
             value2: 6,
             value3: true,
@@ -97,6 +100,13 @@ const expression: IExampleExpression = {
                 {
                     'nested.nested2.value3': true,
                 },
+                {
+                    times: {
+                        lte: {
+                            ref: 'nested.value4'
+                        }
+                    },
+                },
             ],
         },
     ],
@@ -136,9 +146,13 @@ There are 4 types of operators you can use (evaluated in that order of precedenc
             - `between: readonly [number, number] (as const)` - True if the value is between the two specified values: greater than or equal to first value and less than or equal to second value.
     - `{property: value}`
         - compares the property to that value (shorthand to the `eq` op)
+
 > Nested properties in the context can also be accessed using a dot notation (see example above)
 > In each expression level, you can only define 1 operator, and 1 only
 
+> You can reference values (and nested values) from the context using the {"ref":"<dot notation path>"}
+> (see example above) on the right-hand side of expressions (not in parameters to user defined functions though)
+
 Example expressions, assuming we have the `user` and `maxCount` user defined functions in place can be:
 ```json
 {  
@@ -154,6 +168,9 @@ Example expressions, assuming we have the `user` and `maxCount` user defined fun
       {  
          "times": { "eq" : 5}
       },
+      {  
+         "times": { "eq" : { "ref": "nested.preoprty"}}
+      },
       {  
          "country": "USA"
       }
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "json-expression-eval",
-  "version": "4.2.1",
+  "version": "4.3.0",
   "description": "json serializable rule engine / boolean expression evaluator",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
diff --git a/src/examples/engine/example.ts b/src/examples/engine/example.ts
@@ -49,6 +49,7 @@ rules = [
       and: [
         {user: 'a@b.com'},
         {maxCount: 5},
+        {times: {eq:{ref:'nested.value'}}},
       ],
     },
     consequence: {
diff --git a/src/examples/evaluator/example.ts b/src/examples/evaluator/example.ts
@@ -36,6 +36,15 @@ expression = {
 
 run(expression, context);
 
+expression = {
+    and: [
+        {user: 'a@b.com'},
+        {times: {eq:{ref:'nested.value'}}},
+    ],
+};
+
+run(expression, context);
+
 expression = {
     and: [
         {user: 'a@b.com'},
diff --git a/src/lib/evaluator.ts b/src/lib/evaluator.ts
@@ -22,7 +22,7 @@ import {
     FunctionsTable,
     ExtendedCompareOp,
     ValidationContext,
-    PropertyCompareOps
+    PropertyCompareOps, Primitive
 } from '../types';
 import {
     assertUnreachable,
@@ -34,7 +34,27 @@ import {
     expressionNumberAssertion
 } from './helpers';
 
-function evaluateCompareOp(expressionValue: ExtendedCompareOp, expressionKey: string, contextValue: any): boolean {
+type WithRef = {
+    ref: string
+}
+
+const isWithRef = (x: unknown): x is WithRef => Boolean((x as WithRef).ref);
+
+const extractValueOrRef = <C extends Context>(context: C, validation: boolean, valueOrRef: Primitive | WithRef) => {
+    if (isWithRef(valueOrRef)) {
+        const {value, exists} = getFromPath(context, valueOrRef.ref);
+        if (validation && !exists) {
+            throw new Error(`Invalid expression - unknown context key ${valueOrRef.ref}`);
+        }
+        return value;
+    } else {
+        return valueOrRef;
+    }
+}
+
+function evaluateCompareOp<C extends Context>(expressionValue: ExtendedCompareOp<any, any, any>, expressionKey: string,
+                                              contextValue: any, context: C, validation: boolean)
+    : boolean {
     if (!_isObject(expressionValue)) {
         return contextValue === expressionValue;
     }
@@ -43,46 +63,55 @@ function evaluateCompareOp(expressionValue: ExtendedCompareOp, expressionKey: st
         throw new Error('Invalid expression - too may keys');
     }
     if (isEqualCompareOp(expressionValue)) {
-        return contextValue === expressionValue.eq;
+        return contextValue === extractValueOrRef(context, validation, expressionValue.eq);
     } else if (isNotEqualCompareOp(expressionValue)) {
-        return contextValue !== expressionValue.neq;
+        return contextValue !== extractValueOrRef(context, validation, expressionValue.neq);
     } else if (isInqCompareOp(expressionValue)) {
-        return expressionValue.inq.indexOf(contextValue) >= 0;
+        return expressionValue.inq.map((value) => extractValueOrRef(context, validation, value))
+            .indexOf(contextValue) >= 0;
     } else if (isNinCompareOp(expressionValue)) {
-        return expressionValue.nin.indexOf(contextValue) < 0;
+        return expressionValue.nin.map((value) => extractValueOrRef(context, validation, value))
+            .indexOf(contextValue) < 0;
     } else if (isRegexCompareOp(expressionValue)) {
         contextStringAssertion(expressionKey, contextValue);
-        expressionStringAssertion(expressionKey, expressionValue.regexp);
-        return Boolean(contextValue.match(new RegExp(expressionValue.regexp)));
+        const regexpValue = extractValueOrRef(context, validation, expressionValue.regexp);
+        expressionStringAssertion(expressionKey, regexpValue);
+        return Boolean(contextValue.match(new RegExp(regexpValue)));
     } else if (isRegexiCompareOp(expressionValue)) {
         contextStringAssertion(expressionKey, contextValue);
-        expressionStringAssertion(expressionKey, expressionValue.regexpi);
-        return Boolean(contextValue.match(new RegExp(expressionValue.regexpi, `i`)));
+        const regexpiValue = extractValueOrRef(context, validation, expressionValue.regexpi);
+        expressionStringAssertion(expressionKey, regexpiValue);
+        return Boolean(contextValue.match(new RegExp(regexpiValue, `i`)));
     } else if (isGtCompareOp(expressionValue)) {
         contextNumberAssertion(expressionKey, contextValue);
-        expressionNumberAssertion(expressionKey, expressionValue.gt);
-        return contextValue > expressionValue.gt;
+        const gtValue = extractValueOrRef(context, validation, expressionValue.gt);
+        expressionNumberAssertion(expressionKey, gtValue);
+        return contextValue > gtValue;
     } else if (isGteCompareOp(expressionValue)) {
         contextNumberAssertion(expressionKey, contextValue);
-        expressionNumberAssertion(expressionKey, expressionValue.gte);
-        return contextValue >= expressionValue.gte;
+        const gteValue = extractValueOrRef(context, validation, expressionValue.gte);
+        expressionNumberAssertion(expressionKey, gteValue);
+        return contextValue >= gteValue;
     } else if (isLteCompareOp(expressionValue)) {
         contextNumberAssertion(expressionKey, contextValue);
-        expressionNumberAssertion(expressionKey, expressionValue.lte);
-        return contextValue <= expressionValue.lte;
+        const lteValue = extractValueOrRef(context, validation, expressionValue.lte);
+        expressionNumberAssertion(expressionKey, lteValue);
+        return contextValue <= lteValue;
     } else if (isLtCompareOp(expressionValue)) {
         contextNumberAssertion(expressionKey, contextValue);
-        expressionNumberAssertion(expressionKey, expressionValue.lt);
-        return contextValue < expressionValue.lt;
+        const ltValue = extractValueOrRef(context, validation, expressionValue.lt);
+        expressionNumberAssertion(expressionKey, ltValue);
+        return contextValue < ltValue;
     } else if (isBetweenCompareOp(expressionValue)) {
         contextNumberAssertion(expressionKey, contextValue);
         if (expressionValue.between.length !== 2) {
             throw new Error(`Invalid expression - ${expressionKey}.length must be 2`);
         }
-        expressionValue.between.forEach((value, ind) => {
-            expressionNumberAssertion(`${expressionKey}[${ind}]`, value);
-        });
-        const [low, high] = expressionValue.between;
+        const [lowRaw, highRaw] = expressionValue.between;
+        const low = extractValueOrRef(context, validation, lowRaw);
+        const high = extractValueOrRef(context, validation, highRaw);
+        expressionNumberAssertion(`${expressionKey}[0]`, low);
+        expressionNumberAssertion(`${expressionKey}[1]`, high);
         if (low > high) {
             throw new Error(`Invalid expression - ${expressionKey} first value is higher than second value`);
         }
@@ -140,10 +169,11 @@ function run<C extends Context, F extends FunctionsTable<C>, Ignore>
         if (validation && !exists) {
             throw new Error(`Invalid expression - unknown context key ${expressionKey}`);
         }
-        return evaluateCompareOp(
+        return evaluateCompareOp<C>(
             (expression as PropertyCompareOps<C, Ignore>)
-                [expressionKey as any as keyof PropertyCompareOps<C, Ignore>] as ExtendedCompareOp,
-            expressionKey, contextValue);
+                [expressionKey as any as keyof PropertyCompareOps<C, Ignore>] as
+                unknown as ExtendedCompareOp<any, any, any>,
+            expressionKey, contextValue, context, validation);
     }
 }
 
diff --git a/src/lib/typeGuards.ts b/src/lib/typeGuards.ts
@@ -12,94 +12,94 @@ import {
     RegexiCompareOp,
     NotCompareOp,
     NotEqualCompareOp,
-    OrCompareOp, InqCompareOp, NinCompareOp, RuleFunctionsTable, RuleFunctionsParams
-  } from '../types';
+    OrCompareOp, InqCompareOp, NinCompareOp, RuleFunctionsTable, RuleFunctionsParams, Primitive
+} from '../types';
 
-  export const _isObject = (obj: unknown): boolean => {
+export const _isObject = (obj: unknown): boolean => {
     const type = typeof obj;
     return type === 'function' || type === 'object' && !!obj;
-  };
+};
 
-  export const isFunctionCompareOp =
+export const isFunctionCompareOp =
     <C extends Context, F extends FunctionsTable<C>, Ignore>(expression: unknown, functionsTable: F, key: string):
-      expression is FuncCompares<C, F> => {
-      return key in functionsTable;
+        expression is FuncCompares<C, F> => {
+        return key in functionsTable;
     }
 
-  export const isRuleFunction =
+export const isRuleFunction =
     <ConsequencePayload, C extends Context, RF extends RuleFunctionsTable<C, ConsequencePayload>>(
-      expression: unknown, ruleFunctionsTable: RF, key: string):
-      expression is RuleFunctionsParams<ConsequencePayload, C, RF> => {
-      return key in ruleFunctionsTable;
+        expression: unknown, ruleFunctionsTable: RF, key: string):
+        expression is RuleFunctionsParams<ConsequencePayload, C, RF> => {
+        return key in ruleFunctionsTable;
     }
 
-  export const isAndCompareOp =
+export const isAndCompareOp =
     <C extends Context, F extends FunctionsTable<C>, Ignore>(expression: unknown):
-      expression is AndCompareOp<C, F, Ignore> => {
-      return Array.isArray((expression as AndCompareOp<C, F, Ignore>).and);
+        expression is AndCompareOp<C, F, Ignore> => {
+        return Array.isArray((expression as AndCompareOp<C, F, Ignore>).and);
     }
 
-  export const isOrCompareOp = <C extends Context, F extends FunctionsTable<C>, Ignore>(expression: unknown):
+export const isOrCompareOp = <C extends Context, F extends FunctionsTable<C>, Ignore>(expression: unknown):
     expression is OrCompareOp<C, F, Ignore> => {
     return Array.isArray((expression as OrCompareOp<C, F, Ignore>).or);
-  }
+}
 
-  export const isNotCompareOp = <C extends Context, F extends FunctionsTable<C>, Ignore>(expression: unknown):
+export const isNotCompareOp = <C extends Context, F extends FunctionsTable<C>, Ignore>(expression: unknown):
     expression is NotCompareOp<C, F, Ignore> => {
     return _isObject((expression as NotCompareOp<C, F, Ignore>).not);
-  }
-
-  export const isBetweenCompareOp = (op: ExtendedCompareOp)
-    : op is BetweenCompareOp => {
-    return Array.isArray((op as BetweenCompareOp).between);
-  }
-
-  export const isGtCompareOp = (op: ExtendedCompareOp)
-    : op is GtCompareOp => {
-    return (op as GtCompareOp).gt !== undefined;
-  }
-
-  export const isGteCompareOp = (op: ExtendedCompareOp)
-    : op is GteCompareOp => {
-    return (op as GteCompareOp).gte !== undefined;
-  }
-
-  export const isLteCompareOp = (op: ExtendedCompareOp)
-    : op is LteCompareOp => {
-    return (op as LteCompareOp).lte !== undefined;
-  }
-
-  export const isLtCompareOp = (op: ExtendedCompareOp)
-    : op is LtCompareOp => {
-    return (op as LtCompareOp).lt !== undefined;
-  }
-
-  export const isRegexCompareOp = (op: ExtendedCompareOp)
-    : op is RegexCompareOp => {
-    return (op as RegexCompareOp).regexp !== undefined;
-  }
-
-  export const isRegexiCompareOp = (op: ExtendedCompareOp)
-    : op is RegexiCompareOp => {
-    return (op as RegexiCompareOp).regexpi !== undefined;
-  }
-
-  export const isEqualCompareOp = <V>(op: ExtendedCompareOp)
-    : op is EqualCompareOp<V> => {
-    return (op as EqualCompareOp<V>).eq !== undefined;
-  }
-
-  export const isNotEqualCompareOp = <V>(op: ExtendedCompareOp)
-    : op is NotEqualCompareOp<V> => {
-    return (op as NotEqualCompareOp<V>).neq !== undefined;
-  }
-
-  export const isInqCompareOp = <V>(op: ExtendedCompareOp)
-    : op is InqCompareOp<V> => {
-    return Array.isArray((op as InqCompareOp<V>).inq);
-  }
-
-  export const isNinCompareOp = <V>(op: ExtendedCompareOp)
-    : op is NinCompareOp<V> => {
-    return Array.isArray((op as NinCompareOp<V>).nin);
-  }
+}
+
+export const isBetweenCompareOp = (op: ExtendedCompareOp<any, any, any>)
+    : op is BetweenCompareOp<any, any> => {
+    return Array.isArray((op as BetweenCompareOp<any, any>).between);
+}
+
+export const isGtCompareOp = (op: ExtendedCompareOp<any, any, any>)
+    : op is GtCompareOp<any, any> => {
+    return (op as GtCompareOp<any, any>).gt !== undefined;
+}
+
+export const isGteCompareOp = (op: ExtendedCompareOp<any, any, any>)
+    : op is GteCompareOp<any, any> => {
+    return (op as GteCompareOp<any, any>).gte !== undefined;
+}
+
+export const isLteCompareOp = (op: ExtendedCompareOp<any, any, any>)
+    : op is LteCompareOp<any, any> => {
+    return (op as LteCompareOp<any, any>).lte !== undefined;
+}
+
+export const isLtCompareOp = (op: ExtendedCompareOp<any, any, any>)
+    : op is LtCompareOp<any, any> => {
+    return (op as LtCompareOp<any, any>).lt !== undefined;
+}
+
+export const isRegexCompareOp = (op: ExtendedCompareOp<any, any, any>)
+    : op is RegexCompareOp<any, any> => {
+    return (op as RegexCompareOp<any, any>).regexp !== undefined;
+}
+
+export const isRegexiCompareOp = (op: ExtendedCompareOp<any, any, any>)
+    : op is RegexiCompareOp<any, any> => {
+    return (op as RegexiCompareOp<any, any>).regexpi !== undefined;
+}
+
+export const isEqualCompareOp = (op: ExtendedCompareOp<any, any, any>)
+    : op is EqualCompareOp<any, any, any> => {
+    return (op as EqualCompareOp<any, any, any>).eq !== undefined;
+}
+
+export const isNotEqualCompareOp = (op: ExtendedCompareOp<any, any, any>)
+    : op is NotEqualCompareOp<any, any, any> => {
+    return (op as NotEqualCompareOp<any, any, any>).neq !== undefined;
+}
+
+export const isInqCompareOp = (op: ExtendedCompareOp<any, any, any>)
+    : op is InqCompareOp<any, any, any> => {
+    return Array.isArray((op as InqCompareOp<any, any, any>).inq);
+}
+
+export const isNinCompareOp = (op: ExtendedCompareOp<any, any, any>)
+    : op is NinCompareOp<any, any, any> => {
+    return Array.isArray((op as NinCompareOp<any, any, any>).nin);
+}
diff --git a/src/test/evaluator.spec.ts b/src/test/evaluator.spec.ts
diff --git a/src/test/types/evaluator.test-d.ts b/src/test/types/evaluator.test-d.ts
diff --git a/src/types/evaluator.ts b/src/types/evaluator.ts

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "json-expression-eval",`
`3`		`- "version": "4.2.1",`
	`3`	`+ "version": "4.3.0",`
`4`	`4`	`"description": "json serializable rule engine / boolean expression evaluator",`
`5`	`5`	`"main": "dist/index.js",`
`6`	`6`	`"types": "dist/index.d.ts",`