1.0.8

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartrule",
-  "version": "1.0.4",
+  "version": "1.0.8",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartrule",
-  "version": "1.0.4",
+  "version": "1.0.8",
   "private": false,
   "description": "a smart rule library for handling decision trees.",
   "main": "dist/index.js",

test/test.ts

@@ -11,7 +11,7 @@ let testSmartruleInstance: smartrule.SmartRule<ITestMessage>;
 tap.test('first test', async () => {
   testSmartruleInstance = new smartrule.SmartRule<ITestMessage>();
   testSmartruleInstance.createRule(
-    0,
+    2,
     async messageArg => {
       if (messageArg.body.startsWith('hello')) {
         return 'apply-stop';

ts/smartrule.classes.smartrule.ts

@@ -26,34 +26,39 @@ export class SmartRule<T> {
     };
 
     // lets run the checks
-    const runNextBatch = async (startPriority: number) => {
+    const runNextBatch = async (startPriority: number, runRulesAmount: number): Promise<void> => {
-      const nextBatch = getNextParallelBatch(0);
+      const nextBatch = getNextParallelBatch(startPriority);
+      runRulesAmount = runRulesAmount + nextBatch.length;
       const outcomes: TTreeActionResult[] = [];
       for (const rule of nextBatch) {
         const checkResult = await rule.checkFunction(objectArg);
         if (checkResult.startsWith("apply")) {
-          await rule.actionFunction(objectArg);
+          await rule.actionFunction(objectArg); // here the action function is run
         }
         outcomes.push(checkResult);
-      };
-
-      const finalOutcome: TTreeActionResult = outcomes.reduce((previous, current, index, array) => {
-        if (current.includes('continue') || previous.includes('continue')) {
-          return 'continue';
-        } else {
-          return 'stop';
-        }
-      });
-      if (finalOutcome === 'stop') {
-        return;
       }
 
-      if (startPriority < this.rules[this.rules.length-1].priority) {
+      if (outcomes.length > 0) {
-        runNextBatch(startPriority++);
+        const finalOutcomeOfBatch: TTreeActionResult = outcomes.reduce((previous, current, index, array) => {
+          if (current.includes('continue') || previous.includes('continue')) {
+            return 'continue';
+          } else {
+            return 'stop';
+          }
+        });
+        if (finalOutcomeOfBatch === 'stop') {
+          return;
+        }
+      }
+
+      if (runRulesAmount < this.rules.length) {
+        await runNextBatch((startPriority + 1), runRulesAmount);
+      } else {
+        return;
       }
     };
 
-    await runNextBatch(0);
+    await runNextBatch(0,0);
   }
 
   public createRule(priorityArg: number, checkFunctionArg: TCheckFunc<T>, actionFunctionArg: TActionFunc) {