feat: implement vararg operators (WIP)

Author: josdejong

README.md

@@ -210,6 +210,7 @@ filter(.age >= 18 and .age <= 65)
 
 The operators have the following precedence, from highest to lowest:
 
+- `|`
 - `^`
 - `*`, `/`, `%`
 - `+`, `-`

src/functions.ts

@@ -27,6 +27,20 @@ export function buildFunction(fn: (...args: unknown[]) => unknown): FunctionBuil
   }
 }
 
+const validateMaxArgs = (fn: (...args: unknown[]) => unknown) => {
+  return (...args: unknown[]) => {
+    if (args.length > fn.length) {
+      throw new Error('Too many arguments')
+    }
+
+    return fn(...args)
+  }
+}
+
+const reduceArgs = (fn: (...args: unknown[]) => unknown) => {
+  return (...args: unknown[]) => args.reduce(fn)
+}
+
 export const functions: FunctionBuildersMap = {
   pipe: (...entries: JSONQuery[]) => {
     const _entries = entries.map((entry) => compile(entry))
@@ -247,8 +261,8 @@ export const functions: FunctionBuildersMap = {
 
   max: () => (data: number[]) => Math.max(...data),
 
-  and: buildFunction((a, b) => !!(a && b)),
-  or: buildFunction((a, b) => !!(a || b)),
+  and: buildFunction(reduceArgs((a, b) => !!(a && b))),
+  or: buildFunction(reduceArgs((a, b) => !!(a || b))),
   not: buildFunction((a: unknown) => !a),
 
   exists: (queryGet: JSONQueryFunction) => {
@@ -286,19 +300,20 @@ export const functions: FunctionBuildersMap = {
     return (data: unknown) => regex.test(getter(data) as string)
   },
 
-  eq: buildFunction((a, b) => a === b),
-  gt: buildFunction((a, b) => a > b),
-  gte: buildFunction((a, b) => a >= b),
-  lt: buildFunction((a, b) => a < b),
-  lte: buildFunction((a, b) => a <= b),
-  ne: buildFunction((a, b) => a !== b),
-
-  add: buildFunction((a: number, b: number) => a + b),
-  subtract: buildFunction((a: number, b: number) => a - b),
-  multiply: buildFunction((a: number, b: number) => a * b),
-  divide: buildFunction((a: number, b: number) => a / b),
-  pow: buildFunction((a: number, b: number) => a ** b),
-  mod: buildFunction((a: number, b: number) => a % b),
+  eq: buildFunction(validateMaxArgs((a, b) => a === b)),
+  gt: buildFunction(validateMaxArgs((a, b) => a > b)),
+  gte: buildFunction(validateMaxArgs((a, b) => a >= b)),
+  lt: buildFunction(validateMaxArgs((a, b) => a < b)),
+  lte: buildFunction(validateMaxArgs((a, b) => a <= b)),
+  ne: buildFunction(validateMaxArgs((a, b) => a !== b)),
+
+  add: buildFunction(reduceArgs((a: number, b: number) => a + b)),
+  subtract: buildFunction(reduceArgs((a: number, b: number) => a - b)),
+  multiply: buildFunction(reduceArgs((a: number, b: number) => a * b)),
+  divide: buildFunction(reduceArgs((a: number, b: number) => a / b)),
+  pow: buildFunction(validateMaxArgs((a: number, b: number) => a ** b)),
+  mod: buildFunction(validateMaxArgs((a: number, b: number) => a % b)),
+
   abs: buildFunction(Math.abs),
   round: buildFunction((value: number, digits = 0) => {
     const num = Math.round(Number(`${value}e${digits}`))

src/operators.ts

@@ -3,6 +3,7 @@ import type { CustomOperator, OperatorGroup } from './types'
 
 // operator precedence from highest to lowest
 export const operators: OperatorGroup[] = [
+  { pipe: '|' },
   { pow: '^' },
   { multiply: '*', divide: '/', mod: '%' },
   { add: '+', subtract: '-' },

src/parse.ts

@@ -29,27 +29,6 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
   const allFunctions = options?.functions ?? functions
   const allOperators = extendOperators(operators, options?.operators ?? [])
 
-  const parsePipe = () => {
-    skipWhitespace()
-    const first = parseOperator(allOperators.length - 1)
-    skipWhitespace()
-
-    if (query[i] === '|') {
-      const pipe = [first]
-
-      while (query[i] === '|') {
-        i++
-        skipWhitespace()
-
-        pipe.push(parseOperator(allOperators.length - 1))
-      }
-
-      return ['pipe', ...pipe]
-    }
-
-    return first
-  }
-
   const parseOperator = (precedenceLevel: number) => {
     const currentOperators = allOperators[precedenceLevel]
     if (!currentOperators) {
@@ -58,16 +37,16 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
 
     let left = parseOperator(precedenceLevel - 1)
 
-    skipWhitespace()
-
     while (true) {
+      skipWhitespace()
+
       const name = parseOperatorName(currentOperators)
       if (!name) {
         break
       }
 
       const right = parseOperator(precedenceLevel - 1)
-      left = [name, left, right]
+      left = name === left[0] ? [...left, right] : [name, left, right]
     }
 
     return left
@@ -92,9 +71,11 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
   }
 
   const parseParenthesis = () => {
+    skipWhitespace()
+
     if (query[i] === '(') {
       i++
-      const inner = parsePipe()
+      const inner = parseOperator(allOperators.length - 1)
       eatChar(')')
       return inner
     }
@@ -139,11 +120,11 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
 
     skipWhitespace()
 
-    const args = query[i] !== ')' ? [parsePipe()] : []
+    const args = query[i] !== ')' ? [parseOperator(allOperators.length - 1)] : []
     while (i < query.length && query[i] !== ')') {
       skipWhitespace()
       eatChar(',')
-      args.push(parsePipe())
+      args.push(parseOperator(allOperators.length - 1))
     }
 
     eatChar(')')
@@ -172,7 +153,7 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
         skipWhitespace()
         eatChar(':')
 
-        object[key] = parsePipe()
+        object[key] = parseOperator(allOperators.length - 1)
       }
 
       eatChar('}')
@@ -199,7 +180,7 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
           skipWhitespace()
         }
 
-        array.push(parsePipe())
+        array.push(parseOperator(allOperators.length - 1))
       }
 
       eatChar(']')
@@ -258,7 +239,7 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
   }
 
   let i = 0
-  const output = parsePipe()
+  const output = parseOperator(allOperators.length - 1)
   parseEnd()
 
   return output

src/stringify.ts

@@ -40,10 +40,10 @@ export const stringify = (query: JSONQuery, options?: JSONQueryStringifyOptions)
   const _stringify = (
     query: JSONQuery,
     indent: string,
-    operatorPrecedence = allOperators.length - 1
+    parentPrecedence = allOperators.length - 1
   ) =>
     isArray(query)
-      ? stringifyFunction(query as JSONQueryFunction, indent, operatorPrecedence)
+      ? stringifyFunction(query as JSONQueryFunction, indent, parentPrecedence)
       : JSON.stringify(query) // value (string, number, boolean, null)
 
   const stringifyFunction = (
@@ -57,12 +57,6 @@ export const stringify = (query: JSONQuery, options?: JSONQueryStringifyOptions)
       return stringifyPath(args as JSONPath)
     }
 
-    if (name === 'pipe') {
-      const argsStr = args.map((arg) => _stringify(arg, indent + space))
-
-      return join(argsStr, ['', ' | ', ''], ['', `\n${indent + space}| `, ''])
-    }
-
     if (name === 'object') {
       return stringifyObject(args[0] as JSONQueryObject, indent)
     }
@@ -78,15 +72,13 @@ export const stringify = (query: JSONQuery, options?: JSONQueryStringifyOptions)
 
     // operator like ".age >= 18"
     const op = allOperatorsMap[name]
-    if (op && args.length === 2) {
+    if (op) {
       const precedence = allOperators.findIndex((group) => name in group)
-      const [left, right] = args
-      const leftStr = _stringify(left, indent, precedence)
-      const rightStr = _stringify(right, indent, precedence)
+      const start = parentPrecedence < precedence ? '(' : ''
+      const end = parentPrecedence < precedence ? ')' : ''
+      const argsStr = args.map((arg) => _stringify(arg, indent + space, precedence))
 
-      return parentPrecedence < precedence
-        ? `(${leftStr} ${op} ${rightStr})`
-        : `${leftStr} ${op} ${rightStr}`
+      return join(argsStr, [start, ` ${op} `, end], [start, `\n${indent + space}${op} `, end])
     }
 
     // regular function like sort(.age)

test-suite/compile.test.json

@@ -948,6 +948,13 @@
       "query": ["and", true, true],
       "output": true
     },
+    {
+      "category": "and",
+      "description": "should calculate and with more than two arguments",
+      "input": null,
+      "query": ["and", true, true, false],
+      "output": false
+    },
 
     {
       "category": "or",
@@ -998,6 +1005,13 @@
       "query": ["or", false, true],
       "output": true
     },
+    {
+      "category": "or",
+      "description": "should calculate or with more than two arguments",
+      "input": null,
+      "query": ["or", false, false, true],
+      "output": true
+    },
 
     {
       "category": "not",
@@ -1268,6 +1282,13 @@
       "query": ["add", "is:", true],
       "output": "is:true"
     },
+    {
+      "category": "add",
+      "description": "should add more than two arguments",
+      "input": null,
+      "query": ["add", 6, 2, 3],
+      "output": 11
+    },
 
     {
       "category": "subtract",
@@ -1283,6 +1304,13 @@
       "query": ["subtract", 6, 2],
       "output": 4
     },
+    {
+      "category": "subtract",
+      "description": "should subtract more than two arguments",
+      "input": null,
+      "query": ["subtract", 6, 2, 1],
+      "output": 3
+    },
 
     {
       "category": "multiply",
@@ -1298,6 +1326,13 @@
       "query": ["multiply", 6, 2],
       "output": 12
     },
+    {
+      "category": "multiply",
+      "description": "should multiply more than two arguments",
+      "input": null,
+      "query": ["multiply", 6, 2, 3],
+      "output": 36
+    },
 
     {
       "category": "divide",
@@ -1313,6 +1348,13 @@
       "query": ["divide", 6, 2],
       "output": 3
     },
+    {
+      "category": "divide",
+      "description": "should divide more than two arguments",
+      "input": null,
+      "query": ["divide", 6, 2, 3],
+      "output": 1
+    },
 
     {
       "category": "pow",

test-suite/parse.test.json

@@ -165,60 +165,26 @@
       "category": "operator",
       "description": "should parse operators and and or with more than two arguments",
       "tests": [
-        {
-          "input": "1 and 2 and 3",
-          "output": ["and", ["and", 1, 2], 3]
-        },
-        {
-          "input": "1 or 2 or 3",
-          "output": ["or", ["or", 1, 2], 3]
-        },
-        {
-          "input": "1 or 2 or 3 or 4",
-          "output": ["or", ["or", ["or", 1, 2], 3], 4]
-        }
+        { "input": "1 and 2 and 3", "output": ["and", 1, 2, 3] },
+        { "input": "1 or 2 or 3", "output": ["or", 1, 2, 3] },
+        { "input": "1 ^ 2 ^ 3", "output": ["pow", 1, 2, 3] },
+        { "input": "1 * 2 * 3", "output": ["multiply", 1, 2, 3] },
+        { "input": "1 / 2 / 3", "output": ["divide", 1, 2, 3] },
+        { "input": "1 + 2 + 3", "output": ["add", 1, 2, 3] },
+        { "input": "1 - 2 - 3", "output": ["subtract", 1, 2, 3] },
+        { "input": "1 % 2 % 3", "output": ["mod", 1, 2, 3] }
       ]
     },
     {
       "category": "operator",
       "description": "should parse operators with the same precedence",
       "tests": [
-        { "input": "2 * 3 * 4", "output": ["multiply", ["multiply", 2, 3], 4] },
-        { "input": "2 / 3 / 4", "output": ["divide", ["divide", 2, 3], 4] },
         { "input": "2 * 3 / 4", "output": ["divide", ["multiply", 2, 3], 4] },
         { "input": "2 / 3 * 4", "output": ["multiply", ["divide", 2, 3], 4] },
         { "input": "2 * 3 % 4", "output": ["mod", ["multiply", 2, 3], 4] },
         { "input": "2 % 3 * 4", "output": ["multiply", ["mod", 2, 3], 4] },
-        { "input": "2 + 3 + 4", "output": ["add", ["add", 2, 3], 4] },
-        { "input": "2 - 3 - 4", "output": ["subtract", ["subtract", 2, 3], 4] },
         { "input": "2 + 3 - 4", "output": ["subtract", ["add", 2, 3], 4] },
-        { "input": "2 - 3 + 4", "output": ["add", ["subtract", 2, 3], 4] },
-        { "input": "2 > 3 > 4", "output": ["gt", ["gt", 2, 3], 4] },
-        { "input": "2 >= 3 >= 4", "output": ["gte", ["gte", 2, 3], 4] },
-        { "input": "2 < 3 < 4", "output": ["lt", ["lt", 2, 3], 4] },
-        { "input": "2 <= 3 <= 4", "output": ["lte", ["lte", 2, 3], 4] },
-        { "input": "2 in 3 in 4", "output": ["in", ["in", 2, 3], 4] },
-        { "input": "2 not in 3 not in 4", "output": ["not in", ["not in", 2, 3], 4] },
-        { "input": "2 > 3 >= 4", "output": ["gte", ["gt", 2, 3], 4] },
-        { "input": "2 >= 3 > 4", "output": ["gt", ["gte", 2, 3], 4] },
-        { "input": "2 > 3 < 4", "output": ["lt", ["gt", 2, 3], 4] },
-        { "input": "2 < 3 > 4", "output": ["gt", ["lt", 2, 3], 4] },
-        { "input": "2 > 3 <= 4", "output": ["lte", ["gt", 2, 3], 4] },
-        { "input": "2 <= 3 > 4", "output": ["gt", ["lte", 2, 3], 4] },
-        { "input": "2 > .a in .b", "output": ["in", ["gt", 2, ["get", "a"]], ["get", "b"]] },
-        { "input": ".a in .b > 2", "output": ["gt", ["in", ["get", "a"], ["get", "b"]], 2] },
-        {
-          "input": "2 > .a not in .b",
-          "output": ["not in", ["gt", 2, ["get", "a"]], ["get", "b"]]
-        },
-        {
-          "input": ".a not in .b > 2",
-          "output": ["gt", ["not in", ["get", "a"], ["get", "b"]], 2]
-        },
-        { "input": "2 == 3 == 4", "output": ["eq", ["eq", 2, 3], 4] },
-        { "input": "2 != 3 != 4", "output": ["ne", ["ne", 2, 3], 4] },
-        { "input": "2 == 3 != 4", "output": ["ne", ["eq", 2, 3], 4] },
-        { "input": "2 != 3 == 4", "output": ["eq", ["ne", 2, 3], 4] }
+        { "input": "2 - 3 + 4", "output": ["add", ["subtract", 2, 3], 4] }
       ]
     },
     {