@tanstack/db 0.0.4 → 0.0.5

package/src/query/query-builder.ts

@@ -438,6 +438,7 @@ export class BaseQueryBuilder<TContext extends Context<Schema>> {
               Input
           >
         }
+        hasJoin: true
       }
     >
   >
@@ -474,6 +475,7 @@ export class BaseQueryBuilder<TContext extends Context<Schema>> {
         schema: TContext[`schema`] & {
           [K in T]: RemoveIndexSignature<TContext[`baseSchema`][T]>
         }
+        hasJoin: true
       }
     >
   >
@@ -513,6 +515,7 @@ export class BaseQueryBuilder<TContext extends Context<Schema>> {
         schema: TContext[`schema`] & {
           [K in TAs]: RemoveIndexSignature<TContext[`baseSchema`][TFrom]>
         }
+        hasJoin: true
       }
     >
   >
@@ -754,25 +757,6 @@ export class BaseQueryBuilder<TContext extends Context<Schema>> {
     return newBuilder as QueryBuilder<TContext>
   }
 
-  /**
-   * Specify which column(s) to use as keys in the output keyed stream.
-   *
-   * @param keyBy The column(s) to use as keys
-   * @returns A new QueryBuilder with the keyBy clause set
-   */
-  keyBy(
-    keyBy: PropertyReference<TContext> | Array<PropertyReference<TContext>>
-  ): QueryBuilder<TContext> {
-    // Create a new builder with a copy of the current query
-    const newBuilder = new BaseQueryBuilder<TContext>()
-    Object.assign(newBuilder.query, this.query)
-
-    // Set the keyBy clause
-    newBuilder.query.keyBy = keyBy
-
-    return newBuilder as QueryBuilder<TContext>
-  }
-
   /**
    * Add a groupBy clause to group the results by one or more columns.
    *
@@ -883,10 +867,12 @@ export function queryBuilder<TBaseSchema extends Schema = {}>() {
 
 export type ResultsFromContext<TContext extends Context<Schema>> = Flatten<
   TContext[`result`] extends object
-    ? TContext[`result`]
-    : TContext[`result`] extends undefined
-      ? TContext[`schema`]
-      : object
+    ? TContext[`result`] // If there is a select we will have a result type
+    : TContext[`hasJoin`] extends true
+      ? TContext[`schema`] // If there is a join, the query returns the namespaced schema
+      : TContext[`default`] extends keyof TContext[`schema`]
+        ? TContext[`schema`][TContext[`default`]] // If there is no join we return the flat default schema
+        : never // Should never happen
 >
 
 export type ResultFromQueryBuilder<TQueryBuilder> = Flatten<

package/src/query/schema.ts

@@ -169,7 +169,6 @@ export interface JoinClause<TContext extends Context = Context> {
   from: string
   as?: string
   on: Condition<TContext>
-  where?: Condition<TContext>
 }
 
 // The orderBy clause can be a string, an object mapping a column to "asc" or "desc",
@@ -217,7 +216,7 @@ export interface BaseQuery<TContext extends Context = Context> {
   // to expressions. Plain strings starting with "@" denote column references.
   // Plain string "@*" denotes all columns from all tables.
   // Plain string "@table.*" denotes all columns from a specific table.
-  select: Array<Select<TContext>>
+  select?: Array<Select<TContext>>
   as?: As<TContext>
   from: From<TContext>
   join?: Array<JoinClause<TContext>>
@@ -232,7 +231,6 @@ export interface BaseQuery<TContext extends Context = Context> {
 // The top-level query interface.
 export interface Query<TContext extends Context = Context>
   extends BaseQuery<TContext> {
-  keyBy?: PropertyReference<TContext> | Array<PropertyReference<TContext>>
   with?: Array<WithQuery<TContext>>
   collections?: {
     [K: string]: Collection<any>
@@ -246,10 +244,3 @@ export interface WithQuery<TContext extends Context = Context>
   extends BaseQuery<TContext> {
   as: string
 }
-
-// A keyed query is a query that has a keyBy clause, and so the result is always
-// a keyed stream.
-export interface KeyedQuery<TContext extends Context = Context>
-  extends Query<TContext> {
-  keyBy: PropertyReference<TContext> | Array<PropertyReference<TContext>>
-}

package/src/query/select.ts

@@ -1,41 +1,48 @@
 import { map } from "@electric-sql/d2ts"
 import {
-  evaluateOperandOnNestedRow,
-  extractValueFromNestedRow,
+  evaluateOperandOnNamespacedRow,
+  extractValueFromNamespacedRow,
 } from "./extractors"
-import type { IStreamBuilder } from "@electric-sql/d2ts"
 import type { ConditionOperand, Query } from "./schema"
+import type { KeyedStream, NamespacedAndKeyedStream } from "../types"
 
 export function processSelect(
-  pipeline: IStreamBuilder<Record<string, unknown>>,
+  pipeline: NamespacedAndKeyedStream,
   query: Query,
   mainTableAlias: string,
-  inputs: Record<string, IStreamBuilder<Record<string, unknown>>>
-) {
+  inputs: Record<string, KeyedStream>
+): KeyedStream {
   return pipeline.pipe(
-    map((nestedRow: Record<string, unknown>) => {
+    map(([key, namespacedRow]) => {
       const result: Record<string, unknown> = {}
 
       // Check if this is a grouped result (has no nested table structure)
       // If it's a grouped result, we need to handle it differently
       const isGroupedResult =
         query.groupBy &&
-        Object.keys(nestedRow).some(
-          (key) =>
-            !Object.keys(inputs).includes(key) &&
-            typeof nestedRow[key] !== `object`
+        Object.keys(namespacedRow).some(
+          (namespaceKey) =>
+            !Object.keys(inputs).includes(namespaceKey) &&
+            typeof namespacedRow[namespaceKey] !== `object`
         )
 
+      if (!query.select) {
+        throw new Error(`Cannot process missing SELECT clause`)
+      }
+
       for (const item of query.select) {
         if (typeof item === `string`) {
           // Handle wildcard select - all columns from all tables
           if ((item as string) === `@*`) {
             // For grouped results, just return the row as is
             if (isGroupedResult) {
-              Object.assign(result, nestedRow)
+              Object.assign(result, namespacedRow)
             } else {
               // Extract all columns from all tables
-              Object.assign(result, extractAllColumnsFromAllTables(nestedRow))
+              Object.assign(
+                result,
+                extractAllColumnsFromAllTables(namespacedRow)
+              )
             }
             continue
           }
@@ -56,7 +63,7 @@ export function processSelect(
               // Extract all columns from the specified table
               Object.assign(
                 result,
-                extractAllColumnsFromTable(nestedRow, tableAlias)
+                extractAllColumnsFromTable(namespacedRow, tableAlias)
               )
             }
             continue
@@ -68,12 +75,12 @@ export function processSelect(
             const alias = columnRef
 
             // For grouped results, check if the column is directly in the row first
-            if (isGroupedResult && columnRef in nestedRow) {
-              result[alias] = nestedRow[columnRef]
+            if (isGroupedResult && columnRef in namespacedRow) {
+              result[alias] = namespacedRow[columnRef]
             } else {
               // Extract the value from the nested structure
-              result[alias] = extractValueFromNestedRow(
-                nestedRow,
+              result[alias] = extractValueFromNamespacedRow(
+                namespacedRow,
                 columnRef,
                 mainTableAlias,
                 undefined
@@ -95,12 +102,12 @@ export function processSelect(
               const columnRef = (expr as string).substring(1)
 
               // For grouped results, check if the column is directly in the row first
-              if (isGroupedResult && columnRef in nestedRow) {
-                result[alias] = nestedRow[columnRef]
+              if (isGroupedResult && columnRef in namespacedRow) {
+                result[alias] = namespacedRow[columnRef]
               } else {
                 // Extract the value from the nested structure
-                result[alias] = extractValueFromNestedRow(
-                  nestedRow,
+                result[alias] = extractValueFromNamespacedRow(
+                  namespacedRow,
                   columnRef,
                   mainTableAlias,
                   undefined
@@ -108,12 +115,14 @@ export function processSelect(
               }
             } else if (typeof expr === `object`) {
               // For grouped results, the aggregate results are already in the row
-              if (isGroupedResult && alias in nestedRow) {
-                result[alias] = nestedRow[alias]
+              if (isGroupedResult && alias in namespacedRow) {
+                result[alias] = namespacedRow[alias]
+              } else if ((expr as { ORDER_INDEX: unknown }).ORDER_INDEX) {
+                result[alias] = namespacedRow[mainTableAlias]![alias]
               } else {
                 // This might be a function call
-                result[alias] = evaluateOperandOnNestedRow(
-                  nestedRow,
+                result[alias] = evaluateOperandOnNamespacedRow(
+                  namespacedRow,
                   expr as ConditionOperand,
                   mainTableAlias,
                   undefined
@@ -124,23 +133,26 @@ export function processSelect(
         }
       }
 
-      return result
+      return [key, result] as [string, typeof result]
     })
   )
 }
 
 // Helper function to extract all columns from all tables in a nested row
 function extractAllColumnsFromAllTables(
-  nestedRow: Record<string, unknown>
+  namespacedRow: Record<string, unknown>
 ): Record<string, unknown> {
   const result: Record<string, unknown> = {}
 
   // Process each table in the nested row
-  for (const [tableAlias, tableData] of Object.entries(nestedRow)) {
+  for (const [tableAlias, tableData] of Object.entries(namespacedRow)) {
     if (tableData && typeof tableData === `object`) {
       // Add all columns from this table to the result
       // If there are column name conflicts, the last table's columns will overwrite previous ones
-      Object.assign(result, extractAllColumnsFromTable(nestedRow, tableAlias))
+      Object.assign(
+        result,
+        extractAllColumnsFromTable(namespacedRow, tableAlias)
+      )
     }
   }
 
@@ -149,13 +161,13 @@ function extractAllColumnsFromAllTables(
 
 // Helper function to extract all columns from a table in a nested row
 function extractAllColumnsFromTable(
-  nestedRow: Record<string, unknown>,
+  namespacedRow: Record<string, unknown>,
   tableAlias: string
 ): Record<string, unknown> {
   const result: Record<string, unknown> = {}
 
   // Get the table data
-  const tableData = nestedRow[tableAlias] as
+  const tableData = namespacedRow[tableAlias] as
     | Record<string, unknown>
     | null
     | undefined

package/src/query/types.ts

@@ -20,6 +20,7 @@ export type Context<
   schema: TSchema
   default?: keyof TSchema
   result?: Record<string, unknown>
+  hasJoin?: boolean
 }
 
 // Helper types

package/src/transactions.ts

@@ -24,6 +24,7 @@ function generateUUID() {
 }
 
 const transactions: Array<Transaction> = []
+let transactionStack: Array<Transaction> = []
 
 export function createTransaction(config: TransactionConfig): Transaction {
   if (typeof config.mutationFn === `undefined`) {
@@ -35,13 +36,12 @@ export function createTransaction(config: TransactionConfig): Transaction {
     transactionId = generateUUID()
   }
   const newTransaction = new Transaction({ ...config, id: transactionId })
+
   transactions.push(newTransaction)
 
   return newTransaction
 }
 
-let transactionStack: Array<Transaction> = []
-
 export function getActiveTransaction(): Transaction | undefined {
   if (transactionStack.length > 0) {
     return transactionStack.slice(-1)[0]
@@ -58,6 +58,13 @@ function unregisterTransaction(tx: Transaction) {
   transactionStack = transactionStack.filter((t) => t.id !== tx.id)
 }
 
+function removeFromPendingList(tx: Transaction) {
+  const index = transactions.findIndex((t) => t.id === tx.id)
+  if (index !== -1) {
+    transactions.splice(index, 1)
+  }
+}
+
 export class Transaction {
   public id: string
   public state: TransactionState
@@ -85,6 +92,10 @@ export class Transaction {
 
   setState(newState: TransactionState) {
     this.state = newState
+
+    if (newState === `completed` || newState === `failed`) {
+      removeFromPendingList(this)
+    }
   }
 
   mutate(callback: () => void): Transaction {
@@ -130,22 +141,20 @@ export class Transaction {
 
     this.setState(`failed`)
 
-    // See if there's any other transactions w/ mutations on the same keys
+    // See if there's any other transactions w/ mutations on the same ids
     // and roll them back as well.
     if (!isSecondaryRollback) {
-      const mutationKeys = new Set()
-      this.mutations.forEach((m) => mutationKeys.add(m.key))
-      transactions.forEach(
-        (t) =>
-          t.state === `pending` &&
-          t.mutations.some((m) => mutationKeys.has(m.key)) &&
+      const mutationIds = new Set()
+      this.mutations.forEach((m) => mutationIds.add(m.key))
+      for (const t of transactions) {
+        t.state === `pending` &&
+          t.mutations.some((m) => mutationIds.has(m.key)) &&
           t.rollback({ isSecondaryRollback: true })
-      )
+      }
     }
 
     // Reject the promise
     this.isPersisted.reject(this.error?.error)
-
     this.touchCollection()
 
     return this
@@ -154,13 +163,13 @@ export class Transaction {
   // Tell collection that something has changed with the transaction
   touchCollection(): void {
     const hasCalled = new Set()
-    this.mutations.forEach((mutation) => {
+    for (const mutation of this.mutations) {
       if (!hasCalled.has(mutation.collection.id)) {
         mutation.collection.transactions.setState((state) => state)
         mutation.collection.commitPendingTransactions()
         hasCalled.add(mutation.collection.id)
       }
-    })
+    }
   }
 
   async commit(): Promise<Transaction> {

package/src/types.ts

@@ -1,3 +1,4 @@
+import type { IStreamBuilder } from "@electric-sql/d2ts"
 import type { Collection } from "./collection"
 import type { StandardSchemaV1 } from "@standard-schema/spec"
 import type { Transaction } from "./transactions"
@@ -13,7 +14,7 @@ export interface PendingMutation<T extends object = Record<string, unknown>> {
   original: Record<string, unknown>
   modified: Record<string, unknown>
   changes: Record<string, unknown>
-  key: string
+  key: any
   type: OperationType
   metadata: unknown
   syncMetadata: Record<string, unknown>
@@ -51,7 +52,7 @@ type Value<TExtensions = never> =
   | null
   | TExtensions
   | Array<Value<TExtensions>>
-  | { [key: string]: Value<TExtensions> }
+  | { [key: string | number | symbol]: Value<TExtensions> }
 
 export type Row<TExtensions = never> = Record<string, Value<TExtensions>>
 
@@ -61,19 +62,19 @@ export interface SyncConfig<T extends object = Record<string, unknown>> {
   sync: (params: {
     collection: Collection<T>
     begin: () => void
-    write: (message: ChangeMessage<T>) => void
+    write: (message: Omit<ChangeMessage<T>, `key`>) => void
     commit: () => void
   }) => void
 
   /**
    * Get the sync metadata for insert operations
-   * @returns Record containing primaryKey and relation information
+   * @returns Record containing relation information
    */
   getSyncMetadata?: () => Record<string, unknown>
 }
 
 export interface ChangeMessage<T extends object = Record<string, unknown>> {
-  key: string
+  key: any
   value: T
   previousValue?: T
   type: OperationType
@@ -110,16 +111,56 @@ export interface OperationConfig {
 }
 
 export interface InsertConfig {
-  key?: string | Array<string | undefined>
   metadata?: Record<string, unknown>
 }
 
 export interface CollectionConfig<T extends object = Record<string, unknown>> {
-  id: string
+  // If an id isn't passed in, a UUID will be
+  // generated for it.
+  id?: string
   sync: SyncConfig<T>
   schema?: StandardSchema<T>
+  /**
+   * Function to extract the ID from an object
+   * This is required for update/delete operations which now only accept IDs
+   * @param item The item to extract the ID from
+   * @returns The ID string for the item
+   * @example
+   * // For a collection with a 'uuid' field as the primary key
+   * getId: (item) => item.uuid
+   */
+  getId: (item: T) => any
 }
 
 export type ChangesPayload<T extends object = Record<string, unknown>> = Array<
   ChangeMessage<T>
 >
+
+/**
+ * An input row from a collection
+ */
+export type InputRow = [unknown, Record<string, unknown>]
+
+/**
+ * A keyed stream is a stream of rows
+ * This is used as the inputs from a collection to a query
+ */
+export type KeyedStream = IStreamBuilder<InputRow>
+
+/**
+ * A namespaced row is a row withing a pipeline that had each table wrapped in its alias
+ */
+export type NamespacedRow = Record<string, Record<string, unknown>>
+
+/**
+ * A keyed namespaced row is a row with a key and a namespaced row
+ * This is the main representation of a row in a query pipeline
+ */
+export type KeyedNamespacedRow = [unknown, NamespacedRow]
+
+/**
+ * A namespaced and keyed stream is a stream of rows
+ * This is used throughout a query pipeline and as the output from a query without
+ * a `select` clause.
+ */
+export type NamespacedAndKeyedStream = IStreamBuilder<KeyedNamespacedRow>

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

@@ -1,43 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,3 +0,0 @@
-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/esm/query/key-by.d.ts

@@ -1,3 +0,0 @@
-import { IStreamBuilder } from '@electric-sql/d2ts';
-import { Query } from './schema.js';
-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/esm/query/key-by.js

@@ -1,43 +0,0 @@
-import { keyBy } from "@electric-sql/d2ts";
-function processKeyBy(resultPipeline, query) {
-  if (!query.keyBy) {
-    return resultPipeline;
-  }
-  const keyByParam = query.keyBy;
-  resultPipeline = resultPipeline.pipe(
-    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;
-}
-export {
-  processKeyBy
-};
-//# sourceMappingURL=key-by.js.map

package/dist/esm/query/key-by.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"key-by.js","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":[],"mappings":";AAIgB,SAAA,aACd,gBAGA,OACA;AACI,MAAA,CAAC,MAAM,OAAO;AACT,WAAA;AAAA,EAAA;AAET,QAAM,aAAa,MAAM;AAEzB,mBAAiB,eAAe;AAAA,IAC9B,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/src/query/key-by.ts

@@ -1,61 +0,0 @@
-import { keyBy } from "@electric-sql/d2ts"
-import type { IStreamBuilder } from "@electric-sql/d2ts"
-import type { Query } from "./schema"
-
-export function processKeyBy(
-  resultPipeline: IStreamBuilder<
-    Record<string, unknown> | [string | number, Record<string, unknown>]
-  >,
-  query: Query
-) {
-  if (!query.keyBy) {
-    return resultPipeline
-  }
-  const keyByParam = query.keyBy
-
-  resultPipeline = resultPipeline.pipe(
-    keyBy((row: Record<string, unknown>) => {
-      if (Array.isArray(keyByParam)) {
-        // Multiple columns - extract values and JSON stringify
-        const keyValues: Record<string, unknown> = {}
-        for (const keyColumn of keyByParam) {
-          // Remove @ prefix if present
-          const columnName = (keyColumn as string).startsWith(`@`)
-            ? (keyColumn as string).substring(1)
-            : (keyColumn as string)
-
-          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 {
-        // Single column
-        // Remove @ prefix if present
-        const columnName = (keyByParam as string).startsWith(`@`)
-          ? (keyByParam as string).substring(1)
-          : (keyByParam as string)
-
-        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]
-        // Use the value directly if it's a string or number, otherwise JSON stringify
-        if (typeof keyValue === `string` || typeof keyValue === `number`) {
-          return keyValue
-        } else {
-          return JSON.stringify(keyValue)
-        }
-      }
-    })
-  )
-
-  return resultPipeline
-}