@tanstack/db 0.0.4 → 0.0.5

package/dist/cjs/query/extractors.cjs

@@ -1,29 +1,29 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const functions = require("./functions.cjs");
-function extractValueFromNestedRow(nestedRow, columnRef, mainTableAlias, joinedTableAlias) {
+function extractValueFromNamespacedRow(namespacedRow, columnRef, mainTableAlias, joinedTableAlias) {
   if (columnRef.includes(`.`)) {
     const [tableAlias, colName] = columnRef.split(`.`);
-    const tableData = nestedRow[tableAlias];
+    const tableData = namespacedRow[tableAlias];
     if (!tableData) {
       return null;
     }
     const value = tableData[colName];
     return value;
   } else {
-    if (mainTableAlias && nestedRow[mainTableAlias]) {
-      const mainTableData = nestedRow[mainTableAlias];
+    if (mainTableAlias && namespacedRow[mainTableAlias]) {
+      const mainTableData = namespacedRow[mainTableAlias];
       if (typeof mainTableData === `object` && columnRef in mainTableData) {
         return mainTableData[columnRef];
       }
     }
-    if (joinedTableAlias && nestedRow[joinedTableAlias]) {
-      const joinedTableData = nestedRow[joinedTableAlias];
+    if (joinedTableAlias && namespacedRow[joinedTableAlias]) {
+      const joinedTableData = namespacedRow[joinedTableAlias];
       if (typeof joinedTableData === `object` && columnRef in joinedTableData) {
         return joinedTableData[columnRef];
       }
     }
-    for (const [_tableAlias, tableData] of Object.entries(nestedRow)) {
+    for (const [_tableAlias, tableData] of Object.entries(namespacedRow)) {
       if (tableData && typeof tableData === `object` && columnRef in tableData) {
         return tableData[columnRef];
       }
@@ -31,11 +31,11 @@ function extractValueFromNestedRow(nestedRow, columnRef, mainTableAlias, joinedT
     return void 0;
   }
 }
-function evaluateOperandOnNestedRow(nestedRow, operand, mainTableAlias, joinedTableAlias) {
+function evaluateOperandOnNamespacedRow(namespacedRow, operand, mainTableAlias, joinedTableAlias) {
   if (typeof operand === `string` && operand.startsWith(`@`)) {
     const columnRef = operand.substring(1);
-    return extractValueFromNestedRow(
-      nestedRow,
+    return extractValueFromNamespacedRow(
+      namespacedRow,
       columnRef,
       mainTableAlias,
       joinedTableAlias
@@ -44,14 +44,14 @@ function evaluateOperandOnNestedRow(nestedRow, operand, mainTableAlias, joinedTa
   if (operand && typeof operand === `object` && `col` in operand) {
     const colRef = operand.col;
     if (typeof colRef === `string`) {
-      const nestedValue = extractValueFromNestedRow(
-        nestedRow,
+      const nestedValue = extractValueFromNamespacedRow(
+        namespacedRow,
         colRef,
         mainTableAlias,
         joinedTableAlias
       );
-      if (nestedValue === void 0 && colRef in nestedRow) {
-        return nestedRow[colRef];
+      if (nestedValue === void 0 && colRef in namespacedRow) {
+        return namespacedRow[colRef];
       }
       return nestedValue;
     }
@@ -61,14 +61,14 @@ function evaluateOperandOnNestedRow(nestedRow, operand, mainTableAlias, joinedTa
     const functionName = Object.keys(operand)[0];
     const args = operand[functionName];
     const evaluatedArgs = Array.isArray(args) ? args.map(
-      (arg) => evaluateOperandOnNestedRow(
-        nestedRow,
+      (arg) => evaluateOperandOnNamespacedRow(
+        namespacedRow,
         arg,
         mainTableAlias,
         joinedTableAlias
       )
-    ) : evaluateOperandOnNestedRow(
-      nestedRow,
+    ) : evaluateOperandOnNamespacedRow(
+      namespacedRow,
       args,
       mainTableAlias,
       joinedTableAlias
@@ -116,7 +116,7 @@ function extractJoinKey(row, operand, defaultTableAlias) {
   }
   return keyValue;
 }
-exports.evaluateOperandOnNestedRow = evaluateOperandOnNestedRow;
+exports.evaluateOperandOnNamespacedRow = evaluateOperandOnNamespacedRow;
 exports.extractJoinKey = extractJoinKey;
-exports.extractValueFromNestedRow = extractValueFromNestedRow;
+exports.extractValueFromNamespacedRow = extractValueFromNamespacedRow;
 //# sourceMappingURL=extractors.cjs.map

package/dist/cjs/query/extractors.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"extractors.cjs","sources":["../../../src/query/extractors.ts"],"sourcesContent":["import { evaluateFunction, isFunctionCall } from \"./functions.js\"\nimport type { AllowedFunctionName, ConditionOperand } from \"./schema.js\"\n\n/**\n * Extracts a value from a nested row structure\n * @param nestedRow The nested row structure\n * @param columnRef The column reference (may include table.column format)\n * @param mainTableAlias The main table alias to check first for columns without table reference\n * @param joinedTableAlias The joined table alias to check second for columns without table reference\n * @returns The extracted value or undefined if not found\n */\nexport function extractValueFromNestedRow(\n  nestedRow: Record<string, unknown>,\n  columnRef: string,\n  mainTableAlias?: string,\n  joinedTableAlias?: string\n): unknown {\n  // Check if it's a table.column reference\n  if (columnRef.includes(`.`)) {\n    const [tableAlias, colName] = columnRef.split(`.`) as [string, string]\n\n    // Get the table data\n    const tableData = nestedRow[tableAlias] as\n      | Record<string, unknown>\n      | null\n      | undefined\n\n    if (!tableData) {\n      return null\n    }\n\n    // Return the column value from that table\n    const value = tableData[colName]\n    return value\n  } else {\n    // If no table is specified, first try to find in the main table if provided\n    if (mainTableAlias && nestedRow[mainTableAlias]) {\n      const mainTableData = nestedRow[mainTableAlias] as Record<string, unknown>\n      if (typeof mainTableData === `object` && columnRef in mainTableData) {\n        return mainTableData[columnRef]\n      }\n    }\n\n    // Then try the joined table if provided\n    if (joinedTableAlias && nestedRow[joinedTableAlias]) {\n      const joinedTableData = nestedRow[joinedTableAlias] as Record<\n        string,\n        unknown\n      >\n      if (typeof joinedTableData === `object` && columnRef in joinedTableData) {\n        return joinedTableData[columnRef]\n      }\n    }\n\n    // If not found in main or joined table, try to find the column in any table\n    for (const [_tableAlias, tableData] of Object.entries(nestedRow)) {\n      if (\n        tableData &&\n        typeof tableData === `object` &&\n        columnRef in (tableData as Record<string, unknown>)\n      ) {\n        return (tableData as Record<string, unknown>)[columnRef]\n      }\n    }\n    return undefined\n  }\n}\n\n/**\n * Evaluates an operand against a nested row structure\n */\nexport function evaluateOperandOnNestedRow(\n  nestedRow: Record<string, unknown>,\n  operand: ConditionOperand,\n  mainTableAlias?: string,\n  joinedTableAlias?: string\n): unknown {\n  // Handle column references\n  if (typeof operand === `string` && operand.startsWith(`@`)) {\n    const columnRef = operand.substring(1)\n    return extractValueFromNestedRow(\n      nestedRow,\n      columnRef,\n      mainTableAlias,\n      joinedTableAlias\n    )\n  }\n\n  // Handle explicit column references\n  if (operand && typeof operand === `object` && `col` in operand) {\n    const colRef = (operand as { col: unknown }).col\n\n    if (typeof colRef === `string`) {\n      // First try to extract from nested row structure\n      const nestedValue = extractValueFromNestedRow(\n        nestedRow,\n        colRef,\n        mainTableAlias,\n        joinedTableAlias\n      )\n\n      // If not found in nested structure, check if it's a direct property of the row\n      // This is important for HAVING clauses that reference aggregated values\n      if (nestedValue === undefined && colRef in nestedRow) {\n        return nestedRow[colRef]\n      }\n\n      return nestedValue\n    }\n\n    return undefined\n  }\n\n  // Handle function calls\n  if (operand && typeof operand === `object` && isFunctionCall(operand)) {\n    // Get the function name (the only key in the object)\n    const functionName = Object.keys(operand)[0] as AllowedFunctionName\n    // Get the arguments using type assertion with specific function name\n    const args = (operand as any)[functionName]\n\n    // If the arguments are a reference or another expression, evaluate them first\n    const evaluatedArgs = Array.isArray(args)\n      ? args.map((arg) =>\n          evaluateOperandOnNestedRow(\n            nestedRow,\n            arg as ConditionOperand,\n            mainTableAlias,\n            joinedTableAlias\n          )\n        )\n      : evaluateOperandOnNestedRow(\n          nestedRow,\n          args as ConditionOperand,\n          mainTableAlias,\n          joinedTableAlias\n        )\n\n    // Call the function with the evaluated arguments\n    return evaluateFunction(\n      functionName,\n      evaluatedArgs as ConditionOperand | Array<ConditionOperand>\n    )\n  }\n\n  // Handle explicit literals\n  if (operand && typeof operand === `object` && `value` in operand) {\n    return (operand as { value: unknown }).value\n  }\n\n  // Handle literal values\n  return operand\n}\n\n/**\n * Extracts a join key value from a row based on the operand\n * @param row The data row (not nested)\n * @param operand The operand to extract the key from\n * @param defaultTableAlias The default table alias\n * @returns The extracted key value\n */\nexport function extractJoinKey<T extends Record<string, unknown>>(\n  row: T,\n  operand: ConditionOperand,\n  defaultTableAlias?: string\n): unknown {\n  let keyValue: unknown\n\n  // Handle column references (e.g., \"@orders.id\" or \"@id\")\n  if (typeof operand === `string` && operand.startsWith(`@`)) {\n    const columnRef = operand.substring(1)\n\n    // If it contains a dot, extract the table and column\n    if (columnRef.includes(`.`)) {\n      const [tableAlias, colName] = columnRef.split(`.`) as [string, string]\n      // If this is referencing the current table, extract from row directly\n      if (tableAlias === defaultTableAlias) {\n        keyValue = row[colName]\n      } else {\n        // This might be a column from another table, return undefined\n        keyValue = undefined\n      }\n    } else {\n      // No table specified, look directly in the row\n      keyValue = row[columnRef]\n    }\n  } else if (operand && typeof operand === `object` && `col` in operand) {\n    // Handle explicit column references like { col: \"orders.id\" } or { col: \"id\" }\n    const colRef = (operand as { col: unknown }).col\n\n    if (typeof colRef === `string`) {\n      if (colRef.includes(`.`)) {\n        const [tableAlias, colName] = colRef.split(`.`) as [string, string]\n        // If this is referencing the current table, extract from row directly\n        if (tableAlias === defaultTableAlias) {\n          keyValue = row[colName]\n        } else {\n          // This might be a column from another table, return undefined\n          keyValue = undefined\n        }\n      } else {\n        // No table specified, look directly in the row\n        keyValue = row[colRef]\n      }\n    }\n  } else {\n    // Handle literals or other types\n    keyValue = operand\n  }\n\n  return keyValue\n}\n"],"names":["isFunctionCall","evaluateFunction"],"mappings":";;;AAWO,SAAS,0BACd,WACA,WACA,gBACA,kBACS;AAEL,MAAA,UAAU,SAAS,GAAG,GAAG;AAC3B,UAAM,CAAC,YAAY,OAAO,IAAI,UAAU,MAAM,GAAG;AAG3C,UAAA,YAAY,UAAU,UAAU;AAKtC,QAAI,CAAC,WAAW;AACP,aAAA;AAAA,IAAA;AAIH,UAAA,QAAQ,UAAU,OAAO;AACxB,WAAA;AAAA,EAAA,OACF;AAED,QAAA,kBAAkB,UAAU,cAAc,GAAG;AACzC,YAAA,gBAAgB,UAAU,cAAc;AAC9C,UAAI,OAAO,kBAAkB,YAAY,aAAa,eAAe;AACnE,eAAO,cAAc,SAAS;AAAA,MAAA;AAAA,IAChC;AAIE,QAAA,oBAAoB,UAAU,gBAAgB,GAAG;AAC7C,YAAA,kBAAkB,UAAU,gBAAgB;AAIlD,UAAI,OAAO,oBAAoB,YAAY,aAAa,iBAAiB;AACvE,eAAO,gBAAgB,SAAS;AAAA,MAAA;AAAA,IAClC;AAIF,eAAW,CAAC,aAAa,SAAS,KAAK,OAAO,QAAQ,SAAS,GAAG;AAChE,UACE,aACA,OAAO,cAAc,YACrB,aAAc,WACd;AACA,eAAQ,UAAsC,SAAS;AAAA,MAAA;AAAA,IACzD;AAEK,WAAA;AAAA,EAAA;AAEX;AAKO,SAAS,2BACd,WACA,SACA,gBACA,kBACS;AAET,MAAI,OAAO,YAAY,YAAY,QAAQ,WAAW,GAAG,GAAG;AACpD,UAAA,YAAY,QAAQ,UAAU,CAAC;AAC9B,WAAA;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EAAA;AAIF,MAAI,WAAW,OAAO,YAAY,YAAY,SAAS,SAAS;AAC9D,UAAM,SAAU,QAA6B;AAEzC,QAAA,OAAO,WAAW,UAAU;AAE9B,YAAM,cAAc;AAAA,QAClB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAII,UAAA,gBAAgB,UAAa,UAAU,WAAW;AACpD,eAAO,UAAU,MAAM;AAAA,MAAA;AAGlB,aAAA;AAAA,IAAA;AAGF,WAAA;AAAA,EAAA;AAIT,MAAI,WAAW,OAAO,YAAY,YAAYA,UAAAA,eAAe,OAAO,GAAG;AAErE,UAAM,eAAe,OAAO,KAAK,OAAO,EAAE,CAAC;AAErC,UAAA,OAAQ,QAAgB,YAAY;AAG1C,UAAM,gBAAgB,MAAM,QAAQ,IAAI,IACpC,KAAK;AAAA,MAAI,CAAC,QACR;AAAA,QACE;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MAAA;AAAA,IACF,IAEF;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAGG,WAAAC,UAAA;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,EAAA;AAIF,MAAI,WAAW,OAAO,YAAY,YAAY,WAAW,SAAS;AAChE,WAAQ,QAA+B;AAAA,EAAA;AAIlC,SAAA;AACT;AASgB,SAAA,eACd,KACA,SACA,mBACS;AACL,MAAA;AAGJ,MAAI,OAAO,YAAY,YAAY,QAAQ,WAAW,GAAG,GAAG;AACpD,UAAA,YAAY,QAAQ,UAAU,CAAC;AAGjC,QAAA,UAAU,SAAS,GAAG,GAAG;AAC3B,YAAM,CAAC,YAAY,OAAO,IAAI,UAAU,MAAM,GAAG;AAEjD,UAAI,eAAe,mBAAmB;AACpC,mBAAW,IAAI,OAAO;AAAA,MAAA,OACjB;AAEM,mBAAA;AAAA,MAAA;AAAA,IACb,OACK;AAEL,iBAAW,IAAI,SAAS;AAAA,IAAA;AAAA,EAC1B,WACS,WAAW,OAAO,YAAY,YAAY,SAAS,SAAS;AAErE,UAAM,SAAU,QAA6B;AAEzC,QAAA,OAAO,WAAW,UAAU;AAC1B,UAAA,OAAO,SAAS,GAAG,GAAG;AACxB,cAAM,CAAC,YAAY,OAAO,IAAI,OAAO,MAAM,GAAG;AAE9C,YAAI,eAAe,mBAAmB;AACpC,qBAAW,IAAI,OAAO;AAAA,QAAA,OACjB;AAEM,qBAAA;AAAA,QAAA;AAAA,MACb,OACK;AAEL,mBAAW,IAAI,MAAM;AAAA,MAAA;AAAA,IACvB;AAAA,EACF,OACK;AAEM,eAAA;AAAA,EAAA;AAGN,SAAA;AACT;;;;"}
+{"version":3,"file":"extractors.cjs","sources":["../../../src/query/extractors.ts"],"sourcesContent":["import { evaluateFunction, isFunctionCall } from \"./functions.js\"\nimport type { AllowedFunctionName, ConditionOperand } from \"./schema.js\"\n\n/**\n * Extracts a value from a nested row structure\n * @param namespacedRow The nested row structure\n * @param columnRef The column reference (may include table.column format)\n * @param mainTableAlias The main table alias to check first for columns without table reference\n * @param joinedTableAlias The joined table alias to check second for columns without table reference\n * @returns The extracted value or undefined if not found\n */\nexport function extractValueFromNamespacedRow(\n  namespacedRow: Record<string, unknown>,\n  columnRef: string,\n  mainTableAlias?: string,\n  joinedTableAlias?: string\n): unknown {\n  // Check if it's a table.column reference\n  if (columnRef.includes(`.`)) {\n    const [tableAlias, colName] = columnRef.split(`.`) as [string, string]\n\n    // Get the table data\n    const tableData = namespacedRow[tableAlias] as\n      | Record<string, unknown>\n      | null\n      | undefined\n\n    if (!tableData) {\n      return null\n    }\n\n    // Return the column value from that table\n    const value = tableData[colName]\n    return value\n  } else {\n    // If no table is specified, first try to find in the main table if provided\n    if (mainTableAlias && namespacedRow[mainTableAlias]) {\n      const mainTableData = namespacedRow[mainTableAlias] as Record<\n        string,\n        unknown\n      >\n      if (typeof mainTableData === `object` && columnRef in mainTableData) {\n        return mainTableData[columnRef]\n      }\n    }\n\n    // Then try the joined table if provided\n    if (joinedTableAlias && namespacedRow[joinedTableAlias]) {\n      const joinedTableData = namespacedRow[joinedTableAlias] as Record<\n        string,\n        unknown\n      >\n      if (typeof joinedTableData === `object` && columnRef in joinedTableData) {\n        return joinedTableData[columnRef]\n      }\n    }\n\n    // If not found in main or joined table, try to find the column in any table\n    for (const [_tableAlias, tableData] of Object.entries(namespacedRow)) {\n      if (\n        tableData &&\n        typeof tableData === `object` &&\n        columnRef in (tableData as Record<string, unknown>)\n      ) {\n        return (tableData as Record<string, unknown>)[columnRef]\n      }\n    }\n    return undefined\n  }\n}\n\n/**\n * Evaluates an operand against a nested row structure\n */\nexport function evaluateOperandOnNamespacedRow(\n  namespacedRow: Record<string, unknown>,\n  operand: ConditionOperand,\n  mainTableAlias?: string,\n  joinedTableAlias?: string\n): unknown {\n  // Handle column references\n  if (typeof operand === `string` && operand.startsWith(`@`)) {\n    const columnRef = operand.substring(1)\n    return extractValueFromNamespacedRow(\n      namespacedRow,\n      columnRef,\n      mainTableAlias,\n      joinedTableAlias\n    )\n  }\n\n  // Handle explicit column references\n  if (operand && typeof operand === `object` && `col` in operand) {\n    const colRef = (operand as { col: unknown }).col\n\n    if (typeof colRef === `string`) {\n      // First try to extract from nested row structure\n      const nestedValue = extractValueFromNamespacedRow(\n        namespacedRow,\n        colRef,\n        mainTableAlias,\n        joinedTableAlias\n      )\n\n      // If not found in nested structure, check if it's a direct property of the row\n      // This is important for HAVING clauses that reference aggregated values\n      if (nestedValue === undefined && colRef in namespacedRow) {\n        return namespacedRow[colRef]\n      }\n\n      return nestedValue\n    }\n\n    return undefined\n  }\n\n  // Handle function calls\n  if (operand && typeof operand === `object` && isFunctionCall(operand)) {\n    // Get the function name (the only key in the object)\n    const functionName = Object.keys(operand)[0] as AllowedFunctionName\n    // Get the arguments using type assertion with specific function name\n    const args = (operand as any)[functionName]\n\n    // If the arguments are a reference or another expression, evaluate them first\n    const evaluatedArgs = Array.isArray(args)\n      ? args.map((arg) =>\n          evaluateOperandOnNamespacedRow(\n            namespacedRow,\n            arg as ConditionOperand,\n            mainTableAlias,\n            joinedTableAlias\n          )\n        )\n      : evaluateOperandOnNamespacedRow(\n          namespacedRow,\n          args as ConditionOperand,\n          mainTableAlias,\n          joinedTableAlias\n        )\n\n    // Call the function with the evaluated arguments\n    return evaluateFunction(\n      functionName,\n      evaluatedArgs as ConditionOperand | Array<ConditionOperand>\n    )\n  }\n\n  // Handle explicit literals\n  if (operand && typeof operand === `object` && `value` in operand) {\n    return (operand as { value: unknown }).value\n  }\n\n  // Handle literal values\n  return operand\n}\n\n/**\n * Extracts a join key value from a row based on the operand\n * @param row The data row (not nested)\n * @param operand The operand to extract the key from\n * @param defaultTableAlias The default table alias\n * @returns The extracted key value\n */\nexport function extractJoinKey<T extends Record<string, unknown>>(\n  row: T,\n  operand: ConditionOperand,\n  defaultTableAlias?: string\n): unknown {\n  let keyValue: unknown\n\n  // Handle column references (e.g., \"@orders.id\" or \"@id\")\n  if (typeof operand === `string` && operand.startsWith(`@`)) {\n    const columnRef = operand.substring(1)\n\n    // If it contains a dot, extract the table and column\n    if (columnRef.includes(`.`)) {\n      const [tableAlias, colName] = columnRef.split(`.`) as [string, string]\n      // If this is referencing the current table, extract from row directly\n      if (tableAlias === defaultTableAlias) {\n        keyValue = row[colName]\n      } else {\n        // This might be a column from another table, return undefined\n        keyValue = undefined\n      }\n    } else {\n      // No table specified, look directly in the row\n      keyValue = row[columnRef]\n    }\n  } else if (operand && typeof operand === `object` && `col` in operand) {\n    // Handle explicit column references like { col: \"orders.id\" } or { col: \"id\" }\n    const colRef = (operand as { col: unknown }).col\n\n    if (typeof colRef === `string`) {\n      if (colRef.includes(`.`)) {\n        const [tableAlias, colName] = colRef.split(`.`) as [string, string]\n        // If this is referencing the current table, extract from row directly\n        if (tableAlias === defaultTableAlias) {\n          keyValue = row[colName]\n        } else {\n          // This might be a column from another table, return undefined\n          keyValue = undefined\n        }\n      } else {\n        // No table specified, look directly in the row\n        keyValue = row[colRef]\n      }\n    }\n  } else {\n    // Handle literals or other types\n    keyValue = operand\n  }\n\n  return keyValue\n}\n"],"names":["isFunctionCall","evaluateFunction"],"mappings":"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"}

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

@@ -1,17 +1,17 @@
 import { ConditionOperand } from './schema.js';
 /**
  * Extracts a value from a nested row structure
- * @param nestedRow The nested row structure
+ * @param namespacedRow The nested row structure
  * @param columnRef The column reference (may include table.column format)
  * @param mainTableAlias The main table alias to check first for columns without table reference
  * @param joinedTableAlias The joined table alias to check second for columns without table reference
  * @returns The extracted value or undefined if not found
  */
-export declare function extractValueFromNestedRow(nestedRow: Record<string, unknown>, columnRef: string, mainTableAlias?: string, joinedTableAlias?: string): unknown;
+export declare function extractValueFromNamespacedRow(namespacedRow: Record<string, unknown>, columnRef: string, mainTableAlias?: string, joinedTableAlias?: string): unknown;
 /**
  * Evaluates an operand against a nested row structure
  */
-export declare function evaluateOperandOnNestedRow(nestedRow: Record<string, unknown>, operand: ConditionOperand, mainTableAlias?: string, joinedTableAlias?: string): unknown;
+export declare function evaluateOperandOnNamespacedRow(namespacedRow: Record<string, unknown>, operand: ConditionOperand, mainTableAlias?: string, joinedTableAlias?: string): unknown;
 /**
  * Extracts a join key value from a row based on the operand
  * @param row The data row (not nested)

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

@@ -6,14 +6,14 @@ const utils = require("./utils.cjs");
 const { sum, count, avg, min, max, median, mode } = d2ts.groupByOperators;
 function processGroupBy(pipeline, query, mainTableAlias) {
   const groupByColumns = Array.isArray(query.groupBy) ? query.groupBy : [query.groupBy];
-  const keyExtractor = (nestedRow) => {
+  const keyExtractor = ([_oldKey, namespacedRow]) => {
     const key = {};
     for (const column of groupByColumns) {
       if (typeof column === `string` && column.startsWith(`@`)) {
         const columnRef = column.substring(1);
         const columnName = columnRef.includes(`.`) ? columnRef.split(`.`)[1] : columnRef;
-        key[columnName] = extractors.extractValueFromNestedRow(
-          nestedRow,
+        key[columnName] = extractors.extractValueFromNamespacedRow(
+          namespacedRow,
           columnRef,
           mainTableAlias
         );
@@ -22,6 +22,9 @@ function processGroupBy(pipeline, query, mainTableAlias) {
     return key;
   };
   const aggregates = {};
+  if (!query.select) {
+    throw new Error(`SELECT clause is required for GROUP BY`);
+  }
   for (const item of query.select) {
     if (typeof item === `object`) {
       for (const [alias, expr] of Object.entries(item)) {
@@ -38,28 +41,22 @@ function processGroupBy(pipeline, query, mainTableAlias) {
     }
   }
   if (Object.keys(aggregates).length > 0) {
-    pipeline = pipeline.pipe(
-      d2ts.groupBy(keyExtractor, aggregates),
-      // Convert KeyValue<string, ResultType> to Record<string, unknown>
-      d2ts.map(([_key, value]) => {
-        return value;
-      })
-    );
+    pipeline = pipeline.pipe(d2ts.groupBy(keyExtractor, aggregates));
   }
   return pipeline;
 }
 function getAggregateFunction(functionName, columnRef, mainTableAlias) {
-  const valueExtractor = (nestedRow) => {
+  const valueExtractor = ([_oldKey, namespacedRow]) => {
     let value;
     if (typeof columnRef === `string` && columnRef.startsWith(`@`)) {
-      value = extractors.extractValueFromNestedRow(
-        nestedRow,
+      value = extractors.extractValueFromNamespacedRow(
+        namespacedRow,
         columnRef.substring(1),
         mainTableAlias
       );
     } else {
-      value = extractors.evaluateOperandOnNestedRow(
-        nestedRow,
+      value = extractors.evaluateOperandOnNamespacedRow(
+        namespacedRow,
         columnRef,
         mainTableAlias
       );

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

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

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

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

package/dist/cjs/query/joins.cjs

@@ -9,15 +9,12 @@ function processJoinClause(pipeline, query, tables, mainTableAlias, allInputs) {
   for (const joinClause of query.join) {
     const joinedTableAlias = joinClause.as || joinClause.from;
     const joinType = joinClause.type === `cross` ? `inner` : joinClause.type;
+    const [mainKeyRef, , joinedKeyRefs] = joinClause.on;
     const mainPipeline = pipeline.pipe(
-      d2ts.map((nestedRow) => {
-        const mainRow = nestedRow[mainTableAlias];
-        const keyValue = extractors.extractJoinKey(
-          mainRow,
-          joinClause.on[0],
-          mainTableAlias
-        );
-        return [keyValue, nestedRow];
+      d2ts.map(([currentKey, namespacedRow]) => {
+        const mainRow = namespacedRow[mainTableAlias];
+        const key = extractors.extractJoinKey(mainRow, mainKeyRef, mainTableAlias);
+        return [key, [currentKey, namespacedRow]];
       })
     );
     let joinedTableInput;
@@ -28,10 +25,10 @@ function processJoinClause(pipeline, query, tables, mainTableAlias, allInputs) {
     }
     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];
+      d2ts.map(([currentKey, row]) => {
+        const namespacedRow = { [joinedTableAlias]: row };
+        const key = extractors.extractJoinKey(row, joinedKeyRefs, joinedTableAlias);
+        return [key, [currentKey, namespacedRow]];
       })
     );
     switch (joinType) {
@@ -78,74 +75,63 @@ function processJoinResults(mainTableAlias, joinedTableAlias, joinClause) {
     return pipeline.pipe(
       // Process the join result and handle nulls in the same step
       d2ts.map((result) => {
-        const [_key, [mainNestedRow, joinedNestedRow]] = result;
+        const [_key, [main, joined]] = result;
+        const mainKey = main == null ? void 0 : main[0];
+        const mainNamespacedRow = main == null ? void 0 : main[1];
+        const joinedKey = joined == null ? void 0 : joined[0];
+        const joinedNamespacedRow = joined == null ? void 0 : joined[1];
         if (joinClause.type === `inner` || joinClause.type === `cross`) {
-          if (!mainNestedRow || !joinedNestedRow) {
+          if (!mainNamespacedRow || !joinedNamespacedRow) {
             return void 0;
           }
         }
-        if (joinClause.type === `left` && !mainNestedRow) {
+        if (joinClause.type === `left` && !mainNamespacedRow) {
           return void 0;
         }
-        if (joinClause.type === `right` && !joinedNestedRow) {
+        if (joinClause.type === `right` && !joinedNamespacedRow) {
           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;
+        const mergedNamespacedRow = {};
+        if (mainNamespacedRow) {
+          Object.entries(mainNamespacedRow).forEach(
+            ([tableAlias, tableData]) => {
+              mergedNamespacedRow[tableAlias] = tableData;
+            }
+          );
         }
-        return mergedNestedRow;
+        if (joinedNamespacedRow) {
+          Object.entries(joinedNamespacedRow).forEach(
+            ([tableAlias, tableData]) => {
+              mergedNamespacedRow[tableAlias] = tableData;
+            }
+          );
+        } else if (joinClause.type === `left` || joinClause.type === `full`) ;
+        if (!mainNamespacedRow && (joinClause.type === `right` || joinClause.type === `full`)) ;
+        const newKey = `[${mainKey},${joinedKey}]`;
+        return [newKey, mergedNamespacedRow];
       }),
       // Filter out undefined results
-      d2ts.filter(
-        (value) => value !== void 0
-      ),
+      d2ts.filter((value) => value !== void 0),
       // Process the ON condition
-      d2ts.filter((nestedRow) => {
+      d2ts.filter(([_key, namespacedRow]) => {
         if (!joinClause.on || joinClause.type === `cross`) {
           return true;
         }
-        if (joinClause.type === `left` && nestedRow[joinedTableAlias] === null) {
+        if (joinClause.type === `left` && namespacedRow[joinedTableAlias] === void 0) {
           return true;
         }
-        if (joinClause.type === `right` && nestedRow[mainTableAlias] === null) {
+        if (joinClause.type === `right` && namespacedRow[mainTableAlias] === void 0) {
           return true;
         }
-        if (joinClause.type === `full` && (nestedRow[mainTableAlias] === null || nestedRow[joinedTableAlias] === null)) {
+        if (joinClause.type === `full` && (namespacedRow[mainTableAlias] === void 0 || namespacedRow[joinedTableAlias] === void 0)) {
           return true;
         }
-        const result = evaluators.evaluateConditionOnNestedRow(
-          nestedRow,
+        return evaluators.evaluateConditionOnNamespacedRow(
+          namespacedRow,
           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;
       })
     );
   };

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

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

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

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