@tanstack/db 0.0.13 → 0.0.15

package/dist/cjs/query/order-by.cjs

@@ -1,185 +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");
-function processOrderBy(resultPipeline, query, mainTableAlias) {
-  let hasOrderIndexColumn = false;
-  let orderIndexType = `numeric`;
-  let orderIndexAlias = ``;
-  for (const item of query.select) {
-    if (typeof item === `object`) {
-      for (const [alias, expr] of Object.entries(item)) {
-        if (typeof expr === `object` && utils.isOrderIndexFunctionCall(expr)) {
-          hasOrderIndexColumn = true;
-          orderIndexAlias = alias;
-          orderIndexType = getOrderIndexType(expr);
-          break;
-        }
-      }
-    }
-    if (hasOrderIndexColumn) break;
-  }
-  const orderByItems = [];
-  if (typeof query.orderBy === `string`) {
-    orderByItems.push({
-      operand: query.orderBy,
-      direction: `asc`
-    });
-  } else if (Array.isArray(query.orderBy)) {
-    for (const item of query.orderBy) {
-      if (typeof item === `string`) {
-        orderByItems.push({
-          operand: item,
-          direction: `asc`
-        });
-      } else if (typeof item === `object`) {
-        for (const [column, direction] of Object.entries(item)) {
-          orderByItems.push({
-            operand: column,
-            direction
-          });
-        }
-      }
-    }
-  } else if (typeof query.orderBy === `object`) {
-    for (const [column, direction] of Object.entries(query.orderBy)) {
-      orderByItems.push({
-        operand: column,
-        direction
-      });
-    }
-  }
-  const valueExtractor = (namespacedRow) => {
-    if (orderByItems.length > 1) {
-      return orderByItems.map(
-        (item) => extractors.evaluateOperandOnNamespacedRow(
-          namespacedRow,
-          item.operand,
-          mainTableAlias
-        )
-      );
-    } else if (orderByItems.length === 1) {
-      const item = orderByItems[0];
-      const val = extractors.evaluateOperandOnNamespacedRow(
-        namespacedRow,
-        item.operand,
-        mainTableAlias
-      );
-      return val;
-    }
-    return null;
-  };
-  const ascComparator = (a, b) => {
-    if (typeof a === `string` && typeof b === `string`) {
-      return a.localeCompare(b);
-    }
-    if (Array.isArray(a) && Array.isArray(b)) {
-      for (let i = 0; i < Math.min(a.length, b.length); i++) {
-        const result = ascComparator(a[i], b[i]);
-        if (result !== 0) {
-          return result;
-        }
-      }
-      return a.length - b.length;
-    }
-    const bothObjects = typeof a === `object` && typeof b === `object`;
-    const bothDates = a instanceof Date && b instanceof Date;
-    const notNull = a !== null && b !== null;
-    if (bothObjects && !bothDates && notNull) {
-      return a.toString().localeCompare(b.toString());
-    }
-    if (a < b) return -1;
-    if (a > b) return 1;
-    return 0;
-  };
-  const descComparator = (a, b) => {
-    return ascComparator(b, a);
-  };
-  const makeComparator = (orderByProps) => {
-    return (a, b) => {
-      if (orderByProps.length > 1) {
-        const arrayA = a;
-        const arrayB = b;
-        for (let i = 0; i < orderByProps.length; i++) {
-          const direction = orderByProps[i].direction;
-          const compareFn = direction === `desc` ? descComparator : ascComparator;
-          const result = compareFn(arrayA[i], arrayB[i]);
-          if (result !== 0) {
-            return result;
-          }
-        }
-        return arrayA.length - arrayB.length;
-      }
-      if (orderByProps.length === 1) {
-        const direction = orderByProps[0].direction;
-        return direction === `desc` ? descComparator(a, b) : ascComparator(a, b);
-      }
-      return ascComparator(a, b);
-    };
-  };
-  const comparator = makeComparator(orderByItems);
-  if (hasOrderIndexColumn) {
-    if (orderIndexType === `numeric`) {
-      resultPipeline = resultPipeline.pipe(
-        d2mini.orderByWithIndex(valueExtractor, {
-          limit: query.limit,
-          offset: query.offset,
-          comparator
-        }),
-        d2mini.map(([key, [value, index]]) => {
-          const result = {
-            ...value,
-            [mainTableAlias]: {
-              ...value[mainTableAlias],
-              [orderIndexAlias]: index
-            }
-          };
-          return [key, result];
-        })
-      );
-    } else {
-      resultPipeline = resultPipeline.pipe(
-        d2mini.orderByWithFractionalIndex(valueExtractor, {
-          limit: query.limit,
-          offset: query.offset,
-          comparator
-        }),
-        d2mini.map(([key, [value, index]]) => {
-          const result = {
-            ...value,
-            [mainTableAlias]: {
-              ...value[mainTableAlias],
-              [orderIndexAlias]: index
-            }
-          };
-          return [key, result];
-        })
-      );
-    }
-  } else {
-    resultPipeline = resultPipeline.pipe(
-      d2mini.orderBy(valueExtractor, {
-        limit: query.limit,
-        offset: query.offset,
-        comparator
-      })
-    );
-  }
-  return resultPipeline;
-}
-function getOrderIndexType(obj) {
-  if (!utils.isOrderIndexFunctionCall(obj)) {
-    throw new Error(`Not an ORDER_INDEX function call`);
-  }
-  const arg = obj[`ORDER_INDEX`];
-  if (arg === `numeric` || arg === true || arg === `default`) {
-    return `numeric`;
-  } else if (arg === `fractional`) {
-    return `fractional`;
-  } else {
-    throw new Error(`Invalid ORDER_INDEX type: ` + arg);
-  }
-}
-exports.processOrderBy = processOrderBy;
-//# sourceMappingURL=order-by.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"order-by.cjs","sources":["../../../src/query/order-by.ts"],"sourcesContent":["import {\n  map,\n  orderBy,\n  orderByWithFractionalIndex,\n  orderByWithIndex,\n} from \"@electric-sql/d2mini\"\nimport { evaluateOperandOnNamespacedRow } from \"./extractors\"\nimport { isOrderIndexFunctionCall } from \"./utils\"\nimport type { ConditionOperand, Query } from \"./schema\"\nimport type {\n  KeyedNamespacedRow,\n  NamespacedAndKeyedStream,\n  NamespacedRow,\n} from \"../types\"\n\ntype OrderByItem = {\n  operand: ConditionOperand\n  direction: `asc` | `desc`\n}\n\ntype OrderByItems = Array<OrderByItem>\n\nexport function processOrderBy(\n  resultPipeline: NamespacedAndKeyedStream,\n  query: Query,\n  mainTableAlias: string\n) {\n  // Check if any column in the SELECT clause is an ORDER_INDEX function call\n  let hasOrderIndexColumn = false\n  let orderIndexType: `numeric` | `fractional` = `numeric`\n  let orderIndexAlias = ``\n\n  // Scan the SELECT clause for ORDER_INDEX functions\n  // TODO: Select is going to be optional in future - we will automatically add an\n  // attribute for the index column\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` && isOrderIndexFunctionCall(expr)) {\n          hasOrderIndexColumn = true\n          orderIndexAlias = alias\n          orderIndexType = getOrderIndexType(expr)\n          break\n        }\n      }\n    }\n    if (hasOrderIndexColumn) break\n  }\n\n  // Normalize orderBy to an array of objects\n  const orderByItems: OrderByItems = []\n\n  if (typeof query.orderBy === `string`) {\n    // Handle string format: '@column'\n    orderByItems.push({\n      operand: query.orderBy,\n      direction: `asc`,\n    })\n  } else if (Array.isArray(query.orderBy)) {\n    // Handle array format: ['@column1', { '@column2': 'desc' }]\n    for (const item of query.orderBy) {\n      if (typeof item === `string`) {\n        orderByItems.push({\n          operand: item,\n          direction: `asc`,\n        })\n      } else if (typeof item === `object`) {\n        for (const [column, direction] of Object.entries(item)) {\n          orderByItems.push({\n            operand: column,\n            direction: direction as `asc` | `desc`,\n          })\n        }\n      }\n    }\n  } else if (typeof query.orderBy === `object`) {\n    // Handle object format: { '@column': 'desc' }\n    for (const [column, direction] of Object.entries(query.orderBy)) {\n      orderByItems.push({\n        operand: column,\n        direction: direction as `asc` | `desc`,\n      })\n    }\n  }\n\n  // Create a value extractor function for the orderBy operator\n  // const valueExtractor = ([key, namespacedRow]: [\n  const valueExtractor = (namespacedRow: NamespacedRow) => {\n    // For multiple orderBy columns, create a composite key\n    if (orderByItems.length > 1) {\n      return orderByItems.map((item) =>\n        evaluateOperandOnNamespacedRow(\n          namespacedRow,\n          item.operand,\n          mainTableAlias\n        )\n      )\n    } else if (orderByItems.length === 1) {\n      // For a single orderBy column, use the value directly\n      const item = orderByItems[0]\n      const val = evaluateOperandOnNamespacedRow(\n        namespacedRow,\n        item!.operand,\n        mainTableAlias\n      )\n      return val\n    }\n\n    // Default case - no ordering\n    return null\n  }\n\n  const ascComparator = (a: any, b: any): number => {\n    // if a and b are both strings, compare them based on locale\n    if (typeof a === `string` && typeof b === `string`) {\n      return a.localeCompare(b)\n    }\n\n    // if a and b are both arrays, compare them element by element\n    if (Array.isArray(a) && Array.isArray(b)) {\n      for (let i = 0; i < Math.min(a.length, b.length); i++) {\n        // Compare the values\n        const result = ascComparator(a[i], b[i])\n\n        if (result !== 0) {\n          return result\n        }\n      }\n      // All elements are equal up to the minimum length\n      return a.length - b.length\n    }\n\n    // If at least one of the values is an object then we don't really know how to meaningfully compare them\n    // therefore we turn them into strings and compare those\n    // There are 2 exceptions:\n    // 1) if both objects are dates then we can compare them\n    // 2) if either object is nullish then we can't call toString on it\n    const bothObjects = typeof a === `object` && typeof b === `object`\n    const bothDates = a instanceof Date && b instanceof Date\n    const notNull = a !== null && b !== null\n    if (bothObjects && !bothDates && notNull) {\n      // Every object should support `toString`\n      return a.toString().localeCompare(b.toString())\n    }\n\n    if (a < b) return -1\n    if (a > b) return 1\n    return 0\n  }\n\n  const descComparator = (a: unknown, b: unknown): number => {\n    return ascComparator(b, a)\n  }\n\n  // Create a multi-property comparator that respects the order and direction of each property\n  const makeComparator = (orderByProps: OrderByItems) => {\n    return (a: unknown, b: unknown) => {\n      // If we're comparing arrays (multiple properties), compare each property in order\n      if (orderByProps.length > 1) {\n        // `a` and `b` must be arrays since `orderByItems.length > 1`\n        // hence the extracted values must be arrays\n        const arrayA = a as Array<unknown>\n        const arrayB = b as Array<unknown>\n        for (let i = 0; i < orderByProps.length; i++) {\n          const direction = orderByProps[i]!.direction\n          const compareFn =\n            direction === `desc` ? descComparator : ascComparator\n          const result = compareFn(arrayA[i], arrayB[i])\n          if (result !== 0) {\n            return result\n          }\n        }\n        // should normally always be 0 because\n        // both values are extracted based on orderByItems\n        return arrayA.length - arrayB.length\n      }\n\n      // Single property comparison\n      if (orderByProps.length === 1) {\n        const direction = orderByProps[0]!.direction\n        return direction === `desc` ? descComparator(a, b) : ascComparator(a, b)\n      }\n\n      return ascComparator(a, b)\n    }\n  }\n  const comparator = makeComparator(orderByItems)\n\n  // Apply the appropriate orderBy operator based on whether an ORDER_INDEX column is requested\n  if (hasOrderIndexColumn) {\n    if (orderIndexType === `numeric`) {\n      // Use orderByWithIndex for numeric indices\n      resultPipeline = resultPipeline.pipe(\n        orderByWithIndex(valueExtractor, {\n          limit: query.limit,\n          offset: query.offset,\n          comparator,\n        }),\n        map(([key, [value, index]]) => {\n          // Add the index to the result\n          // We add this to the main table alias for now\n          // TODO: re are going to need to refactor the whole order by pipeline\n          const result = {\n            ...(value as Record<string, unknown>),\n            [mainTableAlias]: {\n              ...value[mainTableAlias],\n              [orderIndexAlias]: index,\n            },\n          }\n          return [key, result] as KeyedNamespacedRow\n        })\n      )\n    } else {\n      // Use orderByWithFractionalIndex for fractional indices\n      resultPipeline = resultPipeline.pipe(\n        orderByWithFractionalIndex(valueExtractor, {\n          limit: query.limit,\n          offset: query.offset,\n          comparator,\n        }),\n        map(([key, [value, index]]) => {\n          // Add the index to the result\n          // We add this to the main table alias for now\n          // TODO: re are going to need to refactor the whole order by pipeline\n          const result = {\n            ...(value as Record<string, unknown>),\n            [mainTableAlias]: {\n              ...value[mainTableAlias],\n              [orderIndexAlias]: index,\n            },\n          }\n          return [key, result] as KeyedNamespacedRow\n        })\n      )\n    }\n  } else {\n    // Use regular orderBy if no index column is requested\n    resultPipeline = resultPipeline.pipe(\n      orderBy(valueExtractor, {\n        limit: query.limit,\n        offset: query.offset,\n        comparator,\n      })\n    )\n  }\n\n  return resultPipeline\n}\n\n// Helper function to extract the ORDER_INDEX type from a function call\nfunction getOrderIndexType(obj: any): `numeric` | `fractional` {\n  if (!isOrderIndexFunctionCall(obj)) {\n    throw new Error(`Not an ORDER_INDEX function call`)\n  }\n\n  const arg = obj[`ORDER_INDEX`]\n  if (arg === `numeric` || arg === true || arg === `default`) {\n    return `numeric`\n  } else if (arg === `fractional`) {\n    return `fractional`\n  } else {\n    throw new Error(`Invalid ORDER_INDEX type: ` + arg)\n  }\n}\n"],"names":["isOrderIndexFunctionCall","evaluateOperandOnNamespacedRow","orderByWithIndex","map","orderByWithFractionalIndex","orderBy"],"mappings":"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"}

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

