Remove the Yielding stuff; since it really never ended up in use by anyone, especially myself. Also adds an optimizer for the interpreted logic for performance improvements. The optimizer is not fast as the compiler, but improves performance regardless (seeing 2-3x gains on .run logic).

Author: TotalTechGeek

async.test.js

@@ -1,12 +1,8 @@
 import { AsyncLogicEngine } from './index.js'
-import YieldStructure from './structures/Yield.js'
-import EngineObject from './structures/EngineObject.js'
 
 const modes = [
   new AsyncLogicEngine(),
-  new AsyncLogicEngine(undefined, {
-    yieldSupported: true
-  })
+  new AsyncLogicEngine(undefined, { disableInterpretedOptimization: true })
 ]
 
 modes.forEach((logic) => {
@@ -832,9 +828,9 @@ modes.forEach((logic) => {
           {
             var: 'toString'
           },
-          {toString: 'hello'}
+          { toString: 'hello' }
         )
-      ).toBe("hello")
+      ).toBe('hello')
     })
 
     test('allow access to functions on objects when enabled', async () => {
@@ -849,65 +845,4 @@ modes.forEach((logic) => {
       ).toBe('hello'.toString)
     })
   })
-
-  if (logic.options.yieldSupported) {
-    describe('Yield technology', () => {
-      test('Yield if variable does not exist', async () => {
-        logic.addMethod(
-          'yieldVar',
-          (key, context, above, engine) => {
-            if (!key) return context
-
-            if (typeof context !== 'object' && key.startsWith('../')) {
-              return engine.methods.var(
-                key.substring(3),
-                above,
-                undefined,
-                engine
-              )
-            }
-
-            if (engine.allowFunctions || typeof (context && context[key]) !== 'function') {
-              if (!(key in context)) {
-                return new YieldStructure({
-                  message: 'Data does not exist in context.'
-                })
-              }
-              return context[key]
-            }
-          },
-          { sync: true }
-        )
-
-        const script = {
-          '+': [1, { '+': [1, 2, 3] }, { yieldVar: 'a' }]
-        }
-
-        const instance = await logic.run(script)
-
-        expect(instance instanceof EngineObject).toBe(true)
-
-        expect(instance.yields().map((i) => ({ ...i }))).toStrictEqual([
-          {
-            _input: null,
-            message: 'Data does not exist in context.',
-            _logic: { yieldVar: 'a' },
-            resumable: null
-          }
-        ])
-
-        expect(instance.logic()).toStrictEqual({
-          '+': [1, 6, { yieldVar: 'a' }]
-        })
-
-        expect(
-          await logic.run(instance.logic(), {
-            a: 1
-          })
-        ).toBe(8)
-
-        expect(await logic.run(script, { a: 1 })).toBe(8)
-      })
-    })
-  }
 })

asyncLogic.js

@@ -1,16 +1,14 @@
 // @ts-check
 'use strict'
 
-import checkYield from './utilities/checkYield.js'
 import defaultMethods from './defaultMethods.js'
-import YieldStructure from './structures/Yield.js'
-import EngineObject from './structures/EngineObject.js'
 import LogicEngine from './logic.js'
 import asyncPool from './asyncPool.js'
 import { Sync, isSync } from './constants.js'
 import declareSync from './utilities/declareSync.js'
 import { buildAsync } from './compiler.js'
 import omitUndefined from './utilities/omitUndefined.js'
