Get rid of factMapId

Author: akmjenkins

README.md

@@ -190,7 +190,7 @@ const engine = createRulesEngine({ actions: saveAuditRecord });
 
 ### Rules
 
-Rules are written as **when**, **then**, **otherwise**. A when clause consists of an array of [`FactMap`s](#factmap). If any of the `FactMap`s evaluate to true, the properties of the `then` clause of the rule are evaluated. If not, the `otherwise` clause is evaluated.
+Rules are written as **when**, **then**, **otherwise**. A when clause consists of an array of [`FactMap`s](#factmap), or an object whose values are [`FactMap`s](#factmap). If any of the `FactMap`s in the object or array evaluate to true, the properties of the `then` clause of the rule are evaluated. If not, the `otherwise` clause is evaluated.
 
 ```js
 const myRule = {
@@ -235,7 +235,6 @@ The `then` or `otherwise` property can consist of either `actions`, but it can a
 const myRule = {
   when: [
     {
-      factMapId: 'weatherCondition',
       weather: {
         params: {
           query: '{{city}}',
@@ -256,7 +255,7 @@ const myRule = {
         forecast: {
           params: {
             appId: '{{apiKey}}',
-            coord: '{{results.weatherCondition.weather.value.coord}}' // interpolate a value returned from the first fact
+            coord: '{{results[0].weather.value.coord}}' // interpolate a value returned from the first fact
           },
           path: 'daily',
           is: {
@@ -304,8 +303,6 @@ const myRule = {
 
 A FactMap is a plain object whose keys are facts (static or functional) and values are [`Evaluator`'s](#evaluator).
 
-**NOTE: `factMapId` is a reserved word in a `FactMap`. It is used internally to allow easy access to the results of a `FactMap` for interpolation in the `then` or `otherwise` clauses. For this reason `factMapId` _CANNOT_ be given as a fact or context**.
-
 #### Evaluator
 
 An evaluator is an object that specifies a JSON Schema to evaluate a fact against. If the fact is a functional fact, the evaluator can specify params to pass to the fact as an argument. A `path` can also be specified to more easily evaluate a nested property contained within the fact.

src/fact.map.processor.js

@@ -2,17 +2,14 @@ import { createEvaluator } from './evaluator';
 
 export const createFactMapProcessor = (validator, opts, emit) => (rule) => {
   const evaluator = createEvaluator(validator, opts, emit, rule);
-  return async (factMap, index) => {
-    // factMapId is a reserved word
-    const { factMapId = index, ...map } = factMap;
-
+  return async (factMap, id) => {
     // flags for if there was an error processing the fact map
     // and if all evaluations in the fact map passed
     let error = false;
     let passed = true;
 
     const results = (
-      await Promise.all(Object.entries(map).map(evaluator(factMapId)))
+      await Promise.all(Object.entries(factMap).map(evaluator(id)))
     ).reduce((acc, { factName, ...rest }) => {
       if (error) return acc;
       error = error || !!rest.error;
@@ -23,7 +20,7 @@ export const createFactMapProcessor = (validator, opts, emit) => (rule) => {
 
     // return the results in the same form they were passed in
     return {
-      [factMapId]: {
+      [id]: {
         ...results,
         __passed: passed,
         __error: error,

src/index.d.ts

@@ -4,7 +4,7 @@ export type Facts = Record<string, UnaryFunction>;
 export type Actions = Record<string, UnaryFunction>;
 export type Rules = Record<string, Rule>;
 export type Rule = {
-  when: FactMap[];
+  when: FactMap[] | NamedFactMap;
   then?: RuleActions | Rule | (Rule & RuleActions);
   otherwise?: RuleActions | Rule | (Rule & RuleActions);
 };
@@ -20,6 +20,10 @@ type RuleActions = {
   actions: Action[];
 };
 
+interface NamedFactMap {
+  [named: string]: FactMap;
+}
+
 interface FactMap {
   [fact: string]: Evaluator;
 }

src/rule.runner.js

@@ -6,10 +6,20 @@ export const createRuleRunner = (validator, opts, emit) => {
   const processor = createFactMapProcessor(validator, opts, emit);
   const executor = createActionExecutor(opts, emit);
   return async ([rule, { when, ...rest }]) => {
+    // interpolated can be an array FactMap[] OR an object NamedFactMap
+    const interpolated = interpolateDeep(
+      when,
+      opts.context,
+      opts.pattern,
+      opts.resolver,
+    );
+
     const ruleResults = await Promise.all(
-      interpolateDeep(when, opts.context, opts.pattern, opts.resolver).map(
-        processor(rule),
-      ),
+      Array.isArray(interpolated)
+        ? interpolated.map(processor(rule))
+        : Object.entries(interpolated).map(([factMap, id]) =>
+            processor(rule)(factMap, id),
+          ),
     );
 
     // create the context and evaluate whether the rules have passed or errored in a single loop

test/engine.test.ts

@@ -34,6 +34,7 @@ describe('rules engine', () => {
     await engine.run({ firstName: 'John' });
     expect(log).toHaveBeenCalledWith({ message: 'Hi friend!' });
     log.mockClear();
+    await engine.run({ firstName: 'Bill' });
     expect(log).not.toHaveBeenCalled();
     expect(call).toHaveBeenCalledWith({ message: 'Who are you?' });
   });