Function parseWhereExpression

packages/db/src/query/expression-helpers.ts:201–248

(
  expr: BasicExpression<boolean> | undefined | null,
  options: ParseWhereOptions<T>,
)

 * ```
 */
export function parseWhereExpression<T = any>(
  expr: BasicExpression<boolean> | undefined | null,
  options: ParseWhereOptions<T>,
): T | null {
  if (!expr) return null

  const { handlers, onUnknownOperator } = options

  // Handle value expressions
  if (expr.type === `val`) {
    return expr.value as unknown as T
  }

  // Handle property references
  if (expr.type === `ref`) {
    return expr.path as unknown as T
  }

  // Handle function expressions
  // After checking val and ref, expr must be func
  const { name, args } = expr
  const handler = handlers[name]

  if (!handler) {
    if (onUnknownOperator) {
      return onUnknownOperator(name, args)
    }
    throw new Error(
      `No handler provided for operator: ${name}. Available handlers: ${Object.keys(handlers).join(`, `)}`,
    )
  }

  // Parse arguments recursively
  const parsedArgs = args.map((arg: BasicExpression) => {
    // For refs, extract the field path
    if (arg.type === `ref`) {
      return arg.path
    }
    // For values, extract the value
    if (arg.type === `val`) {
      return arg.value
    }
    // For nested functions, recurse (after checking ref and val, must be func)
    return parseWhereExpression(arg, options)
  })

  return handler(...parsedArgs)
}

/**
 * Parses an ORDER BY expression into a simple array of sort specifications.