chore: reverse the order of the operator list so it is from highest to lowest precedence

Author: josdejong

README.md

@@ -209,16 +209,15 @@ When using multiple operators, they will be evaluated according to their precede
 filter(.age >= 18 and .age <= 65)
 ```
 
-The operators have the following precedence, from lowest to highest:
+The operators have the following precedence, from highest to lowest:
 
-- 
-- `or`
-- `and`
-- `==`, `!=`
--  `>`, `>=`, `<`, `<=`, `in`, `not in`
-- `+`, `-`
-- `*`, `/`, `%`
 - `^`
+- `*`, `/`, `%`
+- `+`, `-`
+-  `>`, `>=`, `<`, `<=`, `in`, `not in`
+- `==`, `!=`
+- `and`
+- `or`
 
 See section [Function reference](reference/functions.md) for a detailed overview of all available functions and operators.
 
@@ -411,17 +410,17 @@ Here:
 
       You can have a look at the source code of the functions in `/src/functions.ts` for more examples.
 
-  - `operators` is an optional array with maps of operators having the same precedence, ordered from lowest to highest precedence. The default array with operators is the following, with the precedence going from lowest to highest:
+  - `operators` is an optional array with maps of operators having the same precedence, ordered from highest to lowest precedence. The default array with operators is the following, with the precedence going from lowest to highest:
 
     ```js
     const operators = [
-      { or: 'or' },
-      { and: 'and' },
-      { eq: '==', ne: '!=' },
-      { gt: '>', gte: '>=', lt: '<', lte: '<=', in: 'in', 'not in': 'not in' },
-      { add: '+', subtract: '-' },
+      { pow: '^' },
       { multiply: '*', divide: '/', mod: '%' },
-      { pow: '^' }
+      { add: '+', subtract: '-' },
+      { gt: '>', gte: '>=', lt: '<', lte: '<=', in: 'in', 'not in': 'not in' },
+      { eq: '==', ne: '!=' },
+      { and: 'and' },
+      { or: 'or' }
     ]
     ```
 

src/constants.ts

@@ -1,12 +1,14 @@
-// operator precedence from lowest to highest
-export const operators = [
-  { or: 'or' },
-  { and: 'and' },
-  { eq: '==', ne: '!=' },
-  { gt: '>', gte: '>=', lt: '<', lte: '<=', in: 'in', 'not in': 'not in' },
-  { add: '+', subtract: '-' },
+import type { JSONQueryOperatorGroup } from './types'
+
+// operator precedence from highest to lowest
+export const operators: JSONQueryOperatorGroup[] = [
+  { pow: '^' },
   { multiply: '*', divide: '/', mod: '%' },
-  { pow: '^' }
+  { add: '+', subtract: '-' },
+  { gt: '>', gte: '>=', lt: '<', lte: '<=', in: 'in', 'not in': 'not in' },
+  { eq: '==', ne: '!=' },
+  { and: 'and' },
+  { or: 'or' }
 ]
 
 export const unquotedPropertyRegex = /^[a-zA-Z_$][a-zA-Z\d_$]*$/

src/parse.ts

@@ -8,7 +8,7 @@ import {
   startsWithWhitespaceRegex
 } from './constants'
 import { functions } from './functions'
-import type { JSONQuery, JSONQueryParseOptions } from './types'
+import type { JSONQuery, JSONQueryOperatorGroup, JSONQueryParseOptions } from './types'
 
 /**
  * Parse a string containing a JSON Query into JSON.
@@ -31,7 +31,7 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
 
   const parsePipe = () => {
     skipWhitespace()
-    const first = parseOperator(0)
+    const first = parseOperator(allOperators.length - 1)
     skipWhitespace()
 
     if (query[i] === '|') {
@@ -41,7 +41,7 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
         i++
         skipWhitespace()
 
-        pipe.push(parseOperator(0))
+        pipe.push(parseOperator(allOperators.length - 1))
       }
 
       return ['pipe', ...pipe]
@@ -56,7 +56,7 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
       return parseParenthesis()
     }
 
-    let left = parseOperator(precedenceLevel + 1)
+    let left = parseOperator(precedenceLevel - 1)
 
     skipWhitespace()
 
@@ -66,14 +66,14 @@ export function parse(query: string, options?: JSONQueryParseOptions): JSONQuery
         break
       }
 
-      const right = parseOperator(precedenceLevel + 1)
+      const right = parseOperator(precedenceLevel - 1)
       left = [name, left, right]
     }
 
     return left
   }
 
-  const parseOperatorName = (currentOperators: Record<string, string>): string | undefined => {
+  const parseOperatorName = (currentOperators: JSONQueryOperatorGroup): 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)
 

src/stringify.ts

@@ -36,7 +36,11 @@ export const stringify = (query: JSONQuery, options?: JSONQueryStringifyOptions)
   const allOperators = options?.operators ?? operators
   const allOperatorsMap = Object.assign({}, ...allOperators)
 
-  const _stringify = (query: JSONQuery, indent: string, operatorPrecedence = 0) =>
+  const _stringify = (
+    query: JSONQuery,
+    indent: string,
+    operatorPrecedence = allOperators.length - 1
+  ) =>
     isArray(query)
       ? stringifyFunction(query as JSONQueryFunction, indent, operatorPrecedence)
       : JSON.stringify(query) // value (string, number, boolean, null)
@@ -79,7 +83,7 @@ export const stringify = (query: JSONQuery, options?: JSONQueryStringifyOptions)
       const leftStr = _stringify(left, indent, precedence)
       const rightStr = _stringify(right, indent, precedence)
 
-      return parentPrecedence > precedence
+      return parentPrecedence < precedence
         ? `(${leftStr} ${op} ${rightStr})`
         : `${leftStr} ${op} ${rightStr}`
     }

src/types.ts

@@ -7,25 +7,26 @@ export type JSONQuery = JSONQueryFunction | JSONQueryPipe | JSONQueryObject | JS
 export type JSONProperty = string
 export type JSONPath = JSONProperty[]
 export type JSONQueryProperty = ['get', path?: string | JSONPath]
+export type JSONQueryOperatorGroup = Record<string, string>
 
 export interface JSONQueryOptions {
   functions?: FunctionBuildersMap
-  operators?: Record<string, string>[]
+  operators?: JSONQueryOperatorGroup[]
 }
 
 export interface JSONQueryCompileOptions {
   functions?: FunctionBuildersMap
 }
 
 export interface JSONQueryStringifyOptions {
-  operators?: Record<string, string>[]
+  operators?: JSONQueryOperatorGroup[]
   maxLineLength?: number
   indentation?: string
 }
 
 export interface JSONQueryParseOptions {
   functions?: Record<string, boolean> | FunctionBuildersMap
-  operators?: Record<string, string>[]
+  operators?: JSONQueryOperatorGroup[]
 }
 
 export type Fun = (data: unknown) => unknown