#14

src/conditionsMeet.js

@@ -3,6 +3,21 @@ import checkField from "./checkField";
 import { OR, AND, NOT } from "./constants";
 import selectn from "selectn";
 
+export function toRelCondition(refCondition, formData) {
+  if (Array.isArray(refCondition)) {
+    return refCondition.map(cond => toRelCondition(cond, formData));
+  } else if (isObject(refCondition)) {
+    return Object.keys(refCondition).reduce((agg, field) => {
+      agg[field] = toRelCondition(refCondition[field], formData);
+      return agg;
+    }, {});
+  } else if (typeof refCondition === "string" && refCondition.startsWith("$")) {
+    return selectn(refCondition.substr(1), formData);
+  } else {
+    return refCondition;
+  }
+}
+
 export default function conditionsMeet(condition, formData) {
   if (!isObject(condition) || !isObject(formData)) {
     toError(
@@ -21,12 +36,15 @@ export default function conditionsMeet(condition, formData) {
     } else {
       let refVal = selectn(ref, formData);
       if (Array.isArray(refVal)) {
+        let condMeatOnce = refVal.some(val =>
+          conditionsMeet(refCondition, val)
+        );
         return (
-          refVal.some(val => conditionsMeet(refCondition, val)) ||
-          checkField(refVal, refCondition)
+          condMeatOnce ||
+          checkField(refVal, toRelCondition(refCondition, formData))
         );
       } else {
-        return checkField(refVal, refCondition);
+        return checkField(refVal, toRelCondition(refCondition, formData));
       }
     }
   });

test/conditionsMeet.toRelCondition.test.js

@@ -0,0 +1,38 @@
+import { toRelCondition } from "../src/conditionsMeet";
+
+test("rel simple condition", () => {
+  expect(toRelCondition({ less: "$b" }, { b: 11 })).toEqual({ less: 11 });
+});
+
+test("rel complicated condition", () => {
+  let condition = {
+    decreasedByMoreThanPercent: {
+      average: "$averages_monthly.cost",
+      target: 20,
+    },
+  };
+
+  let formData = {
+    averages_monthly: { cost: 100 },
+  };
+
+  let expCondition = {
+    decreasedByMoreThanPercent: {
+      average: 100,
+      target: 20,
+    },
+  };
+
+  expect(toRelCondition(condition, formData)).toEqual(expCondition);
+});
+
+test("work with OR condition", () => {
+  let cond = { or: [{ lessEq: "$b" }, { greaterEq: "$c" }] };
+  let formData = { b: 16, c: 70 };
+  let expCond = { or: [{ lessEq: 16 }, { greaterEq: 70 }] };
+  expect(toRelCondition(cond, formData)).toEqual(expCond);
+});
+
+test("keep non relevant", () => {
+  expect(toRelCondition({ range: [20, 40] }, {})).toEqual({ range: [20, 40] });
+});

test/issues/14.test.js

@@ -0,0 +1,37 @@
+import Engine from "../../src";
+
+test("simple relevant rules work", () => {
+  let rules = [
+    {
+      conditions: {
+        a: { less: "$b" },
+      },
+      event: {
+        type: "match",
+      },
+    },
+  ];
+  let engine = new Engine(rules);
+  return engine.run({ a: 10, b: 11 }).then(events => {
+    expect(events.length).toEqual(1);
+    expect(events[0]).toEqual({ type: "match" });
+  });
+});
+
+test("complicated rules work", () => {
+  let rules = [
+    {
+      conditions: {
+        a: { or: [{ less: "$b" }] },
+      },
+      event: {
+        type: "match",
+      },
+    },
+  ];
+  let engine = new Engine(rules);
+  return engine.run({ a: 10, b: 11 }).then(events => {
+    expect(events.length).toEqual(1);
+    expect(events[0]).toEqual({ type: "match" });
+  });
+});