@tanstack/db 0.0.14 → 0.0.16

package/dist/cjs/query/compiler/index.cjs

@@ -0,0 +1,181 @@
+"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 compileQuery(query, inputs, cache = /* @__PURE__ */ new WeakMap()) {
+  const cachedResult = cache.get(query);
+  if (cachedResult) {
+    return cachedResult;
+  }
+  const allInputs = { ...inputs };
+  const tables = {};
+  const { alias: mainTableAlias, input: mainInput } = processFrom(
+    query.from,
+    allInputs,
+    cache
+  );
+  tables[mainTableAlias] = mainInput;
+  let pipeline = mainInput.pipe(
+    d2mini.map(([key, row]) => {
+      const ret = [key, { [mainTableAlias]: row }];
+      return ret;
+    })
+  );
+  if (query.join && query.join.length > 0) {
+    pipeline = joins.processJoins(
+      pipeline,
+      query.join,
+      tables,
+      mainTableAlias,
+      allInputs,
+      cache
+    );
+  }
+  if (query.where && query.where.length > 0) {
+    const compiledWheres = query.where.map((where) => evaluators.compileExpression(where));
+    for (const compiledWhere of compiledWheres) {
+      pipeline = pipeline.pipe(
+        d2mini.filter(([_key, namespacedRow]) => {
+          return compiledWhere(namespacedRow);
+        })
+      );
+    }
+  }
+  if (query.fnWhere && query.fnWhere.length > 0) {
+    for (const fnWhere of query.fnWhere) {
+      pipeline = pipeline.pipe(
+        d2mini.filter(([_key, namespacedRow]) => {
+          return fnWhere(namespacedRow);
+        })
+      );
+    }
+  }
+  if (query.fnSelect) {
+    pipeline = pipeline.pipe(
+      d2mini.map(([key, namespacedRow]) => {
+        const selectResults = query.fnSelect(namespacedRow);
+        return [
+          key,
+          {
+            ...namespacedRow,
+            __select_results: selectResults
+          }
+        ];
+      })
+    );
+  } else if (query.select) {
+    pipeline = select.processSelectToResults(pipeline, query.select);
+  } else {
+    pipeline = pipeline.pipe(
+      d2mini.map(([key, namespacedRow]) => {
+        const selectResults = !query.join && !query.groupBy ? namespacedRow[mainTableAlias] : namespacedRow;
+        return [
+          key,
+          {
+            ...namespacedRow,
+            __select_results: selectResults
+          }
+        ];
+      })
+    );
+  }
+  if (query.groupBy && query.groupBy.length > 0) {
+    pipeline = groupBy.processGroupBy(
+      pipeline,
+      query.groupBy,
+      query.having,
+      query.select,
+      query.fnHaving
+    );
+  } else if (query.select) {
+    const hasAggregates = Object.values(query.select).some(
+      (expr) => expr.type === `agg`
+    );
+    if (hasAggregates) {
+      pipeline = groupBy.processGroupBy(
+        pipeline,
+        [],
+        // Empty group by means single group
+        query.having,
+        query.select,
+        query.fnHaving
+      );
+    }
+  }
+  if (query.having && (!query.groupBy || query.groupBy.length === 0)) {
+    const hasAggregates = query.select ? Object.values(query.select).some((expr) => expr.type === `agg`) : false;
+    if (!hasAggregates) {
+      throw new Error(`HAVING clause requires GROUP BY clause`);
+    }
+  }
+  if (query.fnHaving && query.fnHaving.length > 0 && (!query.groupBy || query.groupBy.length === 0)) {
+    for (const fnHaving of query.fnHaving) {
+      pipeline = pipeline.pipe(
+        d2mini.filter(([_key, namespacedRow]) => {
+          return fnHaving(namespacedRow);
+        })
+      );
+    }
+  }
+  if (query.orderBy && query.orderBy.length > 0) {
+    const orderedPipeline = orderBy.processOrderBy(
+      pipeline,
+      query.orderBy,
+      query.limit,
+      query.offset
+    );
+    const resultPipeline2 = orderedPipeline.pipe(
+      d2mini.map(([key, [row, orderByIndex]]) => {
+        const finalResults = row.__select_results;
+        return [key, [finalResults, orderByIndex]];
+      })
+    );
+    const result2 = resultPipeline2;
+    cache.set(query, result2);
+    return result2;
+  } 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 = pipeline.pipe(
+    d2mini.map(([key, row]) => {
+      const finalResults = row.__select_results;
+      return [key, [finalResults, void 0]];
+    })
+  );
+  const result = resultPipeline;
+  cache.set(query, result);
+  return result;
+}
+function processFrom(from, allInputs, cache) {
+  switch (from.type) {
+    case `collectionRef`: {
+      const input = allInputs[from.collection.id];
+      if (!input) {
+        throw new Error(
+          `Input for collection "${from.collection.id}" not found in inputs map`
+        );
+      }
+      return { alias: from.alias, input };
+    }
+    case `queryRef`: {
+      const subQueryInput = compileQuery(from.query, allInputs, cache);
+      const extractedInput = subQueryInput.pipe(
+        d2mini.map((data) => {
+          const [key, [value, _orderByIndex]] = data;
+          return [key, value];
+        })
+      );
+      return { alias: from.alias, input: extractedInput };
+    }
+    default:
+      throw new Error(`Unsupported FROM type: ${from.type}`);
+  }
+}
+exports.compileQuery = compileQuery;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/query/compiler/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../../../src/query/compiler/index.ts"],"sourcesContent":["import { filter, map } from \"@electric-sql/d2mini\"\nimport { compileExpression } from \"./evaluators.js\"\nimport { processJoins } from \"./joins.js\"\nimport { processGroupBy } from \"./group-by.js\"\nimport { processOrderBy } from \"./order-by.js\"\nimport { processSelectToResults } from \"./select.js\"\nimport type { CollectionRef, QueryIR, QueryRef } from \"../ir.js\"\nimport type {\n  KeyedStream,\n  NamespacedAndKeyedStream,\n  ResultStream,\n} from \"../../types.js\"\n\n/**\n * Cache for compiled subqueries to avoid duplicate compilation\n */\ntype QueryCache = WeakMap<QueryIR, ResultStream>\n\n/**\n * Compiles a query2 IR into a D2 pipeline\n * @param query The query IR to compile\n * @param inputs Mapping of collection names to input streams\n * @param cache Optional cache for compiled subqueries (used internally for recursion)\n * @returns A stream builder representing the compiled query\n */\nexport function compileQuery(\n  query: QueryIR,\n  inputs: Record<string, KeyedStream>,\n  cache: QueryCache = new WeakMap()\n): ResultStream {\n  // Check if this query has already been compiled\n  const cachedResult = cache.get(query)\n  if (cachedResult) {\n    return cachedResult\n  }\n\n  // Create a copy of the inputs map to avoid modifying the original\n  const allInputs = { ...inputs }\n\n  // Create a map of table aliases to inputs\n  const tables: Record<string, KeyedStream> = {}\n\n  // Process the FROM clause to get the main table\n  const { alias: mainTableAlias, input: mainInput } = processFrom(\n    query.from,\n    allInputs,\n    cache\n  )\n  tables[mainTableAlias] = mainInput\n\n  // Prepare the initial pipeline with the main table wrapped in its alias\n  let pipeline: NamespacedAndKeyedStream = mainInput.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 && query.join.length > 0) {\n    pipeline = processJoins(\n      pipeline,\n      query.join,\n      tables,\n      mainTableAlias,\n      allInputs,\n      cache\n    )\n  }\n\n  // Process the WHERE clause if it exists\n  if (query.where && query.where.length > 0) {\n    // Compile all WHERE expressions\n    const compiledWheres = query.where.map((where) => compileExpression(where))\n\n    // Apply each WHERE condition as a filter (they are ANDed together)\n    for (const compiledWhere of compiledWheres) {\n      pipeline = pipeline.pipe(\n        filter(([_key, namespacedRow]) => {\n          return compiledWhere(namespacedRow)\n        })\n      )\n    }\n  }\n\n  // Process functional WHERE clauses if they exist\n  if (query.fnWhere && query.fnWhere.length > 0) {\n    for (const fnWhere of query.fnWhere) {\n      pipeline = pipeline.pipe(\n        filter(([_key, namespacedRow]) => {\n          return fnWhere(namespacedRow)\n        })\n      )\n    }\n  }\n\n  // Process the SELECT clause early - always create __select_results\n  // This eliminates duplication and allows for future DISTINCT implementation\n  if (query.fnSelect) {\n    // Handle functional select - apply the function to transform the row\n    pipeline = pipeline.pipe(\n      map(([key, namespacedRow]) => {\n        const selectResults = query.fnSelect!(namespacedRow)\n        return [\n          key,\n          {\n            ...namespacedRow,\n            __select_results: selectResults,\n          },\n        ] as [string, typeof namespacedRow & { __select_results: any }]\n      })\n    )\n  } else if (query.select) {\n    pipeline = processSelectToResults(pipeline, query.select, allInputs)\n  } else {\n    // If no SELECT clause, create __select_results with the main table data\n    pipeline = pipeline.pipe(\n      map(([key, namespacedRow]) => {\n        const selectResults =\n          !query.join && !query.groupBy\n            ? namespacedRow[mainTableAlias]\n            : namespacedRow\n\n        return [\n          key,\n          {\n            ...namespacedRow,\n            __select_results: selectResults,\n          },\n        ] as [string, typeof namespacedRow & { __select_results: any }]\n      })\n    )\n  }\n\n  // Process the GROUP BY clause if it exists\n  if (query.groupBy && query.groupBy.length > 0) {\n    pipeline = processGroupBy(\n      pipeline,\n      query.groupBy,\n      query.having,\n      query.select,\n      query.fnHaving\n    )\n  } else if (query.select) {\n    // Check if SELECT contains aggregates but no GROUP BY (implicit single-group aggregation)\n    const hasAggregates = Object.values(query.select).some(\n      (expr) => expr.type === `agg`\n    )\n    if (hasAggregates) {\n      // Handle implicit single-group aggregation\n      pipeline = processGroupBy(\n        pipeline,\n        [], // Empty group by means single group\n        query.having,\n        query.select,\n        query.fnHaving\n      )\n    }\n  }\n\n  // Process the HAVING clause if it exists (only applies after GROUP BY)\n  if (query.having && (!query.groupBy || query.groupBy.length === 0)) {\n    // Check if we have aggregates in SELECT that would trigger implicit grouping\n    const hasAggregates = query.select\n      ? Object.values(query.select).some((expr) => expr.type === `agg`)\n      : false\n\n    if (!hasAggregates) {\n      throw new Error(`HAVING clause requires GROUP BY clause`)\n    }\n  }\n\n  // Process functional HAVING clauses outside of GROUP BY (treat as additional WHERE filters)\n  if (\n    query.fnHaving &&\n    query.fnHaving.length > 0 &&\n    (!query.groupBy || query.groupBy.length === 0)\n  ) {\n    // If there's no GROUP BY but there are fnHaving clauses, apply them as filters\n    for (const fnHaving of query.fnHaving) {\n      pipeline = pipeline.pipe(\n        filter(([_key, namespacedRow]) => {\n          return fnHaving(namespacedRow)\n        })\n      )\n    }\n  }\n\n  // Process orderBy parameter if it exists\n  if (query.orderBy && query.orderBy.length > 0) {\n    const orderedPipeline = processOrderBy(\n      pipeline,\n      query.orderBy,\n      query.limit,\n      query.offset\n    )\n\n    // Final step: extract the __select_results and include orderBy index\n    const resultPipeline = orderedPipeline.pipe(\n      map(([key, [row, orderByIndex]]) => {\n        // Extract the final results from __select_results and include orderBy index\n        const finalResults = (row as any).__select_results\n        return [key, [finalResults, orderByIndex]] as [unknown, [any, string]]\n      })\n    )\n\n    const result = resultPipeline\n    // Cache the result before returning\n    cache.set(query, result)\n    return result\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  // Final step: extract the __select_results and return tuple format (no orderBy)\n  const resultPipeline: ResultStream = pipeline.pipe(\n    map(([key, row]) => {\n      // Extract the final results from __select_results and return [key, [results, undefined]]\n      const finalResults = (row as any).__select_results\n      return [key, [finalResults, undefined]] as [\n        unknown,\n        [any, string | undefined],\n      ]\n    })\n  )\n\n  const result = resultPipeline\n  // Cache the result before returning\n  cache.set(query, result)\n  return result\n}\n\n/**\n * Processes the FROM clause to extract the main table alias and input stream\n */\nfunction processFrom(\n  from: CollectionRef | QueryRef,\n  allInputs: Record<string, KeyedStream>,\n  cache: QueryCache\n): { alias: string; input: KeyedStream } {\n  switch (from.type) {\n    case `collectionRef`: {\n      const input = allInputs[from.collection.id]\n      if (!input) {\n        throw new Error(\n          `Input for collection \"${from.collection.id}\" not found in inputs map`\n        )\n      }\n      return { alias: from.alias, input }\n    }\n    case `queryRef`: {\n      // Recursively compile the sub-query with cache\n      const subQueryInput = compileQuery(from.query, allInputs, cache)\n\n      // Subqueries may return [key, [value, orderByIndex]] (with ORDER BY) or [key, value] (without ORDER BY)\n      // We need to extract just the value for use in parent queries\n      const extractedInput = subQueryInput.pipe(\n        map((data: any) => {\n          const [key, [value, _orderByIndex]] = data\n          return [key, value] as [unknown, any]\n        })\n      )\n\n      return { alias: from.alias, input: extractedInput }\n    }\n    default:\n      throw new Error(`Unsupported FROM type: ${(from as any).type}`)\n  }\n}\n"],"names":["map","processJoins","compileExpression","filter","processSelectToResults","processGroupBy","processOrderBy","resultPipeline","result"],"mappings":"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"}

