feat: implement support for operator precedence (WIP)

Author: josdejong

src/constants.ts

@@ -1,24 +1,35 @@
-export const operators = {
-  and: 'and',
-  or: 'or',
-
-  eq: '==',
-  gt: '>',
-  gte: '>=',
-  lt: '<',
-  lte: '<=',
-  ne: '!=',
-
-  add: '+',
-  subtract: '-',
-  multiply: '*',
-  divide: '/',
-  pow: '^',
-  mod: '%',
-
-  in: 'in',
-  'not in': 'not in'
-}
+export const operators = [
+  {
+    in: 'in',
+    'not in': 'not in'
+  },
+  {
+    or: 'or'
+  },
+  {
+    and: 'and'
+  },
+  {
+    eq: '==',
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+    ne: '!='
+  },
+  {
+    add: '+',
+    subtract: '-'
+  },
+  {
+    multiply: '*',
+    divide: '/',
+    mod: '%'
+  },
+  {
+    pow: '^'
+  }
+]
 
 export const unquotedPropertyRegex = /^[a-zA-Z_$][a-zA-Z\d_$]*$/
 export const startsWithUnquotedPropertyRegex = /^[a-zA-Z_$][a-zA-Z\d_$]*/

src/jsonquery.test.ts

@@ -41,19 +41,23 @@ describe('jsonquery', () => {
 
   test('should execute a JSON query with custom operators', () => {
     const options: JSONQueryOptions = {
-      operators: {
-        aboutEq: '~='
-      }
+      operators: [
+        {
+          aboutEq: '~='
+        }
+      ]
     }
 
     expect(jsonquery({ name: 'Joe' }, ['get', 'name'], options)).toEqual('Joe')
   })
 
   test('should execute a text query with custom operators', () => {
     const options: JSONQueryOptions = {
-      operators: {
-        aboutEq: '~='
-      }
+      operators: [
+        {
+          aboutEq: '~='
+        }
+      ]
     }
 
     expect(jsonquery({ name: 'Joe' }, '.name', options)).toEqual('Joe')

src/parse.test.ts

@@ -51,7 +51,7 @@ describe('customization', () => {
 
   test('should parse a custom operator', () => {
     const options: JSONQueryParseOptions = {
-      operators: { aboutEq: '~=' }
+      operators: [{ aboutEq: '~=' }]
     }
 
     expect(parse('.score ~= 8', options)).toEqual(['aboutEq', ['get', 'score'], 8])

src/parse.ts

@@ -26,12 +26,12 @@ import type { JSONQuery, JSONQueryParseOptions } from './types'
  *     //  ]
  */
 export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery {
-  const allOperators = { ...operators, ...options?.operators }
-  const sortedOperatorNames = Object.keys(allOperators).sort((a, b) => b.length - a.length)
+  // FIXME: user must be able to specify precedence
+  const allOperators = [...operators, ...(options?.operators ?? [])]
 
   const parsePipe = () => {
     skipWhitespace()
-    const first = parseOperator()
+    const first = parseOperator(0)
     skipWhitespace()
 
     if (query[i] === '|') {
@@ -41,7 +41,7 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
         i++
         skipWhitespace()
 
-        pipe.push(parseOperator())
+        pipe.push(parseOperator(0))
       }
 
       return ['pipe', ...pipe]
@@ -50,24 +50,47 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
     return first
   }
 
-  const parseOperator = () => {
-    const left = parseParenthesis()
+  const parseOperator = (precedenceLevel: number) => {
+    const currentOperators = allOperators[precedenceLevel]
+    if (!currentOperators) {
+      return parseParenthesis()
+    }
+
+    let left = parseOperator(precedenceLevel + 1)
 
     skipWhitespace()
 
+    while (true) {
+      const name = parseOperatorName(currentOperators)
+      if (!name) {
+        break
+      }
+
+      const right = parseOperator(precedenceLevel + 1)
+      left = [name, left, right]
+
+      skipWhitespace()
+    }
+
+    return left
+  }
+
+  const parseOperatorName = (currentOperators: Record<string, string>): string | undefined => {
     // we sort the operators from longest to shortest, so we first handle "<=" and next "<"
+    const sortedOperatorNames = Object.keys(currentOperators).sort((a, b) => b.length - a.length)
+
     for (const name of sortedOperatorNames) {
-      const op = allOperators[name]
+      const op = currentOperators[name]
       if (query.substring(i, i + op.length) === op) {
         i += op.length
+
         skipWhitespace()
-        const right = parseParenthesis()
 
-        return [name, left, right]
+        return name
       }
     }
 
-    return left
+    return undefined
   }
 
   const parseParenthesis = () => {

src/stringify.ts

@@ -33,6 +33,10 @@ const DEFAULT_INDENTATION = '  '
  */
 export const stringify = (query: JSONQuery, options?: JSONQueryStringifyOptions) => {
   const space = options?.indentation ?? DEFAULT_INDENTATION
+  const allOperators =
+    // biome-ignore lint/performance/noAccumulatingSpread: <explanation>
+    [...operators, ...(options?.operators ?? [])].reduce((all, ops) => ({ ...all, ...ops }), {}) ??
+    {}
 
   const _stringify = (query: JSONQuery, indent: string) =>
     isArray(query) ? stringifyFunction(query as JSONQueryFunction, indent) : JSON.stringify(query) // value (string, number, boolean, null)
@@ -64,7 +68,7 @@ export const stringify = (query: JSONQuery, options?: JSONQueryStringifyOptions)
     }
 
     // operator like ".age >= 18"
-    const op = options?.operators?.[name] ?? operators[name]
+    const op = allOperators[name]
     if (op && args.length === 2) {
       const [left, right] = args
       const leftStr = _stringify(left, indent)

src/types.ts

@@ -10,22 +10,22 @@ export type JSONQueryProperty = ['get', path?: string | JSONPath]
 
 export interface JSONQueryOptions {
   functions?: FunctionBuildersMap
-  operators?: Record<string, string>
+  operators?: Record<string, string>[]
 }
 
 export interface JSONQueryCompileOptions {
   functions?: FunctionBuildersMap
 }
 
 export interface JSONQueryStringifyOptions {
-  operators?: Record<string, string>
+  operators?: Record<string, string>[]
   maxLineLength?: number
   indentation?: string
 }
 
 export interface JSONQueryParseOptions {
   functions?: Record<string, boolean> | FunctionBuildersMap
-  operators?: Record<string, string>
+  operators?: Record<string, string>[]
 }
 
 export type Fun = (data: unknown) => unknown

test-suite/parse.test.json

@@ -163,14 +163,33 @@
     },
     {
       "category": "operator",
-      "description": "should throw an error when using multiple operators without parenthesis",
+      "description": "should parse operators and and or with more than two arguments",
       "tests": [
-        { "input": ".a == \"A\" and .b == \"B\"", "throws": "Unexpected part 'and .b == \"B\"'" },
         {
-          "input": "2 and 3 and 4",
-          "throws": "Unexpected part 'and 4' (pos: 8)"
+          "input": "1 and 2 and 3",
+          "output": ["and", ["and", 1, 2], 3]
         },
-        { "input": ".a + 2 * 3", "throws": "Unexpected part '* 3' (pos: 7)" }
+        {
+          "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]
+        }
+      ]
+    },
+    {
+      "category": "operator",
+      "description": "should parse operators with the right precedence",
+      "tests": [
+        { "input": "1 + 2 * 3", "output": ["add", 1, ["multiply", 2, 3]] },
+        { "input": "2 * 3 + 1", "output": ["add", ["multiply", 2, 3], 1] },
+        { "input": "1 * 2 / 3", "output": ["divide", ["multiply", 1, 2], 3] },
+        { "input": "1 + 2 - 3", "output": ["subtract", ["add", 1, 2], 3] },
+        { "input": "1 and 2 and 3", "output": ["and", ["and", 1, 2], 3] },
+        { "input": "1 and 2 or 3", "output": ["or", ["and", 1, 2], 3] },
+        { "input": "3 or 1 and 2", "output": ["or", 3, ["and", 1, 2]] }
       ]
     },
     {

test-suite/stringify.test.json

@@ -48,7 +48,7 @@
       "category": "operator",
       "description": "should stringify a custom operator",
       "options": {
-        "operators": { "aboutEq": "~=" }
+        "operators": [{ "aboutEq": "~=" }]
       },
       "tests": [
         { "input": ["aboutEq", 2, 3], "output": "(2 ~= 3)" },

test-suite/stringify.test.schema.json

@@ -18,7 +18,10 @@
             "properties": {
               "indentation": { "type": "string" },
               "maxLineLength": { "type": "number" },
-              "operators": { "type": "object" }
+              "operators": {
+                "type": "array",
+                "items": { "type": "object" }
+              }
             }
           },
           "tests": {