@tanstack/db 0.0.14 → 0.0.15

package/dist/cjs/query/extractors.d.cts

@@ -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/cjs/query/functions.cjs

@@ -1,152 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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);
-}
-exports.evaluateFunction = evaluateFunction;
-exports.isFunctionCall = isFunctionCall;
-//# sourceMappingURL=functions.cjs.map

package/dist/cjs/query/functions.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"functions.cjs","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":"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"}

package/dist/cjs/query/functions.d.cts

@@ -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/cjs/query/group-by.cjs

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const d2mini = require("@electric-sql/d2mini");
-const extractors = require("./extractors.cjs");
-const utils = require("./utils.cjs");
-const { sum, count, avg, min, max, median, mode } = d2mini.groupByOperators;
-function processGroupBy(pipeline, query, mainTableAlias) {
-  const groupByColumns = Array.isArray(query.groupBy) ? query.groupBy : [query.groupBy];
-  const keyExtractor = ([_oldKey, namespacedRow]) => {
-    const key = {};
-    for (const column of groupByColumns) {
-      if (typeof column === `string` && column.startsWith(`@`)) {
-        const columnRef = column.substring(1);
-        const columnName = columnRef.includes(`.`) ? columnRef.split(`.`)[1] : columnRef;
-        key[columnName] = extractors.extractValueFromNamespacedRow(
-          namespacedRow,
-          columnRef,
-          mainTableAlias
-        );
-      }
-    }
-    return key;
-  };
-  const aggregates = {};
-  if (!query.select) {
-    throw new Error(`SELECT clause is required for GROUP BY`);
-  }
-  for (const item of query.select) {
-    if (typeof item === `object`) {
-      for (const [alias, expr] of Object.entries(item)) {
-        if (typeof expr === `object` && utils.isAggregateFunctionCall(expr)) {
-          const functionName = Object.keys(expr)[0];
-          const columnRef = expr[functionName];
-          aggregates[alias] = getAggregateFunction(
-            functionName,
-            columnRef,
-            mainTableAlias
-          );
-        }
-      }
-    }
-  }
-  if (Object.keys(aggregates).length > 0) {
-    pipeline = pipeline.pipe(d2mini.groupBy(keyExtractor, aggregates));
-  }
-  return pipeline;
-}
-function getAggregateFunction(functionName, columnRef, mainTableAlias) {
-  const valueExtractor = ([_oldKey, namespacedRow]) => {
-    let value;
-    if (typeof columnRef === `string` && columnRef.startsWith(`@`)) {
-      value = extractors.extractValueFromNamespacedRow(
-        namespacedRow,
-        columnRef.substring(1),
-        mainTableAlias
-      );
-    } else {
-      value = extractors.evaluateOperandOnNamespacedRow(
-        namespacedRow,
-        columnRef,
-        mainTableAlias
-      );
-    }
-    return typeof value === `number` ? value : 0;
-  };
-  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}`);
-  }
-}
-exports.getAggregateFunction = getAggregateFunction;
-exports.processGroupBy = processGroupBy;
-//# sourceMappingURL=group-by.cjs.map

package/dist/cjs/query/group-by.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"group-by.cjs","sources":["../../../src/query/group-by.ts"],"sourcesContent":["import { groupBy, groupByOperators } from \"@electric-sql/d2mini\"\nimport {\n  evaluateOperandOnNamespacedRow,\n  extractValueFromNamespacedRow,\n} from \"./extractors\"\nimport { isAggregateFunctionCall } from \"./utils\"\nimport type { ConditionOperand, FunctionCall, Query } from \"./schema\"\nimport type { NamespacedAndKeyedStream } from \"../types.js\"\n\nconst { sum, count, avg, min, max, median, mode } = groupByOperators\n\n/**\n * Process the groupBy clause in a D2QL query\n */\nexport function processGroupBy(\n  pipeline: NamespacedAndKeyedStream,\n  query: Query,\n  mainTableAlias: string\n) {\n  // Normalize groupBy to an array of column references\n  const groupByColumns = Array.isArray(query.groupBy)\n    ? query.groupBy\n    : [query.groupBy]\n\n  // Create a key extractor function for the groupBy operator\n  const keyExtractor = ([_oldKey, namespacedRow]: [\n    string,\n    Record<string, unknown>,\n  ]) => {\n    const key: Record<string, unknown> = {}\n\n    // Extract each groupBy column value\n    for (const column of groupByColumns) {\n      if (typeof column === `string` && (column as string).startsWith(`@`)) {\n        const columnRef = (column as string).substring(1)\n        const columnName = columnRef.includes(`.`)\n          ? columnRef.split(`.`)[1]\n          : columnRef\n\n        key[columnName!] = extractValueFromNamespacedRow(\n          namespacedRow,\n          columnRef,\n          mainTableAlias\n        )\n      }\n    }\n\n    return key\n  }\n\n  // Create aggregate functions for any aggregated columns in the SELECT clause\n  const aggregates: Record<string, any> = {}\n\n  if (!query.select) {\n    throw new Error(`SELECT clause is required for GROUP BY`)\n  }\n\n  // Scan the SELECT clause for aggregate functions\n  for (const item of query.select) {\n    if (typeof item === `object`) {\n      for (const [alias, expr] of Object.entries(item)) {\n        if (typeof expr === `object` && isAggregateFunctionCall(expr)) {\n          // Get the function name (the only key in the object)\n          const functionName = Object.keys(expr)[0]\n          // Get the column reference or expression to aggregate\n          const columnRef = (expr as FunctionCall)[\n            functionName as keyof FunctionCall\n          ]\n\n          // Add the aggregate function to our aggregates object\n          aggregates[alias] = getAggregateFunction(\n            functionName!,\n            columnRef,\n            mainTableAlias\n          )\n        }\n      }\n    }\n  }\n\n  // Apply the groupBy operator if we have any aggregates\n  if (Object.keys(aggregates).length > 0) {\n    pipeline = pipeline.pipe(groupBy(keyExtractor, aggregates))\n  }\n\n  return pipeline\n}\n\n/**\n * Helper function to get an aggregate function based on the function name\n */\nexport function getAggregateFunction(\n  functionName: string,\n  columnRef: string | ConditionOperand,\n  mainTableAlias: string\n) {\n  // Create a value extractor function for the column to aggregate\n  const valueExtractor = ([_oldKey, namespacedRow]: [\n    string,\n    Record<string, unknown>,\n  ]) => {\n    let value: unknown\n    if (typeof columnRef === `string` && columnRef.startsWith(`@`)) {\n      value = extractValueFromNamespacedRow(\n        namespacedRow,\n        columnRef.substring(1),\n        mainTableAlias\n      )\n    } else {\n      value = evaluateOperandOnNamespacedRow(\n        namespacedRow,\n        columnRef as ConditionOperand,\n        mainTableAlias\n      )\n    }\n    // Ensure we return a number for aggregate functions\n    return typeof value === `number` ? value : 0\n  }\n\n  // Return the appropriate aggregate function\n  switch (functionName.toUpperCase()) {\n    case `SUM`:\n      return sum(valueExtractor)\n    case `COUNT`:\n      return count() // count() doesn't need a value extractor\n    case `AVG`:\n      return avg(valueExtractor)\n    case `MIN`:\n      return min(valueExtractor)\n    case `MAX`:\n      return max(valueExtractor)\n    case `MEDIAN`:\n      return median(valueExtractor)\n    case `MODE`:\n      return mode(valueExtractor)\n    default:\n      throw new Error(`Unsupported aggregate function: ${functionName}`)\n  }\n}\n"],"names":["groupByOperators","extractValueFromNamespacedRow","isAggregateFunctionCall","groupBy","evaluateOperandOnNamespacedRow"],"mappings":";;;;;AASA,MAAM,EAAE,KAAK,OAAO,KAAK,KAAK,KAAK,QAAQ,SAASA,OAAA;AAKpC,SAAA,eACd,UACA,OACA,gBACA;AAEM,QAAA,iBAAiB,MAAM,QAAQ,MAAM,OAAO,IAC9C,MAAM,UACN,CAAC,MAAM,OAAO;AAGlB,QAAM,eAAe,CAAC,CAAC,SAAS,aAAa,MAGvC;AACJ,UAAM,MAA+B,CAAC;AAGtC,eAAW,UAAU,gBAAgB;AACnC,UAAI,OAAO,WAAW,YAAa,OAAkB,WAAW,GAAG,GAAG;AAC9D,cAAA,YAAa,OAAkB,UAAU,CAAC;AAC1C,cAAA,aAAa,UAAU,SAAS,GAAG,IACrC,UAAU,MAAM,GAAG,EAAE,CAAC,IACtB;AAEJ,YAAI,UAAW,IAAIC,WAAA;AAAA,UACjB;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAAA,MAAA;AAAA,IACF;AAGK,WAAA;AAAA,EACT;AAGA,QAAM,aAAkC,CAAC;AAErC,MAAA,CAAC,MAAM,QAAQ;AACX,UAAA,IAAI,MAAM,wCAAwC;AAAA,EAAA;AAI/C,aAAA,QAAQ,MAAM,QAAQ;AAC3B,QAAA,OAAO,SAAS,UAAU;AAC5B,iBAAW,CAAC,OAAO,IAAI,KAAK,OAAO,QAAQ,IAAI,GAAG;AAChD,YAAI,OAAO,SAAS,YAAYC,MAAA,wBAAwB,IAAI,GAAG;AAE7D,gBAAM,eAAe,OAAO,KAAK,IAAI,EAAE,CAAC;AAElC,gBAAA,YAAa,KACjB,YACF;AAGA,qBAAW,KAAK,IAAI;AAAA,YAClB;AAAA,YACA;AAAA,YACA;AAAA,UACF;AAAA,QAAA;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAIF,MAAI,OAAO,KAAK,UAAU,EAAE,SAAS,GAAG;AACtC,eAAW,SAAS,KAAKC,OAAQ,QAAA,cAAc,UAAU,CAAC;AAAA,EAAA;AAGrD,SAAA;AACT;AAKgB,SAAA,qBACd,cACA,WACA,gBACA;AAEA,QAAM,iBAAiB,CAAC,CAAC,SAAS,aAAa,MAGzC;AACA,QAAA;AACJ,QAAI,OAAO,cAAc,YAAY,UAAU,WAAW,GAAG,GAAG;AACtD,cAAAF,WAAA;AAAA,QACN;AAAA,QACA,UAAU,UAAU,CAAC;AAAA,QACrB;AAAA,MACF;AAAA,IAAA,OACK;AACG,cAAAG,WAAA;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IAAA;AAGK,WAAA,OAAO,UAAU,WAAW,QAAQ;AAAA,EAC7C;AAGQ,UAAA,aAAa,YAAe,GAAA;AAAA,IAClC,KAAK;AACH,aAAO,IAAI,cAAc;AAAA,IAC3B,KAAK;AACH,aAAO,MAAM;AAAA;AAAA,IACf,KAAK;AACH,aAAO,IAAI,cAAc;AAAA,IAC3B,KAAK;AACH,aAAO,IAAI,cAAc;AAAA,IAC3B,KAAK;AACH,aAAO,IAAI,cAAc;AAAA,IAC3B,KAAK;AACH,aAAO,OAAO,cAAc;AAAA,IAC9B,KAAK;AACH,aAAO,KAAK,cAAc;AAAA,IAC5B;AACE,YAAM,IAAI,MAAM,mCAAmC,YAAY,EAAE;AAAA,EAAA;AAEvE;;;"}

package/dist/cjs/query/group-by.d.cts

@@ -1,40 +0,0 @@
-import { ConditionOperand, Query } from './schema.cjs';
-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;
-};

package/dist/cjs/query/joins.cjs

@@ -1,141 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const d2mini = require("@electric-sql/d2mini");
-const evaluators = require("./evaluators.cjs");
-const extractors = require("./extractors.cjs");
-function processJoinClause(pipeline, query, tables, mainTableAlias, allInputs) {
-  if (!query.join) return pipeline;
-  const input = allInputs[query.from];
-  for (const joinClause of query.join) {
-    const joinedTableAlias = joinClause.as || joinClause.from;
-    const joinType = joinClause.type === `cross` ? `inner` : joinClause.type;
-    const [mainKeyRef, , joinedKeyRefs] = joinClause.on;
-    const mainPipeline = pipeline.pipe(
-      d2mini.map(([currentKey, namespacedRow]) => {
-        const mainRow = namespacedRow[mainTableAlias];
-        const key = extractors.extractJoinKey(mainRow, mainKeyRef, mainTableAlias);
-        return [key, [currentKey, namespacedRow]];
-      })
-    );
-    let joinedTableInput;
-    if (allInputs[joinClause.from]) {
-      joinedTableInput = allInputs[joinClause.from];
-    } else {
-      joinedTableInput = input.graph.newInput();
-    }
-    tables[joinedTableAlias] = joinedTableInput;
-    const joinedPipeline = joinedTableInput.pipe(
-      d2mini.map(([currentKey, row]) => {
-        const namespacedRow = { [joinedTableAlias]: row };
-        const key = extractors.extractJoinKey(row, joinedKeyRefs, joinedTableAlias);
-        return [key, [currentKey, namespacedRow]];
-      })
-    );
-    switch (joinType) {
-      case `inner`:
-        pipeline = mainPipeline.pipe(
-          d2mini.join(joinedPipeline, `inner`),
-          d2mini.consolidate(),
-          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
-        );
-        break;
-      case `left`:
-        pipeline = mainPipeline.pipe(
-          d2mini.join(joinedPipeline, `left`),
-          d2mini.consolidate(),
-          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
-        );
-        break;
-      case `right`:
-        pipeline = mainPipeline.pipe(
-          d2mini.join(joinedPipeline, `right`),
-          d2mini.consolidate(),
-          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
-        );
-        break;
-      case `full`:
-        pipeline = mainPipeline.pipe(
-          d2mini.join(joinedPipeline, `full`),
-          d2mini.consolidate(),
-          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
-        );
-        break;
-      default:
-        pipeline = mainPipeline.pipe(
-          d2mini.join(joinedPipeline, `inner`),
-          d2mini.consolidate(),
-          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
-        );
-    }
-  }
-  return pipeline;
-}
-function processJoinResults(mainTableAlias, joinedTableAlias, joinClause) {
-  return function(pipeline) {
-    return pipeline.pipe(
-      // Process the join result and handle nulls in the same step
-      d2mini.map((result) => {
-        const [_key, [main, joined]] = result;
-        const mainKey = main == null ? void 0 : main[0];
-        const mainNamespacedRow = main == null ? void 0 : main[1];
-        const joinedKey = joined == null ? void 0 : joined[0];
-        const joinedNamespacedRow = joined == null ? void 0 : joined[1];
-        if (joinClause.type === `inner` || joinClause.type === `cross`) {
-          if (!mainNamespacedRow || !joinedNamespacedRow) {
-            return void 0;
-          }
-        }
-        if (joinClause.type === `left` && !mainNamespacedRow) {
-          return void 0;
-        }
-        if (joinClause.type === `right` && !joinedNamespacedRow) {
-          return void 0;
-        }
-        const mergedNamespacedRow = {};
-        if (mainNamespacedRow) {
-          Object.entries(mainNamespacedRow).forEach(
-            ([tableAlias, tableData]) => {
-              mergedNamespacedRow[tableAlias] = tableData;
-            }
-          );
-        }
-        if (joinedNamespacedRow) {
-          Object.entries(joinedNamespacedRow).forEach(
-            ([tableAlias, tableData]) => {
-              mergedNamespacedRow[tableAlias] = tableData;
-            }
-          );
-        } else if (joinClause.type === `left` || joinClause.type === `full`) ;
-        if (!mainNamespacedRow && (joinClause.type === `right` || joinClause.type === `full`)) ;
-        const newKey = `[${mainKey},${joinedKey}]`;
-        return [newKey, mergedNamespacedRow];
-      }),
-      // Filter out undefined results
-      d2mini.filter((value) => value !== void 0),
-      // Process the ON condition
-      d2mini.filter(([_key, namespacedRow]) => {
-        if (!joinClause.on || joinClause.type === `cross`) {
-          return true;
-        }
-        if (joinClause.type === `left` && namespacedRow[joinedTableAlias] === void 0) {
-          return true;
-        }
-        if (joinClause.type === `right` && namespacedRow[mainTableAlias] === void 0) {
-          return true;
-        }
-        if (joinClause.type === `full` && (namespacedRow[mainTableAlias] === void 0 || namespacedRow[joinedTableAlias] === void 0)) {
-          return true;
-        }
-        return evaluators.evaluateConditionOnNamespacedRow(
-          namespacedRow,
-          joinClause.on,
-          mainTableAlias,
-          joinedTableAlias
-        );
-      })
-    );
-  };
-}
-exports.processJoinClause = processJoinClause;
-exports.processJoinResults = processJoinResults;
-//# sourceMappingURL=joins.cjs.map

package/dist/cjs/query/joins.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"joins.cjs","sources":["../../../src/query/joins.ts"],"sourcesContent":["import {\n  consolidate,\n  filter,\n  join as joinOperator,\n  map,\n} from \"@electric-sql/d2mini\"\nimport { evaluateConditionOnNamespacedRow } from \"./evaluators.js\"\nimport { extractJoinKey } from \"./extractors.js\"\nimport type { Query } from \"./index.js\"\nimport type { IStreamBuilder, JoinType } from \"@electric-sql/d2mini\"\nimport type {\n  KeyedStream,\n  NamespacedAndKeyedStream,\n  NamespacedRow,\n} from \"../types.js\"\n\n/**\n * Creates a processing pipeline for join clauses\n */\nexport function processJoinClause(\n  pipeline: NamespacedAndKeyedStream,\n  query: Query,\n  tables: Record<string, KeyedStream>,\n  mainTableAlias: string,\n  allInputs: Record<string, KeyedStream>\n) {\n  if (!query.join) return pipeline\n  const input = allInputs[query.from]\n\n  for (const joinClause of query.join) {\n    // Create a stream for the joined table\n    const joinedTableAlias = joinClause.as || joinClause.from\n\n    // Get the right join type for the operator\n    const joinType: JoinType =\n      joinClause.type === `cross` ? `inner` : joinClause.type\n\n    // The `in` is formatted as ['@mainKeyRef', '=', '@joinedKeyRef']\n    // Destructure the main key reference and the joined key references\n    const [mainKeyRef, , joinedKeyRefs] = joinClause.on\n\n    // We need to prepare the main pipeline and the joined pipeline\n    // to have the correct key format for joining\n    const mainPipeline = pipeline.pipe(\n      map(([currentKey, namespacedRow]) => {\n        // Extract the key from the ON condition left side for the main table\n        const mainRow = namespacedRow[mainTableAlias]!\n\n        // Extract the join key from the main row\n        const key = extractJoinKey(mainRow, mainKeyRef, mainTableAlias)\n\n        // Return [key, namespacedRow] as a KeyValue type\n        return [key, [currentKey, namespacedRow]] as [\n          unknown,\n          [string, typeof namespacedRow],\n        ]\n      })\n    )\n\n    // Get the joined table input from the inputs map\n    let joinedTableInput: KeyedStream\n\n    if (allInputs[joinClause.from]) {\n      // Use the provided input if available\n      joinedTableInput = allInputs[joinClause.from]!\n    } else {\n      // Create a new input if not provided\n      joinedTableInput =\n        input!.graph.newInput<[string, Record<string, unknown>]>()\n    }\n\n    tables[joinedTableAlias] = joinedTableInput\n\n    // Create a pipeline for the joined table\n    const joinedPipeline = joinedTableInput.pipe(\n      map(([currentKey, row]) => {\n        // Wrap the row in an object with the table alias as the key\n        const namespacedRow: NamespacedRow = { [joinedTableAlias]: row }\n\n        // Extract the key from the ON condition right side for the joined table\n        const key = extractJoinKey(row, joinedKeyRefs, joinedTableAlias)\n\n        // Return [key, namespacedRow] as a KeyValue type\n        return [key, [currentKey, namespacedRow]] as [\n          string,\n          [string, typeof namespacedRow],\n        ]\n      })\n    )\n\n    // Apply join with appropriate typings based on join type\n    switch (joinType) {\n      case `inner`:\n        pipeline = mainPipeline.pipe(\n          joinOperator(joinedPipeline, `inner`),\n          consolidate(),\n          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)\n        )\n        break\n      case `left`:\n        pipeline = mainPipeline.pipe(\n          joinOperator(joinedPipeline, `left`),\n          consolidate(),\n          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)\n        )\n        break\n      case `right`:\n        pipeline = mainPipeline.pipe(\n          joinOperator(joinedPipeline, `right`),\n          consolidate(),\n          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)\n        )\n        break\n      case `full`:\n        pipeline = mainPipeline.pipe(\n          joinOperator(joinedPipeline, `full`),\n          consolidate(),\n          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)\n        )\n        break\n      default:\n        pipeline = mainPipeline.pipe(\n          joinOperator(joinedPipeline, `inner`),\n          consolidate(),\n          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)\n        )\n    }\n  }\n  return pipeline\n}\n\n/**\n * Creates a processing pipeline for join results\n */\nexport function processJoinResults(\n  mainTableAlias: string,\n  joinedTableAlias: string,\n  joinClause: { on: any; type: string }\n) {\n  return function (\n    pipeline: IStreamBuilder<\n      [\n        key: string,\n        [\n          [string, NamespacedRow] | undefined,\n          [string, NamespacedRow] | undefined,\n        ],\n      ]\n    >\n  ): NamespacedAndKeyedStream {\n    return pipeline.pipe(\n      // Process the join result and handle nulls in the same step\n      map((result) => {\n        const [_key, [main, joined]] = result\n        const mainKey = main?.[0]\n        const mainNamespacedRow = main?.[1]\n        const joinedKey = joined?.[0]\n        const joinedNamespacedRow = joined?.[1]\n\n        // For inner joins, both sides should be non-null\n        if (joinClause.type === `inner` || joinClause.type === `cross`) {\n          if (!mainNamespacedRow || !joinedNamespacedRow) {\n            return undefined // Will be filtered out\n          }\n        }\n\n        // For left joins, the main row must be non-null\n        if (joinClause.type === `left` && !mainNamespacedRow) {\n          return undefined // Will be filtered out\n        }\n\n        // For right joins, the joined row must be non-null\n        if (joinClause.type === `right` && !joinedNamespacedRow) {\n          return undefined // Will be filtered out\n        }\n\n        // Merge the nested rows\n        const mergedNamespacedRow: NamespacedRow = {}\n\n        // Add main row data if it exists\n        if (mainNamespacedRow) {\n          Object.entries(mainNamespacedRow).forEach(\n            ([tableAlias, tableData]) => {\n              mergedNamespacedRow[tableAlias] = tableData\n            }\n          )\n        }\n\n        // If we have a joined row, add it to the merged result\n        if (joinedNamespacedRow) {\n          Object.entries(joinedNamespacedRow).forEach(\n            ([tableAlias, tableData]) => {\n              mergedNamespacedRow[tableAlias] = tableData\n            }\n          )\n        } else if (joinClause.type === `left` || joinClause.type === `full`) {\n          // For left or full joins, add the joined table with undefined data if missing\n          // mergedNamespacedRow[joinedTableAlias] = undefined\n        }\n\n        // For right or full joins, add the main table with undefined data if missing\n        if (\n          !mainNamespacedRow &&\n          (joinClause.type === `right` || joinClause.type === `full`)\n        ) {\n          // mergedNamespacedRow[mainTableAlias] = undefined\n        }\n\n        // New key\n        const newKey = `[${mainKey},${joinedKey}]`\n\n        return [newKey, mergedNamespacedRow] as [\n          string,\n          typeof mergedNamespacedRow,\n        ]\n      }),\n      // Filter out undefined results\n      filter((value) => value !== undefined),\n      // Process the ON condition\n      filter(([_key, namespacedRow]: [string, NamespacedRow]) => {\n        // If there's no ON condition, or it's a cross join, always return true\n        if (!joinClause.on || joinClause.type === `cross`) {\n          return true\n        }\n\n        // For LEFT JOIN, if the right side is null, we should include the row\n        if (\n          joinClause.type === `left` &&\n          namespacedRow[joinedTableAlias] === undefined\n        ) {\n          return true\n        }\n\n        // For RIGHT JOIN, if the left side is null, we should include the row\n        if (\n          joinClause.type === `right` &&\n          namespacedRow[mainTableAlias] === undefined\n        ) {\n          return true\n        }\n\n        // For FULL JOIN, if either side is null, we should include the row\n        if (\n          joinClause.type === `full` &&\n          (namespacedRow[mainTableAlias] === undefined ||\n            namespacedRow[joinedTableAlias] === undefined)\n        ) {\n          return true\n        }\n\n        return evaluateConditionOnNamespacedRow(\n          namespacedRow,\n          joinClause.on,\n          mainTableAlias,\n          joinedTableAlias\n        )\n      })\n    )\n  }\n}\n"],"names":["map","extractJoinKey","joinOperator","consolidate","filter","evaluateConditionOnNamespacedRow"],"mappings":"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"}

package/dist/cjs/query/joins.d.cts

@@ -1,14 +0,0 @@
-import { Query } from './index.js';
-import { IStreamBuilder } from '@electric-sql/d2mini';
-import { KeyedStream, NamespacedAndKeyedStream, NamespacedRow } from '../types.js';
-/**
- * Creates a processing pipeline for join clauses
- */
-export declare function processJoinClause(pipeline: NamespacedAndKeyedStream, query: Query, tables: Record<string, KeyedStream>, mainTableAlias: string, allInputs: Record<string, KeyedStream>): NamespacedAndKeyedStream;
-/**
- * Creates a processing pipeline for join results
- */
-export declare function processJoinResults(mainTableAlias: string, joinedTableAlias: string, joinClause: {
-    on: any;
-    type: string;
-}): (pipeline: IStreamBuilder<[key: string, [[string, NamespacedRow] | undefined, [string, NamespacedRow] | undefined]]>) => NamespacedAndKeyedStream;