@tanstack/db 0.0.14 → 0.0.16

package/src/query/extractors.ts

@@ -1,214 +0,0 @@
-import { evaluateFunction, isFunctionCall } from "./functions.js"
-import type { AllowedFunctionName, ConditionOperand } from "./schema.js"
-
-/**
- * Extracts a value from a nested row structure
- * @param namespacedRow The nested row structure
- * @param columnRef The column reference (may include table.column format)
- * @param mainTableAlias The main table alias to check first for columns without table reference
- * @param joinedTableAlias The joined table alias to check second for columns without table reference
- * @returns The extracted value or undefined if not found
- */
-export function extractValueFromNamespacedRow(
-  namespacedRow: Record<string, unknown>,
-  columnRef: string,
-  mainTableAlias?: string,
-  joinedTableAlias?: string
-): unknown {
-  // Check if it's a table.column reference
-  if (columnRef.includes(`.`)) {
-    const [tableAlias, colName] = columnRef.split(`.`) as [string, string]
-
-    // Get the table data
-    const tableData = namespacedRow[tableAlias] as
-      | Record<string, unknown>
-      | null
-      | undefined
-
-    if (!tableData) {
-      return null
-    }
-
-    // Return the column value from that table
-    const value = tableData[colName]
-    return value
-  } else {
-    // If no table is specified, first try to find in the main table if provided
-    if (mainTableAlias && namespacedRow[mainTableAlias]) {
-      const mainTableData = namespacedRow[mainTableAlias] as Record<
-        string,
-        unknown
-      >
-      if (typeof mainTableData === `object` && columnRef in mainTableData) {
-        return mainTableData[columnRef]
-      }
-    }
-
-    // Then try the joined table if provided
-    if (joinedTableAlias && namespacedRow[joinedTableAlias]) {
-      const joinedTableData = namespacedRow[joinedTableAlias] as Record<
-        string,
-        unknown
-      >
-      if (typeof joinedTableData === `object` && columnRef in joinedTableData) {
-        return joinedTableData[columnRef]
-      }
-    }
-
-    // If not found in main or joined table, try to find the column in any table
-    for (const [_tableAlias, tableData] of Object.entries(namespacedRow)) {
-      if (
-        tableData &&
-        typeof tableData === `object` &&
-        columnRef in (tableData as Record<string, unknown>)
-      ) {
-        return (tableData as Record<string, unknown>)[columnRef]
-      }
-    }
-    return undefined
-  }
-}
-
-/**
- * Evaluates an operand against a nested row structure
- */
-export function evaluateOperandOnNamespacedRow(
-  namespacedRow: Record<string, unknown>,
-  operand: ConditionOperand,
-  mainTableAlias?: string,
-  joinedTableAlias?: string
-): unknown {
-  // Handle column references
-  if (typeof operand === `string` && operand.startsWith(`@`)) {
-    const columnRef = operand.substring(1)
-    return extractValueFromNamespacedRow(
-      namespacedRow,
-      columnRef,
-      mainTableAlias,
-      joinedTableAlias
-    )
-  }
-
-  // Handle explicit column references
-  if (operand && typeof operand === `object` && `col` in operand) {
-    const colRef = (operand as { col: unknown }).col
-
-    if (typeof colRef === `string`) {
-      // First try to extract from nested row structure
-      const nestedValue = extractValueFromNamespacedRow(
-        namespacedRow,
-        colRef,
-        mainTableAlias,
-        joinedTableAlias
-      )
-
-      // If not found in nested structure, check if it's a direct property of the row
-      // This is important for HAVING clauses that reference aggregated values
-      if (nestedValue === undefined && colRef in namespacedRow) {
-        return namespacedRow[colRef]
-      }
-
-      return nestedValue
-    }
-
-    return undefined
-  }
-
-  // Handle function calls
-  if (operand && typeof operand === `object` && isFunctionCall(operand)) {
-    // Get the function name (the only key in the object)
-    const functionName = Object.keys(operand)[0] as AllowedFunctionName
-    // Get the arguments using type assertion with specific function name
-    const args = (operand as any)[functionName]
-
-    // If the arguments are a reference or another expression, evaluate them first
-    const evaluatedArgs = Array.isArray(args)
-      ? args.map((arg) =>
-          evaluateOperandOnNamespacedRow(
-            namespacedRow,
-            arg as ConditionOperand,
-            mainTableAlias,
-            joinedTableAlias
-          )
-        )
-      : evaluateOperandOnNamespacedRow(
-          namespacedRow,
-          args as ConditionOperand,
-          mainTableAlias,
-          joinedTableAlias
-        )
-
-    // Call the function with the evaluated arguments
-    return evaluateFunction(
-      functionName,
-      evaluatedArgs as ConditionOperand | Array<ConditionOperand>
-    )
-  }
-
-  // Handle explicit literals
-  if (operand && typeof operand === `object` && `value` in operand) {
-    return (operand as { value: unknown }).value
-  }
-
-  // Handle literal values
-  return operand
-}
-
-/**
- * Extracts a join key value from a row based on the operand
- * @param row The data row (not nested)
- * @param operand The operand to extract the key from
- * @param defaultTableAlias The default table alias
- * @returns The extracted key value
- */
-export function extractJoinKey<T extends Record<string, unknown>>(
-  row: T,
-  operand: ConditionOperand,
-  defaultTableAlias?: string
-): unknown {
-  let keyValue: unknown
-
-  // Handle column references (e.g., "@orders.id" or "@id")
-  if (typeof operand === `string` && operand.startsWith(`@`)) {
-    const columnRef = operand.substring(1)
-
-    // If it contains a dot, extract the table and column
-    if (columnRef.includes(`.`)) {
-      const [tableAlias, colName] = columnRef.split(`.`) as [string, string]
-      // If this is referencing the current table, extract from row directly
-      if (tableAlias === defaultTableAlias) {
-        keyValue = row[colName]
-      } else {
-        // This might be a column from another table, return undefined
-        keyValue = undefined
-      }
-    } else {
-      // No table specified, look directly in the row
-      keyValue = row[columnRef]
-    }
-  } else if (operand && typeof operand === `object` && `col` in operand) {
-    // Handle explicit column references like { col: "orders.id" } or { col: "id" }
-    const colRef = (operand as { col: unknown }).col
-
-    if (typeof colRef === `string`) {
-      if (colRef.includes(`.`)) {
-        const [tableAlias, colName] = colRef.split(`.`) as [string, string]
-        // If this is referencing the current table, extract from row directly
-        if (tableAlias === defaultTableAlias) {
-          keyValue = row[colName]
-        } else {
-          // This might be a column from another table, return undefined
-          keyValue = undefined
-        }
-      } else {
-        // No table specified, look directly in the row
-        keyValue = row[colRef]
-      }
-    }
-  } else {
-    // Handle literals or other types
-    keyValue = operand
-  }
-
-  return keyValue
-}

