@tanstack/db 0.0.1

package/dist/cjs/query/joins.cjs

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const d2ts = require("@electric-sql/d2ts");
+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 mainPipeline = pipeline.pipe(
+      d2ts.map((nestedRow) => {
+        const mainRow = nestedRow[mainTableAlias];
+        const keyValue = extractors.extractJoinKey(
+          mainRow,
+          joinClause.on[0],
+          mainTableAlias
+        );
+        return [keyValue, nestedRow];
+      })
+    );
+    let joinedTableInput;
+    if (allInputs[joinClause.from]) {
+      joinedTableInput = allInputs[joinClause.from];
+    } else {
+      joinedTableInput = input.graph.newInput();
+    }
+    tables[joinedTableAlias] = joinedTableInput;
+    const joinedPipeline = joinedTableInput.pipe(
+      d2ts.map((row) => {
+        const nestedRow = { [joinedTableAlias]: row };
+        const keyValue = extractors.extractJoinKey(row, joinClause.on[2], joinedTableAlias);
+        return [keyValue, nestedRow];
+      })
+    );
+    switch (joinType) {
+      case `inner`:
+        pipeline = mainPipeline.pipe(
+          d2ts.join(joinedPipeline, `inner`),
+          d2ts.consolidate(),
+          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
+        );
+        break;
+      case `left`:
+        pipeline = mainPipeline.pipe(
+          d2ts.join(joinedPipeline, `left`),
+          d2ts.consolidate(),
+          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
+        );
+        break;
+      case `right`:
+        pipeline = mainPipeline.pipe(
+          d2ts.join(joinedPipeline, `right`),
+          d2ts.consolidate(),
+          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
+        );
+        break;
+      case `full`:
+        pipeline = mainPipeline.pipe(
+          d2ts.join(joinedPipeline, `full`),
+          d2ts.consolidate(),
+          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
+        );
+        break;
+      default:
+        pipeline = mainPipeline.pipe(
+          d2ts.join(joinedPipeline, `inner`),
+          d2ts.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
+      d2ts.map((result) => {
+        const [_key, [mainNestedRow, joinedNestedRow]] = result;
+        if (joinClause.type === `inner` || joinClause.type === `cross`) {
+          if (!mainNestedRow || !joinedNestedRow) {
+            return void 0;
+          }
+        }
+        if (joinClause.type === `left` && !mainNestedRow) {
+          return void 0;
+        }
+        if (joinClause.type === `right` && !joinedNestedRow) {
+          return void 0;
+        }
+        const mergedNestedRow = {};
+        if (mainNestedRow) {
+          Object.entries(mainNestedRow).forEach(([tableAlias, tableData]) => {
+            mergedNestedRow[tableAlias] = tableData;
+          });
+        }
+        if (joinedNestedRow) {
+          Object.entries(joinedNestedRow).forEach(([tableAlias, tableData]) => {
+            mergedNestedRow[tableAlias] = tableData;
+          });
+        } else if (joinClause.type === `left` || joinClause.type === `full`) {
+          mergedNestedRow[joinedTableAlias] = null;
+        }
+        if (!mainNestedRow && (joinClause.type === `right` || joinClause.type === `full`)) {
+          mergedNestedRow[mainTableAlias] = null;
+        }
+        return mergedNestedRow;
+      }),
+      // Filter out undefined results
+      d2ts.filter(
+        (value) => value !== void 0
+      ),
+      // Process the ON condition
+      d2ts.filter((nestedRow) => {
+        if (!joinClause.on || joinClause.type === `cross`) {
+          return true;
+        }
+        if (joinClause.type === `left` && nestedRow[joinedTableAlias] === null) {
+          return true;
+        }
+        if (joinClause.type === `right` && nestedRow[mainTableAlias] === null) {
+          return true;
+        }
+        if (joinClause.type === `full` && (nestedRow[mainTableAlias] === null || nestedRow[joinedTableAlias] === null)) {
+          return true;
+        }
+        const result = evaluators.evaluateConditionOnNestedRow(
+          nestedRow,
+          joinClause.on,
+          mainTableAlias,
+          joinedTableAlias
+        );
+        return result;
+      }),
+      // Process the WHERE clause for the join if it exists
+      d2ts.filter((nestedRow) => {
+        if (!joinClause.where) {
+          return true;
+        }
+        const result = evaluators.evaluateConditionOnNestedRow(
+          nestedRow,
+          joinClause.where,
+          mainTableAlias,
+          joinedTableAlias
+        );
+        return result;
+      })
+    );
+  };
+}
+exports.processJoinClause = processJoinClause;
+exports.processJoinResults = processJoinResults;
+//# sourceMappingURL=joins.cjs.map

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

