feat: First approach to compare two fields in the same object

Author: Marco Franceschi

src/rules-engine/evaluators/json-evaluator.ts

@@ -12,6 +12,7 @@ import {
 } from '../types'
 import { RuleEvaluator } from './rule-evaluator'
 import AdditionalOperators from '../operators'
+import ComparisonOperators from '../operators/comparison'
 
 export default class JsonEvaluator implements RuleEvaluator<JsonRule> {
   canEvaluate(rule: JsonRule): boolean {
@@ -124,14 +125,25 @@ export default class JsonEvaluator implements RuleEvaluator<JsonRule> {
     // remaining field should be the op name
     const op = Object.keys(condition)[0] //
     const operator = this.operators[op]
-    const otherArgs = condition[op] // {[and]: xxx }
+    let otherArgs = condition[op] // {[and]: xxx }
     if (!op || !operator) {
       throw new Error(`unrecognized operation${JSON.stringify(condition)}`)
     }
 
     const data = { ..._data }
     let firstArg
 
+    if (
+      Object.keys(ComparisonOperators).includes(operator.name) &&
+      this.isCondition(otherArgs) &&
+      otherArgs.path
+    ) {
+      const otherData = { ..._data }
+      const elementPath = this.calculatePath(otherData, otherArgs.path)
+      otherData.elementPath = elementPath
+      otherArgs = this.resolvePath(otherData, elementPath)
+    }
+
     if (path) {
       const elementPath = this.calculatePath(data, path)
       data.elementPath = elementPath

tests/json-evaluator.test.ts

@@ -421,4 +421,42 @@ describe('JsonEvaluator', () => {
 
     expect(finding.result).toBe(Result.PASS)
   })
+
+  test('Should passed using the same value for the equal operator with the same path', async () => {
+    const data = {
+      data: { a: { b: [0, { e: 'same value', d: 'same value' }] } },
+    }
+    const rule = { path: 'a.b[1].d', equal: { path: 'a.b[1].e' } }
+
+    const finding = await evaluator.evaluateSingleResource(
+      {
+        conditions: rule,
+        resource: {
+          id: cuid(),
+        },
+      } as any,
+      data
+    )
+
+    expect(finding.result).toBe(Result.PASS)
+  })
+
+  test('Should failed using two different values for the equal operator', async () => {
+    const data = {
+      data: { a: { b: [0, { e: 'not the same', d: 'value' }] } },
+    }
+    const rule = { path: 'a.b[1].d', equal: { path: 'a.b[1].e' } }
+
+    const finding = await evaluator.evaluateSingleResource(
+      {
+        conditions: rule,
+        resource: {
+          id: cuid(),
+        },
+      } as any,
+      data
+    )
+
+    expect(finding.result).toBe(Result.FAIL)
+  })
 })

tests/operators/comparison.test.ts

@@ -0,0 +1,7 @@
+import ComparisonOperators from '../../src/rules-engine/operators/comparison'
+
+describe('Comparison Operators', () => {
+  describe('Equal Operator', () => {
+    test.todo('Should pass given two equal values')
+  })
+})