package/src/query/functions.ts

@@ -1,297 +0,0 @@
-import type { AllowedFunctionName } from "./schema.js"
-
-/**
- * Type for function implementations
- */
-type FunctionImplementation = (arg: unknown) => unknown
-
-/**
- * Converts a string to uppercase
- */
-function upperFunction(arg: unknown): string {
-  if (typeof arg !== `string`) {
-    throw new Error(`UPPER function expects a string argument`)
-  }
-  return arg.toUpperCase()
-}
-
-/**
- * Converts a string to lowercase
- */
-function lowerFunction(arg: unknown): string {
-  if (typeof arg !== `string`) {
-    throw new Error(`LOWER function expects a string argument`)
-  }
-  return arg.toLowerCase()
-}
-
-/**
- * Returns the length of a string or array
- */
-function lengthFunction(arg: unknown): number {
-  if (typeof arg === `string` || Array.isArray(arg)) {
-    return arg.length
-  }
-
-  throw new Error(`LENGTH function expects a string or array argument`)
-}
-
-/**
- * Concatenates multiple strings
- */
-function concatFunction(arg: unknown): string {
-  if (!Array.isArray(arg)) {
-    throw new Error(`CONCAT function expects an array of string arguments`)
-  }
-
-  if (arg.length === 0) {
-    return ``
-  }
-
-  // Check that all arguments are strings
-  for (let i = 0; i < arg.length; i++) {
-    if (arg[i] !== null && arg[i] !== undefined && typeof arg[i] !== `string`) {
-      throw new Error(
-        `CONCAT function expects all arguments to be strings, but argument at position ${i} is ${typeof arg[i]}`
-      )
-    }
-  }
-
-  // Concatenate strings, treating null and undefined as empty strings
-  return arg
-    .map((str) => (str === null || str === undefined ? `` : str))
-    .join(``)
-}
-
-/**
- * Returns the first non-null, non-undefined value from an array
- */
-function coalesceFunction(arg: unknown): unknown {
-  if (!Array.isArray(arg)) {
-    throw new Error(`COALESCE function expects an array of arguments`)
-  }
-
-  if (arg.length === 0) {
-    return null
-  }
-
-  // Return the first non-null, non-undefined value
-  for (const value of arg) {
-    if (value !== null && value !== undefined) {
-      return value
-    }
-  }
-
-  // If all values were null or undefined, return null
-  return null
-}
-
-/**
- * Creates or converts a value to a Date object
- */
-function dateFunction(arg: unknown): Date | null {
-  // If the argument is already a Date, return it
-  if (arg instanceof Date) {
-    return arg
-  }
-
-  // If the argument is null or undefined, return null
-  if (arg === null || arg === undefined) {
-    return null
-  }
-
-  // Handle string and number conversions
-  if (typeof arg === `string` || typeof arg === `number`) {
-    const date = new Date(arg)
-
-    // Check if the date is valid
-    if (isNaN(date.getTime())) {
-      throw new Error(`DATE function could not parse "${arg}" as a valid date`)
-    }
-
-    return date
-  }
-
-  throw new Error(`DATE function expects a string, number, or Date argument`)
-}
-
-/**
- * Extracts a value from a JSON string or object using a path.
- * Similar to PostgreSQL's json_extract_path function.
- *
- * Usage: JSON_EXTRACT([jsonInput, 'path', 'to', 'property'])
- * Example: JSON_EXTRACT(['{"user": {"name": "John"}}', 'user', 'name']) returns "John"
- */
-function jsonExtractFunction(arg: unknown): unknown {
-  if (!Array.isArray(arg) || arg.length < 1) {
-    throw new Error(
-      `JSON_EXTRACT function expects an array with at least one element [jsonInput, ...pathElements]`
-    )
-  }
-
-  const [jsonInput, ...pathElements] = arg
-
-  // Handle null or undefined input
-  if (jsonInput === null || jsonInput === undefined) {
-    return null
-  }
-
-  // Parse JSON if it's a string
-  let jsonData: any
-
-  if (typeof jsonInput === `string`) {
-    try {
-      jsonData = JSON.parse(jsonInput)
-    } catch (error) {
-      throw new Error(
-        `JSON_EXTRACT function could not parse JSON string: ${error instanceof Error ? error.message : String(error)}`
-      )
-    }
-  } else if (typeof jsonInput === `object`) {
-    // If already an object, use it directly
-    jsonData = jsonInput
-  } else {
-    throw new Error(
-      `JSON_EXTRACT function expects a JSON string or object as the first argument`
-    )
-  }
-
-  // If no path elements, return the parsed JSON
-  if (pathElements.length === 0) {
-    return jsonData
-  }
-
-  // Navigate through the path elements
-  let current = jsonData
-
-  for (let i = 0; i < pathElements.length; i++) {
-    const pathElement = pathElements[i]
-
-    // Path elements should be strings
-    if (typeof pathElement !== `string`) {
-      throw new Error(
-        `JSON_EXTRACT function expects path elements to be strings, but element at position ${i + 1} is ${typeof pathElement}`
-      )
-    }
-
-    // If current node is null or undefined, or not an object, we can't navigate further
-    if (
-      current === null ||
-      current === undefined ||
-      typeof current !== `object`
-    ) {
-      return null
-    }
-
-    // Access property
-    current = current[pathElement]
-  }
-
-  // Return null instead of undefined for consistency
-  return current === undefined ? null : current
-}
-
-/**
- * Placeholder function for ORDER_INDEX
- * This function doesn't do anything when called directly, as the actual index
- * is provided by the orderBy operator during query execution.
- * The argument can be 'numeric', 'fractional', or any truthy value (defaults to 'numeric')
- */
-function orderIndexFunction(arg: unknown): null {
-  // This is just a placeholder - the actual index is provided by the orderBy operator
-  // The function validates that the argument is one of the expected values
-  if (
-    arg !== `numeric` &&
-    arg !== `fractional` &&
-    arg !== true &&
-    arg !== `default`
-  ) {
-    throw new Error(
-      `ORDER_INDEX function expects "numeric", "fractional", "default", or true as argument`
-    )
-  }
-  return null
-}
-
-/**
- * Map of function names to their implementations
- */
-const functionImplementations: Record<
-  AllowedFunctionName,
-  FunctionImplementation
-> = {
-  // Map function names to their implementation functions
-  DATE: dateFunction,
-  JSON_EXTRACT: jsonExtractFunction,
-  JSON_EXTRACT_PATH: jsonExtractFunction, // Alias for JSON_EXTRACT
-  UPPER: upperFunction,
-  LOWER: lowerFunction,
-  COALESCE: coalesceFunction,
-  CONCAT: concatFunction,
-  LENGTH: lengthFunction,
-  ORDER_INDEX: orderIndexFunction,
-}
-
-/**
- * Evaluates a function call with the given name and arguments
- * @param functionName The name of the function to evaluate
- * @param arg The arguments to pass to the function
- * @returns The result of the function call
- */
-export function evaluateFunction(
-  functionName: AllowedFunctionName,
-  arg: unknown
-): unknown {
-  const implementation = functionImplementations[functionName] as
-    | FunctionImplementation
-    | undefined // Double check that the implementation is defined
-
-  if (!implementation) {
-    throw new Error(`Unknown function: ${functionName}`)
-  }
-  return implementation(arg)
-}
-
-/**
- * Determines if an object is a function call
- * @param obj The object to check
- * @returns True if the object is a function call, false otherwise
- */
-export function isFunctionCall(obj: unknown): boolean {
-  if (!obj || typeof obj !== `object`) {
-    return false
-  }
-
-  const keys = Object.keys(obj)
-  if (keys.length !== 1) {
-    return false
-  }
-
-  const functionName = keys[0] as string
-
-  // Check if the key is one of the allowed function names
-  return Object.keys(functionImplementations).includes(functionName)
-}
-
-/**
- * Extracts the function name and argument from a function call object.
- */
-export function extractFunctionCall(obj: Record<string, unknown>): {
-  functionName: AllowedFunctionName
-  argument: unknown
-} {
-  const keys = Object.keys(obj)
-  if (keys.length !== 1) {
-    throw new Error(`Invalid function call: object must have exactly one key`)
-  }
-
-  const functionName = keys[0] as AllowedFunctionName
-  if (!Object.keys(functionImplementations).includes(functionName)) {
-    throw new Error(`Invalid function name: ${functionName}`)
-  }
-
-  return {
-    functionName,
-    argument: obj[functionName],
-  }
-}