@@ -0,0 +1 @@
+{"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/d2ts\"\nimport { evaluateConditionOnNestedRow } from \"./evaluators.js\"\nimport { extractJoinKey } from \"./extractors.js\"\nimport type { Query } from \"./index.js\"\nimport type { IStreamBuilder, JoinType } from \"@electric-sql/d2ts\"\n\n/**\n * Creates a processing pipeline for join clauses\n */\nexport function processJoinClause(\n  pipeline: IStreamBuilder<Record<string, unknown>>,\n  query: Query,\n  tables: Record<string, IStreamBuilder<Record<string, unknown>>>,\n  mainTableAlias: string,\n  allInputs: Record<string, IStreamBuilder<Record<string, unknown>>>\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    // 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((nestedRow: Record<string, unknown>) => {\n        // Extract the key from the ON condition left side for the main table\n        const mainRow = nestedRow[mainTableAlias] as Record<string, unknown>\n\n        // Extract the join key from the main row\n        const keyValue = extractJoinKey(\n          mainRow,\n          joinClause.on[0],\n          mainTableAlias\n        )\n\n        // Return [key, nestedRow] as a KeyValue type\n        return [keyValue, nestedRow] as [unknown, Record<string, unknown>]\n      })\n    )\n\n    // Get the joined table input from the inputs map\n    let joinedTableInput: IStreamBuilder<Record<string, unknown>>\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 = input!.graph.newInput<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((row: Record<string, unknown>) => {\n        // Wrap the row in an object with the table alias as the key\n        const nestedRow = { [joinedTableAlias]: row }\n\n        // Extract the key from the ON condition right side for the joined table\n        const keyValue = extractJoinKey(row, joinClause.on[2], joinedTableAlias)\n\n        // Return [key, nestedRow] as a KeyValue type\n        return [keyValue, nestedRow] as [unknown, Record<string, unknown>]\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; where?: any; type: string }\n) {\n  return function (\n    pipeline: IStreamBuilder<unknown>\n  ): IStreamBuilder<Record<string, unknown>> {\n    return pipeline.pipe(\n      // Process the join result and handle nulls in the same step\n      map((result: unknown) => {\n        const [_key, [mainNestedRow, joinedNestedRow]] = result as [\n          unknown,\n          [\n            Record<string, unknown> | undefined,\n            Record<string, unknown> | undefined,\n          ],\n        ]\n\n        // For inner joins, both sides should be non-null\n        if (joinClause.type === `inner` || joinClause.type === `cross`) {\n          if (!mainNestedRow || !joinedNestedRow) {\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` && !mainNestedRow) {\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` && !joinedNestedRow) {\n          return undefined // Will be filtered out\n        }\n\n        // Merge the nested rows\n        const mergedNestedRow: Record<string, unknown> = {}\n\n        // Add main row data if it exists\n        if (mainNestedRow) {\n          Object.entries(mainNestedRow).forEach(([tableAlias, tableData]) => {\n            mergedNestedRow[tableAlias] = tableData\n          })\n        }\n\n        // If we have a joined row, add it to the merged result\n        if (joinedNestedRow) {\n          Object.entries(joinedNestedRow).forEach(([tableAlias, tableData]) => {\n            mergedNestedRow[tableAlias] = tableData\n          })\n        } else if (joinClause.type === `left` || joinClause.type === `full`) {\n          // For left or full joins, add the joined table with null data if missing\n          mergedNestedRow[joinedTableAlias] = null\n        }\n\n        // For right or full joins, add the main table with null data if missing\n        if (\n          !mainNestedRow &&\n          (joinClause.type === `right` || joinClause.type === `full`)\n        ) {\n          mergedNestedRow[mainTableAlias] = null\n        }\n\n        return mergedNestedRow\n      }),\n      // Filter out undefined results\n      filter(\n        (value: unknown): value is Record<string, unknown> =>\n          value !== undefined\n      ),\n      // Process the ON condition\n      filter((nestedRow: Record<string, unknown>) => {\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          nestedRow[joinedTableAlias] === null\n        ) {\n          return true\n        }\n\n        // For RIGHT JOIN, if the left side is null, we should include the row\n        if (joinClause.type === `right` && nestedRow[mainTableAlias] === null) {\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          (nestedRow[mainTableAlias] === null ||\n            nestedRow[joinedTableAlias] === null)\n        ) {\n          return true\n        }\n\n        const result = evaluateConditionOnNestedRow(\n          nestedRow,\n          joinClause.on,\n          mainTableAlias,\n          joinedTableAlias\n        )\n        return result\n      }),\n      // Process the WHERE clause for the join if it exists\n      filter((nestedRow: Record<string, unknown>) => {\n        if (!joinClause.where) {\n          return true\n        }\n\n        const result = evaluateConditionOnNestedRow(\n          nestedRow,\n          joinClause.where,\n          mainTableAlias,\n          joinedTableAlias\n        )\n        return result\n      })\n    )\n  }\n}\n"],"names":["map","extractJoinKey","joinOperator","consolidate","filter","evaluateConditionOnNestedRow"],"mappings":"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"}

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

