Add some optimizations to the async optimizer to execute parts of the logic synchronously if possible.

Author: TotalTechGeek

asyncLogic.js

@@ -240,7 +240,7 @@ class AsyncLogicEngine {
       }, top !== true && isSync(constructedFunction))
       // we can avoid the async pool if the constructed function is synchronous since the data
       // can't be updated :)
-      if (top === true && constructedFunction && !constructedFunction[Sync] && typeof constructedFunction === 'function') {
+      if (top === true && constructedFunction && !isSync(constructedFunction) && typeof constructedFunction === 'function') {
         // we use this async pool so that we can execute these in parallel without having
         // concerns about the data.
         return asyncPool({

async_optimizer.js

@@ -1,6 +1,8 @@
 // This is the synchronous version of the optimizer; which the Async one should be based on.
 import { isDeterministic } from './compiler.js'
 import { map } from './async_iterators.js'
+import { isSync, Sync } from './constants.js'
+import declareSync from './utilities/declareSync.js'
 
 /**
  * Turns an expression like { '+': [1, 2] } into a function that can be called with data.
@@ -14,6 +16,7 @@ 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) {
     const args = logic[methodName]
     return (data, abv) => called(args, data, abv || above, engine)
@@ -23,12 +26,27 @@ function getMethod (logic, engine, methodName, above) {
 
   if (Array.isArray(args)) {
     const optimizedArgs = args.map(l => optimize(l, engine, above))
+
+    if (isSync(optimizedArgs) && (method.method || method[Sync])) {
+      const called = method.method ? method.method : method
+      return declareSync((data, abv) => {
+        const evaluatedArgs = optimizedArgs.map(l => typeof l === 'function' ? l(data, abv) : l)
+        return called(evaluatedArgs, data, abv || above, engine)
+      }, true)
+    }
+
     return async (data, abv) => {
       const evaluatedArgs = await map(optimizedArgs, l => typeof l === 'function' ? l(data, abv) : l)
       return called(evaluatedArgs, data, abv || above, engine)
     }
   } else {
     const optimizedArgs = optimize(args, engine, above)
+
+    if (isSync(optimizedArgs) && (method.method || method[Sync])) {
+      const called = method.method ? method.method : method
+      return declareSync((data, abv) => called(typeof optimizedArgs === 'function' ? optimizedArgs(data, abv) : optimizedArgs, data, abv || above, engine), true)
+    }
+
     return async (data, abv) => {
       return called(typeof optimizedArgs === 'function' ? await optimizedArgs(data, abv) : optimizedArgs, data, abv || above, engine)
     }
@@ -45,6 +63,7 @@ function getMethod (logic, engine, methodName, above) {
 export function optimize (logic, engine, above = []) {
   if (Array.isArray(logic)) {
     const arr = logic.map(l => optimize(l, engine, above))
+    if (isSync(arr)) return declareSync((data, abv) => arr.map(l => typeof l === 'function' ? l(data, abv) : l), true)
     return async (data, abv) => map(arr, l => typeof l === 'function' ? l(data, abv) : l)
   };
 
@@ -63,6 +82,14 @@ export function optimize (logic, engine, above = []) {
       const result = getMethod(logic, engine, methodName, above)
       if (deterministic) {
         let computed
+
+        if (isSync(result)) {
+          return declareSync(() => {
+            if (!computed) computed = result()
+            return computed
+          }, true)
+        }
+
         // For async, it's a little less straightforward since it could be a promise,
         // so we'll make it a closure.
         return async () => {

bench/package-lock.json

@@ -9,6 +9,7 @@
   "author": "Jesse Daniel Mitchell",
   "license": "ISC",
   "dependencies": {
+    "@bestow/jsonlogic-rs": "^0.4.0",
     "json-logic-js": "^2.0.1",
     "json-rules-engine": "^6.0.1"
   },

bench/package.json

@@ -3,6 +3,7 @@ import fs from 'fs'
 import { isDeepStrictEqual } from 'util'
 // import traverseCopy from '../utilities/traverseCopy.js'
 import jl from 'json-logic-js'
+import rust from '@bestow/jsonlogic-rs'
 
 const x = new LogicEngine(undefined, { compatible: true })
 const y = new AsyncLogicEngine(undefined, { compatible: true })
@@ -73,6 +74,14 @@ for (let j = 0; j < tests.length; j++) {
 }
 console.timeEnd('json-logic-js')
 
+console.time('json-logic-rs')
+for (let j = 0; j < tests.length; j++) {
+  for (let i = 0; i < 1e5; i++) {
+    rust.apply(tests[j][0], tests[j][1])
+  }
+}
+console.timeEnd('json-logic-rs')
+
 x.disableInterpretedOptimization = true
 console.time('le interpreted')
 for (let j = 0; j < other.length; j++) {
@@ -104,6 +113,15 @@ async function run () {
       return y.build(i[0])
     })
   )
+
+  console.time('le async interpreted')
+  for (let j = 0; j < tests.length; j++) {
+    for (let i = 0; i < 1e5; i++) {
+      await y.run(tests[j][0], tests[j][1])
+    }
+  }
+  console.timeEnd('le async interpreted')
+
   console.time('le async built')
   for (let j = 0; j < tests.length; j++) {
     for (let i = 0; i < 1e5; i++) {

bench/test.js

@@ -4,7 +4,21 @@
 export const Sync = Symbol.for('json_logic_sync')
 export const Override = Symbol.for('json_logic_override')
 export const EfficientTop = Symbol.for('json_logic_efficientTop')
-export const isSync = (x) => Boolean(typeof x !== 'function' || x[Sync])
+
+/**
+ * Checks if an item is synchronous.
+ * This allows us to optimize the logic a bit
+ * further so that we don't need to await everything.
+ *
+ * @param {*} item
+ * @returns {Boolean}
+ */
+export function isSync (item) {
+  if (typeof item === 'function') return item[Sync] === true
+  if (Array.isArray(item)) return item.every(isSync)
+  return true
+}
+
 export default {
   Sync,
   Override,

constants.js

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