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

package/__tests__/evaluate.test.ts

@@ -1,339 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,303 +0,0 @@
-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);
-   });
-});