@@ -0,0 +1,14 @@
+import { Query } from './index.js';
+import { IStreamBuilder } from '@electric-sql/d2ts';
+/**
+ * Creates a processing pipeline for join clauses
+ */
+export declare function processJoinClause(pipeline: IStreamBuilder<Record<string, unknown>>, query: Query, tables: Record<string, IStreamBuilder<Record<string, unknown>>>, mainTableAlias: string, allInputs: Record<string, IStreamBuilder<Record<string, unknown>>>): IStreamBuilder<Record<string, unknown>>;
+/**
+ * Creates a processing pipeline for join results
+ */
+export declare function processJoinResults(mainTableAlias: string, joinedTableAlias: string, joinClause: {
+    on: any;
+    where?: any;
+    type: string;
+}): (pipeline: IStreamBuilder<unknown>) => IStreamBuilder<Record<string, unknown>>;

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const d2ts = require("@electric-sql/d2ts");
+function processKeyBy(resultPipeline, query) {
+  if (!query.keyBy) {
+    return resultPipeline;
+  }
+  const keyByParam = query.keyBy;
+  resultPipeline = resultPipeline.pipe(
+    d2ts.keyBy((row) => {
+      if (Array.isArray(keyByParam)) {
+        const keyValues = {};
+        for (const keyColumn of keyByParam) {
+          const columnName = keyColumn.startsWith(`@`) ? keyColumn.substring(1) : keyColumn;
+          if (columnName in row) {
+            keyValues[columnName] = row[columnName];
+          } else {
+            throw new Error(
+              `Key column "${columnName}" not found in result set. Make sure it's included in the select clause.`
+            );
+          }
+        }
+        return JSON.stringify(keyValues);
+      } else {
+        const columnName = keyByParam.startsWith(`@`) ? keyByParam.substring(1) : keyByParam;
+        if (!(columnName in row)) {
+          throw new Error(
+            `Key column "${columnName}" not found in result set. Make sure it's included in the select clause.`
+          );
+        }
+        const keyValue = row[columnName];
+        if (typeof keyValue === `string` || typeof keyValue === `number`) {
+          return keyValue;
+        } else {
+          return JSON.stringify(keyValue);
+        }
+      }
+    })
+  );
+  return resultPipeline;
+}
+exports.processKeyBy = processKeyBy;
+//# sourceMappingURL=key-by.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"key-by.cjs","sources":["../../../src/query/key-by.ts"],"sourcesContent":["import { keyBy } from \"@electric-sql/d2ts\"\nimport type { IStreamBuilder } from \"@electric-sql/d2ts\"\nimport type { Query } from \"./schema\"\n\nexport function processKeyBy(\n  resultPipeline: IStreamBuilder<\n    Record<string, unknown> | [string | number, Record<string, unknown>]\n  >,\n  query: Query\n) {\n  if (!query.keyBy) {\n    return resultPipeline\n  }\n  const keyByParam = query.keyBy\n\n  resultPipeline = resultPipeline.pipe(\n    keyBy((row: Record<string, unknown>) => {\n      if (Array.isArray(keyByParam)) {\n        // Multiple columns - extract values and JSON stringify\n        const keyValues: Record<string, unknown> = {}\n        for (const keyColumn of keyByParam) {\n          // Remove @ prefix if present\n          const columnName = (keyColumn as string).startsWith(`@`)\n            ? (keyColumn as string).substring(1)\n            : (keyColumn as string)\n\n          if (columnName in row) {\n            keyValues[columnName] = row[columnName]\n          } else {\n            throw new Error(\n              `Key column \"${columnName}\" not found in result set. Make sure it's included in the select clause.`\n            )\n          }\n        }\n        return JSON.stringify(keyValues)\n      } else {\n        // Single column\n        // Remove @ prefix if present\n        const columnName = (keyByParam as string).startsWith(`@`)\n          ? (keyByParam as string).substring(1)\n          : (keyByParam as string)\n\n        if (!(columnName in row)) {\n          throw new Error(\n            `Key column \"${columnName}\" not found in result set. Make sure it's included in the select clause.`\n          )\n        }\n\n        const keyValue = row[columnName]\n        // Use the value directly if it's a string or number, otherwise JSON stringify\n        if (typeof keyValue === `string` || typeof keyValue === `number`) {\n          return keyValue\n        } else {\n          return JSON.stringify(keyValue)\n        }\n      }\n    })\n  )\n\n  return resultPipeline\n}\n"],"names":["keyBy"],"mappings":";;;AAIgB,SAAA,aACd,gBAGA,OACA;AACI,MAAA,CAAC,MAAM,OAAO;AACT,WAAA;AAAA,EAAA;AAET,QAAM,aAAa,MAAM;AAEzB,mBAAiB,eAAe;AAAA,IAC9BA,KAAA,MAAM,CAAC,QAAiC;AAClC,UAAA,MAAM,QAAQ,UAAU,GAAG;AAE7B,cAAM,YAAqC,CAAC;AAC5C,mBAAW,aAAa,YAAY;AAE5B,gBAAA,aAAc,UAAqB,WAAW,GAAG,IAClD,UAAqB,UAAU,CAAC,IAChC;AAEL,cAAI,cAAc,KAAK;AACX,sBAAA,UAAU,IAAI,IAAI,UAAU;AAAA,UAAA,OACjC;AACL,kBAAM,IAAI;AAAA,cACR,eAAe,UAAU;AAAA,YAC3B;AAAA,UAAA;AAAA,QACF;AAEK,eAAA,KAAK,UAAU,SAAS;AAAA,MAAA,OAC1B;AAGC,cAAA,aAAc,WAAsB,WAAW,GAAG,IACnD,WAAsB,UAAU,CAAC,IACjC;AAED,YAAA,EAAE,cAAc,MAAM;AACxB,gBAAM,IAAI;AAAA,YACR,eAAe,UAAU;AAAA,UAC3B;AAAA,QAAA;AAGI,cAAA,WAAW,IAAI,UAAU;AAE/B,YAAI,OAAO,aAAa,YAAY,OAAO,aAAa,UAAU;AACzD,iBAAA;AAAA,QAAA,OACF;AACE,iBAAA,KAAK,UAAU,QAAQ;AAAA,QAAA;AAAA,MAChC;AAAA,IAEH,CAAA;AAAA,EACH;AAEO,SAAA;AACT;;"}

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