package/dist/cjs/query/compiler/index.d.cts

@@ -0,0 +1,15 @@
+import { QueryIR } from '../ir.js';
+import { KeyedStream, ResultStream } from '../../types.js';
+/**
+ * Cache for compiled subqueries to avoid duplicate compilation
+ */
+type QueryCache = WeakMap<QueryIR, ResultStream>;
+/**
+ * Compiles a query2 IR into a D2 pipeline
+ * @param query The query IR to compile
+ * @param inputs Mapping of collection names to input streams
+ * @param cache Optional cache for compiled subqueries (used internally for recursion)
+ * @returns A stream builder representing the compiled query
+ */
+export declare function compileQuery(query: QueryIR, inputs: Record<string, KeyedStream>, cache?: QueryCache): ResultStream;
+export {};

package/dist/cjs/query/compiler/joins.cjs

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const d2mini = require("@electric-sql/d2mini");
+const evaluators = require("./evaluators.cjs");
+const index = require("./index.cjs");
+function processJoins(pipeline, joinClauses, tables, mainTableAlias, allInputs, cache) {
+  let resultPipeline = pipeline;
+  for (const joinClause of joinClauses) {
+    resultPipeline = processJoin(
+      resultPipeline,
+      joinClause,
+      tables,
+      mainTableAlias,
+      allInputs,
+      cache
+    );
+  }
+  return resultPipeline;
+}
+function processJoin(pipeline, joinClause, tables, mainTableAlias, allInputs, cache) {
+  const { alias: joinedTableAlias, input: joinedInput } = processJoinSource(
+    joinClause.from,
+    allInputs,
+    cache
+  );
+  tables[joinedTableAlias] = joinedInput;
+  const joinType = joinClause.type === `cross` ? `inner` : joinClause.type === `outer` ? `full` : joinClause.type;
+  const compiledLeftExpr = evaluators.compileExpression(joinClause.left);
+  const compiledRightExpr = evaluators.compileExpression(joinClause.right);
+  const mainPipeline = pipeline.pipe(
+    d2mini.map(([currentKey, namespacedRow]) => {
+      const leftKey = compiledLeftExpr(namespacedRow);
+      return [leftKey, [currentKey, namespacedRow]];
+    })
+  );
+  const joinedPipeline = joinedInput.pipe(
+    d2mini.map(([currentKey, row]) => {
+      const namespacedRow = { [joinedTableAlias]: row };
+      const rightKey = compiledRightExpr(namespacedRow);
+      return [rightKey, [currentKey, namespacedRow]];
+    })
+  );
+  if (![`inner`, `left`, `right`, `full`].includes(joinType)) {
+    throw new Error(`Unsupported join type: ${joinClause.type}`);
+  }
+  return mainPipeline.pipe(
+    d2mini.join(joinedPipeline, joinType),
+    d2mini.consolidate(),
+    processJoinResults(joinClause.type)
+  );
+}
+function processJoinSource(from, allInputs, cache) {
+  switch (from.type) {
+    case `collectionRef`: {
+      const input = allInputs[from.collection.id];
+      if (!input) {
+        throw new Error(
+          `Input for collection "${from.collection.id}" not found in inputs map`
+        );
+      }
+      return { alias: from.alias, input };
+    }
+    case `queryRef`: {
+      const subQueryInput = index.compileQuery(from.query, allInputs, cache);
+      const extractedInput = subQueryInput.pipe(
+        d2mini.map((data) => {
+          const [key, [value, _orderByIndex]] = data;
+          return [key, value];
+        })
+      );
+      return { alias: from.alias, input: extractedInput };
+    }
+    default:
+      throw new Error(`Unsupported join source type: ${from.type}`);
+  }
+}
+function processJoinResults(joinType) {
+  return function(pipeline) {
+    return pipeline.pipe(
+      // Process the join result and handle nulls
+      d2mini.filter((result) => {
+        const [_key, [main, joined]] = result;
+        const mainNamespacedRow = main == null ? void 0 : main[1];
+        const joinedNamespacedRow = joined == null ? void 0 : joined[1];
+        if (joinType === `inner`) {
+          return !!(mainNamespacedRow && joinedNamespacedRow);
+        }
+        if (joinType === `left`) {
+          return !!mainNamespacedRow;
+        }
+        if (joinType === `right`) {
+          return !!joinedNamespacedRow;
+        }
+        return true;
+      }),
+      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];
+        const mergedNamespacedRow = {};
+        if (mainNamespacedRow) {
+          Object.assign(mergedNamespacedRow, mainNamespacedRow);
+        }
+        if (joinedNamespacedRow) {
+          Object.assign(mergedNamespacedRow, joinedNamespacedRow);
+        }
+        const resultKey = `[${mainKey},${joinedKey}]`;
+        return [resultKey, mergedNamespacedRow];
+      })
+    );
+  };
+}
+exports.processJoins = processJoins;
+//# sourceMappingURL=joins.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"joins.cjs","sources":["../../../../src/query/compiler/joins.ts"],"sourcesContent":["import {\n  consolidate,\n  filter,\n  join as joinOperator,\n  map,\n} from \"@electric-sql/d2mini\"\nimport { compileExpression } from \"./evaluators.js\"\nimport { compileQuery } from \"./index.js\"\nimport type { IStreamBuilder, JoinType } from \"@electric-sql/d2mini\"\nimport type { CollectionRef, JoinClause, QueryIR, QueryRef } from \"../ir.js\"\nimport type {\n  KeyedStream,\n  NamespacedAndKeyedStream,\n  NamespacedRow,\n  ResultStream,\n} from \"../../types.js\"\n\n/**\n * Cache for compiled subqueries to avoid duplicate compilation\n */\ntype QueryCache = WeakMap<QueryIR, ResultStream>\n\n/**\n * Processes all join clauses in a query\n */\nexport function processJoins(\n  pipeline: NamespacedAndKeyedStream,\n  joinClauses: Array<JoinClause>,\n  tables: Record<string, KeyedStream>,\n  mainTableAlias: string,\n  allInputs: Record<string, KeyedStream>,\n  cache: QueryCache\n): NamespacedAndKeyedStream {\n  let resultPipeline = pipeline\n\n  for (const joinClause of joinClauses) {\n    resultPipeline = processJoin(\n      resultPipeline,\n      joinClause,\n      tables,\n      mainTableAlias,\n      allInputs,\n      cache\n    )\n  }\n\n  return resultPipeline\n}\n\n/**\n * Processes a single join clause\n */\nfunction processJoin(\n  pipeline: NamespacedAndKeyedStream,\n  joinClause: JoinClause,\n  tables: Record<string, KeyedStream>,\n  mainTableAlias: string,\n  allInputs: Record<string, KeyedStream>,\n  cache: QueryCache\n): NamespacedAndKeyedStream {\n  // Get the joined table alias and input stream\n  const { alias: joinedTableAlias, input: joinedInput } = processJoinSource(\n    joinClause.from,\n    allInputs,\n    cache\n  )\n\n  // Add the joined table to the tables map\n  tables[joinedTableAlias] = joinedInput\n\n  // Convert join type to D2 join type\n  const joinType: JoinType =\n    joinClause.type === `cross`\n      ? `inner`\n      : joinClause.type === `outer`\n        ? `full`\n        : (joinClause.type as JoinType)\n\n  // Pre-compile the join expressions\n  const compiledLeftExpr = compileExpression(joinClause.left)\n  const compiledRightExpr = compileExpression(joinClause.right)\n\n  // Prepare the main pipeline for joining\n  const mainPipeline = pipeline.pipe(\n    map(([currentKey, namespacedRow]) => {\n      // Extract the join key from the left side of the join condition\n      const leftKey = compiledLeftExpr(namespacedRow)\n\n      // Return [joinKey, [originalKey, namespacedRow]]\n      return [leftKey, [currentKey, namespacedRow]] as [\n        unknown,\n        [string, typeof namespacedRow],\n      ]\n    })\n  )\n\n  // Prepare the joined pipeline\n  const joinedPipeline = joinedInput.pipe(\n    map(([currentKey, row]) => {\n      // Wrap the row in a namespaced structure\n      const namespacedRow: NamespacedRow = { [joinedTableAlias]: row }\n\n      // Extract the join key from the right side of the join condition\n      const rightKey = compiledRightExpr(namespacedRow)\n\n      // Return [joinKey, [originalKey, namespacedRow]]\n      return [rightKey, [currentKey, namespacedRow]] as [\n        unknown,\n        [string, typeof namespacedRow],\n      ]\n    })\n  )\n\n  // Apply the join operation\n  if (![`inner`, `left`, `right`, `full`].includes(joinType)) {\n    throw new Error(`Unsupported join type: ${joinClause.type}`)\n  }\n  return mainPipeline.pipe(\n    joinOperator(joinedPipeline, joinType),\n    consolidate(),\n    processJoinResults(joinClause.type)\n  )\n}\n\n/**\n * Processes the join source (collection or sub-query)\n */\nfunction processJoinSource(\n  from: CollectionRef | QueryRef,\n  allInputs: Record<string, KeyedStream>,\n  cache: QueryCache\n): { alias: string; input: KeyedStream } {\n  switch (from.type) {\n    case `collectionRef`: {\n      const input = allInputs[from.collection.id]\n      if (!input) {\n        throw new Error(\n          `Input for collection \"${from.collection.id}\" not found in inputs map`\n        )\n      }\n      return { alias: from.alias, input }\n    }\n    case `queryRef`: {\n      // Recursively compile the sub-query with cache\n      const subQueryInput = compileQuery(from.query, allInputs, cache)\n\n      // Subqueries may return [key, [value, orderByIndex]] (with ORDER BY) or [key, value] (without ORDER BY)\n      // We need to extract just the value for use in parent queries\n      const extractedInput = subQueryInput.pipe(\n        map((data: any) => {\n          const [key, [value, _orderByIndex]] = data\n          return [key, value] as [unknown, any]\n        })\n      )\n\n      return { alias: from.alias, input: extractedInput as KeyedStream }\n    }\n    default:\n      throw new Error(`Unsupported join source type: ${(from as any).type}`)\n  }\n}\n\n/**\n * Processes the results of a join operation\n */\nfunction processJoinResults(joinType: string) {\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\n      filter((result) => {\n        const [_key, [main, joined]] = result\n        const mainNamespacedRow = main?.[1]\n        const joinedNamespacedRow = joined?.[1]\n\n        // Handle different join types\n        if (joinType === `inner`) {\n          return !!(mainNamespacedRow && joinedNamespacedRow)\n        }\n\n        if (joinType === `left`) {\n          return !!mainNamespacedRow\n        }\n\n        if (joinType === `right`) {\n          return !!joinedNamespacedRow\n        }\n\n        // For full joins, always include\n        return true\n      }),\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        // Merge the namespaced rows\n        const mergedNamespacedRow: NamespacedRow = {}\n\n        // Add main row data if it exists\n        if (mainNamespacedRow) {\n          Object.assign(mergedNamespacedRow, mainNamespacedRow)\n        }\n\n        // Add joined row data if it exists\n        if (joinedNamespacedRow) {\n          Object.assign(mergedNamespacedRow, joinedNamespacedRow)\n        }\n\n        // We create a composite key that combines the main and joined keys\n        const resultKey = `[${mainKey},${joinedKey}]`\n\n        return [resultKey, mergedNamespacedRow] as [string, NamespacedRow]\n      })\n    )\n  }\n}\n"],"names":["compileExpression","map","joinOperator","consolidate","compileQuery","filter"],"mappings":"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"}

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

