@tanstack/db 0.0.13 → 0.0.15

package/dist/esm/query/evaluators.js

@@ -1,161 +0,0 @@
-import { evaluateOperandOnNamespacedRow } from "./extractors.js";
-import { isValueInArray, convertLikeToRegex, compareValues } from "./utils.js";
-function evaluateWhereOnNamespacedRow(namespacedRow, where, mainTableAlias, joinedTableAlias) {
-  return where.every((item) => {
-    if (typeof item === `function`) {
-      return item(namespacedRow);
-    } else {
-      return evaluateConditionOnNamespacedRow(
-        namespacedRow,
-        item,
-        mainTableAlias,
-        joinedTableAlias
-      );
-    }
-  });
-}
-function evaluateConditionOnNamespacedRow(namespacedRow, condition, mainTableAlias, joinedTableAlias) {
-  if (condition.length === 3 && !Array.isArray(condition[0])) {
-    const [left, comparator, right] = condition;
-    return evaluateSimpleConditionOnNamespacedRow(
-      namespacedRow,
-      left,
-      comparator,
-      right,
-      mainTableAlias,
-      joinedTableAlias
-    );
-  }
-  if (condition.length > 3 && !Array.isArray(condition[0]) && typeof condition[1] === `string` && ![`and`, `or`].includes(condition[1])) {
-    let result = evaluateSimpleConditionOnNamespacedRow(
-      namespacedRow,
-      condition[0],
-      condition[1],
-      condition[2],
-      mainTableAlias,
-      joinedTableAlias
-    );
-    for (let i = 3; i < condition.length; i += 4) {
-      const logicalOp = condition[i];
-      if (i + 3 <= condition.length) {
-        const nextResult = evaluateSimpleConditionOnNamespacedRow(
-          namespacedRow,
-          condition[i + 1],
-          condition[i + 2],
-          condition[i + 3],
-          mainTableAlias,
-          joinedTableAlias
-        );
-        if (logicalOp === `and`) {
-          result = result && nextResult;
-        } else {
-          result = result || nextResult;
-        }
-      }
-    }
-    return result;
-  }
-  if (condition.length > 0 && Array.isArray(condition[0])) {
-    let result = evaluateConditionOnNamespacedRow(
-      namespacedRow,
-      condition[0],
-      mainTableAlias,
-      joinedTableAlias
-    );
-    for (let i = 1; i < condition.length; i += 2) {
-      if (i + 1 >= condition.length) break;
-      const operator = condition[i];
-      const nextCondition = condition[i + 1];
-      if (operator === `and`) {
-        result = result && evaluateConditionOnNamespacedRow(
-          namespacedRow,
-          nextCondition,
-          mainTableAlias,
-          joinedTableAlias
-        );
-      } else {
-        result = result || evaluateConditionOnNamespacedRow(
-          namespacedRow,
-          nextCondition,
-          mainTableAlias,
-          joinedTableAlias
-        );
-      }
-    }
-    return result;
-  }
-  return true;
-}
-function evaluateSimpleConditionOnNamespacedRow(namespacedRow, left, comparator, right, mainTableAlias, joinedTableAlias) {
-  const leftValue = evaluateOperandOnNamespacedRow(
-    namespacedRow,
-    left,
-    mainTableAlias,
-    joinedTableAlias
-  );
-  const rightValue = evaluateOperandOnNamespacedRow(
-    namespacedRow,
-    right,
-    mainTableAlias,
-    joinedTableAlias
-  );
-  switch (comparator) {
-    case `=`:
-      return leftValue === rightValue;
-    case `!=`:
-      return leftValue !== rightValue;
-    case `<`:
-      return compareValues(leftValue, rightValue, `<`);
-    case `<=`:
-      return compareValues(leftValue, rightValue, `<=`);
-    case `>`:
-      return compareValues(leftValue, rightValue, `>`);
-    case `>=`:
-      return compareValues(leftValue, rightValue, `>=`);
-    case `like`:
-    case `not like`:
-      if (typeof leftValue === `string` && typeof rightValue === `string`) {
-        const pattern = convertLikeToRegex(rightValue);
-        const matches = new RegExp(`^${pattern}$`, `i`).test(leftValue);
-        return comparator === `like` ? matches : !matches;
-      }
-      return comparator === `like` ? false : true;
-    case `in`:
-      if (!Array.isArray(rightValue)) {
-        return false;
-      }
-      if (rightValue.length === 0) {
-        return false;
-      }
-      if (Array.isArray(leftValue)) {
-        return leftValue.some((item) => isValueInArray(item, rightValue));
-      }
-      return isValueInArray(leftValue, rightValue);
-    case `not in`:
-      if (!Array.isArray(rightValue)) {
-        return true;
-      }
-      if (rightValue.length === 0) {
-        return true;
-      }
-      if (Array.isArray(leftValue)) {
-        return !leftValue.some((item) => isValueInArray(item, rightValue));
-      }
-      return !isValueInArray(leftValue, rightValue);
-    case `is`:
-      return leftValue === rightValue;
-    case `is not`:
-      if (rightValue === null) {
-        return leftValue !== null && leftValue !== void 0;
-      }
-      return leftValue !== rightValue;
-    default:
-      return false;
-  }
-}
-export {
-  evaluateConditionOnNamespacedRow,
-  evaluateSimpleConditionOnNamespacedRow,
-  evaluateWhereOnNamespacedRow
-};
-//# sourceMappingURL=evaluators.js.map