@@ -1,3 +0,0 @@
-import { Query } from './schema.cjs';
-import { NamespacedAndKeyedStream } from '../types.cjs';
-export declare function processOrderBy(resultPipeline: NamespacedAndKeyedStream, query: Query, mainTableAlias: string): NamespacedAndKeyedStream;

package/dist/cjs/query/pipeline-compiler.cjs

@@ -1,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const d2mini = require("@electric-sql/d2mini");
-const evaluators = require("./evaluators.cjs");
-const joins = require("./joins.cjs");
-const groupBy = require("./group-by.cjs");
-const orderBy = require("./order-by.cjs");
-const select = require("./select.cjs");
-function compileQueryPipeline(query, inputs) {
-  const allInputs = { ...inputs };
-  if (query.with && query.with.length > 0) {
-    for (const withQuery of query.with) {
-      if (!withQuery.as) {
-        throw new Error(`WITH query must have an "as" property`);
-      }
-      if (allInputs[withQuery.as]) {
-        throw new Error(`CTE with name "${withQuery.as}" already exists`);
-      }
-      const withQueryWithoutWith = { ...withQuery, with: void 0 };
-      const compiledWithQuery = compileQueryPipeline(
-        withQueryWithoutWith,
-        allInputs
-      );
-      allInputs[withQuery.as] = compiledWithQuery;
-    }
-  }
-  const tables = {};
-  const mainTableAlias = query.as || query.from;
-  const input = allInputs[query.from];
-  if (!input) {
-    throw new Error(`Input for table "${query.from}" not found in inputs map`);
-  }
-  tables[mainTableAlias] = input;
-  let pipeline = input.pipe(
-    d2mini.map(([key, row]) => {
-      const ret = [key, { [mainTableAlias]: row }];
-      return ret;
-    })
-  );
-  if (query.join) {
-    pipeline = joins.processJoinClause(
-      pipeline,
-      query,
-      tables,
-      mainTableAlias,
-      allInputs
-    );
-  }
-  if (query.where) {
-    pipeline = pipeline.pipe(
-      d2mini.filter(([_key, row]) => {
-        const result = evaluators.evaluateWhereOnNamespacedRow(
-          row,
-          query.where,
-          mainTableAlias
-        );
-        return result;
-      })
-    );
-  }
-  if (query.groupBy) {
-    pipeline = groupBy.processGroupBy(pipeline, query, mainTableAlias);
-  }
-  if (query.having) {
-    pipeline = pipeline.pipe(
-      d2mini.filter(([_key, row]) => {
-        const result = evaluators.evaluateWhereOnNamespacedRow(
-          row,
-          query.having,
-          mainTableAlias
-        );
-        return result;
-      })
-    );
-  }
-  if (query.orderBy) {
-    pipeline = orderBy.processOrderBy(pipeline, query, mainTableAlias);
-  } else if (query.limit !== void 0 || query.offset !== void 0) {
-    throw new Error(
-      `LIMIT and OFFSET require an ORDER BY clause to ensure deterministic results`
-    );
-  }
-  const resultPipeline = query.select ? select.processSelect(pipeline, query, mainTableAlias, allInputs) : !query.join && !query.groupBy ? pipeline.pipe(
-    d2mini.map(([key, row]) => [key, row[mainTableAlias]])
-  ) : pipeline;
-  return resultPipeline;
-}
-exports.compileQueryPipeline = compileQueryPipeline;
-//# sourceMappingURL=pipeline-compiler.cjs.map