@@ -0,0 +1,3 @@
+import { IStreamBuilder } from '@electric-sql/d2ts';
+import { Query } from './schema.cjs';
+export declare function processKeyBy(resultPipeline: IStreamBuilder<Record<string, unknown> | [string | number, Record<string, unknown>]>, query: Query): IStreamBuilder<Record<string, unknown> | [string | number, Record<string, unknown>]>;

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

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const d2ts = require("@electric-sql/d2ts");
+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 = (value) => {
+    const row = value;
+    const nestedRow = { [mainTableAlias]: row };
+    if (orderByItems.length > 1) {
+      return orderByItems.map((item) => {
+        const val = extractors.evaluateOperandOnNestedRow(
+          nestedRow,
+          item.operand,
+          mainTableAlias
+        );
+        return item.direction === `desc` && typeof val === `number` ? -val : item.direction === `desc` && typeof val === `string` ? String.fromCharCode(
+          ...[...val].map((c) => 65535 - c.charCodeAt(0))
+        ) : val;
+      });
+    } else if (orderByItems.length === 1) {
+      const item = orderByItems[0];
+      const val = extractors.evaluateOperandOnNestedRow(
+        nestedRow,
+        item.operand,
+        mainTableAlias
+      );
+      return item.direction === `desc` && typeof val === `number` ? -val : item.direction === `desc` && typeof val === `string` ? String.fromCharCode(
+        ...[...val].map((c) => 65535 - c.charCodeAt(0))
+      ) : val;
+    }
+    return null;
+  };
+  const comparator = (a, b) => {
+    if (typeof a === `number` && typeof b === `number`) {
+      return a - b;
+    }
+    if (typeof a === `string` && typeof b === `string`) {
+      return a.localeCompare(b);
+    }
+    if (typeof a === `boolean` && typeof b === `boolean`) {
+      return a === b ? 0 : a ? 1 : -1;
+    }
+    if (a instanceof Date && b instanceof Date) {
+      return a.getTime() - b.getTime();
+    }
+    if (a === null || b === null) {
+      return 0;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+      for (let i = 0; i < Math.min(a.length, b.length); i++) {
+        const aVal = a[i];
+        const bVal = b[i];
+        let result;
+        if (typeof aVal === `boolean` && typeof bVal === `boolean`) {
+          result = aVal === bVal ? 0 : aVal ? 1 : -1;
+        } else if (typeof aVal === `number` && typeof bVal === `number`) {
+          result = aVal - bVal;
+        } else if (typeof aVal === `string` && typeof bVal === `string`) {
+          result = aVal.localeCompare(bVal);
+        } else {
+          result = comparator(aVal, bVal);
+        }
+        if (result !== 0) {
+          return result;
+        }
+      }
+      return a.length - b.length;
+    }
+    if (a == null && b == null) {
+      return 0;
+    }
+    return a.toString().localeCompare(b.toString());
+  };
+  let topKComparator;
+  if (!query.keyBy) {
+    topKComparator = (a, b) => {
+      const aValue = valueExtractor(a);
+      const bValue = valueExtractor(b);
+      return comparator(aValue, bValue);
+    };
+  }
+  if (hasOrderIndexColumn) {
+    if (orderIndexType === `numeric`) {
+      if (query.keyBy) {
+        resultPipeline = resultPipeline.pipe(
+          d2ts.orderByWithIndex(valueExtractor, {
+            limit: query.limit,
+            offset: query.offset,
+            comparator
+          }),
+          d2ts.map(([key, [value, index]]) => {
+            const result = {
+              ...value,
+              [orderIndexAlias]: index
+            };
+            return [key, result];
+          })
+        );
+      } else {
+        resultPipeline = resultPipeline.pipe(
+          d2ts.map((value) => [null, value]),
+          d2ts.topKWithIndex(topKComparator, {
+            limit: query.limit,
+            offset: query.offset
+          }),
+          d2ts.map(([_, [value, index]]) => {
+            return {
+              ...value,
+              [orderIndexAlias]: index
+            };
+          })
+        );
+      }
+    } else {
+      if (query.keyBy) {
+        resultPipeline = resultPipeline.pipe(
+          d2ts.orderByWithFractionalIndex(valueExtractor, {
+            limit: query.limit,
+            offset: query.offset,
+            comparator
+          }),
+          d2ts.map(([key, [value, index]]) => {
+            const result = {
+              ...value,
+              [orderIndexAlias]: index
+            };
+            return [key, result];
+          })
+        );
+      } else {
+        resultPipeline = resultPipeline.pipe(
+          d2ts.map((value) => [null, value]),
+          d2ts.topKWithFractionalIndex(topKComparator, {
+            limit: query.limit,
+            offset: query.offset
+          }),
+          d2ts.map(([_, [value, index]]) => {
+            return {
+              ...value,
+              [orderIndexAlias]: index
+            };
+          })
+        );
+      }
+    }
+  } else {
+    if (query.keyBy) {
+      resultPipeline = resultPipeline.pipe(
+        d2ts.orderBy(valueExtractor, {
+          limit: query.limit,
+          offset: query.offset,
+          comparator
+        })
+      );
+    } else {
+      resultPipeline = resultPipeline.pipe(
+        d2ts.map((value) => [null, value]),
+        d2ts.topK(topKComparator, {
+          limit: query.limit,
+          offset: query.offset
+        }),
+        d2ts.map(([_, value]) => value)
+      );
+    }
+  }
+  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