@@ -0,0 +1,11 @@
+import { JoinClause, QueryIR } from '../ir.js';
+import { KeyedStream, NamespacedAndKeyedStream, ResultStream } from '../../types.js';
+/**
+ * Cache for compiled subqueries to avoid duplicate compilation
+ */
+type QueryCache = WeakMap<QueryIR, ResultStream>;
+/**
+ * Processes all join clauses in a query
+ */
+export declare function processJoins(pipeline: NamespacedAndKeyedStream, joinClauses: Array<JoinClause>, tables: Record<string, KeyedStream>, mainTableAlias: string, allInputs: Record<string, KeyedStream>, cache: QueryCache): NamespacedAndKeyedStream;
+export {};

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const d2mini = require("@electric-sql/d2mini");
+const evaluators = require("./evaluators.cjs");
+function processOrderBy(pipeline, orderByClause, limit, offset) {
+  const compiledOrderBy = orderByClause.map((clause) => ({
+    compiledExpression: evaluators.compileExpression(clause.expression),
+    direction: clause.direction
+  }));
+  const valueExtractor = (row) => {
+    const orderByContext = { ...row };
+    if (row.__select_results) {
+      Object.assign(orderByContext, row.__select_results);
+    }
+    if (orderByClause.length > 1) {
+      return compiledOrderBy.map(
+        (compiled) => compiled.compiledExpression(orderByContext)
+      );
+    } else if (orderByClause.length === 1) {
+      const compiled = compiledOrderBy[0];
+      return compiled.compiledExpression(orderByContext);
+    }
+    return null;
+  };
+  const ascComparator = (a, b) => {
+    if (a == null && b == null) return 0;
+    if (a == null) return -1;
+    if (b == null) return 1;
+    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;
+    }
+    if (a instanceof Date && b instanceof Date) {
+      return a.getTime() - b.getTime();
+    }
+    const bothObjects = typeof a === `object` && typeof b === `object`;
+    const notNull = a !== null && b !== null;
+    if (bothObjects && 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 = () => {
+    return (a, b) => {
+      if (orderByClause.length > 1) {
+        const arrayA = a;
+        const arrayB = b;
+        for (let i = 0; i < orderByClause.length; i++) {
+          const direction = orderByClause[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 (orderByClause.length === 1) {
+        const direction = orderByClause[0].direction;
+        return direction === `desc` ? descComparator(a, b) : ascComparator(a, b);
+      }
+      return ascComparator(a, b);
+    };
+  };
+  const comparator = makeComparator();
+  return pipeline.pipe(
+    d2mini.orderByWithFractionalIndex(valueExtractor, {
+      limit,
+      offset,
+      comparator
+    })
+    // orderByWithFractionalIndex returns [key, [value, index]] - we keep this format
+  );
+}
+exports.processOrderBy = processOrderBy;
+//# sourceMappingURL=order-by.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"order-by.cjs","sources":["../../../../src/query/compiler/order-by.ts"],"sourcesContent":["import { orderByWithFractionalIndex } from \"@electric-sql/d2mini\"\nimport { compileExpression } from \"./evaluators.js\"\nimport type { OrderByClause } from \"../ir.js\"\nimport type { NamespacedAndKeyedStream, NamespacedRow } from \"../../types.js\"\nimport type { IStreamBuilder, KeyValue } from \"@electric-sql/d2mini\"\n\n/**\n * Processes the ORDER BY clause\n * Works with the new structure that has both namespaced row data and __select_results\n * Always uses fractional indexing and adds the index as __ordering_index to the result\n */\nexport function processOrderBy(\n  pipeline: NamespacedAndKeyedStream,\n  orderByClause: Array<OrderByClause>,\n  limit?: number,\n  offset?: number\n): IStreamBuilder<KeyValue<unknown, [NamespacedRow, string]>> {\n  // Pre-compile all order by expressions\n  const compiledOrderBy = orderByClause.map((clause) => ({\n    compiledExpression: compileExpression(clause.expression),\n    direction: clause.direction,\n  }))\n\n  // Create a value extractor function for the orderBy operator\n  const valueExtractor = (row: NamespacedRow & { __select_results?: any }) => {\n    // For ORDER BY expressions, we need to provide access to both:\n    // 1. The original namespaced row data (for direct table column references)\n    // 2. The __select_results (for SELECT alias references)\n\n    // Create a merged context for expression evaluation\n    const orderByContext = { ...row }\n\n    // If there are select results, merge them at the top level for alias access\n    if (row.__select_results) {\n      // Add select results as top-level properties for alias access\n      Object.assign(orderByContext, row.__select_results)\n    }\n\n    if (orderByClause.length > 1) {\n      // For multiple orderBy columns, create a composite key\n      return compiledOrderBy.map((compiled) =>\n        compiled.compiledExpression(orderByContext)\n      )\n    } else if (orderByClause.length === 1) {\n      // For a single orderBy column, use the value directly\n      const compiled = compiledOrderBy[0]!\n      return compiled.compiledExpression(orderByContext)\n    }\n\n    // Default case - no ordering\n    return null\n  }\n\n  // Create comparator functions\n  const ascComparator = (a: any, b: any): number => {\n    // Handle null/undefined\n    if (a == null && b == null) return 0\n    if (a == null) return -1\n    if (b == null) return 1\n\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        const result = ascComparator(a[i], b[i])\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 both are dates, compare them\n    if (a instanceof Date && b instanceof Date) {\n      return a.getTime() - b.getTime()\n    }\n\n    // If at least one of the values is an object, convert to strings\n    const bothObjects = typeof a === `object` && typeof b === `object`\n    const notNull = a !== null && b !== null\n    if (bothObjects && notNull) {\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 = () => {\n    return (a: unknown, b: unknown) => {\n      // If we're comparing arrays (multiple properties), compare each property in order\n      if (orderByClause.length > 1) {\n        const arrayA = a as Array<unknown>\n        const arrayB = b as Array<unknown>\n        for (let i = 0; i < orderByClause.length; i++) {\n          const direction = orderByClause[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        return arrayA.length - arrayB.length\n      }\n\n      // Single property comparison\n      if (orderByClause.length === 1) {\n        const direction = orderByClause[0]!.direction\n        return direction === `desc` ? descComparator(a, b) : ascComparator(a, b)\n      }\n\n      return ascComparator(a, b)\n    }\n  }\n\n  const comparator = makeComparator()\n\n  // Use fractional indexing and return the tuple [value, index]\n  return pipeline.pipe(\n    orderByWithFractionalIndex(valueExtractor, {\n      limit,\n      offset,\n      comparator,\n    })\n    // orderByWithFractionalIndex returns [key, [value, index]] - we keep this format\n  )\n}\n"],"names":["compileExpression","orderByWithFractionalIndex"],"mappings":";;;;AAWO,SAAS,eACd,UACA,eACA,OACA,QAC4D;AAE5D,QAAM,kBAAkB,cAAc,IAAI,CAAC,YAAY;AAAA,IACrD,oBAAoBA,WAAAA,kBAAkB,OAAO,UAAU;AAAA,IACvD,WAAW,OAAO;AAAA,EAAA,EAClB;AAGI,QAAA,iBAAiB,CAAC,QAAoD;AAMpE,UAAA,iBAAiB,EAAE,GAAG,IAAI;AAGhC,QAAI,IAAI,kBAAkB;AAEjB,aAAA,OAAO,gBAAgB,IAAI,gBAAgB;AAAA,IAAA;AAGhD,QAAA,cAAc,SAAS,GAAG;AAE5B,aAAO,gBAAgB;AAAA,QAAI,CAAC,aAC1B,SAAS,mBAAmB,cAAc;AAAA,MAC5C;AAAA,IAAA,WACS,cAAc,WAAW,GAAG;AAE/B,YAAA,WAAW,gBAAgB,CAAC;AAC3B,aAAA,SAAS,mBAAmB,cAAc;AAAA,IAAA;AAI5C,WAAA;AAAA,EACT;AAGM,QAAA,gBAAgB,CAAC,GAAQ,MAAmB;AAEhD,QAAI,KAAK,QAAQ,KAAK,KAAa,QAAA;AAC/B,QAAA,KAAK,KAAa,QAAA;AAClB,QAAA,KAAK,KAAa,QAAA;AAGtB,QAAI,OAAO,MAAM,YAAY,OAAO,MAAM,UAAU;AAC3C,aAAA,EAAE,cAAc,CAAC;AAAA,IAAA;AAI1B,QAAI,MAAM,QAAQ,CAAC,KAAK,MAAM,QAAQ,CAAC,GAAG;AAC/B,eAAA,IAAI,GAAG,IAAI,KAAK,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK;AACrD,cAAM,SAAS,cAAc,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AACvC,YAAI,WAAW,GAAG;AACT,iBAAA;AAAA,QAAA;AAAA,MACT;AAGK,aAAA,EAAE,SAAS,EAAE;AAAA,IAAA;AAIlB,QAAA,aAAa,QAAQ,aAAa,MAAM;AAC1C,aAAO,EAAE,YAAY,EAAE,QAAQ;AAAA,IAAA;AAIjC,UAAM,cAAc,OAAO,MAAM,YAAY,OAAO,MAAM;AACpD,UAAA,UAAU,MAAM,QAAQ,MAAM;AACpC,QAAI,eAAe,SAAS;AAC1B,aAAO,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU;AAAA,IAAA;AAG5C,QAAA,IAAI,EAAU,QAAA;AACd,QAAA,IAAI,EAAU,QAAA;AACX,WAAA;AAAA,EACT;AAEM,QAAA,iBAAiB,CAAC,GAAY,MAAuB;AAClD,WAAA,cAAc,GAAG,CAAC;AAAA,EAC3B;AAGA,QAAM,iBAAiB,MAAM;AACpB,WAAA,CAAC,GAAY,MAAe;AAE7B,UAAA,cAAc,SAAS,GAAG;AAC5B,cAAM,SAAS;AACf,cAAM,SAAS;AACf,iBAAS,IAAI,GAAG,IAAI,cAAc,QAAQ,KAAK;AACvC,gBAAA,YAAY,cAAc,CAAC,EAAG;AAC9B,gBAAA,YACJ,cAAc,SAAS,iBAAiB;AAC1C,gBAAM,SAAS,UAAU,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC;AAC7C,cAAI,WAAW,GAAG;AACT,mBAAA;AAAA,UAAA;AAAA,QACT;AAEK,eAAA,OAAO,SAAS,OAAO;AAAA,MAAA;AAI5B,UAAA,cAAc,WAAW,GAAG;AACxB,cAAA,YAAY,cAAc,CAAC,EAAG;AAC7B,eAAA,cAAc,SAAS,eAAe,GAAG,CAAC,IAAI,cAAc,GAAG,CAAC;AAAA,MAAA;AAGlE,aAAA,cAAc,GAAG,CAAC;AAAA,IAC3B;AAAA,EACF;AAEA,QAAM,aAAa,eAAe;AAGlC,SAAO,SAAS;AAAA,IACdC,OAAAA,2BAA2B,gBAAgB;AAAA,MACzC;AAAA,MACA;AAAA,MACA;AAAA,IACD,CAAA;AAAA;AAAA,EAEH;AACF;;"}

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

@@ -0,0 +1,9 @@
+import { OrderByClause } from '../ir.js';
+import { NamespacedAndKeyedStream, NamespacedRow } from '../../types.js';
+import { IStreamBuilder, KeyValue } from '@electric-sql/d2mini';
+/**
+ * Processes the ORDER BY clause
+ * Works with the new structure that has both namespaced row data and __select_results
+ * Always uses fractional indexing and adds the index as __ordering_index to the result
+ */
+export declare function processOrderBy(pipeline: NamespacedAndKeyedStream, orderByClause: Array<OrderByClause>, limit?: number, offset?: number): IStreamBuilder<KeyValue<unknown, [NamespacedRow, string]>>;

package/dist/cjs/query/compiler/select.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const d2mini = require("@electric-sql/d2mini");
+const evaluators = require("./evaluators.cjs");
+function processSelectToResults(pipeline, select, _allInputs) {
+  const compiledSelect = [];
+  const spreadAliases = [];
+  for (const [alias, expression] of Object.entries(select)) {
+    if (alias.startsWith(`__SPREAD_SENTINEL__`)) {
+      const tableAlias = alias.replace(`__SPREAD_SENTINEL__`, ``);
+      spreadAliases.push(tableAlias);
+    } else {
+      if (isAggregateExpression(expression)) {
+        compiledSelect.push({
+          alias,
+          compiledExpression: () => null
+          // Placeholder - will be handled by GROUP BY
+        });
+      } else {
+        compiledSelect.push({
+          alias,
+          compiledExpression: evaluators.compileExpression(expression)
+        });
+      }
+    }
+  }
+  return pipeline.pipe(
+    d2mini.map(([key, namespacedRow]) => {
+      const selectResults = {};
+      for (const tableAlias of spreadAliases) {
+        const tableData = namespacedRow[tableAlias];
+        if (tableData && typeof tableData === `object`) {
+          for (const [fieldName, fieldValue] of Object.entries(tableData)) {
+            if (!(fieldName in selectResults)) {
+              selectResults[fieldName] = fieldValue;
+            }
+          }
+        }
+      }
+      for (const { alias, compiledExpression } of compiledSelect) {
+        selectResults[alias] = compiledExpression(namespacedRow);
+      }
+      return [
+        key,
+        {
+          ...namespacedRow,
+          __select_results: selectResults
+        }
+      ];
+    })
+  );
+}
+function isAggregateExpression(expr) {
+  return expr.type === `agg`;
+}
+exports.processSelectToResults = processSelectToResults;
+//# sourceMappingURL=select.cjs.map

package/dist/cjs/query/compiler/select.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.cjs","sources":["../../../../src/query/compiler/select.ts"],"sourcesContent":["import { map } from \"@electric-sql/d2mini\"\nimport { compileExpression } from \"./evaluators.js\"\nimport type { Aggregate, BasicExpression, Select } from \"../ir.js\"\nimport type {\n  KeyedStream,\n  NamespacedAndKeyedStream,\n  NamespacedRow,\n} from \"../../types.js\"\n\n/**\n * Processes the SELECT clause and places results in __select_results\n * while preserving the original namespaced row for ORDER BY access\n */\nexport function processSelectToResults(\n  pipeline: NamespacedAndKeyedStream,\n  select: Select,\n  _allInputs: Record<string, KeyedStream>\n): NamespacedAndKeyedStream {\n  // Pre-compile all select expressions\n  const compiledSelect: Array<{\n    alias: string\n    compiledExpression: (row: NamespacedRow) => any\n  }> = []\n  const spreadAliases: Array<string> = []\n\n  for (const [alias, expression] of Object.entries(select)) {\n    if (alias.startsWith(`__SPREAD_SENTINEL__`)) {\n      // Extract the table alias from the sentinel key\n      const tableAlias = alias.replace(`__SPREAD_SENTINEL__`, ``)\n      spreadAliases.push(tableAlias)\n    } else {\n      if (isAggregateExpression(expression)) {\n        // For aggregates, we'll store the expression info for GROUP BY processing\n        // but still compile a placeholder that will be replaced later\n        compiledSelect.push({\n          alias,\n          compiledExpression: () => null, // Placeholder - will be handled by GROUP BY\n        })\n      } else {\n        compiledSelect.push({\n          alias,\n          compiledExpression: compileExpression(expression as BasicExpression),\n        })\n      }\n    }\n  }\n\n  return pipeline.pipe(\n    map(([key, namespacedRow]) => {\n      const selectResults: Record<string, any> = {}\n\n      // First pass: spread table data for any spread sentinels\n      for (const tableAlias of spreadAliases) {\n        const tableData = namespacedRow[tableAlias]\n        if (tableData && typeof tableData === `object`) {\n          // Spread the table data into the result, but don't overwrite explicit fields\n          for (const [fieldName, fieldValue] of Object.entries(tableData)) {\n            if (!(fieldName in selectResults)) {\n              selectResults[fieldName] = fieldValue\n            }\n          }\n        }\n      }\n\n      // Second pass: evaluate all compiled select expressions (non-aggregates)\n      for (const { alias, compiledExpression } of compiledSelect) {\n        selectResults[alias] = compiledExpression(namespacedRow)\n      }\n\n      // Return the namespaced row with __select_results added\n      return [\n        key,\n        {\n          ...namespacedRow,\n          __select_results: selectResults,\n        },\n      ] as [\n        string,\n        typeof namespacedRow & { __select_results: typeof selectResults },\n      ]\n    })\n  )\n}\n\n/**\n * Processes the SELECT clause (legacy function - kept for compatibility)\n */\nexport function processSelect(\n  pipeline: NamespacedAndKeyedStream,\n  select: Select,\n  _allInputs: Record<string, KeyedStream>\n): KeyedStream {\n  // Pre-compile all select expressions\n  const compiledSelect: Array<{\n    alias: string\n    compiledExpression: (row: NamespacedRow) => any\n  }> = []\n  const spreadAliases: Array<string> = []\n\n  for (const [alias, expression] of Object.entries(select)) {\n    if (alias.startsWith(`__SPREAD_SENTINEL__`)) {\n      // Extract the table alias from the sentinel key\n      const tableAlias = alias.replace(`__SPREAD_SENTINEL__`, ``)\n      spreadAliases.push(tableAlias)\n    } else {\n      if (isAggregateExpression(expression)) {\n        // Aggregates should be handled by GROUP BY processing, not here\n        throw new Error(\n          `Aggregate expressions in SELECT clause should be handled by GROUP BY processing`\n        )\n      }\n      compiledSelect.push({\n        alias,\n        compiledExpression: compileExpression(expression as BasicExpression),\n      })\n    }\n  }\n\n  return pipeline.pipe(\n    map(([key, namespacedRow]) => {\n      const result: Record<string, any> = {}\n\n      // First pass: spread table data for any spread sentinels\n      for (const tableAlias of spreadAliases) {\n        const tableData = namespacedRow[tableAlias]\n        if (tableData && typeof tableData === `object`) {\n          // Spread the table data into the result, but don't overwrite explicit fields\n          for (const [fieldName, fieldValue] of Object.entries(tableData)) {\n            if (!(fieldName in result)) {\n              result[fieldName] = fieldValue\n            }\n          }\n        }\n      }\n\n      // Second pass: evaluate all compiled select expressions\n      for (const { alias, compiledExpression } of compiledSelect) {\n        result[alias] = compiledExpression(namespacedRow)\n      }\n\n      return [key, result] as [string, typeof result]\n    })\n  )\n}\n\n/**\n * Helper function to check if an expression is an aggregate\n */\nfunction isAggregateExpression(\n  expr: BasicExpression | Aggregate\n): expr is Aggregate {\n  return expr.type === `agg`\n}\n\n/**\n * Processes a single argument in a function context\n */\nexport function processArgument(\n  arg: BasicExpression | Aggregate,\n  namespacedRow: NamespacedRow\n): any {\n  if (isAggregateExpression(arg)) {\n    throw new Error(\n      `Aggregate expressions are not supported in this context. Use GROUP BY clause for aggregates.`\n    )\n  }\n\n  // Pre-compile the expression and evaluate immediately\n  const compiledExpression = compileExpression(arg)\n  const value = compiledExpression(namespacedRow)\n\n  return value\n}\n"],"names":["compileExpression","map"],"mappings":";;;;AAagB,SAAA,uBACd,UACA,QACA,YAC0B;AAE1B,QAAM,iBAGD,CAAC;AACN,QAAM,gBAA+B,CAAC;AAEtC,aAAW,CAAC,OAAO,UAAU,KAAK,OAAO,QAAQ,MAAM,GAAG;AACpD,QAAA,MAAM,WAAW,qBAAqB,GAAG;AAE3C,YAAM,aAAa,MAAM,QAAQ,uBAAuB,EAAE;AAC1D,oBAAc,KAAK,UAAU;AAAA,IAAA,OACxB;AACD,UAAA,sBAAsB,UAAU,GAAG;AAGrC,uBAAe,KAAK;AAAA,UAClB;AAAA,UACA,oBAAoB,MAAM;AAAA;AAAA,QAAA,CAC3B;AAAA,MAAA,OACI;AACL,uBAAe,KAAK;AAAA,UAClB;AAAA,UACA,oBAAoBA,6BAAkB,UAA6B;AAAA,QAAA,CACpE;AAAA,MAAA;AAAA,IACH;AAAA,EACF;AAGF,SAAO,SAAS;AAAA,IACdC,OAAAA,IAAI,CAAC,CAAC,KAAK,aAAa,MAAM;AAC5B,YAAM,gBAAqC,CAAC;AAG5C,iBAAW,cAAc,eAAe;AAChC,cAAA,YAAY,cAAc,UAAU;AACtC,YAAA,aAAa,OAAO,cAAc,UAAU;AAE9C,qBAAW,CAAC,WAAW,UAAU,KAAK,OAAO,QAAQ,SAAS,GAAG;AAC3D,gBAAA,EAAE,aAAa,gBAAgB;AACjC,4BAAc,SAAS,IAAI;AAAA,YAAA;AAAA,UAC7B;AAAA,QACF;AAAA,MACF;AAIF,iBAAW,EAAE,OAAO,mBAAmB,KAAK,gBAAgB;AAC5C,sBAAA,KAAK,IAAI,mBAAmB,aAAa;AAAA,MAAA;AAIlD,aAAA;AAAA,QACL;AAAA,QACA;AAAA,UACE,GAAG;AAAA,UACH,kBAAkB;AAAA,QAAA;AAAA,MAEtB;AAAA,IAID,CAAA;AAAA,EACH;AACF;AAkEA,SAAS,sBACP,MACmB;AACnB,SAAO,KAAK,SAAS;AACvB;;"}

package/dist/cjs/query/compiler/select.d.cts

@@ -0,0 +1,15 @@
+import { Aggregate, BasicExpression, Select } from '../ir.js';
+import { KeyedStream, NamespacedAndKeyedStream, NamespacedRow } from '../../types.js';
+/**
+ * Processes the SELECT clause and places results in __select_results
+ * while preserving the original namespaced row for ORDER BY access
+ */
+export declare function processSelectToResults(pipeline: NamespacedAndKeyedStream, select: Select, _allInputs: Record<string, KeyedStream>): NamespacedAndKeyedStream;
+/**
+ * Processes the SELECT clause (legacy function - kept for compatibility)
+ */
+export declare function processSelect(pipeline: NamespacedAndKeyedStream, select: Select, _allInputs: Record<string, KeyedStream>): KeyedStream;
+/**
+ * Processes a single argument in a function context
+ */
+export declare function processArgument(arg: BasicExpression | Aggregate, namespacedRow: NamespacedRow): any;

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

@@ -1,5 +1,5 @@
-export * from './query-builder.js';
-export * from './compiled-query.js';
-export * from './pipeline-compiler.js';
-export * from './schema.js';
-export * from './types.js';
+export { BaseQueryBuilder, Query, type InitialQueryBuilder, type QueryBuilder, type Context, type Source, type GetResult, } from './builder/index.js';
+export { eq, gt, gte, lt, lte, and, or, not, inArray, like, ilike, upper, lower, length, concat, coalesce, add, count, avg, sum, min, max, } from './builder/functions.js';
+export type { Ref } from './builder/types.js';
+export { compileQuery } from './compiler/index.js';
+export { createLiveQueryCollection, liveQueryCollectionOptions, type LiveQueryCollectionConfig, } from './live-query-collection.js';

package/dist/cjs/query/ir.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class BaseExpression {
+}
+class CollectionRef extends BaseExpression {
+  constructor(collection, alias) {
+    super();
+    this.collection = collection;
+    this.alias = alias;
+    this.type = `collectionRef`;
+  }
+}
+class QueryRef extends BaseExpression {
+  constructor(query, alias) {
+    super();
+    this.query = query;
+    this.alias = alias;
+    this.type = `queryRef`;
+  }
+}
+class PropRef extends BaseExpression {
+  constructor(path) {
+    super();
+    this.path = path;
+    this.type = `ref`;
+  }
+}
+class Value extends BaseExpression {
+  constructor(value) {
+    super();
+    this.value = value;
+    this.type = `val`;
+  }
+}
+class Func extends BaseExpression {
+  constructor(name, args) {
+    super();
+    this.name = name;
+    this.args = args;
+    this.type = `func`;
+  }
+}
+class Aggregate extends BaseExpression {
+  constructor(name, args) {
+    super();
+    this.name = name;
+    this.args = args;
+    this.type = `agg`;
+  }
+}
+exports.Aggregate = Aggregate;
+exports.CollectionRef = CollectionRef;
+exports.Func = Func;
+exports.PropRef = PropRef;
+exports.QueryRef = QueryRef;
+exports.Value = Value;
+//# sourceMappingURL=ir.cjs.map