package/dist/cjs/query/pipeline-compiler.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"pipeline-compiler.cjs","sources":["../../../src/query/pipeline-compiler.ts"],"sourcesContent":["import { filter, map } from \"@electric-sql/d2mini\"\nimport { evaluateWhereOnNamespacedRow } from \"./evaluators.js\"\nimport { processJoinClause } from \"./joins.js\"\nimport { processGroupBy } from \"./group-by.js\"\nimport { processOrderBy } from \"./order-by.js\"\nimport { processSelect } from \"./select.js\"\nimport type { Query } from \"./schema.js\"\nimport type { IStreamBuilder } from \"@electric-sql/d2mini\"\nimport type {\n  InputRow,\n  KeyedStream,\n  NamespacedAndKeyedStream,\n} from \"../types.js\"\n\n/**\n * Compiles a query into a D2 pipeline\n * @param query The query to compile\n * @param inputs Mapping of table names to input streams\n * @returns A stream builder representing the compiled query\n */\nexport function compileQueryPipeline<T extends IStreamBuilder<unknown>>(\n  query: Query,\n  inputs: Record<string, KeyedStream>\n): T {\n  // Create a copy of the inputs map to avoid modifying the original\n  const allInputs = { ...inputs }\n\n  // Process WITH queries if they exist\n  if (query.with && query.with.length > 0) {\n    // Process each WITH query in order\n    for (const withQuery of query.with) {\n      // Ensure the WITH query has an alias\n      if (!withQuery.as) {\n        throw new Error(`WITH query must have an \"as\" property`)\n      }\n\n      // Check if this CTE name already exists in the inputs\n      if (allInputs[withQuery.as]) {\n        throw new Error(`CTE with name \"${withQuery.as}\" already exists`)\n      }\n\n      // Create a new query without the 'with' property to avoid circular references\n      const withQueryWithoutWith = { ...withQuery, with: undefined }\n\n      // Compile the WITH query using the current set of inputs\n      // (which includes previously compiled WITH queries)\n      const compiledWithQuery = compileQueryPipeline(\n        withQueryWithoutWith,\n        allInputs\n      )\n\n      // Add the compiled query to the inputs map using its alias\n      allInputs[withQuery.as] = compiledWithQuery as KeyedStream\n    }\n  }\n\n  // Create a map of table aliases to inputs\n  const tables: Record<string, KeyedStream> = {}\n\n  // The main table is the one in the FROM clause\n  const mainTableAlias = query.as || query.from\n\n  // Get the main input from the inputs map (now including CTEs)\n  const input = allInputs[query.from]\n  if (!input) {\n    throw new Error(`Input for table \"${query.from}\" not found in inputs map`)\n  }\n\n  tables[mainTableAlias] = input\n\n  // Prepare the initial pipeline with the main table wrapped in its alias\n  let pipeline: NamespacedAndKeyedStream = input.pipe(\n    map(([key, row]) => {\n      // Initialize the record with a nested structure\n      const ret = [key, { [mainTableAlias]: row }] as [\n        string,\n        Record<string, typeof row>,\n      ]\n      return ret\n    })\n  )\n\n  // Process JOIN clauses if they exist\n  if (query.join) {\n    pipeline = processJoinClause(\n      pipeline,\n      query,\n      tables,\n      mainTableAlias,\n      allInputs\n    )\n  }\n\n  // Process the WHERE clause if it exists\n  if (query.where) {\n    pipeline = pipeline.pipe(\n      filter(([_key, row]) => {\n        const result = evaluateWhereOnNamespacedRow(\n          row,\n          query.where!,\n          mainTableAlias\n        )\n        return result\n      })\n    )\n  }\n\n  // Process the GROUP BY clause if it exists\n  if (query.groupBy) {\n    pipeline = processGroupBy(pipeline, query, mainTableAlias)\n  }\n\n  // Process the HAVING clause if it exists\n  // This works similarly to WHERE but is applied after any aggregations\n  if (query.having) {\n    pipeline = pipeline.pipe(\n      filter(([_key, row]) => {\n        // For HAVING, we're working with the flattened row that contains both\n        // the group by keys and the aggregate results directly\n        const result = evaluateWhereOnNamespacedRow(\n          row,\n          query.having!,\n          mainTableAlias\n        )\n        return result\n      })\n    )\n  }\n\n  // Process orderBy parameter if it exists\n  if (query.orderBy) {\n    pipeline = processOrderBy(pipeline, query, mainTableAlias)\n  } else if (query.limit !== undefined || query.offset !== undefined) {\n    // If there's a limit or offset without orderBy, throw an error\n    throw new Error(\n      `LIMIT and OFFSET require an ORDER BY clause to ensure deterministic results`\n    )\n  }\n\n  // Process the SELECT clause - this is where we flatten the structure\n  const resultPipeline: KeyedStream | NamespacedAndKeyedStream = query.select\n    ? processSelect(pipeline, query, mainTableAlias, allInputs)\n    : !query.join && !query.groupBy\n      ? pipeline.pipe(\n          map(([key, row]) => [key, row[mainTableAlias]] as InputRow)\n        )\n      : pipeline\n  return resultPipeline as T\n}\n"],"names":["map","processJoinClause","filter","evaluateWhereOnNamespacedRow","processGroupBy","processOrderBy","processSelect"],"mappings":";;;;;;;;AAoBgB,SAAA,qBACd,OACA,QACG;AAEG,QAAA,YAAY,EAAE,GAAG,OAAO;AAG9B,MAAI,MAAM,QAAQ,MAAM,KAAK,SAAS,GAAG;AAE5B,eAAA,aAAa,MAAM,MAAM;AAE9B,UAAA,CAAC,UAAU,IAAI;AACX,cAAA,IAAI,MAAM,uCAAuC;AAAA,MAAA;AAIrD,UAAA,UAAU,UAAU,EAAE,GAAG;AAC3B,cAAM,IAAI,MAAM,kBAAkB,UAAU,EAAE,kBAAkB;AAAA,MAAA;AAIlE,YAAM,uBAAuB,EAAE,GAAG,WAAW,MAAM,OAAU;AAI7D,YAAM,oBAAoB;AAAA,QACxB;AAAA,QACA;AAAA,MACF;AAGU,gBAAA,UAAU,EAAE,IAAI;AAAA,IAAA;AAAA,EAC5B;AAIF,QAAM,SAAsC,CAAC;AAGvC,QAAA,iBAAiB,MAAM,MAAM,MAAM;AAGnC,QAAA,QAAQ,UAAU,MAAM,IAAI;AAClC,MAAI,CAAC,OAAO;AACV,UAAM,IAAI,MAAM,oBAAoB,MAAM,IAAI,2BAA2B;AAAA,EAAA;AAG3E,SAAO,cAAc,IAAI;AAGzB,MAAI,WAAqC,MAAM;AAAA,IAC7CA,OAAAA,IAAI,CAAC,CAAC,KAAK,GAAG,MAAM;AAEZ,YAAA,MAAM,CAAC,KAAK,EAAE,CAAC,cAAc,GAAG,KAAK;AAIpC,aAAA;AAAA,IACR,CAAA;AAAA,EACH;AAGA,MAAI,MAAM,MAAM;AACH,eAAAC,MAAA;AAAA,MACT;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EAAA;AAIF,MAAI,MAAM,OAAO;AACf,eAAW,SAAS;AAAA,MAClBC,OAAAA,OAAO,CAAC,CAAC,MAAM,GAAG,MAAM;AACtB,cAAM,SAASC,WAAA;AAAA,UACb;AAAA,UACA,MAAM;AAAA,UACN;AAAA,QACF;AACO,eAAA;AAAA,MACR,CAAA;AAAA,IACH;AAAA,EAAA;AAIF,MAAI,MAAM,SAAS;AACN,eAAAC,QAAA,eAAe,UAAU,OAAO,cAAc;AAAA,EAAA;AAK3D,MAAI,MAAM,QAAQ;AAChB,eAAW,SAAS;AAAA,MAClBF,OAAAA,OAAO,CAAC,CAAC,MAAM,GAAG,MAAM;AAGtB,cAAM,SAASC,WAAA;AAAA,UACb;AAAA,UACA,MAAM;AAAA,UACN;AAAA,QACF;AACO,eAAA;AAAA,MACR,CAAA;AAAA,IACH;AAAA,EAAA;AAIF,MAAI,MAAM,SAAS;AACN,eAAAE,QAAA,eAAe,UAAU,OAAO,cAAc;AAAA,EAAA,WAChD,MAAM,UAAU,UAAa,MAAM,WAAW,QAAW;AAElE,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EAAA;AAIF,QAAM,iBAAyD,MAAM,SACjEC,OAAAA,cAAc,UAAU,OAAO,gBAAgB,SAAS,IACxD,CAAC,MAAM,QAAQ,CAAC,MAAM,UACpB,SAAS;AAAA,IACPN,WAAI,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,cAAc,CAAC,CAAa;AAAA,EAAA,IAE5D;AACC,SAAA;AACT;;"}