@@ -0,0 +1 @@
+{"version":3,"file":"order-by.cjs","sources":["../../../src/query/order-by.ts"],"sourcesContent":["import {\n  map,\n  orderBy,\n  orderByWithFractionalIndex,\n  orderByWithIndex,\n  topK,\n  topKWithFractionalIndex,\n  topKWithIndex,\n} from \"@electric-sql/d2ts\"\nimport { evaluateOperandOnNestedRow } from \"./extractors\"\nimport { isOrderIndexFunctionCall } from \"./utils\"\nimport type { ConditionOperand, Query } from \"./schema\"\nimport type { IStreamBuilder } from \"@electric-sql/d2ts\"\n\nexport function processOrderBy(\n  resultPipeline: IStreamBuilder<\n    Record<string, unknown> | [string | number, Record<string, unknown>]\n  >,\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  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: Array<{\n    operand: ConditionOperand\n    direction: `asc` | `desc`\n  }> = []\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 = (value: unknown) => {\n    const row = value as Record<string, unknown>\n\n    // Create a nested row structure for evaluateOperandOnNestedRow\n    const nestedRow: Record<string, unknown> = { [mainTableAlias]: row }\n\n    // For multiple orderBy columns, create a composite key\n    if (orderByItems.length > 1) {\n      return orderByItems.map((item) => {\n        const val = evaluateOperandOnNestedRow(\n          nestedRow,\n          item.operand,\n          mainTableAlias\n        )\n\n        // Reverse the value for 'desc' ordering\n        return item.direction === `desc` && typeof val === `number`\n          ? -val\n          : item.direction === `desc` && typeof val === `string`\n            ? String.fromCharCode(\n                ...[...val].map((c) => 0xffff - c.charCodeAt(0))\n              )\n            : val\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 = evaluateOperandOnNestedRow(\n        nestedRow,\n        item!.operand,\n        mainTableAlias\n      )\n\n      // Reverse the value for 'desc' ordering\n      return item!.direction === `desc` && typeof val === `number`\n        ? -val\n        : item!.direction === `desc` && typeof val === `string`\n          ? String.fromCharCode(\n              ...[...val].map((c) => 0xffff - c.charCodeAt(0))\n            )\n          : val\n    }\n\n    // Default case - no ordering\n    return null\n  }\n\n  const comparator = (a: unknown, b: unknown): number => {\n    // if a and b are both numbers compare them directly\n    if (typeof a === `number` && typeof b === `number`) {\n      return a - b\n    }\n    // if a and b are both strings, compare them lexicographically\n    if (typeof a === `string` && typeof b === `string`) {\n      return a.localeCompare(b)\n    }\n    // if a and b are both booleans, compare them\n    if (typeof a === `boolean` && typeof b === `boolean`) {\n      return a === b ? 0 : a ? 1 : -1\n    }\n    // if a and b are both dates, compare them\n    if (a instanceof Date && b instanceof Date) {\n      return a.getTime() - b.getTime()\n    }\n    // if a and b are both null, return 0\n    if (a === null || b === null) {\n      return 0\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        // Get the values from the array\n        const aVal = a[i]\n        const bVal = b[i]\n\n        // Compare the values\n        let result: number\n\n        if (typeof aVal === `boolean` && typeof bVal === `boolean`) {\n          // Special handling for booleans - false comes before true\n          result = aVal === bVal ? 0 : aVal ? 1 : -1\n        } else if (typeof aVal === `number` && typeof bVal === `number`) {\n          // Numeric comparison\n          result = aVal - bVal\n        } else if (typeof aVal === `string` && typeof bVal === `string`) {\n          // String comparison\n          result = aVal.localeCompare(bVal)\n        } else {\n          // Default comparison using the general comparator\n          result = comparator(aVal, bVal)\n        }\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    // if a and b are both null/undefined, return 0\n    if (a == null && b == null) {\n      return 0\n    }\n    // Fallback to string comparison for all other cases\n    return (a as any).toString().localeCompare((b as any).toString())\n  }\n\n  let topKComparator: (a: unknown, b: unknown) => number\n  if (!query.keyBy) {\n    topKComparator = (a, b) => {\n      const aValue = valueExtractor(a)\n      const bValue = valueExtractor(b)\n      return comparator(aValue, bValue)\n    }\n  }\n\n  // Apply the appropriate orderBy operator based on whether an ORDER_INDEX column is requested\n  if (hasOrderIndexColumn) {\n    if (orderIndexType === `numeric`) {\n      if (query.keyBy) {\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            const result = {\n              ...(value as Record<string, unknown>),\n              [orderIndexAlias]: index,\n            }\n            return [key, result]\n          })\n        )\n      } else {\n        // Use topKWithIndex for numeric indices\n        resultPipeline = resultPipeline.pipe(\n          map((value) => [null, value]),\n          topKWithIndex(topKComparator!, {\n            limit: query.limit,\n            offset: query.offset,\n          }),\n          map(([_, [value, index]]) => {\n            // Add the index to the result\n            return {\n              ...(value as Record<string, unknown>),\n              [orderIndexAlias]: index,\n            }\n          })\n        )\n      }\n    } else {\n      if (query.keyBy) {\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            const result = {\n              ...(value as Record<string, unknown>),\n              [orderIndexAlias]: index,\n            }\n            return [key, result]\n          })\n        )\n      } else {\n        // Use topKWithFractionalIndex for fractional indices\n        resultPipeline = resultPipeline.pipe(\n          map((value) => [null, value]),\n          topKWithFractionalIndex(topKComparator!, {\n            limit: query.limit,\n            offset: query.offset,\n          }),\n          map(([_, [value, index]]) => {\n            // Add the index to the result\n            return {\n              ...(value as Record<string, unknown>),\n              [orderIndexAlias]: index,\n            }\n          })\n        )\n      }\n    }\n  } else {\n    if (query.keyBy) {\n      // Use regular orderBy if no index column is requested and but a keyBy is requested\n      resultPipeline = resultPipeline.pipe(\n        orderBy(valueExtractor, {\n          limit: query.limit,\n          offset: query.offset,\n          comparator,\n        })\n      )\n    } else {\n      // Use topK if no index column is requested and no keyBy is requested\n      resultPipeline = resultPipeline.pipe(\n        map((value) => [null, value]),\n        topK(topKComparator!, {\n          limit: query.limit,\n          offset: query.offset,\n        }),\n        map(([_, value]) => value as Record<string, unknown>)\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","evaluateOperandOnNestedRow","orderByWithIndex","map","topKWithIndex","orderByWithFractionalIndex","topKWithFractionalIndex","orderBy","topK"],"mappings":";;;;;AAcgB,SAAA,eACd,gBAGA,OACA,gBACA;AAEA,MAAI,sBAAsB;AAC1B,MAAI,iBAA2C;AAC/C,MAAI,kBAAkB;AAGX,aAAA,QAAQ,MAAM,QAAQ;AAC3B,QAAA,OAAO,SAAS,UAAU;AAC5B,iBAAW,CAAC,OAAO,IAAI,KAAK,OAAO,QAAQ,IAAI,GAAG;AAChD,YAAI,OAAO,SAAS,YAAYA,MAAA,yBAAyB,IAAI,GAAG;AACxC,gCAAA;AACJ,4BAAA;AAClB,2BAAiB,kBAAkB,IAAI;AACvC;AAAA,QAAA;AAAA,MACF;AAAA,IACF;AAEF,QAAI,oBAAqB;AAAA,EAAA;AAI3B,QAAM,eAGD,CAAC;AAEF,MAAA,OAAO,MAAM,YAAY,UAAU;AAErC,iBAAa,KAAK;AAAA,MAChB,SAAS,MAAM;AAAA,MACf,WAAW;AAAA,IAAA,CACZ;AAAA,EACQ,WAAA,MAAM,QAAQ,MAAM,OAAO,GAAG;AAE5B,eAAA,QAAQ,MAAM,SAAS;AAC5B,UAAA,OAAO,SAAS,UAAU;AAC5B,qBAAa,KAAK;AAAA,UAChB,SAAS;AAAA,UACT,WAAW;AAAA,QAAA,CACZ;AAAA,MACH,WAAW,OAAO,SAAS,UAAU;AACnC,mBAAW,CAAC,QAAQ,SAAS,KAAK,OAAO,QAAQ,IAAI,GAAG;AACtD,uBAAa,KAAK;AAAA,YAChB,SAAS;AAAA,YACT;AAAA,UAAA,CACD;AAAA,QAAA;AAAA,MACH;AAAA,IACF;AAAA,EAEO,WAAA,OAAO,MAAM,YAAY,UAAU;AAEjC,eAAA,CAAC,QAAQ,SAAS,KAAK,OAAO,QAAQ,MAAM,OAAO,GAAG;AAC/D,mBAAa,KAAK;AAAA,QAChB,SAAS;AAAA,QACT;AAAA,MAAA,CACD;AAAA,IAAA;AAAA,EACH;AAII,QAAA,iBAAiB,CAAC,UAAmB;AACzC,UAAM,MAAM;AAGZ,UAAM,YAAqC,EAAE,CAAC,cAAc,GAAG,IAAI;AAG/D,QAAA,aAAa,SAAS,GAAG;AACpB,aAAA,aAAa,IAAI,CAAC,SAAS;AAChC,cAAM,MAAMC,WAAA;AAAA,UACV;AAAA,UACA,KAAK;AAAA,UACL;AAAA,QACF;AAGA,eAAO,KAAK,cAAc,UAAU,OAAO,QAAQ,WAC/C,CAAC,MACD,KAAK,cAAc,UAAU,OAAO,QAAQ,WAC1C,OAAO;AAAA,UACL,GAAG,CAAC,GAAG,GAAG,EAAE,IAAI,CAAC,MAAM,QAAS,EAAE,WAAW,CAAC,CAAC;AAAA,QAAA,IAEjD;AAAA,MAAA,CACP;AAAA,IAAA,WACQ,aAAa,WAAW,GAAG;AAE9B,YAAA,OAAO,aAAa,CAAC;AAC3B,YAAM,MAAMA,WAAA;AAAA,QACV;AAAA,QACA,KAAM;AAAA,QACN;AAAA,MACF;AAGA,aAAO,KAAM,cAAc,UAAU,OAAO,QAAQ,WAChD,CAAC,MACD,KAAM,cAAc,UAAU,OAAO,QAAQ,WAC3C,OAAO;AAAA,QACL,GAAG,CAAC,GAAG,GAAG,EAAE,IAAI,CAAC,MAAM,QAAS,EAAE,WAAW,CAAC,CAAC;AAAA,MAAA,IAEjD;AAAA,IAAA;AAID,WAAA;AAAA,EACT;AAEM,QAAA,aAAa,CAAC,GAAY,MAAuB;AAErD,QAAI,OAAO,MAAM,YAAY,OAAO,MAAM,UAAU;AAClD,aAAO,IAAI;AAAA,IAAA;AAGb,QAAI,OAAO,MAAM,YAAY,OAAO,MAAM,UAAU;AAC3C,aAAA,EAAE,cAAc,CAAC;AAAA,IAAA;AAG1B,QAAI,OAAO,MAAM,aAAa,OAAO,MAAM,WAAW;AACpD,aAAO,MAAM,IAAI,IAAI,IAAI,IAAI;AAAA,IAAA;AAG3B,QAAA,aAAa,QAAQ,aAAa,MAAM;AAC1C,aAAO,EAAE,YAAY,EAAE,QAAQ;AAAA,IAAA;AAG7B,QAAA,MAAM,QAAQ,MAAM,MAAM;AACrB,aAAA;AAAA,IAAA;AAIT,QAAI,MAAM,QAAQ,CAAC,KAAK,MAAM,QAAQ,CAAC,GAAG;AAC/B,eAAA,IAAI,GAAG,IAAI,KAAK,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK;AAE/C,cAAA,OAAO,EAAE,CAAC;AACV,cAAA,OAAO,EAAE,CAAC;AAGZ,YAAA;AAEJ,YAAI,OAAO,SAAS,aAAa,OAAO,SAAS,WAAW;AAE1D,mBAAS,SAAS,OAAO,IAAI,OAAO,IAAI;AAAA,QAAA,WAC/B,OAAO,SAAS,YAAY,OAAO,SAAS,UAAU;AAE/D,mBAAS,OAAO;AAAA,QAAA,WACP,OAAO,SAAS,YAAY,OAAO,SAAS,UAAU;AAEtD,mBAAA,KAAK,cAAc,IAAI;AAAA,QAAA,OAC3B;AAEI,mBAAA,WAAW,MAAM,IAAI;AAAA,QAAA;AAGhC,YAAI,WAAW,GAAG;AACT,iBAAA;AAAA,QAAA;AAAA,MACT;AAGK,aAAA,EAAE,SAAS,EAAE;AAAA,IAAA;AAGlB,QAAA,KAAK,QAAQ,KAAK,MAAM;AACnB,aAAA;AAAA,IAAA;AAGT,WAAQ,EAAU,SAAS,EAAE,cAAe,EAAU,UAAU;AAAA,EAClE;AAEI,MAAA;AACA,MAAA,CAAC,MAAM,OAAO;AACC,qBAAA,CAAC,GAAG,MAAM;AACnB,YAAA,SAAS,eAAe,CAAC;AACzB,YAAA,SAAS,eAAe,CAAC;AACxB,aAAA,WAAW,QAAQ,MAAM;AAAA,IAClC;AAAA,EAAA;AAIF,MAAI,qBAAqB;AACvB,QAAI,mBAAmB,WAAW;AAChC,UAAI,MAAM,OAAO;AAEf,yBAAiB,eAAe;AAAA,UAC9BC,KAAAA,iBAAiB,gBAAgB;AAAA,YAC/B,OAAO,MAAM;AAAA,YACb,QAAQ,MAAM;AAAA,YACd;AAAA,UAAA,CACD;AAAA,UACDC,KAAA,IAAI,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,MAAM;AAE7B,kBAAM,SAAS;AAAA,cACb,GAAI;AAAA,cACJ,CAAC,eAAe,GAAG;AAAA,YACrB;AACO,mBAAA,CAAC,KAAK,MAAM;AAAA,UACpB,CAAA;AAAA,QACH;AAAA,MAAA,OACK;AAEL,yBAAiB,eAAe;AAAA,UAC9BA,KAAAA,IAAI,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC;AAAA,UAC5BC,KAAAA,cAAc,gBAAiB;AAAA,YAC7B,OAAO,MAAM;AAAA,YACb,QAAQ,MAAM;AAAA,UAAA,CACf;AAAA,UACDD,KAAA,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,KAAK,CAAC,MAAM;AAEpB,mBAAA;AAAA,cACL,GAAI;AAAA,cACJ,CAAC,eAAe,GAAG;AAAA,YACrB;AAAA,UACD,CAAA;AAAA,QACH;AAAA,MAAA;AAAA,IACF,OACK;AACL,UAAI,MAAM,OAAO;AAEf,yBAAiB,eAAe;AAAA,UAC9BE,KAAAA,2BAA2B,gBAAgB;AAAA,YACzC,OAAO,MAAM;AAAA,YACb,QAAQ,MAAM;AAAA,YACd;AAAA,UAAA,CACD;AAAA,UACDF,KAAA,IAAI,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,MAAM;AAE7B,kBAAM,SAAS;AAAA,cACb,GAAI;AAAA,cACJ,CAAC,eAAe,GAAG;AAAA,YACrB;AACO,mBAAA,CAAC,KAAK,MAAM;AAAA,UACpB,CAAA;AAAA,QACH;AAAA,MAAA,OACK;AAEL,yBAAiB,eAAe;AAAA,UAC9BA,KAAAA,IAAI,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC;AAAA,UAC5BG,KAAAA,wBAAwB,gBAAiB;AAAA,YACvC,OAAO,MAAM;AAAA,YACb,QAAQ,MAAM;AAAA,UAAA,CACf;AAAA,UACDH,KAAA,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,KAAK,CAAC,MAAM;AAEpB,mBAAA;AAAA,cACL,GAAI;AAAA,cACJ,CAAC,eAAe,GAAG;AAAA,YACrB;AAAA,UACD,CAAA;AAAA,QACH;AAAA,MAAA;AAAA,IACF;AAAA,EACF,OACK;AACL,QAAI,MAAM,OAAO;AAEf,uBAAiB,eAAe;AAAA,QAC9BI,KAAAA,QAAQ,gBAAgB;AAAA,UACtB,OAAO,MAAM;AAAA,UACb,QAAQ,MAAM;AAAA,UACd;AAAA,QACD,CAAA;AAAA,MACH;AAAA,IAAA,OACK;AAEL,uBAAiB,eAAe;AAAA,QAC9BJ,KAAAA,IAAI,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC;AAAA,QAC5BK,KAAAA,KAAK,gBAAiB;AAAA,UACpB,OAAO,MAAM;AAAA,UACb,QAAQ,MAAM;AAAA,QAAA,CACf;AAAA,QACDL,KAAAA,IAAI,CAAC,CAAC,GAAG,KAAK,MAAM,KAAgC;AAAA,MACtD;AAAA,IAAA;AAAA,EACF;AAGK,SAAA;AACT;AAGA,SAAS,kBAAkB,KAAoC;AACzD,MAAA,CAACH,MAAAA,yBAAyB,GAAG,GAAG;AAC5B,UAAA,IAAI,MAAM,kCAAkC;AAAA,EAAA;AAG9C,QAAA,MAAM,IAAI,aAAa;AAC7B,MAAI,QAAQ,aAAa,QAAQ,QAAQ,QAAQ,WAAW;AACnD,WAAA;AAAA,EAAA,WACE,QAAQ,cAAc;AACxB,WAAA;AAAA,EAAA,OACF;AACC,UAAA,IAAI,MAAM,+BAA+B,GAAG;AAAA,EAAA;AAEtD;;"}

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