package/dist/esm/query/evaluators.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"evaluators.js","sources":["../../../src/query/evaluators.ts"],"sourcesContent":["import { evaluateOperandOnNamespacedRow } from \"./extractors.js\"\nimport { compareValues, convertLikeToRegex, isValueInArray } from \"./utils.js\"\nimport type {\n  Comparator,\n  Condition,\n  ConditionOperand,\n  LogicalOperator,\n  SimpleCondition,\n  Where,\n  WhereCallback,\n} from \"./schema.js\"\nimport type { NamespacedRow } from \"../types.js\"\n\n/**\n * Evaluates a Where clause (which is always an array of conditions and/or callbacks) against a nested row structure\n */\nexport function evaluateWhereOnNamespacedRow(\n  namespacedRow: NamespacedRow,\n  where: Where,\n  mainTableAlias?: string,\n  joinedTableAlias?: string\n): boolean {\n  // Where is always an array of conditions and/or callbacks\n  // Evaluate all items and combine with AND logic\n  return where.every((item) => {\n    if (typeof item === `function`) {\n      return (item as WhereCallback)(namespacedRow)\n    } else {\n      return evaluateConditionOnNamespacedRow(\n        namespacedRow,\n        item as Condition,\n        mainTableAlias,\n        joinedTableAlias\n      )\n    }\n  })\n}\n\n/**\n * Evaluates a condition against a nested row structure\n */\nexport function evaluateConditionOnNamespacedRow(\n  namespacedRow: NamespacedRow,\n  condition: Condition,\n  mainTableAlias?: string,\n  joinedTableAlias?: string\n): boolean {\n  // Handle simple conditions with exactly 3 elements\n  if (condition.length === 3 && !Array.isArray(condition[0])) {\n    const [left, comparator, right] = condition as SimpleCondition\n    return evaluateSimpleConditionOnNamespacedRow(\n      namespacedRow,\n      left,\n      comparator,\n      right,\n      mainTableAlias,\n      joinedTableAlias\n    )\n  }\n\n  // Handle flat composite conditions (multiple conditions in a single array)\n  if (\n    condition.length > 3 &&\n    !Array.isArray(condition[0]) &&\n    typeof condition[1] === `string` &&\n    ![`and`, `or`].includes(condition[1] as string)\n  ) {\n    // Start with the first condition (first 3 elements)\n    let result = evaluateSimpleConditionOnNamespacedRow(\n      namespacedRow,\n      condition[0],\n      condition[1] as Comparator,\n      condition[2],\n      mainTableAlias,\n      joinedTableAlias\n    )\n\n    // Process the rest in groups: logical operator, then 3 elements for each condition\n    for (let i = 3; i < condition.length; i += 4) {\n      const logicalOp = condition[i] as LogicalOperator\n\n      // Make sure we have a complete condition to evaluate\n      if (i + 3 <= condition.length) {\n        const nextResult = evaluateSimpleConditionOnNamespacedRow(\n          namespacedRow,\n          condition[i + 1],\n          condition[i + 2] as Comparator,\n          condition[i + 3],\n          mainTableAlias,\n          joinedTableAlias\n        )\n\n        // Apply the logical operator\n        if (logicalOp === `and`) {\n          result = result && nextResult\n        } else {\n          // logicalOp === `or`\n          result = result || nextResult\n        }\n      }\n    }\n\n    return result\n  }\n\n  // Handle nested composite conditions where the first element is an array\n  if (condition.length > 0 && Array.isArray(condition[0])) {\n    // Start with the first condition\n    let result = evaluateConditionOnNamespacedRow(\n      namespacedRow,\n      condition[0] as Condition,\n      mainTableAlias,\n      joinedTableAlias\n    )\n\n    // Process the rest of the conditions and logical operators in pairs\n    for (let i = 1; i < condition.length; i += 2) {\n      if (i + 1 >= condition.length) break // Make sure we have a pair\n\n      const operator = condition[i] as LogicalOperator\n      const nextCondition = condition[i + 1] as Condition\n\n      // Apply the logical operator\n      if (operator === `and`) {\n        result =\n          result &&\n          evaluateConditionOnNamespacedRow(\n            namespacedRow,\n            nextCondition,\n            mainTableAlias,\n            joinedTableAlias\n          )\n      } else {\n        // logicalOp === `or`\n        result =\n          result ||\n          evaluateConditionOnNamespacedRow(\n            namespacedRow,\n            nextCondition,\n            mainTableAlias,\n            joinedTableAlias\n          )\n      }\n    }\n\n    return result\n  }\n\n  // Fallback - this should not happen with valid conditions\n  return true\n}\n\n/**\n * Evaluates a simple condition against a nested row structure\n */\nexport function evaluateSimpleConditionOnNamespacedRow(\n  namespacedRow: Record<string, unknown>,\n  left: ConditionOperand,\n  comparator: Comparator,\n  right: ConditionOperand,\n  mainTableAlias?: string,\n  joinedTableAlias?: string\n): boolean {\n  const leftValue = evaluateOperandOnNamespacedRow(\n    namespacedRow,\n    left,\n    mainTableAlias,\n    joinedTableAlias\n  )\n\n  const rightValue = evaluateOperandOnNamespacedRow(\n    namespacedRow,\n    right,\n    mainTableAlias,\n    joinedTableAlias\n  )\n\n  // The rest of the function remains the same as evaluateSimpleCondition\n  switch (comparator) {\n    case `=`:\n      return leftValue === rightValue\n    case `!=`:\n      return leftValue !== rightValue\n    case `<`:\n      return compareValues(leftValue, rightValue, `<`)\n    case `<=`:\n      return compareValues(leftValue, rightValue, `<=`)\n    case `>`:\n      return compareValues(leftValue, rightValue, `>`)\n    case `>=`:\n      return compareValues(leftValue, rightValue, `>=`)\n    case `like`:\n    case `not like`:\n      if (typeof leftValue === `string` && typeof rightValue === `string`) {\n        // Convert SQL LIKE pattern to proper regex pattern\n        const pattern = convertLikeToRegex(rightValue)\n        const matches = new RegExp(`^${pattern}$`, `i`).test(leftValue)\n        return comparator === `like` ? matches : !matches\n      }\n      return comparator === `like` ? false : true\n    case `in`:\n      // If right value is not an array, we can't do an IN operation\n      if (!Array.isArray(rightValue)) {\n        return false\n      }\n\n      // For empty arrays, nothing is contained in them\n      if (rightValue.length === 0) {\n        return false\n      }\n\n      // Handle array-to-array comparison (check if any element in leftValue exists in rightValue)\n      if (Array.isArray(leftValue)) {\n        return leftValue.some((item) => isValueInArray(item, rightValue))\n      }\n\n      // Handle single value comparison\n      return isValueInArray(leftValue, rightValue)\n\n    case `not in`:\n      // If right value is not an array, everything is \"not in\" it\n      if (!Array.isArray(rightValue)) {\n        return true\n      }\n\n      // For empty arrays, everything is \"not in\" them\n      if (rightValue.length === 0) {\n        return true\n      }\n\n      // Handle array-to-array comparison (check if no element in leftValue exists in rightValue)\n      if (Array.isArray(leftValue)) {\n        return !leftValue.some((item) => isValueInArray(item, rightValue))\n      }\n\n      // Handle single value comparison\n      return !isValueInArray(leftValue, rightValue)\n\n    case `is`:\n      return leftValue === rightValue\n    case `is not`:\n      // Properly handle null/undefined checks\n      if (rightValue === null) {\n        return leftValue !== null && leftValue !== undefined\n      }\n      return leftValue !== rightValue\n    default:\n      return false\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/query/extractors.d.ts

@@ -1,22 +0,0 @@
-import { 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 declare function extractValueFromNamespacedRow(namespacedRow: Record<string, unknown>, columnRef: string, mainTableAlias?: string, joinedTableAlias?: string): unknown;
-/**
- * Evaluates an operand against a nested row structure
- */
-export declare function evaluateOperandOnNamespacedRow(namespacedRow: Record<string, unknown>, operand: ConditionOperand, mainTableAlias?: string, joinedTableAlias?: string): unknown;
-/**
- * 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 declare function extractJoinKey<T extends Record<string, unknown>>(row: T, operand: ConditionOperand, defaultTableAlias?: string): unknown;

package/dist/esm/query/extractors.js

@@ -1,122 +0,0 @@
-import { isFunctionCall, evaluateFunction } from "./functions.js";
-function extractValueFromNamespacedRow(namespacedRow, columnRef, mainTableAlias, joinedTableAlias) {
-  if (columnRef.includes(`.`)) {
-    const [tableAlias, colName] = columnRef.split(`.`);
-    const tableData = namespacedRow[tableAlias];
-    if (!tableData) {
-      return null;
-    }
-    const value = tableData[colName];
-    return value;
-  } else {
-    if (mainTableAlias && namespacedRow[mainTableAlias]) {
-      const mainTableData = namespacedRow[mainTableAlias];
-      if (typeof mainTableData === `object` && columnRef in mainTableData) {
-        return mainTableData[columnRef];
-      }
-    }
-    if (joinedTableAlias && namespacedRow[joinedTableAlias]) {
-      const joinedTableData = namespacedRow[joinedTableAlias];
-      if (typeof joinedTableData === `object` && columnRef in joinedTableData) {
-        return joinedTableData[columnRef];
-      }
-    }
-    for (const [_tableAlias, tableData] of Object.entries(namespacedRow)) {
-      if (tableData && typeof tableData === `object` && columnRef in tableData) {
-        return tableData[columnRef];
-      }
-    }
-    return void 0;
-  }
-}
-function evaluateOperandOnNamespacedRow(namespacedRow, operand, mainTableAlias, joinedTableAlias) {
-  if (typeof operand === `string` && operand.startsWith(`@`)) {
-    const columnRef = operand.substring(1);
-    return extractValueFromNamespacedRow(
-      namespacedRow,
-      columnRef,
-      mainTableAlias,
-      joinedTableAlias
-    );
-  }
-  if (operand && typeof operand === `object` && `col` in operand) {
-    const colRef = operand.col;
-    if (typeof colRef === `string`) {
-      const nestedValue = extractValueFromNamespacedRow(
-        namespacedRow,
-        colRef,
-        mainTableAlias,
-        joinedTableAlias
-      );
-      if (nestedValue === void 0 && colRef in namespacedRow) {
-        return namespacedRow[colRef];
-      }
-      return nestedValue;
-    }
-    return void 0;
-  }
-  if (operand && typeof operand === `object` && isFunctionCall(operand)) {
-    const functionName = Object.keys(operand)[0];
-    const args = operand[functionName];
-    const evaluatedArgs = Array.isArray(args) ? args.map(
-      (arg) => evaluateOperandOnNamespacedRow(
-        namespacedRow,
-        arg,
-        mainTableAlias,
-        joinedTableAlias
-      )
-    ) : evaluateOperandOnNamespacedRow(
-      namespacedRow,
-      args,
-      mainTableAlias,
-      joinedTableAlias
-    );
-    return evaluateFunction(
-      functionName,
-      evaluatedArgs
-    );
-  }
-  if (operand && typeof operand === `object` && `value` in operand) {
-    return operand.value;
-  }
-  return operand;
-}
-function extractJoinKey(row, operand, defaultTableAlias) {
-  let keyValue;
-  if (typeof operand === `string` && operand.startsWith(`@`)) {
-    const columnRef = operand.substring(1);
-    if (columnRef.includes(`.`)) {
-      const [tableAlias, colName] = columnRef.split(`.`);
-      if (tableAlias === defaultTableAlias) {
-        keyValue = row[colName];
-      } else {
-        keyValue = void 0;
-      }
-    } else {
-      keyValue = row[columnRef];
-    }
-  } else if (operand && typeof operand === `object` && `col` in operand) {
-    const colRef = operand.col;
-    if (typeof colRef === `string`) {
-      if (colRef.includes(`.`)) {
-        const [tableAlias, colName] = colRef.split(`.`);
-        if (tableAlias === defaultTableAlias) {
-          keyValue = row[colName];
-        } else {
-          keyValue = void 0;
-        }
-      } else {
-        keyValue = row[colRef];
-      }
-    }
-  } else {
-    keyValue = operand;
-  }
-  return keyValue;
-}
-export {
-  evaluateOperandOnNamespacedRow,
-  extractJoinKey,
-  extractValueFromNamespacedRow
-};
-//# sourceMappingURL=extractors.js.map

package/dist/esm/query/extractors.js.map

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

package/dist/esm/query/functions.d.ts

@@ -1,21 +0,0 @@
-import { AllowedFunctionName } from './schema.js';
-/**
- * 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 declare function evaluateFunction(functionName: AllowedFunctionName, arg: unknown): unknown;
-/**
- * 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 declare function isFunctionCall(obj: unknown): boolean;
-/**
- * Extracts the function name and argument from a function call object.
- */
-export declare function extractFunctionCall(obj: Record<string, unknown>): {
-    functionName: AllowedFunctionName;
-    argument: unknown;
-};

package/dist/esm/query/functions.js

@@ -1,152 +0,0 @@
-function upperFunction(arg) {
-  if (typeof arg !== `string`) {
-    throw new Error(`UPPER function expects a string argument`);
-  }
-  return arg.toUpperCase();
-}
-function lowerFunction(arg) {
-  if (typeof arg !== `string`) {
-    throw new Error(`LOWER function expects a string argument`);
-  }
-  return arg.toLowerCase();
-}
-function lengthFunction(arg) {
-  if (typeof arg === `string` || Array.isArray(arg)) {
-    return arg.length;
-  }
-  throw new Error(`LENGTH function expects a string or array argument`);
-}
-function concatFunction(arg) {
-  if (!Array.isArray(arg)) {
-    throw new Error(`CONCAT function expects an array of string arguments`);
-  }
-  if (arg.length === 0) {
-    return ``;
-  }
-  for (let i = 0; i < arg.length; i++) {
-    if (arg[i] !== null && arg[i] !== void 0 && typeof arg[i] !== `string`) {
-      throw new Error(
-        `CONCAT function expects all arguments to be strings, but argument at position ${i} is ${typeof arg[i]}`
-      );
-    }
-  }
-  return arg.map((str) => str === null || str === void 0 ? `` : str).join(``);
-}
-function coalesceFunction(arg) {
-  if (!Array.isArray(arg)) {
-    throw new Error(`COALESCE function expects an array of arguments`);
-  }
-  if (arg.length === 0) {
-    return null;
-  }
-  for (const value of arg) {
-    if (value !== null && value !== void 0) {
-      return value;
-    }
-  }
-  return null;
-}
-function dateFunction(arg) {
-  if (arg instanceof Date) {
-    return arg;
-  }
-  if (arg === null || arg === void 0) {
-    return null;
-  }
-  if (typeof arg === `string` || typeof arg === `number`) {
-    const date = new Date(arg);
-    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`);
-}
-function jsonExtractFunction(arg) {
-  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;
-  if (jsonInput === null || jsonInput === void 0) {
-    return null;
-  }
-  let jsonData;
-  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`) {
-    jsonData = jsonInput;
-  } else {
-    throw new Error(
-      `JSON_EXTRACT function expects a JSON string or object as the first argument`
-    );
-  }
-  if (pathElements.length === 0) {
-    return jsonData;
-  }
-  let current = jsonData;
-  for (let i = 0; i < pathElements.length; i++) {
-    const pathElement = pathElements[i];
-    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 === null || current === void 0 || typeof current !== `object`) {
-      return null;
-    }
-    current = current[pathElement];
-  }
-  return current === void 0 ? null : current;
-}
-function orderIndexFunction(arg) {
-  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;
-}
-const functionImplementations = {
-  // 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
-};
-function evaluateFunction(functionName, arg) {
-  const implementation = functionImplementations[functionName];
-  if (!implementation) {
-    throw new Error(`Unknown function: ${functionName}`);
-  }
-  return implementation(arg);
-}
-function isFunctionCall(obj) {
-  if (!obj || typeof obj !== `object`) {
-    return false;
-  }
-  const keys = Object.keys(obj);
-  if (keys.length !== 1) {
-    return false;
-  }
-  const functionName = keys[0];
-  return Object.keys(functionImplementations).includes(functionName);
-}
-export {
-  evaluateFunction,
-  isFunctionCall
-};
-//# sourceMappingURL=functions.js.map

package/dist/esm/query/functions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"functions.js","sources":["../../../src/query/functions.ts"],"sourcesContent":["import type { AllowedFunctionName } from \"./schema.js\"\n\n/**\n * Type for function implementations\n */\ntype FunctionImplementation = (arg: unknown) => unknown\n\n/**\n * Converts a string to uppercase\n */\nfunction upperFunction(arg: unknown): string {\n  if (typeof arg !== `string`) {\n    throw new Error(`UPPER function expects a string argument`)\n  }\n  return arg.toUpperCase()\n}\n\n/**\n * Converts a string to lowercase\n */\nfunction lowerFunction(arg: unknown): string {\n  if (typeof arg !== `string`) {\n    throw new Error(`LOWER function expects a string argument`)\n  }\n  return arg.toLowerCase()\n}\n\n/**\n * Returns the length of a string or array\n */\nfunction lengthFunction(arg: unknown): number {\n  if (typeof arg === `string` || Array.isArray(arg)) {\n    return arg.length\n  }\n\n  throw new Error(`LENGTH function expects a string or array argument`)\n}\n\n/**\n * Concatenates multiple strings\n */\nfunction concatFunction(arg: unknown): string {\n  if (!Array.isArray(arg)) {\n    throw new Error(`CONCAT function expects an array of string arguments`)\n  }\n\n  if (arg.length === 0) {\n    return ``\n  }\n\n  // Check that all arguments are strings\n  for (let i = 0; i < arg.length; i++) {\n    if (arg[i] !== null && arg[i] !== undefined && typeof arg[i] !== `string`) {\n      throw new Error(\n        `CONCAT function expects all arguments to be strings, but argument at position ${i} is ${typeof arg[i]}`\n      )\n    }\n  }\n\n  // Concatenate strings, treating null and undefined as empty strings\n  return arg\n    .map((str) => (str === null || str === undefined ? `` : str))\n    .join(``)\n}\n\n/**\n * Returns the first non-null, non-undefined value from an array\n */\nfunction coalesceFunction(arg: unknown): unknown {\n  if (!Array.isArray(arg)) {\n    throw new Error(`COALESCE function expects an array of arguments`)\n  }\n\n  if (arg.length === 0) {\n    return null\n  }\n\n  // Return the first non-null, non-undefined value\n  for (const value of arg) {\n    if (value !== null && value !== undefined) {\n      return value\n    }\n  }\n\n  // If all values were null or undefined, return null\n  return null\n}\n\n/**\n * Creates or converts a value to a Date object\n */\nfunction dateFunction(arg: unknown): Date | null {\n  // If the argument is already a Date, return it\n  if (arg instanceof Date) {\n    return arg\n  }\n\n  // If the argument is null or undefined, return null\n  if (arg === null || arg === undefined) {\n    return null\n  }\n\n  // Handle string and number conversions\n  if (typeof arg === `string` || typeof arg === `number`) {\n    const date = new Date(arg)\n\n    // Check if the date is valid\n    if (isNaN(date.getTime())) {\n      throw new Error(`DATE function could not parse \"${arg}\" as a valid date`)\n    }\n\n    return date\n  }\n\n  throw new Error(`DATE function expects a string, number, or Date argument`)\n}\n\n/**\n * Extracts a value from a JSON string or object using a path.\n * Similar to PostgreSQL's json_extract_path function.\n *\n * Usage: JSON_EXTRACT([jsonInput, 'path', 'to', 'property'])\n * Example: JSON_EXTRACT(['{\"user\": {\"name\": \"John\"}}', 'user', 'name']) returns \"John\"\n */\nfunction jsonExtractFunction(arg: unknown): unknown {\n  if (!Array.isArray(arg) || arg.length < 1) {\n    throw new Error(\n      `JSON_EXTRACT function expects an array with at least one element [jsonInput, ...pathElements]`\n    )\n  }\n\n  const [jsonInput, ...pathElements] = arg\n\n  // Handle null or undefined input\n  if (jsonInput === null || jsonInput === undefined) {\n    return null\n  }\n\n  // Parse JSON if it's a string\n  let jsonData: any\n\n  if (typeof jsonInput === `string`) {\n    try {\n      jsonData = JSON.parse(jsonInput)\n    } catch (error) {\n      throw new Error(\n        `JSON_EXTRACT function could not parse JSON string: ${error instanceof Error ? error.message : String(error)}`\n      )\n    }\n  } else if (typeof jsonInput === `object`) {\n    // If already an object, use it directly\n    jsonData = jsonInput\n  } else {\n    throw new Error(\n      `JSON_EXTRACT function expects a JSON string or object as the first argument`\n    )\n  }\n\n  // If no path elements, return the parsed JSON\n  if (pathElements.length === 0) {\n    return jsonData\n  }\n\n  // Navigate through the path elements\n  let current = jsonData\n\n  for (let i = 0; i < pathElements.length; i++) {\n    const pathElement = pathElements[i]\n\n    // Path elements should be strings\n    if (typeof pathElement !== `string`) {\n      throw new Error(\n        `JSON_EXTRACT function expects path elements to be strings, but element at position ${i + 1} is ${typeof pathElement}`\n      )\n    }\n\n    // If current node is null or undefined, or not an object, we can't navigate further\n    if (\n      current === null ||\n      current === undefined ||\n      typeof current !== `object`\n    ) {\n      return null\n    }\n\n    // Access property\n    current = current[pathElement]\n  }\n\n  // Return null instead of undefined for consistency\n  return current === undefined ? null : current\n}\n\n/**\n * Placeholder function for ORDER_INDEX\n * This function doesn't do anything when called directly, as the actual index\n * is provided by the orderBy operator during query execution.\n * The argument can be 'numeric', 'fractional', or any truthy value (defaults to 'numeric')\n */\nfunction orderIndexFunction(arg: unknown): null {\n  // This is just a placeholder - the actual index is provided by the orderBy operator\n  // The function validates that the argument is one of the expected values\n  if (\n    arg !== `numeric` &&\n    arg !== `fractional` &&\n    arg !== true &&\n    arg !== `default`\n  ) {\n    throw new Error(\n      `ORDER_INDEX function expects \"numeric\", \"fractional\", \"default\", or true as argument`\n    )\n  }\n  return null\n}\n\n/**\n * Map of function names to their implementations\n */\nconst functionImplementations: Record<\n  AllowedFunctionName,\n  FunctionImplementation\n> = {\n  // Map function names to their implementation functions\n  DATE: dateFunction,\n  JSON_EXTRACT: jsonExtractFunction,\n  JSON_EXTRACT_PATH: jsonExtractFunction, // Alias for JSON_EXTRACT\n  UPPER: upperFunction,\n  LOWER: lowerFunction,\n  COALESCE: coalesceFunction,\n  CONCAT: concatFunction,\n  LENGTH: lengthFunction,\n  ORDER_INDEX: orderIndexFunction,\n}\n\n/**\n * Evaluates a function call with the given name and arguments\n * @param functionName The name of the function to evaluate\n * @param arg The arguments to pass to the function\n * @returns The result of the function call\n */\nexport function evaluateFunction(\n  functionName: AllowedFunctionName,\n  arg: unknown\n): unknown {\n  const implementation = functionImplementations[functionName] as\n    | FunctionImplementation\n    | undefined // Double check that the implementation is defined\n\n  if (!implementation) {\n    throw new Error(`Unknown function: ${functionName}`)\n  }\n  return implementation(arg)\n}\n\n/**\n * Determines if an object is a function call\n * @param obj The object to check\n * @returns True if the object is a function call, false otherwise\n */\nexport function isFunctionCall(obj: unknown): boolean {\n  if (!obj || typeof obj !== `object`) {\n    return false\n  }\n\n  const keys = Object.keys(obj)\n  if (keys.length !== 1) {\n    return false\n  }\n\n  const functionName = keys[0] as string\n\n  // Check if the key is one of the allowed function names\n  return Object.keys(functionImplementations).includes(functionName)\n}\n\n/**\n * Extracts the function name and argument from a function call object.\n */\nexport function extractFunctionCall(obj: Record<string, unknown>): {\n  functionName: AllowedFunctionName\n  argument: unknown\n} {\n  const keys = Object.keys(obj)\n  if (keys.length !== 1) {\n    throw new Error(`Invalid function call: object must have exactly one key`)\n  }\n\n  const functionName = keys[0] as AllowedFunctionName\n  if (!Object.keys(functionImplementations).includes(functionName)) {\n    throw new Error(`Invalid function name: ${functionName}`)\n  }\n\n  return {\n    functionName,\n    argument: obj[functionName],\n  }\n}\n"],"names":[],"mappings":"AAUA,SAAS,cAAc,KAAsB;AACvC,MAAA,OAAO,QAAQ,UAAU;AACrB,UAAA,IAAI,MAAM,0CAA0C;AAAA,EAAA;AAE5D,SAAO,IAAI,YAAY;AACzB;AAKA,SAAS,cAAc,KAAsB;AACvC,MAAA,OAAO,QAAQ,UAAU;AACrB,UAAA,IAAI,MAAM,0CAA0C;AAAA,EAAA;AAE5D,SAAO,IAAI,YAAY;AACzB;AAKA,SAAS,eAAe,KAAsB;AAC5C,MAAI,OAAO,QAAQ,YAAY,MAAM,QAAQ,GAAG,GAAG;AACjD,WAAO,IAAI;AAAA,EAAA;AAGP,QAAA,IAAI,MAAM,oDAAoD;AACtE;AAKA,SAAS,eAAe,KAAsB;AAC5C,MAAI,CAAC,MAAM,QAAQ,GAAG,GAAG;AACjB,UAAA,IAAI,MAAM,sDAAsD;AAAA,EAAA;AAGpE,MAAA,IAAI,WAAW,GAAG;AACb,WAAA;AAAA,EAAA;AAIT,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,QAAI,IAAI,CAAC,MAAM,QAAQ,IAAI,CAAC,MAAM,UAAa,OAAO,IAAI,CAAC,MAAM,UAAU;AACzE,YAAM,IAAI;AAAA,QACR,iFAAiF,CAAC,OAAO,OAAO,IAAI,CAAC,CAAC;AAAA,MACxG;AAAA,IAAA;AAAA,EACF;AAIF,SAAO,IACJ,IAAI,CAAC,QAAS,QAAQ,QAAQ,QAAQ,SAAY,KAAK,GAAI,EAC3D,KAAK,EAAE;AACZ;AAKA,SAAS,iBAAiB,KAAuB;AAC/C,MAAI,CAAC,MAAM,QAAQ,GAAG,GAAG;AACjB,UAAA,IAAI,MAAM,iDAAiD;AAAA,EAAA;AAG/D,MAAA,IAAI,WAAW,GAAG;AACb,WAAA;AAAA,EAAA;AAIT,aAAW,SAAS,KAAK;AACnB,QAAA,UAAU,QAAQ,UAAU,QAAW;AAClC,aAAA;AAAA,IAAA;AAAA,EACT;AAIK,SAAA;AACT;AAKA,SAAS,aAAa,KAA2B;AAE/C,MAAI,eAAe,MAAM;AAChB,WAAA;AAAA,EAAA;AAIL,MAAA,QAAQ,QAAQ,QAAQ,QAAW;AAC9B,WAAA;AAAA,EAAA;AAIT,MAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ,UAAU;AAChD,UAAA,OAAO,IAAI,KAAK,GAAG;AAGzB,QAAI,MAAM,KAAK,QAAQ,CAAC,GAAG;AACzB,YAAM,IAAI,MAAM,kCAAkC,GAAG,mBAAmB;AAAA,IAAA;AAGnE,WAAA;AAAA,EAAA;AAGH,QAAA,IAAI,MAAM,0DAA0D;AAC5E;AASA,SAAS,oBAAoB,KAAuB;AAClD,MAAI,CAAC,MAAM,QAAQ,GAAG,KAAK,IAAI,SAAS,GAAG;AACzC,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EAAA;AAGF,QAAM,CAAC,WAAW,GAAG,YAAY,IAAI;AAGjC,MAAA,cAAc,QAAQ,cAAc,QAAW;AAC1C,WAAA;AAAA,EAAA;AAIL,MAAA;AAEA,MAAA,OAAO,cAAc,UAAU;AAC7B,QAAA;AACS,iBAAA,KAAK,MAAM,SAAS;AAAA,aACxB,OAAO;AACd,YAAM,IAAI;AAAA,QACR,sDAAsD,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC;AAAA,MAC9G;AAAA,IAAA;AAAA,EAEJ,WAAW,OAAO,cAAc,UAAU;AAE7B,eAAA;AAAA,EAAA,OACN;AACL,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EAAA;AAIE,MAAA,aAAa,WAAW,GAAG;AACtB,WAAA;AAAA,EAAA;AAIT,MAAI,UAAU;AAEd,WAAS,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;AACtC,UAAA,cAAc,aAAa,CAAC;AAG9B,QAAA,OAAO,gBAAgB,UAAU;AACnC,YAAM,IAAI;AAAA,QACR,sFAAsF,IAAI,CAAC,OAAO,OAAO,WAAW;AAAA,MACtH;AAAA,IAAA;AAIF,QACE,YAAY,QACZ,YAAY,UACZ,OAAO,YAAY,UACnB;AACO,aAAA;AAAA,IAAA;AAIT,cAAU,QAAQ,WAAW;AAAA,EAAA;AAIxB,SAAA,YAAY,SAAY,OAAO;AACxC;AAQA,SAAS,mBAAmB,KAAoB;AAG9C,MACE,QAAQ,aACR,QAAQ,gBACR,QAAQ,QACR,QAAQ,WACR;AACA,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EAAA;AAEK,SAAA;AACT;AAKA,MAAM,0BAGF;AAAA;AAAA,EAEF,MAAM;AAAA,EACN,cAAc;AAAA,EACd,mBAAmB;AAAA;AAAA,EACnB,OAAO;AAAA,EACP,OAAO;AAAA,EACP,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,aAAa;AACf;AAQgB,SAAA,iBACd,cACA,KACS;AACH,QAAA,iBAAiB,wBAAwB,YAAY;AAI3D,MAAI,CAAC,gBAAgB;AACnB,UAAM,IAAI,MAAM,qBAAqB,YAAY,EAAE;AAAA,EAAA;AAErD,SAAO,eAAe,GAAG;AAC3B;AAOO,SAAS,eAAe,KAAuB;AACpD,MAAI,CAAC,OAAO,OAAO,QAAQ,UAAU;AAC5B,WAAA;AAAA,EAAA;AAGH,QAAA,OAAO,OAAO,KAAK,GAAG;AACxB,MAAA,KAAK,WAAW,GAAG;AACd,WAAA;AAAA,EAAA;AAGH,QAAA,eAAe,KAAK,CAAC;AAG3B,SAAO,OAAO,KAAK,uBAAuB,EAAE,SAAS,YAAY;AACnE;"}

