squirreling 0.4.6 → 0.4.8

package/src/execute/expression.js

@@ -1,8 +1,16 @@
+import {
+  argCountError,
+  argValueError,
+  castError,
+  invalidContextError,
+  unknownFunctionError,
+} from '../errors.js'
+import { applyIntervalToDate } from './date.js'
 import { executeSelect } from './execute.js'
-import { applyBinaryOp } from './utils.js'
+import { applyBinaryOp, stringify } from './utils.js'
 
 /**
- * @import { ExprNode, AsyncRow, SqlPrimitive, AsyncDataSource } from '../types.js'
+ * @import { ExprNode, AsyncRow, SqlPrimitive, AsyncDataSource, IntervalUnit } from '../types.js'
  */
 
 /**
@@ -31,7 +39,7 @@ export async function evaluateExpr({ node, row, tables }) {
         return row[colName]()
       }
     }
-    return undefined
+    return null
   }
 
   // Scalar subquery - returns a single value
@@ -66,6 +74,16 @@ export async function evaluateExpr({ node, row, tables }) {
 
   // Binary operators
   if (node.type === 'binary') {
+    // Handle date +/- interval at AST level
+    if ((node.op === '+' || node.op === '-') && node.right.type === 'interval') {
+      const dateVal = await evaluateExpr({ node: node.left, row, tables })
+      return applyIntervalToDate(dateVal, node.right.value, node.right.unit, node.op)
+    }
+    if (node.op === '+' && node.left.type === 'interval') {
+      const dateVal = await evaluateExpr({ node: node.right, row, tables })
+      return applyIntervalToDate(dateVal, node.left.value, node.left.unit, '+')
+    }
+
     const left = await evaluateExpr({ node: node.left, row, tables })
 
     // Short-circuit evaluation for AND and OR
@@ -83,33 +101,39 @@ export async function evaluateExpr({ node, row, tables }) {
   // Function calls
   if (node.type === 'function') {
     const funcName = node.name.toUpperCase()
+    /** @type {SqlPrimitive[]} */
     const args = await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, tables })))
 
     if (funcName === 'UPPER') {
-      if (args.length !== 1) throw new Error('UPPER requires exactly 1 argument')
+      if (args.length !== 1) throw argCountError('UPPER', 1, args.length)
       const val = args[0]
       if (val == null) return null
       return String(val).toUpperCase()
     }
 
     if (funcName === 'LOWER') {
-      if (args.length !== 1) throw new Error('LOWER requires exactly 1 argument')
+      if (args.length !== 1) throw argCountError('LOWER', 1, args.length)
       const val = args[0]
       if (val == null) return null
       return String(val).toLowerCase()
     }
 
     if (funcName === 'CONCAT') {
-      if (args.length < 1) throw new Error('CONCAT requires at least 1 argument')
+      if (args.length < 1) throw argCountError('CONCAT', 'at least 1', args.length)
       // SQL CONCAT returns NULL if any argument is NULL
-      for (let i = 0; i < args.length; i += 1) {
-        if (args[i] == null) return null
+      if (args.some(a => a == null)) return null
+      if (args.some(a => typeof a === 'object')) {
+        throw argValueError({
+          funcName: 'CONCAT',
+          message: 'does not support object arguments',
+          hint: 'Use CAST to convert objects to strings first.',
+        })
       }
       return args.map(a => String(a)).join('')
     }
 
     if (funcName === 'LENGTH') {
-      if (args.length !== 1) throw new Error('LENGTH requires exactly 1 argument')
+      if (args.length !== 1) throw argCountError('LENGTH', 1, args.length)
       const val = args[0]
       if (val == null) return null
       return String(val).length
@@ -117,21 +141,28 @@ export async function evaluateExpr({ node, row, tables }) {
 
     if (funcName === 'SUBSTRING' || funcName === 'SUBSTR') {
       if (args.length < 2 || args.length > 3) {
-        throw new Error(`${funcName} requires 2 or 3 arguments`)
+        throw argCountError(funcName, '2 or 3', args.length)
       }
       const str = args[0]
       if (str == null) return null
       const strVal = String(str)
       const start = Number(args[1])
       if (!Number.isInteger(start) || start < 1) {
-        throw new Error(`${funcName} start position must be a positive integer`)
+        throw argValueError({
+          funcName,
+          message: `start position must be a positive integer, got ${args[1]}`,
+          hint: 'SQL uses 1-based indexing.',
+        })
       }
       // SQL uses 1-based indexing
       const startIdx = start - 1
       if (args.length === 3) {
         const len = Number(args[2])
         if (!Number.isInteger(len) || len < 0) {
-          throw new Error(`${funcName} length must be a non-negative integer`)
+          throw argValueError({
+            funcName,
+            message: `length must be a non-negative integer, got ${args[2]}`,
+          })
         }
         return strVal.substring(startIdx, startIdx + len)
       }
@@ -139,14 +170,14 @@ export async function evaluateExpr({ node, row, tables }) {
     }
 
     if (funcName === 'TRIM') {
-      if (args.length !== 1) throw new Error('TRIM requires exactly 1 argument')
+      if (args.length !== 1) throw argCountError('TRIM', 1, args.length)
       const val = args[0]
       if (val == null) return null
       return String(val).trim()
     }
 
     if (funcName === 'REPLACE') {
-      if (args.length !== 3) throw new Error('REPLACE requires exactly 3 arguments')
+      if (args.length !== 3) throw argCountError('REPLACE', 3, args.length)
       const str = args[0]
       const searchStr = args[1]
       const replaceStr = args[2]
@@ -156,17 +187,110 @@ export async function evaluateExpr({ node, row, tables }) {
     }
 
     if (funcName === 'RANDOM' || funcName === 'RAND') {
-      if (args.length !== 0) throw new Error(`${funcName} takes no arguments`)
+      if (args.length !== 0) throw argCountError(funcName, 0, args.length)
       return Math.random()
     }
 
-    throw new Error('Unsupported function ' + funcName)
+    if (funcName === 'CURRENT_DATE') {
+      if (args.length !== 0) throw argCountError('CURRENT_DATE', 0, args.length)
+      return new Date().toISOString().split('T')[0]
+    }
+
+    if (funcName === 'CURRENT_TIME') {
+      if (args.length !== 0) throw argCountError('CURRENT_TIME', 0, args.length)
+      return new Date().toISOString().split('T')[1].replace('Z', '')
+    }
+
+    if (funcName === 'CURRENT_TIMESTAMP') {
+      if (args.length !== 0) throw argCountError('CURRENT_TIMESTAMP', 0, args.length)
+      return new Date().toISOString()
+    }
+
+    if (funcName === 'JSON_OBJECT') {
+      if (args.length % 2 !== 0) {
+        throw argCountError('JSON_OBJECT', 'even number', args.length)
+      }
+      /** @type {Record<string, SqlPrimitive>} */
+      const result = {}
+      for (let i = 0; i < args.length; i += 2) {
+        const key = args[i]
+        const value = args[i + 1]
+        if (key == null) {
+          throw argValueError({
+            funcName: 'JSON_OBJECT',
+            message: 'key cannot be null',
+            hint: 'All keys must be non-null values.',
+          })
+        }
+        result[String(key)] = value
+      }
+      return result
+    }
+
+    if (funcName === 'JSON_VALUE' || funcName === 'JSON_QUERY') {
+      if (args.length !== 2) throw argCountError(funcName, 2, args.length)
+      let jsonArg = args[0]
+      const pathArg = args[1]
+      if (jsonArg == null || pathArg == null) return null
+
+      // Parse JSON if string, otherwise use directly
+      if (typeof jsonArg === 'string') {
+        try {
+          jsonArg = JSON.parse(jsonArg)
+        } catch {
+          throw argValueError({
+            funcName,
+            message: 'invalid JSON string',
+            hint: 'First argument must be valid JSON.',
+          })
+        }
+      }
+      if (typeof jsonArg !== 'object' || jsonArg instanceof Date) {
+        throw argValueError({
+          funcName,
+          message: `first argument must be JSON string or object, got ${typeof jsonArg}`,
+        })
+      }
+
+      // Parse path ("$.foo.bar[0].baz" or "foo.bar[0]")
+      const path = String(pathArg)
+      const normalizedPath = path.startsWith('$') ? path.slice(1) : path
+
+      // Navigate the path
+      let current = jsonArg
+      const segments = normalizedPath.match(/\.?([^.[]+)|\[(\d+)\]/g) || []
+      for (const segment of segments) {
+        if (current == null) return null
+        if (segment.startsWith('[')) {
+          // Array index access
+          const index = parseInt(segment.slice(1, -1), 10)
+          if (!Array.isArray(current)) return null
+          current = current[index]
+        } else {
+          // Property access
+          const key = segment.startsWith('.') ? segment.slice(1) : segment
+          if (typeof current !== 'object' || Array.isArray(current)) return null
+          current = current[key]
+        }
+      }
+
+      if (current == null) return null
+      return current
+    }
+
+    throw unknownFunctionError(funcName)
   }
 
   if (node.type === 'cast') {
     const val = await evaluateExpr({ node: node.expr, row, tables })
     if (val == null) return null
     const toType = node.toType.toUpperCase()
+    if (toType === 'TEXT' || toType === 'STRING' || toType === 'VARCHAR') {
+      if (typeof val === 'object') return stringify(val)
+      return String(val)
+    }
+    // Can only cast primitives to other primitive types
+    if (typeof val === 'object') throw castError(node.toType, 'object')
     if (toType === 'INTEGER' || toType === 'INT') {
       const num = Number(val)
       if (isNaN(num)) return null
@@ -180,13 +304,10 @@ export async function evaluateExpr({ node, row, tables }) {
       if (isNaN(num)) return null
       return num
     }
-    if (toType === 'TEXT' || toType === 'STRING' || toType === 'VARCHAR') {
-      return String(val)
-    }
     if (toType === 'BOOLEAN' || toType === 'BOOL') {
       return Boolean(val)
     }
-    throw new Error('Unsupported CAST to type ' + node.toType)
+    throw castError(node.toType)
   }
 
   // IN and NOT IN with value lists
@@ -251,5 +372,14 @@ export async function evaluateExpr({ node, row, tables }) {
     return null
   }
 
-  throw new Error('Unknown expression node type ' + node.type)
+  // INTERVAL expressions should only appear as part of binary +/- operations
+  // which are handled above. A standalone interval is an error.
+  if (node.type === 'interval') {
+    throw invalidContextError({
+      item: 'INTERVAL',
+      validContext: 'date arithmetic (+ or -)',
+    })
+  }
+
+  throw new Error(`Unknown expression node type: ${node.type}. This is an internal error - the query may contain unsupported syntax.`)
 }

package/src/execute/having.js

@@ -1,3 +1,4 @@
+import { unknownFunctionError } from '../errors.js'
 import { isAggregateFunc } from '../validation.js'
 import { evaluateExpr } from './expression.js'
 import { applyBinaryOp } from './utils.js'
@@ -41,7 +42,7 @@ export async function evaluateHavingExpr(expr, row, group, tables) {
     }
 
     const right = await evaluateHavingValue(expr.right, context, group, tables)
-    return applyBinaryOp(expr.op, left, right)
+    return Boolean(applyBinaryOp(expr.op, left, right))
   }
 
   if (expr.type === 'unary') {
@@ -152,5 +153,5 @@ async function evaluateAggregateFunction(funcName, args, group, tables) {
     return max
   }
 
-  throw new Error('Unsupported aggregate function: ' + funcName)
+  throw unknownFunctionError(funcName, undefined, 'COUNT, SUM, AVG, MIN, MAX')
 }

package/src/execute/join.js

@@ -1,4 +1,6 @@
+import { missingClauseError, tableNotFoundError } from '../errors.js'
 import { evaluateExpr } from './expression.js'
+import { stringify } from './utils.js'
 
 /**
  * @import { AsyncRow, AsyncDataSource, JoinClause, ExprNode } from '../types.js'
@@ -21,7 +23,7 @@ export async function executeJoins(leftSource, joins, leftTableName, tables) {
     const join = joins[0]
     const rightSource = tables[join.table]
     if (rightSource === undefined) {
-      throw new Error(`Table "${join.table}" not found`)
+      throw tableNotFoundError(join.table)
     }
 
     // Buffer right rows for hash index (required for hash join)
@@ -61,7 +63,7 @@ export async function executeJoins(leftSource, joins, leftTableName, tables) {
     const join = joins[i]
     const rightSource = tables[join.table]
     if (rightSource === undefined) {
-      throw new Error(`Table "${join.table}" not found`)
+      throw tableNotFoundError(join.table)
     }
 
     /** @type {AsyncRow[]} */
@@ -97,7 +99,7 @@ export async function executeJoins(leftSource, joins, leftTableName, tables) {
   const lastJoin = joins[joins.length - 1]
   const rightSource = tables[lastJoin.table]
   if (rightSource === undefined) {
-    throw new Error(`Table "${lastJoin.table}" not found`)
+    throw tableNotFoundError(lastJoin.table)
   }
 
   /** @type {AsyncRow[]} */
@@ -233,7 +235,10 @@ async function* hashJoin({ leftRows, rightRows, join, leftTable, rightTable, tab
   const { joinType, on: onCondition } = join
 
   if (!onCondition) {
-    throw new Error('JOIN requires ON condition')
+    throw missingClauseError({
+      missing: 'ON condition',
+      context: 'JOIN',
+    })
   }
 
   const keys = extractJoinKeys(onCondition, leftTable, rightTable)
@@ -258,8 +263,7 @@ async function* hashJoin({ leftRows, rightRows, join, leftTable, rightTable, tab
     for (const rightRow of rightRows) {
       const keyValue = await evaluateExpr({ node: keys.rightKey, row: rightRow, tables })
       if (keyValue == null) continue // NULL keys never match
-      const keyStr = JSON.stringify(keyValue)
-
+      const keyStr = stringify(keyValue)
       let bucket = hashMap.get(keyStr)
       if (!bucket) {
         bucket = []
@@ -283,7 +287,7 @@ async function* hashJoin({ leftRows, rightRows, join, leftTable, rightTable, tab
       }
 
       const keyValue = await evaluateExpr({ node: keys.leftKey, row: leftRow, tables })
-      const keyStr = JSON.stringify(keyValue)
+      const keyStr = stringify(keyValue)
 
       const matchingRightRows = hashMap.get(keyStr)
 

package/src/execute/utils.js

@@ -3,14 +3,27 @@
  */
 
 /**
- * Compares two values with the given operator, handling nulls according to SQL semantics
+ * Applies a binary operator to two values, handling nulls according to SQL semantics
  *
  * @param {BinaryOp} op
  * @param {SqlPrimitive} a
  * @param {SqlPrimitive} b
- * @returns {boolean}
+ * @returns {SqlPrimitive}
  */
 export function applyBinaryOp(op, a, b) {
+  // Arithmetic operators return null if either operand is null
+  if (op === '+' || op === '-' || op === '*' || op === '/' || op === '%') {
+    if (a == null || b == null) return null
+    const numA = Number(a)
+    const numB = Number(b)
+    if (op === '+') return numA + numB
+    if (op === '-') return numA - numB
+    if (op === '*') return numA * numB
+    if (op === '/') return numB === 0 ? null : numA / numB
+    if (op === '%') return numB === 0 ? null : numA % numB
+  }
+
+  // Comparison and logical operators
   if (a == null || b == null) {
     return false
   }
@@ -33,6 +46,8 @@ export function applyBinaryOp(op, a, b) {
     const regex = new RegExp(`^${regexPattern}$`, 'i')
     return regex.test(str)
   }
+
+  return null
 }
 
 /**
@@ -119,5 +134,22 @@ export function defaultDerivedAlias(expr) {
   if (expr.type === 'function') {
     return expr.name.toLowerCase() + '_' + expr.args.map(defaultDerivedAlias).join('_')
   }
+  if (expr.type === 'interval') {
+    return `interval_${expr.value}_${expr.unit.toLowerCase()}`
+  }
   return 'expr'
 }
+
+/**
+ * @param {SqlPrimitive} value
+ * @returns {string}
+ */
+export function stringify(value) {
+  if (value == null) return 'NULL'
+  return JSON.stringify(value, (_, val) => {
+    if (typeof val === 'bigint') {
+      return val <= Number.MAX_SAFE_INTEGER ? Number(val) : val.toString()
+    }
+    return val
+  })
+}

package/src/parse/comparison.js

@@ -1,5 +1,6 @@
+import { syntaxError } from '../errors.js'
 import { isBinaryOp } from '../validation.js'
-import { parseExpression, parsePrimary, parseSubquery } from './expression.js'
+import { parseAdditive, parseExpression, parseSubquery } from './expression.js'
 import { consume, current, expect, match, peekToken } from './state.js'
 
 /**
@@ -11,7 +12,7 @@ import { consume, current, expect, match, peekToken } from './state.js'
  * @returns {ExprNode}
  */
 export function parseComparison(state) {
-  const left = parsePrimary(state)
+  const left = parseAdditive(state)
   const tok = current(state)
 
   // IS [NOT] NULL
@@ -41,7 +42,7 @@ export function parseComparison(state) {
     if (nextTok.type === 'keyword' && nextTok.value === 'LIKE') {
       consume(state) // NOT
       consume(state) // LIKE
-      const right = parsePrimary(state)
+      const right = parseAdditive(state)
       return {
         type: 'unary',
         op: 'NOT',
@@ -57,7 +58,7 @@ export function parseComparison(state) {
 
   if (tok.type === 'keyword' && tok.value === 'LIKE') {
     consume(state)
-    const right = parsePrimary(state)
+    const right = parseAdditive(state)
     return {
       type: 'binary',
       op: 'LIKE',
@@ -72,9 +73,9 @@ export function parseComparison(state) {
     if (nextTok.type === 'keyword' && nextTok.value === 'BETWEEN') {
       consume(state) // NOT
       consume(state) // BETWEEN
-      const lower = parsePrimary(state)
+      const lower = parseAdditive(state)
       expect(state, 'keyword', 'AND')
-      const upper = parsePrimary(state)
+      const upper = parseAdditive(state)
       // NOT BETWEEN -> expr < lower OR expr > upper
       return {
         type: 'binary',
@@ -87,9 +88,9 @@ export function parseComparison(state) {
 
   if (tok.type === 'keyword' && tok.value === 'BETWEEN') {
     consume(state)
-    const lower = parsePrimary(state)
+    const lower = parseAdditive(state)
     expect(state, 'keyword', 'AND')
-    const upper = parsePrimary(state)
+    const upper = parseAdditive(state)
     // BETWEEN -> expr >= lower AND expr <= upper
     return {
       type: 'binary',
@@ -110,7 +111,7 @@ export function parseComparison(state) {
       // parseSubquery expects to consume the opening paren itself
       const parenTok = current(state)
       if (parenTok.type !== 'paren' || parenTok.value !== '(') {
-        throw new Error('Expected ( after IN')
+        throw syntaxError({ expected: '(', received: `"${parenTok.value}"`, position: parenTok.position, after: 'IN' })
       }
       const peekTok = peekToken(state, 1)
       if (peekTok.type === 'keyword' && peekTok.value === 'SELECT') {
@@ -155,7 +156,7 @@ export function parseComparison(state) {
     // parseSubquery expects to consume the opening paren itself
     const parenTok = current(state)
     if (parenTok.type !== 'paren' || parenTok.value !== '(') {
-      throw new Error('Expected ( after IN')
+      throw syntaxError({ expected: '(', received: `"${parenTok.value}"`, position: parenTok.position, after: 'IN' })
     }
     const peekTok = peekToken(state, 1)
     if (peekTok.type === 'keyword' && peekTok.value === 'SELECT') {
@@ -186,7 +187,7 @@ export function parseComparison(state) {
 
   if (tok.type === 'operator' && isBinaryOp(tok.value)) {
     consume(state)
-    const right = parsePrimary(state)
+    const right = parseAdditive(state)
     return {
       type: 'binary',
       op: tok.value,

package/src/parse/expression.js

@@ -1,12 +1,66 @@
-import { isAggregateFunc, isStringFunc } from '../validation.js'
+import {
+  invalidLiteralError,
+  missingClauseError,
+  syntaxError,
+  unknownFunctionError,
+} from '../errors.js'
+import { isAggregateFunc, isIntervalUnit, isStringFunc } from '../validation.js'
 import { parseComparison } from './comparison.js'
 import { parseSelectInternal } from './parse.js'
 import { consume, current, expect, expectIdentifier, match, peekToken } from './state.js'
 
 /**
- * @import { ExprNode, ParserState, SelectStatement, WhenClause } from '../types.js'
+ * @import { ExprNode, IntervalNode, ParserState, SelectStatement, WhenClause } from '../types.js'
  */
 
+/**
+ * @param {ParserState} state
+ * @returns {IntervalNode}
+ */
+function parseInterval(state) {
+  consume(state) // INTERVAL
+
+  // Handle optional negative sign
+  let sign = 1
+  const signTok = current(state)
+  if (signTok.type === 'operator' && signTok.value === '-') {
+    consume(state)
+    sign = -1
+  }
+
+  // Get value (number or quoted string)
+  const valueTok = current(state)
+  /** @type {number} */
+  let value
+  if (valueTok.type === 'number') {
+    consume(state)
+    value = sign * Number(valueTok.numericValue)
+  } else if (valueTok.type === 'string') {
+    consume(state)
+    const parsed = parseFloat(valueTok.value)
+    if (isNaN(parsed)) {
+      throw invalidLiteralError({ type: 'interval value', value: valueTok.value, position: valueTok.position })
+    }
+    value = sign * parsed
+  } else {
+    throw syntaxError({ expected: 'interval value (number)', received: `"${valueTok.value}"`, position: valueTok.position })
+  }
+
+  // Get unit keyword
+  const unitTok = current(state)
+  if (unitTok.type !== 'keyword' || !isIntervalUnit(unitTok.value)) {
+    throw invalidLiteralError({
+      type: 'interval unit',
+      value: unitTok.value,
+      position: unitTok.position,
+      validValues: 'DAY, MONTH, YEAR, HOUR, MINUTE, SECOND',
+    })
+  }
+  consume(state)
+
+  return { type: 'interval', value, unit: unitTok.value }
+}
+
 /**
  * @param {ParserState} state
  * @returns {ExprNode}
@@ -64,7 +118,7 @@ export function parsePrimary(state) {
 
       // validate function names
       if (!isStringFunc(funcName) && !isAggregateFunc(funcName)) {
-        throw new Error(`Unknown function "${funcName}" at position ${tok.position}`)
+        throw unknownFunctionError(funcName, tok.position)
       }
 
       consume(state) // function name
@@ -99,6 +153,17 @@ export function parsePrimary(state) {
       }
     }
 
+    // Niladic datetime functions (no parentheses required per ANSI SQL)
+    const niladicFuncs = ['CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP']
+    if (niladicFuncs.includes(tok.value)) {
+      consume(state)
+      return {
+        type: 'function',
+        name: tok.value,
+        args: [],
+      }
+    }
+
     consume(state)
     let name = tok.value
 
@@ -175,7 +240,10 @@ export function parsePrimary(state) {
       }
 
       if (whenClauses.length === 0) {
-        throw new Error('CASE expression must have at least one WHEN clause')
+        throw missingClauseError({
+          missing: 'at least one WHEN clause',
+          context: 'CASE expression',
+        })
       }
 
       // Parse optional ELSE clause
@@ -194,6 +262,9 @@ export function parsePrimary(state) {
         elseResult,
       }
     }
+    if (tok.value === 'INTERVAL') {
+      return parseInterval(state)
+    }
   }
 
   if (tok.type === 'operator' && tok.value === '-') {
@@ -207,7 +278,7 @@ export function parsePrimary(state) {
   }
 
   const found = tok.type === 'eof' ? 'end of query' : `"${tok.originalValue ?? tok.value}"`
-  throw new Error(`Expected expression but found ${found} at position ${tok.position}`)
+  throw syntaxError({ expected: 'expression', received: found, position: tok.position })
 }
 
 /**
@@ -272,6 +343,54 @@ function parseNot(state) {
   return parseComparison(state)
 }
 
+/**
+ * @param {ParserState} state
+ * @returns {ExprNode}
+ */
+export function parseAdditive(state) {
+  let node = parseMultiplicative(state)
+  while (true) {
+    const tok = current(state)
+    if (tok.type === 'operator' && (tok.value === '+' || tok.value === '-')) {
+      consume(state)
+      const right = parseMultiplicative(state)
+      node = {
+        type: 'binary',
+        op: tok.value,
+        left: node,
+        right,
+      }
+    } else {
+      break
+    }
+  }
+  return node
+}
+
+/**
+ * @param {ParserState} state
+ * @returns {ExprNode}
+ */
+function parseMultiplicative(state) {
+  let node = parsePrimary(state)
+  while (true) {
+    const tok = current(state)
+    if (tok.type === 'operator' && (tok.value === '*' || tok.value === '/' || tok.value === '%')) {
+      consume(state)
+      const right = parsePrimary(state)
+      node = {
+        type: 'binary',
+        op: tok.value,
+        left: node,
+        right,
+      }
+    } else {
+      break
+    }
+  }
+  return node
+}
+
 /**
  * Creates an ExprCursor adapter for the ParserState.
  *