@f-o-t/rules-engine 2.0.2 → 3.0.0

package/__tests__/evaluate.test.ts

@@ -0,0 +1,339 @@
+import { describe, expect, test } from "bun:test";
+import type { ConditionGroup } from "@f-o-t/condition-evaluator";
+import { createEvaluator, createOperator } from "@f-o-t/condition-evaluator";
+import { evaluateRule, evaluateRules } from "../src/core/evaluate";
+import type { DefaultConsequences } from "../src/types/consequence";
+import type { Rule } from "../src/types/rule";
+
+type TestRule = Rule<unknown, DefaultConsequences>;
+
+const createTestRule = (overrides: Partial<TestRule> = {}): TestRule => ({
+   id: "rule-1",
+   name: "Test Rule",
+   description: "A test rule",
+   conditions: {
+      id: "group-1",
+      operator: "AND",
+      conditions: [
+         {
+            id: "cond-1",
+            type: "number",
+            field: "amount",
+            operator: "gt",
+            value: 100,
+         },
+      ],
+   },
+   consequences: [
+      {
+         type: "set_category",
+         payload: { categoryId: "high-value" },
+      },
+   ],
+   priority: 10,
+   enabled: true,
+   stopOnMatch: false,
+   tags: ["test"],
+   category: "finance",
+   createdAt: new Date(),
+   updatedAt: new Date(),
+   ...overrides,
+});
+
+describe("evaluateRule", () => {
+   test("should match rule when conditions pass", () => {
+      const rule = createTestRule();
+      const context = {
+         data: { amount: 150 },
+         timestamp: new Date(),
+      };
+
+      const evaluator = createEvaluator();
+      const result = evaluateRule(rule, context, evaluator);
+
+      expect(result.matched).toBe(true);
+      expect(result.ruleId).toBe("rule-1");
+      expect(result.ruleName).toBe("Test Rule");
+      expect(result.consequences).toHaveLength(1);
+      expect(result.consequences[0]?.type).toBe("set_category");
+      expect(result.skipped).toBe(false);
+   });
+
+   test("should not match rule when conditions fail", () => {
+      const rule = createTestRule();
+      const context = {
+         data: { amount: 50 },
+         timestamp: new Date(),
+      };
+
+      const evaluator = createEvaluator();
+      const result = evaluateRule(rule, context, evaluator);
+
+      expect(result.matched).toBe(false);
+      expect(result.consequences).toHaveLength(0);
+   });
+
+   test("should skip disabled rules when skipDisabled is true", () => {
+      const rule = createTestRule({ enabled: false });
+      const context = {
+         data: { amount: 150 },
+         timestamp: new Date(),
+      };
+
+      const evaluator = createEvaluator();
+      const result = evaluateRule(rule, context, evaluator, { skipDisabled: true });
+
+      expect(result.skipped).toBe(true);
+      expect(result.skipReason).toBe("Rule is disabled");
+      expect(result.matched).toBe(false);
+   });
+
+   test("should evaluate disabled rules when skipDisabled is false", () => {
+      const rule = createTestRule({ enabled: false });
+      const context = {
+         data: { amount: 150 },
+         timestamp: new Date(),
+      };
+
+      const evaluator = createEvaluator();
+      const result = evaluateRule(rule, context, evaluator, { skipDisabled: false });
+
+      expect(result.skipped).toBe(false);
+      expect(result.matched).toBe(true);
+   });
+
+   test("should include evaluation time", () => {
+      const rule = createTestRule();
+      const context = {
+         data: { amount: 150 },
+         timestamp: new Date(),
+      };
+
+      const evaluator = createEvaluator();
+      const result = evaluateRule(rule, context, evaluator);
+
+      expect(result.evaluationTimeMs).toBeGreaterThanOrEqual(0);
+   });
+
+   test("should handle complex condition groups", () => {
+      const conditions: ConditionGroup = {
+         id: "group-1",
+         operator: "AND",
+         conditions: [
+            {
+               id: "cond-1",
+               type: "number",
+               field: "amount",
+               operator: "gt",
+               value: 100,
+            },
+            {
+               id: "cond-2",
+               type: "string",
+               field: "status",
+               operator: "eq",
+               value: "active",
+            },
+         ],
+      };
+
+      const rule = createTestRule({ conditions });
+      const context = {
+         data: { amount: 150, status: "active" },
+         timestamp: new Date(),
+      };
+
+      const evaluator = createEvaluator();
+      const result = evaluateRule(rule, context, evaluator);
+
+      expect(result.matched).toBe(true);
+   });
+
+   test("should handle OR condition groups", () => {
+      const conditions: ConditionGroup = {
+         id: "group-1",
+         operator: "OR",
+         conditions: [
+            {
+               id: "cond-1",
+               type: "number",
+               field: "amount",
+               operator: "gt",
+               value: 1000,
+            },
+            {
+               id: "cond-2",
+               type: "string",
+               field: "status",
+               operator: "eq",
+               value: "premium",
+            },
+         ],
+      };
+
+      const rule = createTestRule({ conditions });
+      const context = {
+         data: { amount: 50, status: "premium" },
+         timestamp: new Date(),
+      };
+
+      const evaluator = createEvaluator();
+      const result = evaluateRule(rule, context, evaluator);
+
+      expect(result.matched).toBe(true);
+   });
+});
+
+describe("evaluateRules", () => {
+   test("should evaluate multiple rules", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", priority: 10 }),
+         createTestRule({ id: "rule-2", priority: 5 }),
+      ];
+      const context = {
+         data: { amount: 150 },
+         timestamp: new Date(),
+      };
+
+      const evaluator = createEvaluator();
+      const result = evaluateRules(rules, context, evaluator);
+
+      expect(result.results).toHaveLength(2);
+      expect(result.matchedRules).toHaveLength(2);
+      expect(result.stoppedEarly).toBe(false);
+   });
+
+   test("should stop on stopOnMatch", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", stopOnMatch: true }),
+         createTestRule({ id: "rule-2" }),
+      ];
+      const context = {
+         data: { amount: 150 },
+         timestamp: new Date(),
+      };
+
+      const evaluator = createEvaluator();
+      const result = evaluateRules(rules, context, evaluator);
+
+      expect(result.results).toHaveLength(1);
+      expect(result.matchedRules).toHaveLength(1);
+      expect(result.stoppedEarly).toBe(true);
+      expect(result.stoppedByRuleId).toBe("rule-1");
+   });
+
+   test("should stop on first-match conflict resolution", () => {
+      const rules = [
+         createTestRule({ id: "rule-1" }),
+         createTestRule({ id: "rule-2" }),
+      ];
+      const context = {
+         data: { amount: 150 },
+         timestamp: new Date(),
+      };
+
+      const evaluator = createEvaluator();
+      const result = evaluateRules(rules, context, evaluator, {
+         config: { conflictResolution: "first-match" },
+      });
+
+      expect(result.matchedRules).toHaveLength(1);
+      expect(result.stoppedEarly).toBe(true);
+   });
+
+   test("should collect all consequences with priority strategy", () => {
+      const rules = [
+         createTestRule({
+            id: "rule-1",
+            consequences: [{ type: "action1", payload: {} }],
+         }),
+         createTestRule({
+            id: "rule-2",
+            consequences: [{ type: "action2", payload: {} }],
+         }),
+      ];
+      const context = {
+         data: { amount: 150 },
+         timestamp: new Date(),
+      };
+
+      const evaluator = createEvaluator();
+      const result = evaluateRules(rules, context, evaluator);
+
+      expect(result.consequences).toHaveLength(2);
+   });
+
+   test("should skip disabled rules", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", enabled: true }),
+         createTestRule({ id: "rule-2", enabled: false }),
+      ];
+      const context = {
+         data: { amount: 150 },
+         timestamp: new Date(),
+      };
+
+      const evaluator = createEvaluator();
+      const result = evaluateRules(rules, context, evaluator);
+
+      expect(result.matchedRules).toHaveLength(1);
+      expect(result.results[1]?.skipped).toBe(true);
+   });
+
+   test("should call onRuleEvaluated callback", () => {
+      const rules = [createTestRule({ id: "rule-1" })];
+      const context = {
+         data: { amount: 150 },
+         timestamp: new Date(),
+      };
+
+      const evaluatedRules: string[] = [];
+
+      const evaluator = createEvaluator();
+      evaluateRules(rules, context, evaluator, {
+         onRuleEvaluated: (result) => {
+            evaluatedRules.push(result.ruleId);
+         },
+      });
+
+      expect(evaluatedRules).toContain("rule-1");
+   });
+});
+
+describe("evaluateRule with custom evaluator", () => {
+  test("should use provided evaluator for custom operators", () => {
+    const customOp = createOperator({
+      name: "always_true",
+      type: "custom",
+      evaluate: () => true,
+    });
+
+    const evaluator = createEvaluator({
+      operators: { always_true: customOp }
+    });
+
+    const rule = createTestRule({
+      conditions: {
+        id: "group-1",
+        operator: "AND",
+        conditions: [
+          {
+            id: "cond-1",
+            type: "custom",
+            field: "anything",
+            operator: "always_true",
+          },
+        ],
+      },
+    });
+
+    const context = {
+      data: { anything: "value" },
+      timestamp: new Date(),
+    };
+
+    const result = evaluateRule(rule, context, evaluator);
+
+    expect(result.matched).toBe(true);
+  });
+});