package/dist/esm/query/group-by.d.ts

@@ -1,40 +0,0 @@
-import { ConditionOperand, Query } from './schema.js';
-import { NamespacedAndKeyedStream } from '../types.js';
-/**
- * Process the groupBy clause in a D2QL query
- */
-export declare function processGroupBy(pipeline: NamespacedAndKeyedStream, query: Query, mainTableAlias: string): NamespacedAndKeyedStream;
-/**
- * Helper function to get an aggregate function based on the function name
- */
-export declare function getAggregateFunction(functionName: string, columnRef: string | ConditionOperand, mainTableAlias: string): {
-    preMap: (data: [string, Record<string, unknown>]) => number;
-    reduce: (values: [number, number][]) => number;
-    postMap?: ((result: number) => number) | undefined;
-} | {
-    pipe: (stream: import('@electric-sql/d2mini').IStreamBuilder<[string, Record<string, unknown>]>) => import('@electric-sql/d2mini').IStreamBuilder<import('@electric-sql/d2mini').KeyValue<string, number>>;
-} | {
-    preMap: (data: [string, Record<string, unknown>]) => {
-        sum: number;
-        count: number;
-    };
-    reduce: (values: [{
-        sum: number;
-        count: number;
-    }, number][]) => {
-        sum: number;
-        count: number;
-    };
-    postMap?: ((result: {
-        sum: number;
-        count: number;
-    }) => number) | undefined;
-} | {
-    preMap: (data: [string, Record<string, unknown>]) => number[];
-    reduce: (values: [number[], number][]) => number[];
-    postMap?: ((result: number[]) => number) | undefined;
-} | {
-    preMap: (data: [string, Record<string, unknown>]) => Map<number, number>;
-    reduce: (values: [Map<number, number>, number][]) => Map<number, number>;
-    postMap?: ((result: Map<number, number>) => number) | undefined;
-};