Update examples to use async/await

Author: Cache Hamm

examples/01-hello-world.js

@@ -10,52 +10,49 @@
  */
 
 require('colors')
-const { Engine, Rule } = require('json-rules-engine')
+const { Engine } = require('json-rules-engine')
 
-/**
- * Setup a new engine
- */
-const engine = new Engine()
+async function start() {
+  /**
+   * Setup a new engine
+   */
+  const engine = new Engine()
 
-/**
- * Create a rule
- */
-const rule = new Rule({
-  // define the 'conditions' for when "hello world" should display
-  conditions: {
-    all: [{
-      fact: 'displayMessage',
-      operator: 'equal',
-      value: true
-    }]
-  },
-  // define the 'event' that will fire when the condition evaluates truthy
-  event: {
-    type: 'message',
-    params: {
-      data: 'hello-world!'
+  /**
+   * Create a rule
+   */
+  engine.addRule({
+    // define the 'conditions' for when "hello world" should display
+    conditions: {
+      all: [{
+        fact: 'displayMessage',
+        operator: 'equal',
+        value: true
+      }]
+    },
+    // define the 'event' that will fire when the condition evaluates truthy
+    event: {
+      type: 'message',
+      params: {
+        data: 'hello-world!'
+      }
     }
-  }
-})
+  })
 
-// add rule to engine
-engine.addRule(rule)
+  /**
+   * Define a 'displayMessage' as a constant value
+   * Fact values do NOT need to be known at engine runtime; see the
+   * 03-dynamic-facts.js example for how to pull in data asynchronously during runtime
+   */
+  const facts = { displayMessage: true }
 
-/**
- * Define a 'displayMessage' as a constant value
- * Fact values do NOT need to be known at engine runtime; see the
- * 03-dynamic-facts.js example for how to pull in data asynchronously during runtime
- */
-const facts = { displayMessage: true }
+  // engine.run() evaluates the rule using the facts provided
+  const { successResults } = await engine.run(facts)
 
-// run the engine
-engine
-  .run(facts)
-  .then(results => { // engine returns an object with a list of events with truthy conditions
-    results.events.map(event => console.log(event.params.data.green))
-  })
-  .catch(console.log)
+  successResults.map(result => console.log(result.event.params.data.green))
+}
 
+start()
 /*
  * OUTPUT:
  *

examples/02-nested-boolean-logic.js

@@ -11,62 +11,61 @@
 
 require('colors')
 const { Engine } = require('json-rules-engine')
-/**
- * Setup a new engine
- */
-const engine = new Engine()
 
-// define a rule for detecting the player has exceeded foul limits.  Foul out any player who:
-// (has committed 5 fouls AND game is 40 minutes) OR (has committed 6 fouls AND game is 48 minutes)
-engine.addRule({
-  conditions: {
-    any: [{
-      all: [{
-        fact: 'gameDuration',
-        operator: 'equal',
-        value: 40
-      }, {
-        fact: 'personalFoulCount',
-        operator: 'greaterThanInclusive',
-        value: 5
-      }]
-    }, {
-      all: [{
-        fact: 'gameDuration',
-        operator: 'equal',
-        value: 48
+async function start() {
+  /**
+   * Setup a new engine
+   */
+  const engine = new Engine()
+
+  // define a rule for detecting the player has exceeded foul limits.  Foul out any player who:
+  // (has committed 5 fouls AND game is 40 minutes) OR (has committed 6 fouls AND game is 48 minutes)
+  engine.addRule({
+    conditions: {
+      any: [{
+        all: [{
+          fact: 'gameDuration',
+          operator: 'equal',
+          value: 40
+        }, {
+          fact: 'personalFoulCount',
+          operator: 'greaterThanInclusive',
+          value: 5
+        }]
       }, {
-        fact: 'personalFoulCount',
-        operator: 'greaterThanInclusive',
-        value: 6
+        all: [{
+          fact: 'gameDuration',
+          operator: 'equal',
+          value: 48
+        }, {
+          fact: 'personalFoulCount',
+          operator: 'greaterThanInclusive',
+          value: 6
+        }]
       }]
-    }]
-  },
-  event: { // define the event to fire when the conditions evaluate truthy
-    type: 'fouledOut',
-    params: {
-      message: 'Player has fouled out!'
+    },
+    event: { // define the event to fire when the conditions evaluate truthy
+      type: 'fouledOut',
+      params: {
+        message: 'Player has fouled out!'
+      }
     }
-  }
-})
+  })
 
-/**
- * define the facts
- * note: facts may be loaded asynchronously at runtime; see the advanced example below
- */
-const facts = {
-  personalFoulCount: 6,
-  gameDuration: 40
-}
+  /**
+   * define the facts
+   * note: facts may be loaded asynchronously at runtime; see the advanced example below
+   */
+  const facts = {
+    personalFoulCount: 6,
+    gameDuration: 40
+  }
 
-// run the engine
-engine
-  .run(facts)
-  .then(results => { // run() return and object containing events with truthy conditions
-    results.events.map(event => console.log(event.params.message.red))
-  })
-  .catch(console.log)
+  const { successResults } = await engine.run(facts)
 
+  successResults.map(result => console.log(result.event.params.message.red))
+}
+start()
 /*
  * OUTPUT:
  *

examples/03-dynamic-facts.js

@@ -12,69 +12,69 @@
 
 require('colors')
 const { Engine } = require('json-rules-engine')
+
 // example client for making asynchronous requests to an api, database, etc
 const apiClient = require('./support/account-api-client')
 
-/**
- * Setup a new engine
- */
-const engine = new Engine()
+async function start() {
+  /**
+   * Setup a new engine
+   */
+  const engine = new Engine()
 
-/**
- * Rule for identifying microsoft employees taking pto on christmas
- *
- * the account-information fact returns:
- *  { company: 'XYZ', status: 'ABC', ptoDaysTaken: ['YYYY-MM-DD', 'YYYY-MM-DD'] }
- */
-const microsoftRule = {
-  conditions: {
-    all: [{
-      fact: 'account-information',
-      operator: 'equal',
-      value: 'microsoft',
-      path: '$.company' // access the 'company' property of "account-information"
-    }, {
-      fact: 'account-information',
-      operator: 'in',
-      value: ['active', 'paid-leave'], // 'status'' can be active or paid-leave
-      path: '$.status' // access the 'status' property of "account-information"
-    }, {
-      fact: 'account-information',
-      operator: 'contains',
-      value: '2016-12-25',
-      path: '$.ptoDaysTaken' // access the 'ptoDaysTaken' property of "account-information"
-    }]
-  },
-  event: {
-    type: 'microsoft-christmas-pto',
-    params: {
-      message: 'current microsoft employee taking christmas day off'
+  /**
+   * Rule for identifying microsoft employees taking pto on christmas
+   *
+   * the account-information fact returns:
+   *  { company: 'XYZ', status: 'ABC', ptoDaysTaken: ['YYYY-MM-DD', 'YYYY-MM-DD'] }
+   */
+  const microsoftRule = {
+    conditions: {
+      all: [{
+        fact: 'account-information',
+        operator: 'equal',
+        value: 'microsoft',
+        path: '$.company' // access the 'company' property of "account-information"
+      }, {
+        fact: 'account-information',
+        operator: 'in',
+        value: ['active', 'paid-leave'], // 'status'' can be active or paid-leave
+        path: '$.status' // access the 'status' property of "account-information"
+      }, {
+        fact: 'account-information',
+        operator: 'contains',
+        value: '2016-12-25',
+        path: '$.ptoDaysTaken' // access the 'ptoDaysTaken' property of "account-information"
+      }]
+    },
+    event: {
+      type: 'microsoft-christmas-pto',
+      params: {
+        message: 'current microsoft employee taking christmas day off'
+      }
     }
   }
-}
-engine.addRule(microsoftRule)
+  engine.addRule(microsoftRule)
 
-/**
- * 'account-information' fact executes an api call and retrieves account data, feeding the results
- * into the engine.  The major advantage of this technique is that although there are THREE conditions
- * requiring this data, only ONE api call is made.  This results in much more efficient runtime performance.
- */
-engine.addFact('account-information', function (params, almanac) {
-  return almanac.factValue('accountId')
-    .then(accountId => {
-      return apiClient.getAccountInformation(accountId)
-    })
-})
-
-// define fact(s) known at runtime
-const facts = { accountId: 'lincoln' }
-engine
-  .run(facts)
-  .then(results => {
-    if (!results.events.length) return
-    console.log(facts.accountId + ' is a ' + results.events.map(event => event.params.message))
+  /**
+   * 'account-information' fact executes an api call and retrieves account data, feeding the results
+   * into the engine.  The major advantage of this technique is that although there are THREE conditions
+   * requiring this data, only ONE api call is made.  This results in much more efficient runtime performance.
+   */
+  engine.addFact('account-information', function (params, almanac) {
+    return almanac.factValue('accountId')
+      .then(accountId => {
+        return apiClient.getAccountInformation(accountId)
+      })
   })
-  .catch(err => console.log(err.stack))
+
+  // define fact(s) known at runtime
+  const facts = { accountId: 'lincoln' }
+  const { successResults } = await engine.run(facts)
+
+  console.log(facts.accountId + ' is a ' + successResults.map(result => result.event.params.message))
+}
+start()
 
 /*
  * OUTPUT: