Add pipe operation to the engine, I believe this is fairly general purpose

Author: TotalTechGeek

compiler.js

@@ -19,14 +19,16 @@ import asyncIterators from './async_iterators.js'
  */
 function compileTemplate (strings, ...items) {
   let res = ''
+  const buildState = this
   for (let i = 0; i < strings.length; i++) {
     res += strings[i]
     if (i < items.length) {
       if (typeof items[i] === 'function') {
         this.methods.push(items[i])
-        res += 'methods[' + (this.methods.length - 1) + ']'
+        if (!isSync(items[i])) buildState.asyncDetected = true
+        res += (isSync(items[i]) ? '' : ' await ') + 'methods[' + (buildState.methods.length - 1) + ']'
       } else if (items[i] && typeof items[i][Compiled] !== 'undefined') res += items[i][Compiled]
-      else res += buildString(items[i], this)
+      else res += buildString(items[i], buildState)
     }
   }
   return { [Compiled]: res }

defaultMethods.js

@@ -393,6 +393,33 @@ const defaultMethods = {
     return res
   },
   keys: (obj) => typeof obj === 'object' ? Object.keys(obj) : [],
+  pipe: {
+    traverse: false,
+    [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
+    method: (args, context, above, engine) => {
+      if (!Array.isArray(args)) throw new Error('Data for pipe must be an array')
+      let answer = (engine.fallback || engine).run(args[0], context, { above: [args, context, ...above] })
+      for (let i = 1; i < args.length; i++) answer = (engine.fallback || engine).run(args[i], answer, { above: [args, context, ...above] })
+      return answer
+    },
+    asyncMethod: async (args, context, above, engine) => {
+      if (!Array.isArray(args)) throw new Error('Data for pipe must be an array')
+      let answer = await engine.run(args[0], context, { above: [args, context, ...above] })
+      for (let i = 1; i < args.length; i++) answer = await engine.run(args[i], answer, { above: [args, context, ...above] })
+      return answer
+    },
+    compile: (args, buildState) => {
+      let res = buildState.compile`${args[0]}`
+      for (let i = 1; i < args.length; i++) res = buildState.compile`${build(args[i], { ...buildState, extraArguments: 'above' })}(${res}, [null, context, ...above])`
+      return res
+    },
+    deterministic: (data, buildState) => {
+      if (!Array.isArray(data)) return false
+      data = [...data]
+      const first = data.shift()
+      return isDeterministic(first, buildState.engine, buildState) && isDeterministic(data, buildState.engine, { ...buildState, insideIterator: true })
+    }
+  },
   eachKey: {
     traverse: false,
     [Sync]: (data, buildState) => isSyncDeep(Object.values(data[Object.keys(data)[0]]), buildState.engine, buildState),
@@ -506,7 +533,7 @@ function createArrayIterativeMethod (name, useTruthy = false) {
       if (async) {
         if (!isSyncDeep(mapper, buildState.engine, buildState)) {
           buildState.detectAsync = true
-          return buildState.compile`await asyncIterators[${name}](${selector} || [], (i, x) => ${build(mapper, mapState)}(i, x, [{ item: null }, context, ...above]))`
+          return buildState.compile`await asyncIterators[${name}](${selector} || [], async (i, x) => ${build(mapper, mapState)}(i, x, [{ item: null }, context, ...above]))`
         }
       }
 

general.test.js

@@ -162,6 +162,11 @@ describe('Various Test Cases', () => {
     for (const engine of [...normalEngines, ...permissiveEngines]) await testEngine(engine, { map: [[0, 1, 2, 3], { '+': [{ var: '' }, { var: '../index' }] }] }, {}, [0, 2, 4, 6])
   })
 
+  it('is able to use pipe', async () => {
+    for (const engine of [...normalEngines, ...permissiveEngines]) await testEngine(engine, { pipe: ['Austin', { cat: ['Hello, ', { var: '' }, '!'] }] }, {}, 'Hello, Austin!')
+    for (const engine of [...normalEngines, ...permissiveEngines]) await testEngine(engine, { pipe: [{ var: 'name' }, { cat: ['Hello, ', { var: '' }, '!'] }] }, { name: 'Austin' }, 'Hello, Austin!')
+  })
+
   it('disables interpreted optimization when it realizes it will not be faster', async () => {
     for (const engine of [...normalEngines, ...permissiveEngines]) {
       const disableInterpretedOptimization = engine.disableInterpretedOptimization

package.json

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