package/__tests__/exports.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+import { createEngine, createEvaluator, createOperator } from "../src/index";
+
+describe("Public API exports", () => {
+  test("should export createEvaluator", () => {
+    expect(createEvaluator).toBeDefined();
+    expect(typeof createEvaluator).toBe("function");
+  });
+
+  test("should export createOperator", () => {
+    expect(createOperator).toBeDefined();
+    expect(typeof createOperator).toBe("function");
+  });
+
+  test("should be able to use all exports together", () => {
+    const customOp = createOperator({
+      name: "test_op",
+      type: "custom",
+      evaluate: () => true,
+    });
+
+    const evaluator = createEvaluator({ operators: { test_op: customOp } });
+
+    const engine = createEngine({
+      evaluator,
+    });
+
+    expect(engine).toBeDefined();
+  });
+});

package/__tests__/filter-sort.test.ts

@@ -0,0 +1,303 @@
+import { describe, expect, test } from "bun:test";
+import {
+   filterByCategory,
+   filterByEnabled,
+   filterByTags,
+   filterRules,
+} from "../src/core/filter";
+import { groupByCategory, groupByCustom, groupRules } from "../src/core/group";
+import { sortByName, sortByPriority, sortRules } from "../src/core/sort";
+import type { DefaultConsequences } from "../src/types/consequence";
+import type { Rule } from "../src/types/rule";
+
+type TestRule = Rule<unknown, DefaultConsequences>;
+
+const createTestRule = (overrides: Partial<TestRule> = {}): TestRule => ({
+   id: "rule-1",
+   name: "Test Rule",
+   description: "A test rule",
+   conditions: {
+      id: "group-1",
+      operator: "AND",
+      conditions: [],
+   },
+   consequences: [],
+   priority: 10,
+   enabled: true,
+   stopOnMatch: false,
+   tags: ["test"],
+   category: "finance",
+   createdAt: new Date("2024-01-01"),
+   updatedAt: new Date("2024-01-01"),
+   ...overrides,
+});
+
+describe("filterRules", () => {
+   test("should filter by enabled", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", enabled: true }),
+         createTestRule({ id: "rule-2", enabled: false }),
+      ];
+
+      const result = filterRules({ enabled: true })(rules);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]?.id).toBe("rule-1");
+   });
+
+   test("should filter by tags", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", tags: ["finance", "alerts"] }),
+         createTestRule({ id: "rule-2", tags: ["marketing"] }),
+      ];
+
+      const result = filterRules({ tags: ["finance"] })(rules);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]?.id).toBe("rule-1");
+   });
+
+   test("should filter by category", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", category: "finance" }),
+         createTestRule({ id: "rule-2", category: "marketing" }),
+      ];
+
+      const result = filterRules({ category: "finance" })(rules);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]?.id).toBe("rule-1");
+   });
+
+   test("should filter by ids", () => {
+      const rules = [
+         createTestRule({ id: "rule-1" }),
+         createTestRule({ id: "rule-2" }),
+         createTestRule({ id: "rule-3" }),
+      ];
+
+      const result = filterRules({ ids: ["rule-1", "rule-3"] })(rules);
+
+      expect(result).toHaveLength(2);
+   });
+
+   test("should combine multiple filters", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", enabled: true, category: "finance" }),
+         createTestRule({ id: "rule-2", enabled: false, category: "finance" }),
+         createTestRule({ id: "rule-3", enabled: true, category: "marketing" }),
+      ];
+
+      const result = filterRules({ enabled: true, category: "finance" })(rules);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]?.id).toBe("rule-1");
+   });
+});
+
+describe("filterByEnabled", () => {
+   test("should filter enabled rules", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", enabled: true }),
+         createTestRule({ id: "rule-2", enabled: false }),
+      ];
+
+      const result = filterByEnabled(true)(rules);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]?.id).toBe("rule-1");
+   });
+});
+
+describe("filterByTags", () => {
+   test("should filter by tags", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", tags: ["finance"] }),
+         createTestRule({ id: "rule-2", tags: ["marketing"] }),
+      ];
+
+      const result = filterByTags(["finance"])(rules);
+
+      expect(result).toHaveLength(1);
+   });
+});
+
+describe("filterByCategory", () => {
+   test("should filter by category", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", category: "finance" }),
+         createTestRule({ id: "rule-2", category: "marketing" }),
+      ];
+
+      const result = filterByCategory("finance")(rules);
+
+      expect(result).toHaveLength(1);
+   });
+});
+
+describe("sortRules", () => {
+   test("should sort by priority descending", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", priority: 5 }),
+         createTestRule({ id: "rule-2", priority: 10 }),
+         createTestRule({ id: "rule-3", priority: 1 }),
+      ];
+
+      const result = sortRules("priority")(rules);
+
+      expect(result[0]?.id).toBe("rule-2");
+      expect(result[1]?.id).toBe("rule-1");
+      expect(result[2]?.id).toBe("rule-3");
+   });
+
+   test("should sort by priority ascending", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", priority: 5 }),
+         createTestRule({ id: "rule-2", priority: 10 }),
+         createTestRule({ id: "rule-3", priority: 1 }),
+      ];
+
+      const result = sortRules({ field: "priority", direction: "asc" })(rules);
+
+      expect(result[0]?.id).toBe("rule-3");
+      expect(result[1]?.id).toBe("rule-1");
+      expect(result[2]?.id).toBe("rule-2");
+   });
+
+   test("should sort by name", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", name: "Zebra" }),
+         createTestRule({ id: "rule-2", name: "Alpha" }),
+         createTestRule({ id: "rule-3", name: "Beta" }),
+      ];
+
+      const result = sortRules({ field: "name", direction: "asc" })(rules);
+
+      expect(result[0]?.id).toBe("rule-2");
+      expect(result[1]?.id).toBe("rule-3");
+      expect(result[2]?.id).toBe("rule-1");
+   });
+
+   test("should sort by createdAt", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", createdAt: new Date("2024-01-15") }),
+         createTestRule({ id: "rule-2", createdAt: new Date("2024-01-01") }),
+         createTestRule({ id: "rule-3", createdAt: new Date("2024-01-10") }),
+      ];
+
+      const result = sortRules({ field: "createdAt", direction: "desc" })(
+         rules,
+      );
+
+      expect(result[0]?.id).toBe("rule-1");
+      expect(result[2]?.id).toBe("rule-2");
+   });
+});
+
+describe("sortByPriority", () => {
+   test("should sort by priority", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", priority: 1 }),
+         createTestRule({ id: "rule-2", priority: 10 }),
+      ];
+
+      const result = sortByPriority()(rules);
+
+      expect(result[0]?.id).toBe("rule-2");
+   });
+});
+
+describe("sortByName", () => {
+   test("should sort by name", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", name: "Zebra" }),
+         createTestRule({ id: "rule-2", name: "Alpha" }),
+      ];
+
+      const result = sortByName()(rules);
+
+      expect(result[0]?.id).toBe("rule-2");
+   });
+});
+
+describe("groupRules", () => {
+   test("should group by category", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", category: "finance" }),
+         createTestRule({ id: "rule-2", category: "finance" }),
+         createTestRule({ id: "rule-3", category: "marketing" }),
+      ];
+
+      const result = groupRules("category")(rules);
+
+      expect(result.get("finance")).toHaveLength(2);
+      expect(result.get("marketing")).toHaveLength(1);
+   });
+
+   test("should group by priority", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", priority: 10 }),
+         createTestRule({ id: "rule-2", priority: 10 }),
+         createTestRule({ id: "rule-3", priority: 5 }),
+      ];
+
+      const result = groupRules("priority")(rules);
+
+      expect(result.get(10)).toHaveLength(2);
+      expect(result.get(5)).toHaveLength(1);
+   });
+
+   test("should group by enabled", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", enabled: true }),
+         createTestRule({ id: "rule-2", enabled: false }),
+         createTestRule({ id: "rule-3", enabled: true }),
+      ];
+
+      const result = groupRules("enabled")(rules);
+
+      expect(result.get(true)).toHaveLength(2);
+      expect(result.get(false)).toHaveLength(1);
+   });
+
+   test("should handle uncategorized rules", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", category: undefined }),
+         createTestRule({ id: "rule-2", category: "finance" }),
+      ];
+
+      const result = groupRules("category")(rules);
+
+      expect(result.get("uncategorized")).toHaveLength(1);
+   });
+});
+
+describe("groupByCategory", () => {
+   test("should group by category", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", category: "finance" }),
+         createTestRule({ id: "rule-2", category: "marketing" }),
+      ];
+
+      const result = groupByCategory()(rules);
+
+      expect(result.size).toBe(2);
+   });
+});
+
+describe("groupByCustom", () => {
+   test("should group by custom function", () => {
+      const rules = [
+         createTestRule({ id: "rule-1", priority: 5 }),
+         createTestRule({ id: "rule-2", priority: 15 }),
+         createTestRule({ id: "rule-3", priority: 3 }),
+      ];
+
+      const result = groupByCustom<unknown, DefaultConsequences, string>(
+         (rule) => (rule.priority >= 10 ? "high" : "low"),
+      )(rules);
+
+      expect(result.get("high")).toHaveLength(1);
+      expect(result.get("low")).toHaveLength(2);
+   });
+});