Merge branch 'master' of https://github.com/TotalTechGeek/json-logic-engine

Author: TotalTechGeek

asyncLogic.js

@@ -19,13 +19,14 @@ class AsyncLogicEngine {
   /**
    *
    * @param {Object} methods An object that stores key-value pairs between the names of the commands & the functions they execute.
-   * @param {{ yieldSupported?: Boolean, disableInline?: Boolean }} options
+   * @param {{ yieldSupported?: Boolean, disableInline?: Boolean, permissive?: boolean }} options
    */
   constructor (
     methods = defaultMethods,
-    options = { yieldSupported: false, disableInline: false }
+    options = { yieldSupported: false, disableInline: false, permissive: false }
   ) {
     this.methods = { ...methods }
+    /** @type {{yieldSupported?: Boolean, disableInline?: Boolean, permissive?: boolean}} */
     this.options = { ...options }
     this.disableInline = options.disableInline
     this.async = true
@@ -34,22 +35,22 @@ class AsyncLogicEngine {
 
   /**
    * An internal method used to parse through the JSON Logic at a lower level.
-   * @param {String} func The name of the function being executed
-   * @param {*} data The data to traverse / execute upon
+   * @param {*} logic The logic being executed.
    * @param {*} context The context of the logic being run (input to the function.)
    * @param {*} above The context above (can be used for handlebars-style data traversal.)
-   * @returns {Promise}
+   * @returns {Promise<{ func: string, result: * }>}
    */
-  async _parse (func, data, context, above) {
+  async _parse (logic, context, above) {
+    const [func] = Object.keys(logic)
+    const data = logic[func]
     if (this.methods[func]) {
       if (typeof this.methods[func] === 'function') {
         const input = await this.run(data, context, { above })
         if (this.options.yieldSupported && (await checkYield(input))) {
-          return input
+          return { result: input, func }
         }
         const result = await this.methods[func](input, context, above, this)
-
-        return Array.isArray(result) ? Promise.all(result) : result
+        return { result: Array.isArray(result) ? Promise.all(result) : result, func }
       }
 
       if (typeof this.methods[func] === 'object') {
@@ -61,7 +62,7 @@ class AsyncLogicEngine {
           : data
 
         if (this.options.yieldSupported && (await checkYield(parsedData))) {
-          return parsedData
+          return { result: parsedData, func }
         }
 
         const result = await (asyncMethod || method)(
@@ -70,9 +71,11 @@ class AsyncLogicEngine {
           above,
           this
         )
-        return Array.isArray(result) ? Promise.all(result) : result
+        return { result: Array.isArray(result) ? Promise.all(result) : result, func }
       }
     }
+    if (this.options.permissive) return { result: logic, func }
+    throw new Error(`Method '${func}' was not found in the Logic Engine.`)
   }
 
   /**
@@ -148,8 +151,7 @@ class AsyncLogicEngine {
     }
 
     if (logic && typeof logic === 'object') {
-      const [func] = Object.keys(logic)
-      const result = await this._parse(func, logic[func], data, above)
+      const { func, result } = await this._parse(logic, data, above)
 
       if (this.options.yieldSupported && (await checkYield(result))) {
         if (result instanceof YieldStructure) {

compiler.js

@@ -36,12 +36,13 @@ import asyncIterators from './async_iterators.js'
  * @param {*} x
  * @returns
  */
-function isPrimitive (x) {
+function isPrimitive (x, preserveObject) {
   if (typeof x === 'number' && (x === Infinity || x === -Infinity || Number.isNaN(x))) return false
   return (
     x === null ||
     x === undefined ||
-    ['Number', 'String', 'Boolean', 'Object'].includes(x.constructor.name)
+    ['Number', 'String', 'Boolean'].includes(x.constructor.name) ||
+    (!preserveObject && x.constructor.name === 'Object')
   )
 }
 
@@ -245,8 +246,8 @@ function buildString (method, buildState = {}) {
     values = [],
     engine
   } = buildState
-  function pushValue (value) {
-    if (isPrimitive(value)) return JSON.stringify(value)
+  function pushValue (value, preserveObject = false) {
+    if (isPrimitive(value, preserveObject)) return JSON.stringify(value)
     values.push(value)
     return `values[${values.length - 1}]`
   }
@@ -271,7 +272,11 @@ function buildString (method, buildState = {}) {
     buildState.useContext || (engine.methods[func] || {}).useContext
 
   if (method && typeof method === 'object') {
-    if (!engine.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+    if (!engine.methods[func]) {
+      // If we are in permissive mode, we will just return the object.
+      if (engine.options.permissive) return pushValue(method, true)
+      throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+    }
     functions[func] = functions[func] || 2
 
     if (
@@ -280,7 +285,7 @@ function buildString (method, buildState = {}) {
       isDeterministic(method, engine, buildState)
     ) {
       if (isDeepSync(method, engine)) {
-        return pushValue((engine.fallback || engine).run(method))
+        return pushValue((engine.fallback || engine).run(method), true)
       } else if (!buildState.avoidInlineAsync) {
         processing.push(engine.run(method).then((i) => pushValue(i)))
         return `__%%%${processing.length - 1}%%%__`

defaultMethods.js

@@ -16,6 +16,9 @@ function isDeterministic (method, engine, buildState) {
   if (method && typeof method === 'object') {
     const func = Object.keys(method)[0]
     const lower = method[func]
+
+    if (!engine.methods[func] && engine.options.permissive) return true
+
     if (engine.methods[func].traverse === false) {
       return typeof engine.methods[func].deterministic === 'function'
         ? engine.methods[func].deterministic(lower, buildState)

general.test.js

@@ -0,0 +1,103 @@
+
+import assert from 'assert'
+import { LogicEngine, AsyncLogicEngine } from './index.js'
+
+const normalEngines = [
+  new LogicEngine(),
+  new AsyncLogicEngine(),
+  new LogicEngine(undefined, { yieldSupported: true }),
+  new AsyncLogicEngine(undefined, { yieldSupported: true })
+]
+
+const permissiveEngines = [
+  new LogicEngine(undefined, { permissive: true }),
+  new AsyncLogicEngine(undefined, { permissive: true }),
+  new LogicEngine(undefined, { yieldSupported: true, permissive: true }),
+  new AsyncLogicEngine(undefined, { yieldSupported: true, permissive: true })
+]
+
+async function testEngineAsync (engine, rule, data, expected, matcher = 'deepStrictEqual') {
+  // run
+  if (expected === Error) {
+    try {
+      await engine.run(rule, data)
+      throw new Error('Should have failed')
+    } catch (e) {}
+  } else {
+    const result = await engine.run(rule, data)
+    assert[matcher](result, expected)
+  }
+
+  // build
+  if (expected === Error) {
+    try {
+      const built = await engine.build(rule)
+      await built(data)
+      throw new Error('Should have failed')
+    } catch (e) {}
+  } else {
+    const built = await engine.build(rule)
+    const builtResult = await built(data)
+    assert[matcher](builtResult, expected)
+  }
+}
+
+function testEngine (engine, rule, data, expected, matcher = 'deepStrictEqual') {
+  if (engine instanceof AsyncLogicEngine) {
+    return testEngineAsync(engine, rule, data, expected, matcher)
+  }
+
+  // run
+  if (expected === Error) {
+    try {
+      engine.run(rule, data)
+      throw new Error('Should have failed')
+    } catch (e) {}
+  } else {
+    const result = engine.run(rule, data)
+    assert[matcher](result, expected)
+  }
+
+  // build
+  if (expected === Error) {
+    try {
+      const built = engine.build(rule)
+      built(data)
+      throw new Error('Should have failed')
+    } catch (e) {}
+  } else {
+    const built = engine.build(rule)
+    const builtResult = built(data)
+    assert[matcher](builtResult, expected)
+  }
+}
+
+describe('Various Test Cases', () => {
+  it('Should fail when an unrecognized method is used.', async () => {
+    for (const engine of normalEngines) await testEngine(engine, { unknown: true }, {}, Error)
+  })
+
+  it('Should return the object when an unrecognized method is used.', async () => {
+    for (const engine of permissiveEngines) {
+      await testEngine(engine, { unknown: true }, {}, { unknown: true })
+
+      await testEngine(engine, {
+        if: [true, { unknown: true, unknown2: 2 }, 5]
+      }, {}, { unknown: true, unknown2: 2 })
+
+      const obj = { unknown: true, unknown2: 2 }
+
+      // test with deterministic function returning a passively preserved element.
+      await testEngine(engine, {
+        if: [true, obj, 5]
+      }, {}, obj, 'equal')
+
+      // test with a non-deterministic function returning a passively preserved element.
+      await testEngine(engine, {
+        if: [{ var: 'data' }, obj, 5]
+      }, {
+        data: true
+      }, obj, 'equal')
+    }
+  })
+})

logic.js

@@ -16,45 +16,46 @@ class LogicEngine {
   /**
    *
    * @param {Object} methods An object that stores key-value pairs between the names of the commands & the functions they execute.
-   * @param {{ yieldSupported?: Boolean, disableInline?: Boolean }} options
+   * @param {{ yieldSupported?: Boolean, disableInline?: Boolean, permissive?: boolean }} options
    */
   constructor (
     methods = defaultMethods,
-    options = { yieldSupported: false, disableInline: false }
+    options = { yieldSupported: false, disableInline: false, permissive: false }
   ) {
     this.disableInline = options.disableInline
     this.methods = { ...methods }
+    /** @type {{yieldSupported?: Boolean, disableInline?: Boolean, permissive?: boolean}} */
     this.options = { ...options }
   }
 
   /**
    * An internal method used to parse through the JSON Logic at a lower level.
-   * @param {String} func The name of the function being executed
-   * @param {*} data The data to traverse / execute upon
+   * @param {*} logic The logic being executed.
    * @param {*} context The context of the logic being run (input to the function.)
    * @param {*} above The context above (can be used for handlebars-style data traversal.)
-   * @returns {*}
+   * @returns {{ result: *, func: string }}
    */
-  _parse (func, data, context, above) {
+  _parse (logic, context, above) {
+    const [func] = Object.keys(logic)
+    const data = logic[func]
     if (this.methods[func]) {
       if (typeof this.methods[func] === 'function') {
         const input = this.run(data, context, { above })
-        if (this.options.yieldSupported && checkYield(input)) return input
-        return this.methods[func](input, context, above, this)
+        if (this.options.yieldSupported && checkYield(input)) return { result: input, func }
+        return { result: this.methods[func](input, context, above, this), func }
       }
       if (typeof this.methods[func] === 'object') {
         const { method, traverse } = this.methods[func]
-        const shouldTraverse =
-          typeof traverse === 'undefined' ? true : traverse
+        const shouldTraverse = typeof traverse === 'undefined' ? true : traverse
         const parsedData = shouldTraverse
           ? this.run(data, context, { above })
           : data
-        if (this.options.yieldSupported && checkYield(parsedData)) {
-          return parsedData
-        }
-        return method(parsedData, context, above, this)
+        if (this.options.yieldSupported && checkYield(parsedData)) return { result: parsedData, func }
+        return { result: method(parsedData, context, above, this), func }
       }
     }
+    if (this.options.permissive) return { result: logic, func }
+    throw new Error(`Method '${func}' was not found in the Logic Engine.`)
   }
 
   /**
@@ -111,8 +112,7 @@ class LogicEngine {
       return result
     }
     if (logic && typeof logic === 'object') {
-      const [func] = Object.keys(logic)
-      const result = this._parse(func, logic[func], data, above)
+      const { func, result } = this._parse(logic, data, above)
       if (this.options.yieldSupported && checkYield(result)) {
         if (result instanceof YieldStructure) {
           if (result._input) {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-logic-engine",
-  "version": "1.2.0",
+  "version": "1.2.3",
   "description": "Construct complex rules with JSON & process them.",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",