package/src/query/group-by.ts

@@ -1,139 +0,0 @@
-import { groupBy, groupByOperators } from "@electric-sql/d2mini"
-import {
-  evaluateOperandOnNamespacedRow,
-  extractValueFromNamespacedRow,
-} from "./extractors"
-import { isAggregateFunctionCall } from "./utils"
-import type { ConditionOperand, FunctionCall, Query } from "./schema"
-import type { NamespacedAndKeyedStream } from "../types.js"
-
-const { sum, count, avg, min, max, median, mode } = groupByOperators
-
-/**
- * Process the groupBy clause in a D2QL query
- */
-export function processGroupBy(
-  pipeline: NamespacedAndKeyedStream,
-  query: Query,
-  mainTableAlias: string
-) {
-  // Normalize groupBy to an array of column references
-  const groupByColumns = Array.isArray(query.groupBy)
-    ? query.groupBy
-    : [query.groupBy]
-
-  // Create a key extractor function for the groupBy operator
-  const keyExtractor = ([_oldKey, namespacedRow]: [
-    string,
-    Record<string, unknown>,
-  ]) => {
-    const key: Record<string, unknown> = {}
-
-    // Extract each groupBy column value
-    for (const column of groupByColumns) {
-      if (typeof column === `string` && (column as string).startsWith(`@`)) {
-        const columnRef = (column as string).substring(1)
-        const columnName = columnRef.includes(`.`)
-          ? columnRef.split(`.`)[1]
-          : columnRef
-
-        key[columnName!] = extractValueFromNamespacedRow(
-          namespacedRow,
-          columnRef,
-          mainTableAlias
-        )
-      }
-    }
-
-    return key
-  }
-
-  // Create aggregate functions for any aggregated columns in the SELECT clause
-  const aggregates: Record<string, any> = {}
-
-  if (!query.select) {
-    throw new Error(`SELECT clause is required for GROUP BY`)
-  }
-
-  // Scan the SELECT clause for aggregate functions
-  for (const item of query.select) {
-    if (typeof item === `object`) {
-      for (const [alias, expr] of Object.entries(item)) {
-        if (typeof expr === `object` && isAggregateFunctionCall(expr)) {
-          // Get the function name (the only key in the object)
-          const functionName = Object.keys(expr)[0]
-          // Get the column reference or expression to aggregate
-          const columnRef = (expr as FunctionCall)[
-            functionName as keyof FunctionCall
-          ]
-
-          // Add the aggregate function to our aggregates object
-          aggregates[alias] = getAggregateFunction(
-            functionName!,
-            columnRef,
-            mainTableAlias
-          )
-        }
-      }
-    }
-  }
-
-  // Apply the groupBy operator if we have any aggregates
-  if (Object.keys(aggregates).length > 0) {
-    pipeline = pipeline.pipe(groupBy(keyExtractor, aggregates))
-  }
-
-  return pipeline
-}
-
-/**
- * Helper function to get an aggregate function based on the function name
- */
-export function getAggregateFunction(
-  functionName: string,
-  columnRef: string | ConditionOperand,
-  mainTableAlias: string
-) {
-  // Create a value extractor function for the column to aggregate
-  const valueExtractor = ([_oldKey, namespacedRow]: [
-    string,
-    Record<string, unknown>,
-  ]) => {
-    let value: unknown
-    if (typeof columnRef === `string` && columnRef.startsWith(`@`)) {
-      value = extractValueFromNamespacedRow(
-        namespacedRow,
-        columnRef.substring(1),
-        mainTableAlias
-      )
-    } else {
-      value = evaluateOperandOnNamespacedRow(
-        namespacedRow,
-        columnRef as ConditionOperand,
-        mainTableAlias
-      )
-    }
-    // Ensure we return a number for aggregate functions
-    return typeof value === `number` ? value : 0
-  }
-
-  // Return the appropriate aggregate function
-  switch (functionName.toUpperCase()) {
-    case `SUM`:
-      return sum(valueExtractor)
-    case `COUNT`:
-      return count() // count() doesn't need a value extractor
-    case `AVG`:
-      return avg(valueExtractor)
-    case `MIN`:
-      return min(valueExtractor)
-    case `MAX`:
-      return max(valueExtractor)
-    case `MEDIAN`:
-      return median(valueExtractor)
-    case `MODE`:
-      return mode(valueExtractor)
-    default:
-      throw new Error(`Unsupported aggregate function: ${functionName}`)
-  }
-}