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

package/__tests__/integration.test.ts

@@ -0,0 +1,419 @@
+import { describe, expect, test } from "bun:test";
+import type { ConditionGroup } from "@f-o-t/condition-evaluator";
+import { createEvaluator } from "@f-o-t/condition-evaluator";
+import {
+   addVersion,
+   all,
+   analyzeRuleSet,
+   and,
+   buildIndex,
+   checkIntegrity,
+   createEngine,
+   createVersionStore,
+   detectConflicts,
+   exportToJson,
+   getLatestVersion,
+   getRulesByField,
+   importFromJson,
+   num,
+   type Rule,
+   rollbackToVersion,
+   rule,
+   simulate,
+   str,
+   validateRule,
+   whatIf,
+} from "../src/index";
+
+const toRule = (input: ReturnType<ReturnType<typeof rule>["build"]>): Rule => ({
+   id: input.id ?? `rule-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+   name: input.name,
+   description: input.description,
+   conditions: input.conditions,
+   consequences: input.consequences.map((c) => ({
+      type: String(c.type),
+      payload: c.payload,
+   })),
+   priority: input.priority ?? 0,
+   enabled: input.enabled ?? true,
+   stopOnMatch: input.stopOnMatch ?? false,
+   tags: input.tags ?? [],
+   category: input.category,
+   metadata: input.metadata,
+   createdAt: new Date(),
+   updatedAt: new Date(),
+});
+
+describe("Integration Tests", () => {
+   describe("Rule Builder and Conditions", () => {
+      test("creates rules with fluent builder", () => {
+         const discountRule = rule()
+            .named("Discount Rule")
+            .describedAs("Apply discount for large orders")
+            .when(
+               and((c) =>
+                  c.number("amount", "gt", 100).number("itemCount", "gte", 5),
+               ),
+            )
+            .then("apply_discount", { percentage: 10 })
+            .withPriority(50)
+            .tagged("pricing", "discount")
+            .inCategory("pricing")
+            .build();
+
+         expect(discountRule.name).toBe("Discount Rule");
+         expect(discountRule.description).toBe(
+            "Apply discount for large orders",
+         );
+         expect(discountRule.priority).toBe(50);
+         expect(discountRule.tags).toContain("pricing");
+         expect(discountRule.category).toBe("pricing");
+         expect(discountRule.consequences.length).toBe(1);
+      });
+
+      test("creates rules with shorthand condition helpers", () => {
+         const conditions = all(
+            num("amount", "gt", 50),
+            str("customerType", "eq", "premium"),
+         );
+
+         const myRule = rule()
+            .named("Simple Rule")
+            .when(conditions)
+            .then("notify", { message: "Hello" })
+            .build();
+
+         expect(myRule.name).toBe("Simple Rule");
+         expect(myRule.enabled).toBe(true);
+      });
+   });
+
+   describe("Engine Operations", () => {
+      test("creates engine and manages rules", () => {
+         const engine = createEngine({ evaluator: createEvaluator() });
+
+         const ruleInput = rule()
+            .named("Rule 1")
+            .when(all(num("amount", "gt", 100)))
+            .then("action", { type: "discount" })
+            .build();
+
+         const rule1 = engine.addRule(ruleInput);
+         expect(engine.getRules().length).toBe(1);
+
+         engine.disableRule(rule1.id);
+         expect(engine.getRule(rule1.id)?.enabled).toBe(false);
+
+         engine.enableRule(rule1.id);
+         expect(engine.getRule(rule1.id)?.enabled).toBe(true);
+
+         engine.removeRule(rule1.id);
+         expect(engine.getRules().length).toBe(0);
+      });
+
+      test("evaluates rules against context", async () => {
+         const engine = createEngine({ evaluator: createEvaluator() });
+
+         engine.addRule(
+            rule()
+               .named("High Amount")
+               .when(all(num("amount", "gt", 100)))
+               .then("flag", { level: "high" })
+               .withPriority(100)
+               .build(),
+         );
+
+         engine.addRule(
+            rule()
+               .named("Medium Amount")
+               .when(all(num("amount", "gt", 50)))
+               .then("flag", { level: "medium" })
+               .withPriority(50)
+               .build(),
+         );
+
+         const result = await engine.evaluate({ amount: 150, itemCount: 2 });
+
+         expect(result.matchedRules.length).toBe(2);
+         expect(result.totalRulesEvaluated).toBe(2);
+      });
+   });
+
+   describe("Simulation", () => {
+      test("simulates rules without side effects", () => {
+         const rules: Rule[] = [
+            toRule(
+               rule()
+                  .named("Simulation Test")
+                  .when(all(num("amount", "gt", 100)))
+                  .then("discount", { percent: 10 })
+                  .build(),
+            ),
+         ];
+
+         const result = simulate(rules, { data: { amount: 150 } });
+
+         expect(result.matchedRules.length).toBe(1);
+         expect(result.consequences.length).toBe(1);
+         expect(result.executionTimeMs).toBeGreaterThanOrEqual(0);
+      });
+
+      test("compares rules with whatIf", () => {
+         const originalRules: Rule[] = [
+            toRule(
+               rule()
+                  .named("Original")
+                  .when(all(num("amount", "gt", 100)))
+                  .then("discount", { percent: 10 })
+                  .build(),
+            ),
+         ];
+
+         const modifiedRules: Rule[] = [
+            toRule(
+               rule()
+                  .named("Modified")
+                  .when(all(num("amount", "gt", 50)))
+                  .then("discount", { percent: 15 })
+                  .build(),
+            ),
+         ];
+
+         const context = { data: { amount: 75 } };
+         const comparison = whatIf(originalRules, modifiedRules, context);
+
+         expect(comparison.original.matchedRules.length).toBe(0);
+         expect(comparison.modified.matchedRules.length).toBe(1);
+         expect(comparison.differences.newMatches.length).toBe(1);
+      });
+   });
+
+   describe("Serialization", () => {
+      test("exports and imports rules", () => {
+         const rules: Rule[] = [
+            toRule(
+               rule()
+                  .named("Export Test")
+                  .when(all(num("amount", "gt", 0)))
+                  .then("action", { type: "test" })
+                  .tagged("test")
+                  .build(),
+            ),
+         ];
+
+         const json = exportToJson(rules);
+         expect(json).toContain("Export Test");
+         expect(json).toContain("action");
+
+         const imported = importFromJson(json);
+         expect(imported.success).toBe(true);
+         expect(imported.rules.length).toBe(1);
+         expect(imported.rules[0]?.name).toBe("Export Test");
+      });
+
+      test("generates new IDs on import", () => {
+         const originalRule = toRule(
+            rule()
+               .named("ID Test")
+               .when(all(num("amount", "gt", 0)))
+               .then("action", {})
+               .build(),
+         );
+
+         const json = exportToJson([originalRule]);
+         const imported = importFromJson(json, { generateNewIds: true });
+
+         expect(imported.rules[0]?.id).not.toBe(originalRule.id);
+      });
+   });
+
+   describe("Versioning", () => {
+      test("tracks rule versions", () => {
+         const myRule = toRule(
+            rule()
+               .named("Versioned")
+               .when(all(num("amount", "gt", 100)))
+               .then("action", { version: 1 })
+               .build(),
+         );
+
+         let store = createVersionStore();
+         store = addVersion(store, myRule, "create", { comment: "v1" });
+
+         const latest = getLatestVersion(store, myRule.id);
+         expect(latest?.version).toBe(1);
+         expect(latest?.comment).toBe("v1");
+      });
+
+      test("supports rollback", () => {
+         const myRule = toRule(
+            rule()
+               .named("Rollback Test")
+               .when(all(num("amount", "gt", 100)))
+               .then("action", { v: 1 })
+               .build(),
+         );
+
+         let store = createVersionStore();
+         store = addVersion(store, myRule, "create");
+
+         const updatedRule: Rule = {
+            ...myRule,
+            consequences: [{ type: "action", payload: { v: 2 } }],
+            updatedAt: new Date(),
+         };
+         store = addVersion(store, updatedRule, "update");
+
+         const { store: rolledBack } = rollbackToVersion(store, myRule.id, 1);
+         const latest = getLatestVersion(rolledBack, myRule.id);
+
+         expect(latest?.version).toBe(3);
+      });
+   });
+
+   describe("Indexing", () => {
+      test("builds and queries index", () => {
+         const rules: Rule[] = [
+            toRule(
+               rule()
+                  .named("Amount Rule")
+                  .when(all(num("amount", "gt", 100)))
+                  .then("action", {})
+                  .build(),
+            ),
+            toRule(
+               rule()
+                  .named("Count Rule")
+                  .when(all(num("itemCount", "gt", 5)))
+                  .then("action", {})
+                  .build(),
+            ),
+         ];
+
+         const index = buildIndex(rules);
+
+         expect(getRulesByField(index, "amount").length).toBe(1);
+         expect(getRulesByField(index, "itemCount").length).toBe(1);
+         expect(getRulesByField(index, "nonexistent").length).toBe(0);
+      });
+   });
+
+   describe("Analysis", () => {
+      test("analyzes rule set", () => {
+         const rules: Rule[] = [
+            toRule(
+               rule()
+                  .named("Rule 1")
+                  .when(all(num("amount", "gt", 100)))
+                  .then("action", {})
+                  .inCategory("pricing")
+                  .build(),
+            ),
+            toRule(
+               rule()
+                  .named("Rule 2")
+                  .when(
+                     and((c) =>
+                        c
+                           .number("amount", "gt", 50)
+                           .number("itemCount", "gt", 3),
+                     ),
+                  )
+                  .then("action", {})
+                  .then("notify", { msg: "test" })
+                  .inCategory("pricing")
+                  .build(),
+            ),
+         ];
+
+         const analysis = analyzeRuleSet(rules);
+
+         expect(analysis.ruleCount).toBe(2);
+         expect(analysis.uniqueCategories).toContain("pricing");
+         expect(analysis.ruleComplexities.length).toBe(2);
+      });
+   });
+
+   describe("Conflict Detection", () => {
+      test("detects duplicate conditions", () => {
+         const conditions: ConditionGroup = {
+            id: "g1",
+            operator: "AND",
+            conditions: [
+               {
+                  id: "c1",
+                  type: "number",
+                  field: "amount",
+                  operator: "gt",
+                  value: 100,
+               },
+            ],
+         };
+
+         const rules: Rule[] = [
+            {
+               id: "rule-1",
+               name: "Rule 1",
+               conditions,
+               consequences: [{ type: "a", payload: {} }],
+               priority: 50,
+               enabled: true,
+               stopOnMatch: false,
+               tags: [],
+               createdAt: new Date(),
+               updatedAt: new Date(),
+            },
+            {
+               id: "rule-2",
+               name: "Rule 2",
+               conditions,
+               consequences: [{ type: "b", payload: {} }],
+               priority: 50,
+               enabled: true,
+               stopOnMatch: false,
+               tags: [],
+               createdAt: new Date(),
+               updatedAt: new Date(),
+            },
+         ];
+
+         const conflicts = detectConflicts(rules);
+         expect(conflicts.some((c) => c.type === "DUPLICATE_CONDITIONS")).toBe(
+            true,
+         );
+      });
+   });
+
+   describe("Validation", () => {
+      test("validates rule structure", () => {
+         const validRule = toRule(
+            rule()
+               .named("Valid Rule")
+               .when(all(num("amount", "gt", 0)))
+               .then("action", {})
+               .build(),
+         );
+
+         const result = validateRule(validRule);
+         expect(result.valid).toBe(true);
+      });
+
+      test("checks integrity", () => {
+         const rules: Rule[] = [
+            toRule(
+               rule()
+                  .named("Warning Rule")
+                  .when(all(num("amount", "gt", 0)))
+                  .then("action", {})
+                  .withPriority(-10)
+                  .build(),
+            ),
+         ];
+
+         const integrity = checkIntegrity(rules);
+         expect(
+            integrity.issues.some((i) => i.code === "NEGATIVE_PRIORITY"),
+         ).toBe(true);
+      });
+   });
+});

package/__tests__/money-integration.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, test } from "bun:test";
+import { createEngine } from "../src/engine/engine";
+import { moneyOperators } from "@f-o-t/money/plugins/operators";
+import { z } from "zod";
+
+type TransactionContext = {
+  amount: {
+    amount: string;
+    currency: string;
+  };
+  accountBalance: {
+    amount: string;
+    currency: string;
+  };
+};
+
+const TransactionConsequences = {
+  approve: z.object({ approved: z.boolean() }),
+  require_review: z.object({ reason: z.string() }),
+  reject: z.object({ reason: z.string() }),
+} as const;
+
+describe("Money operators integration", () => {
+  test("should use money_gt operator in rules", async () => {
+    const engine = createEngine<TransactionContext, typeof TransactionConsequences>({
+      consequences: TransactionConsequences,
+      operators: moneyOperators,
+    });
+
+    engine.addRule({
+      name: "high-value-transaction",
+      conditions: {
+        id: "g1",
+        operator: "AND",
+        conditions: [
+          {
+            id: "c1",
+            type: "custom",
+            field: "amount",
+            operator: "money_gt",
+            value: { amount: "1000.00", currency: "BRL" },
+          },
+        ],
+      },
+      consequences: [
+        {
+          type: "require_review",
+          payload: { reason: "High value transaction" },
+        },
+      ],
+    });
+
+    const result = await engine.evaluate({
+      amount: { amount: "1500.00", currency: "BRL" },
+      accountBalance: { amount: "10000.00", currency: "BRL" },
+    });
+
+    expect(result.matchedRules).toHaveLength(1);
+    expect(result.matchedRules[0]?.name).toBe("high-value-transaction");
+    expect(result.consequences).toHaveLength(1);
+    expect(result.consequences[0]?.type).toBe("require_review");
+  });
+
+  test("should use money_between operator", async () => {
+    const engine = createEngine<TransactionContext, typeof TransactionConsequences>({
+      consequences: TransactionConsequences,
+      operators: moneyOperators,
+    });
+
+    engine.addRule({
+      name: "medium-value-transaction",
+      conditions: {
+        id: "g1",
+        operator: "AND",
+        conditions: [
+          {
+            id: "c1",
+            type: "custom",
+            field: "amount",
+            operator: "money_between",
+            value: [
+              { amount: "100.00", currency: "BRL" },
+              { amount: "1000.00", currency: "BRL" },
+            ],
+          },
+        ],
+      },
+      consequences: [
+        {
+          type: "approve",
+          payload: { approved: true },
+        },
+      ],
+    });
+
+    const result = await engine.evaluate({
+      amount: { amount: "500.00", currency: "BRL" },
+      accountBalance: { amount: "10000.00", currency: "BRL" },
+    });
+
+    expect(result.matchedRules).toHaveLength(1);
+    expect(result.consequences[0]?.type).toBe("approve");
+  });
+
+  test("should handle multiple money conditions", async () => {
+    const engine = createEngine<TransactionContext, typeof TransactionConsequences>({
+      consequences: TransactionConsequences,
+      operators: moneyOperators,
+    });
+
+    engine.addRule({
+      name: "insufficient-funds",
+      conditions: {
+        id: "g1",
+        operator: "AND",
+        conditions: [
+          {
+            id: "c1",
+            type: "custom",
+            field: "amount",
+            operator: "money_gt",
+            value: { amount: "0.00", currency: "BRL" },
+          },
+          {
+            id: "c2",
+            type: "custom",
+            field: "accountBalance",
+            operator: "money_lt",
+            value: { amount: "100.00", currency: "BRL" },
+          },
+        ],
+      },
+      consequences: [
+        {
+          type: "reject",
+          payload: { reason: "Insufficient funds" },
+        },
+      ],
+    });
+
+    const result = await engine.evaluate({
+      amount: { amount: "50.00", currency: "BRL" },
+      accountBalance: { amount: "25.00", currency: "BRL" },
+    });
+
+    expect(result.matchedRules).toHaveLength(1);
+    expect(result.consequences[0]?.type).toBe("reject");
+  });
+});