[NodeRules] 6.0.0

- Process.tick polyfill for browsers
- Unit Tests for Parallelism
- Browser Support Definision in place
- Renamed webpack Library Definition to "NodeRules"
- Reduction in whole library size by 80%

Author: Mithun Satheesh

.babelrc

@@ -1,3 +1,16 @@
 {
-  "presets": ["@babel/preset-env"]
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "targets": {
+          "edge": "17",
+          "firefox": "60",
+          "chrome": "67",
+          "safari": "11.1",
+        },
+        "useBuiltIns": "usage",
+      }
+    ]
+  ]
 }

dist/node-rules.min.js

@@ -14,7 +14,7 @@
             this.ignoreFactChanges = options.ignoreFactChanges;
         }
         return this;
-    }
+    };
     RuleEngine.prototype.init = function(rules) {
         this.rules = [];
         this.activeRules = [];
@@ -62,12 +62,12 @@
                     if (outcome) {
                         var _consequence = _rules[x].consequence;
                         _consequence.ruleRef = _rules[x].id || _rules[x].name || 'index_'+x;
-                        process.nextTick(function() {
+                        thisHolder.nextTick(function() {
                             matchPath.push(_consequence.ruleRef);
                             _consequence.call(session, API, session);
                         });
                     } else {
-                        process.nextTick(function() {
+                        thisHolder.nextTick(function() {
                             API.next();
                         });
                     }
@@ -82,11 +82,11 @@
                 "next": function() {
                     if (!ignoreFactChanges && !isEqual(lastSession, session)) {
                         lastSession = clonedeep(session);
-                        process.nextTick(function() {
+                        thisHolder.nextTick(function() {
                             API.restart();
                         });
                     } else {
-                        process.nextTick(function() {
+                        thisHolder.nextTick(function() {
                             return FnRuleLoop(x + 1);
                         });
                     }
@@ -97,13 +97,20 @@
                 var _rule = _rules[x].condition;
                 _rule.call(session, API, session);
             } else {
-                process.nextTick(function() {
+                thisHolder.nextTick(function() {
                     session.matchPath = matchPath;
                     return callback(session);
                 });
             }
         })(0);
     };
+    RuleEngine.prototype.nextTick = function(callbackFn) {
+        if (process && process.nextTick) {
+            process.nextTick(callbackFn);
+        } else {
+            setTimeout(callbackFn, 0);
+        }
+    }; 
     RuleEngine.prototype.findRules = function(query) {
         if (typeof(query) === "undefined") {
             return this.rules;
@@ -117,22 +124,22 @@
                 });
             });
         }
-    }
+    };
     RuleEngine.prototype.turn = function(state, filter) {
         var state = (state === "on" || state === "ON") ? true : false;
         var rules = this.findRules(filter);
         for (var i = 0, j = rules.length; i < j; i++) {
             rules[i].on = state;
         }
         this.sync();
-    }
+    };
     RuleEngine.prototype.prioritize = function(priority, filter) {
         priority = parseInt(priority, 10);
         var rules = this.findRules(filter);
         for (var i = 0, j = rules.length; i < j; i++) {
             rules[i].priority = priority;
         }
         this.sync();
-    }
+    };
     module.exports = RuleEngine;
 }(module.exports));

lib/node-rules.js

@@ -1,6 +1,6 @@
 {
   "name": "node-rules",
-  "version": "5.2.0",
+  "version": "6.0.0",
   "description": "Business Rules Engine for JavaScript",
   "keywords": [
     "bre",

package.json

@@ -408,4 +408,95 @@ describe("Rules", function() {
             });
         });
     });
+    describe("test Parallelism", function() {
+        var rules = [
+            {
+                "name": "high credibility customer - avoid checks and bypass",
+                "priority": 4,
+                "on": true,
+                "condition": function(R) {
+                    console.log(`Executing rule 1 on ${this.name}`);
+                    R.when(this.userCredibility && this.userCredibility > 5);
+                },
+                "consequence": function(R) {
+                    console.log(`Rule 1 matched for ${this.name} user credibility is more, then avoid further check. Accepting payment.`);
+                    this.result = true;
+                    R.stop();
+                }
+            },
+            {
+                "name": "block guest payment above 10000",
+                "priority": 3,
+                "condition": function(R) {
+                    console.log(`Executing rule 2 on ${this.name}`);
+                    R.when(this.customerType && this.transactionTotal > 10000 && this.customerType == "guest");
+                },
+                "consequence": function(R) {
+                    console.log(`Rule 2 matched for ${this.name} reject if above 10000 and customer type is guest. Rejecting payment.`);
+                    this.result = false;
+                    R.stop();
+                }
+            },
+            {
+                "name": "is customer guest?",
+                "priority": 2,
+                "condition": function(R) {
+                    console.log(`Executing rule 3 on ${this.name}`);
+                    R.when(!this.userLoggedIn);
+                },
+                "consequence": function(R) {
+                    console.log(`Rule 3 matched for ${this.name} support rule written for blocking payment above 10000 from guests.`);
+                    console.log("Process left to chain with rule 2.");
+                    this.customerType = "guest";
+                    // the fact has been altered above, so all rules will run again since ignoreFactChanges is not set.
+                    R.next();
+                }
+            },
+            {
+                "name": "block Cashcard Payment",
+                "priority": 1,
+                "condition": function(R) {
+                    console.log(`Executing rule 4 on ${this.name}`);
+                    R.when(this.cardType == "Cash Card");
+                },
+                "consequence": function(R) {
+                    console.log(`Rule 4 matched for ${this.name} reject the payment if cash card. Rejecting payment.`);
+                    this.result = false;
+                    R.stop();
+                }
+            }
+        ];
+
+        var straightFact = {
+            "name": "straightFact",
+            "userCredibility": 1,
+            "userLoggedIn": true,
+            "transactionTotal": 12000,
+            "cardType": "Cash Card"
+        };
+
+        /** example of a chaned up rule. will take two iterations. ****/
+        var chainedFact = {
+            "name": "chainedFact",
+            "userCredibility": 2,
+            "userLoggedIn": false,
+            "transactionTotal": 100000,
+            "cardType": "Credit Card"
+        };
+
+        it("context switches and finishes the fact which needs least iteration first", function(done) {
+            var R = new RuleEngine(rules);
+            var isStraightFactFast = false;
+
+            R.execute(chainedFact, function(result) {
+                expect(isStraightFactFast).eql(true);
+                done();
+            });
+
+            R.execute(straightFact, function(result) {
+                isStraightFactFast = true;
+            });
+
+        });
+    });
 });

test/index.js

@@ -9,7 +9,7 @@ module.exports = {
     path: path.resolve(__dirname, 'dist'),
     filename: 'node-rules.min.js',
     libraryTarget: 'umd',
-    library: 'node-rules'
+    library: 'NodeRules'
   },
   module: {
     rules: [