@tanstack/db 0.0.4 → 0.0.6

package/src/query/query-builder.ts

@@ -10,6 +10,7 @@ import type {
   OrderBy,
   Query,
   Select,
+  WhereCallback,
   WithQuery,
 } from "./schema.js"
 import type {
@@ -197,8 +198,9 @@ export class BaseQueryBuilder<TContext extends Context<Schema>> {
   /**
    * Specify what columns to select.
    * Overwrites any previous select clause.
+   * Also supports callback functions that receive the row context and return selected data.
    *
-   * @param selects The columns to select
+   * @param selects The columns to select (can include callbacks)
    * @returns A new QueryBuilder with the select clause set
    */
   select<TSelects extends Array<Select<TContext>>>(
@@ -296,17 +298,23 @@ export class BaseQueryBuilder<TContext extends Context<Schema>> {
    */
   where(condition: Condition<TContext>): QueryBuilder<TContext>
 
+  /**
+   * Add a where clause with a callback function.
+   */
+  where(callback: WhereCallback<TContext>): QueryBuilder<TContext>
+
   /**
    * Add a where clause to filter the results.
    * Can be called multiple times to add AND conditions.
+   * Also supports callback functions that receive the row context.
    *
-   * @param leftOrCondition The left operand or complete condition
+   * @param leftOrConditionOrCallback The left operand, complete condition, or callback function
    * @param operator Optional comparison operator
    * @param right Optional right operand
    * @returns A new QueryBuilder with the where clause added
    */
   where(
-    leftOrCondition: any,
+    leftOrConditionOrCallback: any,
     operator?: any,
     right?: any
   ): QueryBuilder<TContext> {
@@ -317,22 +325,23 @@ export class BaseQueryBuilder<TContext extends Context<Schema>> {
 
     let condition: any
 
-    // Determine if this is a complete condition or individual parts
-    if (operator !== undefined && right !== undefined) {
+    // Determine if this is a callback, complete condition, or individual parts
+    if (typeof leftOrConditionOrCallback === `function`) {
+      // It's a callback function
+      condition = leftOrConditionOrCallback
+    } else if (operator !== undefined && right !== undefined) {
       // Create a condition from parts
-      condition = [leftOrCondition, operator, right]
+      condition = [leftOrConditionOrCallback, operator, right]
     } else {
       // Use the provided condition directly
-      condition = leftOrCondition
+      condition = leftOrConditionOrCallback
     }
 
+    // Where is always an array, so initialize or append
     if (!newBuilder.query.where) {
-      newBuilder.query.where = condition
+      newBuilder.query.where = [condition]
     } else {
-      // Create a composite condition with AND
-      // Use any to bypass type checking issues
-      const andArray: any = [newBuilder.query.where, `and`, condition]
-      newBuilder.query.where = andArray
+      newBuilder.query.where = [...newBuilder.query.where, condition]
     }
 
     return newBuilder as unknown as QueryBuilder<TContext>
@@ -354,17 +363,24 @@ export class BaseQueryBuilder<TContext extends Context<Schema>> {
    */
   having(condition: Condition<TContext>): QueryBuilder<TContext>
 
+  /**
+   * Add a having clause with a callback function.
+   * For filtering results after they have been grouped.
+   */
+  having(callback: WhereCallback<TContext>): QueryBuilder<TContext>
+
   /**
    * Add a having clause to filter the grouped results.
    * Can be called multiple times to add AND conditions.
+   * Also supports callback functions that receive the row context.
    *
-   * @param leftOrCondition The left operand or complete condition
+   * @param leftOrConditionOrCallback The left operand, complete condition, or callback function
    * @param operator Optional comparison operator
    * @param right Optional right operand
    * @returns A new QueryBuilder with the having clause added
    */
   having(
-    leftOrCondition: any,
+    leftOrConditionOrCallback: any,
     operator?: any,
     right?: any
   ): QueryBuilder<TContext> {
@@ -374,22 +390,23 @@ export class BaseQueryBuilder<TContext extends Context<Schema>> {
 
     let condition: any
 
-    // Determine if this is a complete condition or individual parts
-    if (operator !== undefined && right !== undefined) {
+    // Determine if this is a callback, complete condition, or individual parts
+    if (typeof leftOrConditionOrCallback === `function`) {
+      // It's a callback function
+      condition = leftOrConditionOrCallback
+    } else if (operator !== undefined && right !== undefined) {
       // Create a condition from parts
-      condition = [leftOrCondition, operator, right]
+      condition = [leftOrConditionOrCallback, operator, right]
     } else {
       // Use the provided condition directly
-      condition = leftOrCondition
+      condition = leftOrConditionOrCallback
     }
 
+    // Having is always an array, so initialize or append
     if (!newBuilder.query.having) {
-      newBuilder.query.having = condition
+      newBuilder.query.having = [condition]
     } else {
-      // Create a composite condition with AND
-      // Use any to bypass type checking issues
-      const andArray: any = [newBuilder.query.having, `and`, condition]
-      newBuilder.query.having = andArray
+      newBuilder.query.having = [...newBuilder.query.having, condition]
     }
 
     return newBuilder as QueryBuilder<TContext>
@@ -438,6 +455,7 @@ export class BaseQueryBuilder<TContext extends Context<Schema>> {
               Input
           >
         }
+        hasJoin: true
       }
     >
   >
@@ -474,6 +492,7 @@ export class BaseQueryBuilder<TContext extends Context<Schema>> {
         schema: TContext[`schema`] & {
           [K in T]: RemoveIndexSignature<TContext[`baseSchema`][T]>
         }
+        hasJoin: true
       }
     >
   >
@@ -513,6 +532,7 @@ export class BaseQueryBuilder<TContext extends Context<Schema>> {
         schema: TContext[`schema`] & {
           [K in TAs]: RemoveIndexSignature<TContext[`baseSchema`][TFrom]>
         }
+        hasJoin: true
       }
     >
   >
@@ -754,25 +774,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 +884,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",
@@ -192,6 +191,11 @@ export type Select<TContext extends Context = Context> =
         | AggregateFunctionCall<TContext>
     }
   | WildcardReferenceString<TContext>
+  | SelectCallback<TContext>
+
+export type SelectCallback<TContext extends Context = Context> = (
+  context: TContext extends { schema: infer S } ? S : any
+) => any
 
 export type As<TContext extends Context = Context> = string
 
@@ -200,14 +204,21 @@ export type From<TContext extends Context = Context> = InputReference<{
   schema: TContext[`baseSchema`]
 }>
 
-export type Where<TContext extends Context = Context> = Condition<TContext>
+export type WhereCallback<TContext extends Context = Context> = (
+  context: TContext extends { schema: infer S } ? S : any
+) => boolean
+
+export type Where<TContext extends Context = Context> = Array<
+  Condition<TContext> | WhereCallback<TContext>
+>
+
+// Having is the same implementation as a where clause, its just run after the group by
+export type Having<TContext extends Context = Context> = Where<TContext>
 
 export type GroupBy<TContext extends Context = Context> =
   | PropertyReference<TContext>
   | Array<PropertyReference<TContext>>
 
-export type Having<TContext extends Context = Context> = Condition<TContext>
-
 export type Limit<TContext extends Context = Context> = number
 
 export type Offset<TContext extends Context = Context> = number
@@ -217,13 +228,13 @@ 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>>
-  where?: Condition<TContext>
+  where?: Where<TContext>
   groupBy?: GroupBy<TContext>
-  having?: Condition<TContext>
+  having?: Having<TContext>
   orderBy?: OrderBy<TContext>
   limit?: Limit<TContext>
   offset?: Offset<TContext>
@@ -232,7 +243,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 +256,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,71 @@
 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 { ConditionOperand, Query, SelectCallback } 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) {
+        // Handle callback functions
+        if (typeof item === `function`) {
+          const callback = item as SelectCallback
+          const callbackResult = callback(namespacedRow)
+
+          // If the callback returns an object, merge its properties into the result
+          if (
+            callbackResult &&
+            typeof callbackResult === `object` &&
+            !Array.isArray(callbackResult)
+          ) {
+            Object.assign(result, callbackResult)
+          } else {
+            // If the callback returns a primitive value, we can't merge it
+            // This would need a specific key, but since we don't have one, we'll skip it
+            // In practice, select callbacks should return objects with keys
+            console.warn(
+              `SelectCallback returned a non-object value. SelectCallbacks should return objects with key-value pairs.`
+            )
+          }
+          continue
+        }
+
         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 +86,7 @@ export function processSelect(
               // Extract all columns from the specified table
               Object.assign(
                 result,
-                extractAllColumnsFromTable(nestedRow, tableAlias)
+                extractAllColumnsFromTable(namespacedRow, tableAlias)
               )
             }
             continue
@@ -68,12 +98,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 +125,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 +138,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 +156,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 +184,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

@@ -4,6 +4,7 @@ import type {
   PendingMutation,
   TransactionConfig,
   TransactionState,
+  TransactionWithMutations,
 } from "./types"
 
 function generateUUID() {
@@ -24,6 +25,7 @@ function generateUUID() {
 }
 
 const transactions: Array<Transaction> = []
+let transactionStack: Array<Transaction> = []
 
 export function createTransaction(config: TransactionConfig): Transaction {
   if (typeof config.mutationFn === `undefined`) {
@@ -35,13 +37,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 +59,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 +93,10 @@ export class Transaction {
 
   setState(newState: TransactionState) {
     this.state = newState
+
+    if (newState === `completed` || newState === `failed`) {
+      removeFromPendingList(this)
+    }
   }
 
   mutate(callback: () => void): Transaction {
@@ -130,22 +142,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 +164,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> {
@@ -172,11 +182,17 @@ export class Transaction {
 
     if (this.mutations.length === 0) {
       this.setState(`completed`)
+
+      return this
     }
 
     // Run mutationFn
     try {
-      await this.mutationFn({ transaction: this })
+      // At this point we know there's at least one mutation
+      // Use type assertion to tell TypeScript about this guarantee
+      const transactionWithMutations =
+        this as unknown as TransactionWithMutations
+      await this.mutationFn({ transaction: transactionWithMutations })
 
       this.setState(`completed`)
       this.touchCollection()