@@ -0,0 +1,3 @@
+import { Query } from './schema.cjs';
+import { IStreamBuilder } from '@electric-sql/d2ts';
+export declare function processOrderBy(resultPipeline: IStreamBuilder<Record<string, unknown> | [string | number, Record<string, unknown>]>, query: Query, mainTableAlias: string): IStreamBuilder<Record<string, unknown> | [string | number, Record<string, unknown>]>;

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const d2ts = require("@electric-sql/d2ts");
+const evaluators = require("./evaluators.cjs");
+const joins = require("./joins.cjs");
+const groupBy = require("./group-by.cjs");
+const orderBy = require("./order-by.cjs");
+const keyBy = require("./key-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 (withQuery.keyBy !== void 0) {
+        throw new Error(`WITH query cannot have a "keyBy" 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(
+    d2ts.map((row) => {
+      return { [mainTableAlias]: row };
+    })
+  );
+  if (query.join) {
+    pipeline = joins.processJoinClause(
+      pipeline,
+      query,
+      tables,
+      mainTableAlias,
+      allInputs
+    );
+  }
+  if (query.where) {
+    pipeline = pipeline.pipe(
+      d2ts.filter((nestedRow) => {
+        const result = evaluators.evaluateConditionOnNestedRow(
+          nestedRow,
+          query.where,
+          mainTableAlias
+        );
+        return result;
+      })
+    );
+  }
+  if (query.groupBy) {
+    pipeline = groupBy.processGroupBy(pipeline, query, mainTableAlias);
+  }
+  if (query.having) {
+    pipeline = pipeline.pipe(
+      d2ts.filter((row) => {
+        const result = evaluators.evaluateConditionOnNestedRow(
+          { [mainTableAlias]: row, ...row },
+          query.having,
+          mainTableAlias
+        );
+        return result;
+      })
+    );
+  }
+  pipeline = select.processSelect(pipeline, query, mainTableAlias, allInputs);
+  let resultPipeline = pipeline;
+  if (query.keyBy) {
+    resultPipeline = keyBy.processKeyBy(resultPipeline, query);
+  }
+  if (query.orderBy) {
+    resultPipeline = orderBy.processOrderBy(resultPipeline, 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`
+    );
+  }
+  return resultPipeline;
+}
+exports.compileQueryPipeline = compileQueryPipeline;
+//# sourceMappingURL=pipeline-compiler.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-compiler.cjs","sources":["../../../src/query/pipeline-compiler.ts"],"sourcesContent":["import { filter, map } from \"@electric-sql/d2ts\"\nimport { evaluateConditionOnNestedRow } from \"./evaluators.js\"\nimport { processJoinClause } from \"./joins.js\"\nimport { processGroupBy } from \"./group-by.js\"\nimport { processOrderBy } from \"./order-by.js\"\nimport { processKeyBy } from \"./key-by.js\"\nimport { processSelect } from \"./select.js\"\nimport type { Condition, Query } from \"./schema.js\"\nimport type { IStreamBuilder } from \"@electric-sql/d2ts\"\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, IStreamBuilder<Record<string, unknown>>>\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      // Ensure the WITH query is not keyed\n      if ((withQuery as Query).keyBy !== undefined) {\n        throw new Error(`WITH query cannot have a \"keyBy\" 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 IStreamBuilder<\n        Record<string, unknown>\n      >\n    }\n  }\n\n  // Create a map of table aliases to inputs\n  const tables: Record<string, IStreamBuilder<Record<string, unknown>>> = {}\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 = input.pipe(\n    map((row: unknown) => {\n      // Initialize the record with a nested structure\n      return { [mainTableAlias]: row } as Record<string, unknown>\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((nestedRow) => {\n        const result = evaluateConditionOnNestedRow(\n          nestedRow,\n          query.where as Condition,\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((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 = evaluateConditionOnNestedRow(\n          { [mainTableAlias]: row, ...row } as Record<string, unknown>,\n          query.having as Condition,\n          mainTableAlias\n        )\n        return result\n      })\n    )\n  }\n\n  // Process the SELECT clause - this is where we flatten the structure\n  pipeline = processSelect(pipeline, query, mainTableAlias, allInputs)\n\n  let resultPipeline: IStreamBuilder<\n    Record<string, unknown> | [string | number, Record<string, unknown>]\n  > = pipeline\n\n  // Process keyBy parameter if it exists\n  if (query.keyBy) {\n    resultPipeline = processKeyBy(resultPipeline, query)\n  }\n\n  // Process orderBy parameter if it exists\n  if (query.orderBy) {\n    resultPipeline = processOrderBy(resultPipeline, 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  return resultPipeline as T\n}\n"],"names":["map","processJoinClause","filter","evaluateConditionOnNestedRow","processGroupBy","processSelect","processKeyBy","processOrderBy"],"mappings":";;;;;;;;;AAgBgB,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;AAIpD,UAAA,UAAoB,UAAU,QAAW;AACtC,cAAA,IAAI,MAAM,2CAA2C;AAAA,MAAA;AAIzD,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,EAG5B;AAIF,QAAM,SAAkE,CAAC;AAGnE,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,WAAW,MAAM;AAAA,IACnBA,KAAA,IAAI,CAAC,QAAiB;AAEpB,aAAO,EAAE,CAAC,cAAc,GAAG,IAAI;AAAA,IAChC,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,KAAA,OAAO,CAAC,cAAc;AACpB,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,KAAA,OAAO,CAAC,QAAQ;AAGd,cAAM,SAASC,WAAA;AAAA,UACb,EAAE,CAAC,cAAc,GAAG,KAAK,GAAG,IAAI;AAAA,UAChC,MAAM;AAAA,UACN;AAAA,QACF;AACO,eAAA;AAAA,MACR,CAAA;AAAA,IACH;AAAA,EAAA;AAIF,aAAWE,OAAAA,cAAc,UAAU,OAAO,gBAAgB,SAAS;AAEnE,MAAI,iBAEA;AAGJ,MAAI,MAAM,OAAO;AACE,qBAAAC,MAAAA,aAAa,gBAAgB,KAAK;AAAA,EAAA;AAIrD,MAAI,MAAM,SAAS;AACA,qBAAAC,QAAA,eAAe,gBAAgB,OAAO,cAAc;AAAA,EAAA,WAC5D,MAAM,UAAU,UAAa,MAAM,WAAW,QAAW;AAElE,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EAAA;AAGK,SAAA;AACT;;"}

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

@@ -0,0 +1,9 @@
+import { Query } from './schema.js';
+import { IStreamBuilder } from '@electric-sql/d2ts';
+/**
+ * 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, IStreamBuilder<Record<string, unknown>>>): T;