package/dist/cjs/query/pipeline-compiler.d.cts

@@ -1,10 +0,0 @@
-import { Query } from './schema.js';
-import { IStreamBuilder } from '@electric-sql/d2mini';
-import { KeyedStream } from '../types.js';
-/**
- * Compiles a query into a D2 pipeline
- * @param query The query to compile
- * @param inputs Mapping of table names to input streams
- * @returns A stream builder representing the compiled query
- */
-export declare function compileQueryPipeline<T extends IStreamBuilder<unknown>>(query: Query, inputs: Record<string, KeyedStream>): T;

package/dist/cjs/query/query-builder.cjs

@@ -1,307 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-class BaseQueryBuilder {
-  /**
-   * Create a new QueryBuilder instance.
-   */
-  constructor(query = {}) {
-    this.query = {};
-    this.query = query;
-  }
-  /**
-   * Specify the collection to query from.
-   * This is the first method that must be called in the chain.
-   *
-   * @param collection The collection name to query from
-   * @param as Optional alias for the collection
-   * @returns A new QueryBuilder with the from clause set
-   */
-  from(collection, as) {
-    if (typeof collection === `object` && collection !== null) {
-      return this.fromCollectionRef(collection);
-    } else if (typeof collection === `string`) {
-      return this.fromInputReference(
-        collection,
-        as
-      );
-    } else {
-      throw new Error(`Invalid collection type`);
-    }
-  }
-  fromCollectionRef(collectionRef) {
-    var _a;
-    const keys = Object.keys(collectionRef);
-    if (keys.length !== 1) {
-      throw new Error(`Expected exactly one key`);
-    }
-    const key = keys[0];
-    const collection = collectionRef[key];
-    const newBuilder = new BaseQueryBuilder();
-    Object.assign(newBuilder.query, this.query);
-    newBuilder.query.from = key;
-    (_a = newBuilder.query).collections ?? (_a.collections = {});
-    newBuilder.query.collections[key] = collection;
-    return newBuilder;
-  }
-  fromInputReference(collection, as) {
-    const newBuilder = new BaseQueryBuilder();
-    Object.assign(newBuilder.query, this.query);
-    newBuilder.query.from = collection;
-    if (as) {
-      newBuilder.query.as = as;
-    }
-    return newBuilder;
-  }
-  /**
-   * Specify what columns to select.
-   * Overwrites any previous select clause.
-   * Also supports callback functions that receive the row context and return selected data.
-   *
-   * @param selects The columns to select (can include callbacks)
-   * @returns A new QueryBuilder with the select clause set
-   */
-  select(...selects) {
-    const validatedSelects = selects.map((select) => {
-      if (typeof select === `object` && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      select !== null && !Array.isArray(select)) {
-        const result = {};
-        for (const [key, value] of Object.entries(select)) {
-          if (typeof value === `object` && value !== null && !Array.isArray(value)) {
-            const keys = Object.keys(value);
-            if (keys.length === 1) {
-              const funcName = keys[0];
-              const allowedFunctions = [
-                `SUM`,
-                `COUNT`,
-                `AVG`,
-                `MIN`,
-                `MAX`,
-                `DATE`,
-                `JSON_EXTRACT`,
-                `JSON_EXTRACT_PATH`,
-                `UPPER`,
-                `LOWER`,
-                `COALESCE`,
-                `CONCAT`,
-                `LENGTH`,
-                `ORDER_INDEX`
-              ];
-              if (!allowedFunctions.includes(funcName)) {
-                console.warn(
-                  `Unsupported function: ${funcName}. Expected one of: ${allowedFunctions.join(`, `)}`
-                );
-              }
-            }
-          }
-          result[key] = value;
-        }
-        return result;
-      }
-      return select;
-    });
-    if (this._query.orderBy) {
-      validatedSelects.push({ _orderByIndex: { ORDER_INDEX: `fractional` } });
-    }
-    const newBuilder = new BaseQueryBuilder(
-      this.query
-    );
-    newBuilder.query.select = validatedSelects;
-    return newBuilder;
-  }
-  /**
-   * Add a where clause to filter the results.
-   * Can be called multiple times to add AND conditions.
-   * Also supports callback functions that receive the row context.
-   *
-   * @param leftOrConditionOrCallback The left operand, complete condition, or callback function
-   * @param operator Optional comparison operator
-   * @param right Optional right operand
-   * @returns A new QueryBuilder with the where clause added
-   */
-  where(leftOrConditionOrCallback, operator, right) {
-    const newBuilder = new BaseQueryBuilder();
-    Object.assign(newBuilder.query, this.query);
-    let condition;
-    if (typeof leftOrConditionOrCallback === `function`) {
-      condition = leftOrConditionOrCallback;
-    } else if (operator !== void 0 && right !== void 0) {
-      condition = [leftOrConditionOrCallback, operator, right];
-    } else {
-      condition = leftOrConditionOrCallback;
-    }
-    if (!newBuilder.query.where) {
-      newBuilder.query.where = [condition];
-    } else {
-      newBuilder.query.where = [...newBuilder.query.where, condition];
-    }
-    return newBuilder;
-  }
-  /**
-   * Add a having clause to filter the grouped results.
-   * Can be called multiple times to add AND conditions.
-   * Also supports callback functions that receive the row context.
-   *
-   * @param leftOrConditionOrCallback The left operand, complete condition, or callback function
-   * @param operator Optional comparison operator
-   * @param right Optional right operand
-   * @returns A new QueryBuilder with the having clause added
-   */
-  having(leftOrConditionOrCallback, operator, right) {
-    const newBuilder = new BaseQueryBuilder();
-    Object.assign(newBuilder.query, this.query);
-    let condition;
-    if (typeof leftOrConditionOrCallback === `function`) {
-      condition = leftOrConditionOrCallback;
-    } else if (operator !== void 0 && right !== void 0) {
-      condition = [leftOrConditionOrCallback, operator, right];
-    } else {
-      condition = leftOrConditionOrCallback;
-    }
-    if (!newBuilder.query.having) {
-      newBuilder.query.having = [condition];
-    } else {
-      newBuilder.query.having = [...newBuilder.query.having, condition];
-    }
-    return newBuilder;
-  }
-  join(joinClause) {
-    if (typeof joinClause.from === `object` && joinClause.from !== null) {
-      return this.joinCollectionRef(
-        joinClause
-      );
-    } else {
-      return this.joinInputReference(
-        joinClause
-      );
-    }
-  }
-  joinCollectionRef(joinClause) {
-    var _a;
-    const newBuilder = new BaseQueryBuilder();
-    Object.assign(newBuilder.query, this.query);
-    const keys = Object.keys(joinClause.from);
-    if (keys.length !== 1) {
-      throw new Error(`Expected exactly one key in CollectionRef`);
-    }
-    const key = keys[0];
-    const collection = joinClause.from[key];
-    if (!collection) {
-      throw new Error(`Collection not found for key: ${key}`);
-    }
-    const joinClauseCopy = {
-      type: joinClause.type,
-      from: key,
-      on: joinClause.on,
-      where: joinClause.where
-    };
-    if (!newBuilder.query.join) {
-      newBuilder.query.join = [joinClauseCopy];
-    } else {
-      newBuilder.query.join = [...newBuilder.query.join, joinClauseCopy];
-    }
-    (_a = newBuilder.query).collections ?? (_a.collections = {});
-    newBuilder.query.collections[key] = collection;
-    return newBuilder;
-  }
-  joinInputReference(joinClause) {
-    const newBuilder = new BaseQueryBuilder();
-    Object.assign(newBuilder.query, this.query);
-    const joinClauseCopy = { ...joinClause };
-    if (!newBuilder.query.join) {
-      newBuilder.query.join = [joinClauseCopy];
-    } else {
-      newBuilder.query.join = [...newBuilder.query.join, joinClauseCopy];
-    }
-    joinClause.as ?? joinClause.from;
-    return newBuilder;
-  }
-  /**
-   * Add an orderBy clause to sort the results.
-   * Overwrites any previous orderBy clause.
-   *
-   * @param orderBy The order specification
-   * @returns A new QueryBuilder with the orderBy clause set
-   */
-  orderBy(orderBy) {
-    const newBuilder = new BaseQueryBuilder();
-    Object.assign(newBuilder.query, this.query);
-    newBuilder.query.orderBy = orderBy;
-    newBuilder.query.select = [
-      ...newBuilder.query.select ?? [],
-      { _orderByIndex: { ORDER_INDEX: `fractional` } }
-    ];
-    return newBuilder;
-  }
-  /**
-   * Set a limit on the number of results returned.
-   *
-   * @param limit Maximum number of results to return
-   * @returns A new QueryBuilder with the limit set
-   */
-  limit(limit) {
-    const newBuilder = new BaseQueryBuilder();
-    Object.assign(newBuilder.query, this.query);
-    newBuilder.query.limit = limit;
-    return newBuilder;
-  }
-  /**
-   * Set an offset to skip a number of results.
-   *
-   * @param offset Number of results to skip
-   * @returns A new QueryBuilder with the offset set
-   */
-  offset(offset) {
-    const newBuilder = new BaseQueryBuilder();
-    Object.assign(newBuilder.query, this.query);
-    newBuilder.query.offset = offset;
-    return newBuilder;
-  }
-  /**
-   * Add a groupBy clause to group the results by one or more columns.
-   *
-   * @param groupBy The column(s) to group by
-   * @returns A new QueryBuilder with the groupBy clause set
-   */
-  groupBy(groupBy) {
-    const newBuilder = new BaseQueryBuilder();
-    Object.assign(newBuilder.query, this.query);
-    newBuilder.query.groupBy = groupBy;
-    return newBuilder;
-  }
-  /**
-   * Define a Common Table Expression (CTE) that can be referenced in the main query.
-   * This allows referencing the CTE by name in subsequent from/join clauses.
-   *
-   * @param name The name of the CTE
-   * @param queryBuilderCallback A function that builds the CTE query
-   * @returns A new QueryBuilder with the CTE added
-   */
-  with(name, queryBuilderCallback) {
-    const newBuilder = new BaseQueryBuilder();
-    Object.assign(newBuilder.query, this.query);
-    const cteBuilder = new BaseQueryBuilder();
-    const cteQueryBuilder = queryBuilderCallback(
-      cteBuilder
-    );
-    const cteQuery = cteQueryBuilder._query;
-    const withQuery = {
-      ...cteQuery,
-      as: name
-    };
-    if (!newBuilder.query.with) {
-      newBuilder.query.with = [withQuery];
-    } else {
-      newBuilder.query.with = [...newBuilder.query.with, withQuery];
-    }
-    return newBuilder;
-  }
-  get _query() {
-    return this.query;
-  }
-}
-function queryBuilder() {
-  return new BaseQueryBuilder();
-}
-exports.BaseQueryBuilder = BaseQueryBuilder;
-exports.queryBuilder = queryBuilder;
-//# sourceMappingURL=query-builder.cjs.map