+import { optimize } from './async_optimizer.js'
 
 /**
  * An engine capable of running asynchronous JSON Logic.
@@ -19,18 +17,21 @@ 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, permissive?: boolean }} options
+   * @param {{ disableInline?: Boolean, disableInterpretedOptimization?: boolean, permissive?: boolean }} options
    */
   constructor (
     methods = defaultMethods,
-    options = { yieldSupported: false, disableInline: false, permissive: false }
+    options = { disableInline: false, disableInterpretedOptimization: false, permissive: false }
   ) {
     this.methods = { ...methods }
-    /** @type {{yieldSupported?: Boolean, disableInline?: Boolean }} */
-    this.options = { yieldSupported: options.yieldSupported, disableInline: options.disableInline }
+    /** @type {{disableInline?: Boolean, disableInterpretedOptimization?: Boolean }} */
+    this.options = { disableInline: options.disableInline, disableInterpretedOptimization: options.disableInterpretedOptimization }
     this.disableInline = options.disableInline
+    this.disableInterpretedOptimization = options.disableInterpretedOptimization
     this.async = true
     this.fallback = new LogicEngine(methods, options)
+    this.optimizedMap = new WeakMap()
+    this.missesSinceSeen = 0
 
     if (!this.isData) {
       if (!options.permissive) this.isData = () => false
@@ -57,9 +58,7 @@ class AsyncLogicEngine {
 
     if (typeof this.methods[func] === 'function') {
       const input = await this.run(data, context, { above })
-      if (this.options.yieldSupported && (await checkYield(input))) {
-        return { result: input, func }
-      }
+
       const result = await this.methods[func](input, context, above, this)
       return { result: Array.isArray(result) ? Promise.all(result) : result, func }
     }
@@ -72,10 +71,6 @@ class AsyncLogicEngine {
         ? await this.run(data, context, { above })
         : data
 
-      if (this.options.yieldSupported && (await checkYield(parsedData))) {
-        return { result: parsedData, func }
-      }
-
       const result = await (asyncMethod || method)(
         parsedData,
         context,
@@ -92,12 +87,12 @@ class AsyncLogicEngine {
    *
    * @param {String} name The name of the method being added.
    * @param {Function|{ traverse?: Boolean, method?: Function, asyncMethod?: Function, deterministic?: Function | Boolean }} method
-   * @param {{ deterministic?: Boolean, yields?: Boolean, useContext?: Boolean, async?: Boolean, sync?: Boolean }} annotations This is used by the compiler to help determine if it can optimize the function being generated.
+   * @param {{ deterministic?: Boolean, useContext?: Boolean, async?: Boolean, sync?: Boolean }} annotations This is used by the compiler to help determine if it can optimize the function being generated.
    */
   addMethod (
     name,
     method,
-    { deterministic, async, sync, yields, useContext } = {}
+    { deterministic, async, sync, useContext } = {}
   ) {
     if (typeof async === 'undefined' && typeof sync === 'undefined') sync = false
     if (typeof sync !== 'undefined') async = !sync
@@ -113,17 +108,17 @@ class AsyncLogicEngine {
       method = { ...method }
     }
 
-    Object.assign(method, omitUndefined({ yields, deterministic, useContext }))
+    Object.assign(method, omitUndefined({ deterministic, useContext }))
     // @ts-ignore
-    this.fallback.addMethod(name, method, { deterministic, yields, useContext })
+    this.fallback.addMethod(name, method, { deterministic, useContext })
     this.methods[name] = declareSync(method, sync)
   }
 
   /**
    * Adds a batch of functions to the engine
    * @param {String} name
    * @param {Object} obj
-   * @param {{ deterministic?: Boolean, yields?: Boolean, useContext?: Boolean, async?: Boolean, sync?: Boolean }} annotations Not recommended unless you're sure every function from the module will match these annotations.
+   * @param {{ deterministic?: Boolean, useContext?: Boolean, async?: Boolean, sync?: Boolean }} annotations Not recommended unless you're sure every function from the module will match these annotations.
    */
   addModule (name, obj, annotations = {}) {
     Object.getOwnPropertyNames(obj).forEach((key) => {
@@ -138,6 +133,14 @@ class AsyncLogicEngine {
   }
 
   /**
+   * Runs the logic against the data.
+   *
+   * NOTE: With interpreted optimizations enabled, it will cache the execution plan for the logic for
+   * future invocations; if you plan to modify the logic, you should disable this feature, by passing
+   * `disableInterpretedOptimization: true` in the constructor.
+   *
+   * If it detects that a bunch of dynamic objects are being passed in, and it doesn't see the same object,
+   * it will disable the interpreted optimization.
    *
    * @param {*} logic The logic to be executed
    * @param {*} data The data being passed in to the logic to be executed against.
@@ -146,39 +149,35 @@ class AsyncLogicEngine {
    */
   async run (logic, data = {}, options = {}) {
     const { above = [] } = options
+
+    // OPTIMIZER BLOCK //
+    if (this.missesSinceSeen > 500) {
+      this.disableInterpretedOptimization = true
+      this.missesSinceSeen = 0
+    }
+
+    if (!this.disableInterpretedOptimization && typeof logic === 'object' && logic && !this.optimizedMap.has(logic)) {
+      this.optimizedMap.set(logic, optimize(logic, this, above))
+      this.missesSinceSeen++
+      return typeof this.optimizedMap.get(logic) === 'function' ? this.optimizedMap.get(logic)(data, above) : this.optimizedMap.get(logic)
+    }
+
+    if (!this.disableInterpretedOptimization && logic && typeof logic === 'object' && this.optimizedMap.get(logic)) {
+      this.missesSinceSeen = 0
+      return typeof this.optimizedMap.get(logic) === 'function' ? this.optimizedMap.get(logic)(data, above) : this.optimizedMap.get(logic)
+    }
+    // END OPTIMIZER BLOCK //
+
     if (Array.isArray(logic)) {
       const result = await Promise.all(
         logic.map((i) => this.run(i, data, { above }))
       )
 
-      if (this.options.yieldSupported && (await checkYield(result))) {
-        return new EngineObject({
-          result
-        })
-      }
-
       return result
     }
 
     if (logic && typeof logic === 'object' && Object.keys(logic).length > 0) {
-      const { func, result } = await this._parse(logic, data, above)
-
-      if (this.options.yieldSupported && (await checkYield(result))) {
-        if (result instanceof YieldStructure) {
-          if (result._input) {
-            result._logic = { [func]: result._input }
-          }
-          if (!result._logic) {
-            result._logic = logic
-          }
-          return result
-        }
-
-        return new EngineObject({
-          result: { [func]: result.data.result }
-        })
-      }
-
+      const { result } = await this._parse(logic, data, above)
       return result
     }
 

async_optimizer.js

@@ -0,0 +1,78 @@
+// 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'
+
+/**
+ * Turns an expression like { '+': [1, 2] } into a function that can be called with data.
+ * @param {*} logic
+ * @param {*} engine
+ * @param {string} methodName
+ * @param {any[]} above
+ * @returns A method that can be called to execute the logic.
+ */
+function getMethod (logic, engine, methodName, above) {
+  const method = engine.methods[methodName]
+  const called = method.asyncMethod ? method.asyncMethod : method.method ? method.method : method
+
+  if (method.traverse === false) {
+    const args = logic[methodName]
+    return (data, abv) => called(args, data, abv || above, engine)
+  }
+
+  const args = logic[methodName]
+
+  if (Array.isArray(args)) {
+    const optimizedArgs = args.map(l => optimize(l, engine, above))
+    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)
+    return async (data, abv) => {
+      return called(typeof optimizedArgs === 'function' ? await optimizedArgs(data, abv) : optimizedArgs, data, abv || above, engine)
+    }
+  }
+}
+
+/**
+ * Processes the logic for the engine once so that it doesn't need to be traversed again.
+ * @param {*} logic
+ * @param {*} engine
+ * @param {any[]} above
+ * @returns A function that optimizes the logic for the engine in advance.
+ */
+export function optimize (logic, engine, above = []) {
+  if (Array.isArray(logic)) {
+    const arr = logic.map(l => optimize(l, engine, above))
+    return async (data, abv) => map(arr, l => typeof l === 'function' ? l(data, abv) : l)
+  };
+
+  if (logic && typeof logic === 'object') {
+    const keys = Object.keys(logic)
+    const methodName = keys[0]
+
+    const isData = engine.isData(logic, methodName)
+    if (isData) return () => logic
+
+    // If we have a deterministic function, we can just return the result of the evaluation,
+    // basically inlining the operation.
+    const deterministic = !engine.disableInline && isDeterministic(logic, engine, { engine })
+
+    if (methodName in engine.methods) {
+      const result = getMethod(logic, engine, methodName, above)
+      if (deterministic) {
+        let computed
+        // For async, it's a little less straightforward since it could be a promise,
+        // so we'll make it a closure.
+        return async () => {
+          if (!computed) computed = await result()
+          return computed
+        }
+      }
+      return result
+    }
+  }
+
+  return logic
+}

bench/test.js

@@ -1,7 +1,7 @@
 import { LogicEngine, AsyncLogicEngine } from '../index.js'
 import fs from 'fs'
 import { isDeepStrictEqual } from 'util'
-import traverseCopy from '../utilities/traverseCopy.js'
+// import traverseCopy from '../utilities/traverseCopy.js'
 import jl from 'json-logic-js'
 
 const x = new LogicEngine()
@@ -60,28 +60,7 @@ const defined = [
   [{ '*': [{ var: 'x' }, { var: 'y' }] }, { x: 1, y: 3 }, 3]
 ]
 const tests = defined || compatible
-const other =
-  tests ||
-  traverseCopy(tests, [], {
-    mutateKey: (i) => {
-      if (i === 'map') {
-        return 'mapYield'
-      }
-      if (i === 'reduce') {
-        return 'reduceYield'
-      }
-      if (i === 'filter') {
-        return 'filterYield'
-      }
-      if (i === 'every') {
-        return 'everyYield'
-      }
-      if (i === 'some') {
-        return 'someYield'
-      }
-      return i
-    }
-  })
+const other = tests
 const built = other.map((i) => {
   return x.build(i[0])
 })