1.0.10

.vscode/settings.json

@@ -11,7 +11,13 @@
           },
           "gitzone": {
             "type": "object",
-            "description": "settings for gitzone"
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm"]
+              }
+            }
           }
         }
       }

npmextra.json

@@ -1,5 +1,6 @@
 {
   "gitzone": {
+    "projectType": "npm",
     "module": {
       "githost": "gitlab.com",
       "gitscope": "pushrocks",

package-lock.json

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartrule",
-  "version": "1.0.5",
+  "version": "1.0.10",
   "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';
@@ -27,7 +27,7 @@ tap.test('make a decision based on an object', async () => {
   testSmartruleInstance.makeDecision({
     id: '123456',
     body: 'hello, there. This is a cool message!'
-  })
+  });
 });
 
 tap.start();

ts/index.ts

@@ -1 +1 @@
-export * from './smartrule.classes.smartrule';
+export * from './smartrule.classes.smartrule';

ts/smartrule.classes.rule.ts

@@ -12,10 +12,15 @@ export class Rule<T> {
   public checkFunction: TCheckFunc<T>;
   public actionFunction: TActionFunc;
 
-  constructor(smartRuleRef: SmartRule<T>, priorityArg: number, checkFunctionArg: TCheckFunc<T>, actionFunctionArg: TActionFunc) {
+  constructor(
+    smartRuleRef: SmartRule<T>,
+    priorityArg: number,
+    checkFunctionArg: TCheckFunc<T>,
+    actionFunctionArg: TActionFunc
+  ) {
     this.smartRuleRef = smartRuleRef;
     this.priority = priorityArg;
     this.checkFunction = checkFunctionArg;
     this.actionFunction = actionFunctionArg;
   }
-}
+}

ts/smartrule.classes.smartrule.ts

@@ -6,11 +6,11 @@ export class SmartRule<T> {
 
   /**
    * makes a decision based on the given obect and the given rules
-   * @param objectArg 
+   * @param objectArg
    */
   public async makeDecision(objectArg: T) {
     // lets sort the rules
-    this.rules = this.rules.sort((a,b) => {
+    this.rules = this.rules.sort((a, b) => {
       if (a.priority > b.priority) {
         return 1;
       } else {
@@ -26,40 +26,55 @@ export class SmartRule<T> {
     };
 
     // lets run the checks
-    const runNextBatch = async (startPriority: number) => {
-      const nextBatch = getNextParallelBatch(0);
+    const runNextBatch = async (startPriority: number, runRulesAmount: number): Promise<void> => {
+      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);
+        checkResult
+          ? null
+          : console.log(
+              'WARNING!!! Please make sure your rule always returns a statement of how to continue!'
+            );
+
+        if (checkResult.startsWith('apply')) {
+          await rule.actionFunction(objectArg); // here the action function is run
         }
         outcomes.push(checkResult);
       }
 
       if (outcomes.length > 0) {
-        const finalOutcomeOfBatch: TTreeActionResult = outcomes.reduce((previous, current, index, array) => {
-          if (current.includes('continue') || previous.includes('continue')) {
-            return 'continue';
-          } else {
-            return 'stop';
+        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 (startPriority < this.rules[this.rules.length-1].priority) {
-        runNextBatch(startPriority++);
+      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) {
+  public createRule(
+    priorityArg: number,
+    checkFunctionArg: TCheckFunc<T>,
+    actionFunctionArg: TActionFunc
+  ) {
     const rule = new Rule<T>(this, priorityArg, checkFunctionArg, actionFunctionArg);
     this.rules.push(rule);
   }
-}
+}