Fix Typing in Tests

Author: chris-pardy

examples/01-hello-world.mts

@@ -50,7 +50,7 @@ async function start() {
   // engine.run() evaluates the rule using the facts provided
   const { events } = await engine.run(facts);
 
-  events.map((event) => console.log(event.params!.data.green));
+  events.map((event) => console.log(`${event.params!.data}`.green));
 }
 
 start();

examples/02-nested-boolean-logic.mts

@@ -76,7 +76,7 @@ async function start() {
 
   const { events } = await engine.run(facts);
 
-  events.map((event) => console.log(event.params!.message.red));
+  events.map((event) => console.log(`${event.params!.message}`.red));
 }
 start();
 /*

examples/09-rule-results.mts

@@ -8,7 +8,12 @@
  *   DEBUG=json-rules-engine node ./examples/09-rule-results.js
  */
 import "colors";
-import { Engine, NestedCondition, RuleResult } from "json-rules-engine";
+import {
+  Engine,
+  NestedCondition,
+  NestedConditionResult,
+  RuleResult,
+} from "json-rules-engine";
 
 async function start() {
   /**
@@ -48,14 +53,16 @@ async function start() {
       return console.log(`${message}`.green);
     }
     // if rule failed, iterate over each failed condition to determine why the student didn't qualify for athletics honor roll
-    const detail = (ruleResult.conditions as { all: NestedCondition[] }).all
-      .filter((condition) => !(condition as { result?: boolean }).result)
+    const detail = (
+      ruleResult.conditions as { all: NestedConditionResult[] }
+    ).all
+      .filter(({ result }) => !result)
       .map((condition) => {
-        switch ((condition as { operator?: string }).operator) {
+        switch (condition.operator) {
           case "equal":
-            return `was not an ${(condition as { fact?: string }).fact}`;
+            return `was not an ${condition.fact}`;
           case "greaterThanInclusive":
-            return `${(condition as { fact: string }).fact} of ${(condition as { factResult?: unknown }).factResult} was too low`;
+            return `${condition.fact} of ${condition.factResult} was too low`;
           default:
             return "";
         }

test/types.test-d.mts

@@ -14,8 +14,7 @@ import rulesEngine, {
   Rule,
   RuleProperties,
   RuleResult,
-  RuleSerializable,
-} from "../types/index.js";
+} from "../src/index.mjs";
 
 // setup basic fixture data
 const ruleProps: RuleProperties = {
@@ -81,27 +80,6 @@ describe("type tests", () => {
     it("returns void when updating a rule", () => {
       expectTypeOf<void>(engine.updateRule(ruleFromString));
     });
-
-    it("returns rule when setting conditions", () => {
-      expectTypeOf<Rule>(rule.setConditions({ any: [] }));
-    });
-
-    it("returns rule when setting event", () => {
-      expectTypeOf<Rule>(rule.setEvent({ type: "test" }));
-    });
-
-    it("returns rule when setting priority", () => {
-      expectTypeOf<Rule>(rule.setPriority(1));
-    });
-
-    it("returns string when json stringifying", () => {
-      expectTypeOf<string>(rule.toJSON());
-      expectTypeOf<string>(rule.toJSON(true));
-    });
-
-    it("returns serializable props when converting to json", () => {
-      expectTypeOf<RuleSerializable>(rule.toJSON(false));
-    });
   });
 
   describe("operator tests", () => {
@@ -110,10 +88,10 @@ describe("type tests", () => {
       b: number,
     ) => a === b;
 
-    const operator: Operator = new Operator(
+    const operator: Operator<number, number> = new Operator(
       "test",
       operatorEvaluator,
-      (num: number) => num > 0,
+      (num: unknown): num is number => Number(num) > 0,
     );
 
     it("returns void when adding an operatorEvaluator", () => {
@@ -137,10 +115,10 @@ describe("type tests", () => {
       number
     > = (a: number[], b: number, next: OperatorEvaluator<number, number>) =>
       next(a[0], b);
-    const operatorDecorator: OperatorDecorator = new OperatorDecorator(
+    const operatorDecorator: OperatorDecorator<number[], number, number, number> = new OperatorDecorator(
       "first",
       operatorDecoratorEvaluator,
-      (a: number[]) => a.length > 0,
+      (a: unknown): a is number[] => Array.isArray(a) && a.length > 0,
     );
 
     it("returns void when adding a decorator evaluator", () => {
@@ -181,7 +159,7 @@ describe("type tests", () => {
     });
 
     it("returns fact when getting a fact", () => {
-      expectTypeOf<Fact<string>>(engine.getFact<string>("test"));
+      expectTypeOf<Fact | undefined>(engine.getFact("test"));
     });
   });
 
@@ -191,10 +169,6 @@ describe("type tests", () => {
     it("factValue returns promise of value", () => {
       expectTypeOf<Promise<string>>(almanac.factValue<string>("test-fact"));
     });
-
-    it("addRuntimeFact returns void", () => {
-      expectTypeOf<void>(almanac.addRuntimeFact("test-fact", "some-value"));
-    });
   });
 
   describe("event tests", () => {