Add one additional optimization to the async optimizer to allow for async optimizations on traverse: false w/ async method defs

Author: TotalTechGeek

asyncLogic.js

@@ -4,7 +4,7 @@
 import defaultMethods from './defaultMethods.js'
 import LogicEngine from './logic.js'
 import asyncPool from './asyncPool.js'
-import { Sync, isSync } from './constants.js'
+import { isSync } from './constants.js'
 import declareSync from './utilities/declareSync.js'
 import { buildAsync } from './compiler.js'
 import omitUndefined from './utilities/omitUndefined.js'

async_optimizer.js

@@ -16,8 +16,12 @@ function getMethod (logic, engine, methodName, above) {
   const method = engine.methods[methodName]
   const called = method.asyncMethod ? method.asyncMethod : method.method ? method.method : method
 
-  // Todo: Like "deterministic", we should add "sync" to the method object to determine if the structure can be run synchronously.
   if (method.traverse === false) {
+    if (typeof method[Sync] === 'function' && method[Sync](logic, { engine })) {
+      const called = method.method ? method.method : method
+      return declareSync((data, abv) => called(logic[methodName], data, abv || above, engine), true)
+    }
+
     const args = logic[methodName]
     return (data, abv) => called(args, data, abv || above, engine)
   }

defaultMethods.js

@@ -33,6 +33,23 @@ function isDeterministic (method, engine, buildState) {
   return true
 }
 
+function isSyncDeep (method, engine, buildState) {
+  if (Array.isArray(method)) {
+    return method.every((i) => isSyncDeep(i, engine, buildState))
+  }
+
+  if (method && typeof method === 'object') {
+    const func = Object.keys(method)[0]
+    const lower = method[func]
+    if (engine.isData(method, func)) return true
+    if (!engine.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+    if (engine.methods[func].traverse === false) return typeof engine.methods[func][Sync] === 'function' ? engine.methods[func][Sync](lower, buildState) : engine.methods[func][Sync]
+    return typeof engine.methods[func][Sync] === 'function' ? engine.methods[func][Sync](lower, buildState) : engine.methods[func][Sync] && isSyncDeep(lower, engine, buildState)
+  }
+
+  return true
+}
+
 const defaultMethods = {
   '+': (data) => {
     if (typeof data === 'string') return +data
@@ -77,7 +94,7 @@ const defaultMethods = {
     method: (input, context, above, engine) => {
       if (!Array.isArray(input)) throw new InvalidControlInput(input)
 
-      if (input.length === 1) return engine.run(input[0], context, { above })
+      if (input.length === 1) return (engine.fallback || engine).run(input[0], context, { above })
       if (input.length < 2) return null
 
       input = [...input]
@@ -91,14 +108,15 @@ const defaultMethods = {
         const check = input.shift()
         const onTrue = input.shift()
 
-        const test = engine.run(check, context, { above })
+        const test = (engine.fallback || engine).run(check, context, { above })
 
         // if the condition is true, run the true branch
-        if (engine.truthy(test)) return engine.run(onTrue, context, { above })
+        if (engine.truthy(test)) return (engine.fallback || engine).run(onTrue, context, { above })
       }
 
-      return engine.run(onFalse, context, { above })
+      return (engine.fallback || engine).run(onFalse, context, { above })
     },
+    [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     deterministic: (data, buildState) => {
       return isDeterministic(data, buildState.engine, buildState)
     },
@@ -316,15 +334,15 @@ const defaultMethods = {
     method: (input, context, above, engine) => {
       if (!Array.isArray(input)) throw new InvalidControlInput(input)
       let [selector, mapper, defaultValue] = input
-      defaultValue = engine.run(defaultValue, context, {
+      defaultValue = (engine.fallback || engine).run(defaultValue, context, {
         above
       })
       selector =
-        engine.run(selector, context, {
+        (engine.fallback || engine).run(selector, context, {
           above
         }) || []
       const func = (accumulator, current) => {
-        return engine.run(
+        return (engine.fallback || engine).run(
           mapper,
           {
             accumulator,
@@ -340,6 +358,7 @@ const defaultMethods = {
       }
       return selector.reduce(func, defaultValue)
     },
+    [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     asyncMethod: async (input, context, above, engine) => {
       if (!Array.isArray(input)) throw new InvalidControlInput(input)
       let [selector, mapper, defaultValue] = input
@@ -385,7 +404,7 @@ const defaultMethods = {
         const item = object[key]
         Object.defineProperty(accumulator, key, {
           enumerable: true,
-          value: engine.run(item, context, { above })
+          value: (engine.fallback || engine).run(item, context, { above })
         })
         return accumulator
       }, {})
@@ -445,16 +464,17 @@ function createArrayIterativeMethod (name, useTruthy = false) {
         })
       )
     },
+    [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     method: (input, context, above, engine) => {
       if (!Array.isArray(input)) throw new InvalidControlInput(input)
       let [selector, mapper] = input
       selector =
-        engine.run(selector, context, {
+        (engine.fallback || engine).run(selector, context, {
           above
         }) || []
 
       return selector[name]((i, index) => {
-        const result = engine.run(mapper, i, {
+        const result = (engine.fallback || engine).run(mapper, i, {
           above: [{ item: selector, index }, context, ...above]
         })
         return useTruthy ? engine.truthy(result) : result

general.test.js

@@ -82,6 +82,10 @@ describe('Various Test Cases', () => {
     for (const engine of permissiveEngines) await testEngine(engine, {}, {}, {})
   })
 
+  it('Should work with preserve', async () => {
+    for (const engine of [...permissiveEngines, ...normalEngines]) await testEngine(engine, { preserve: { x: 5 } }, null, { x: 5 })
+  })
+
   it('Should return the object when an unrecognized method is used.', async () => {
     for (const engine of permissiveEngines) {
       await testEngine(engine, { unknown: true }, {}, { unknown: true })

package.json

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