@tanstack/db 0.5.2 → 0.5.4

package/src/query/live/collection-subscriber.ts

@@ -1,9 +1,8 @@
 import { MultiSet } from "@tanstack/db-ivm"
 import {
-  convertOrderByToBasicExpression,
-  convertToBasicExpression,
+  normalizeExpressionPaths,
+  normalizeOrderByPaths,
 } from "../compiler/expressions.js"
-import { WhereClauseConversionError } from "../../errors.js"
 import type { MultiSetArray, RootStreamBuilder } from "@tanstack/db-ivm"
 import type { Collection } from "../../collection/index.js"
 import type { ChangeMessage } from "../../types.js"
@@ -41,13 +40,8 @@ export class CollectionSubscriber<
     const whereClause = this.getWhereClauseForAlias()
 
     if (whereClause) {
-      const whereExpression = convertToBasicExpression(whereClause, this.alias)
-
-      if (whereExpression) {
-        return this.subscribeToChanges(whereExpression)
-      }
-
-      throw new WhereClauseConversionError(this.collectionId, this.alias)
+      const whereExpression = normalizeExpressionPaths(whereClause, this.alias)
+      return this.subscribeToChanges(whereExpression)
     }
 
     return this.subscribeToChanges()
@@ -199,10 +193,7 @@ export class CollectionSubscriber<
     subscription.setOrderByIndex(index)
 
     // Normalize the orderBy clauses such that the references are relative to the collection
-    const normalizedOrderBy = convertOrderByToBasicExpression(
-      orderBy,
-      this.alias
-    )
+    const normalizedOrderBy = normalizeOrderByPaths(orderBy, this.alias)
 
     // Load the first `offset + limit` values from the index
     // i.e. the K items from the collection that fall into the requested range: [offset, offset + limit[
@@ -289,10 +280,7 @@ export class CollectionSubscriber<
       : biggestSentRow
 
     // Normalize the orderBy clauses such that the references are relative to the collection
-    const normalizedOrderBy = convertOrderByToBasicExpression(
-      orderBy,
-      this.alias
-    )
+    const normalizedOrderBy = normalizeOrderByPaths(orderBy, this.alias)
 
     // Take the `n` items after the biggest sent value
     subscription.requestLimitedSnapshot({

package/src/query/optimizer.ts

@@ -131,7 +131,6 @@ import {
   getWhereExpression,
   isResidualWhere,
 } from "./ir.js"
-import { isConvertibleToCollectionFilter } from "./compiler/expressions.js"
 import type { BasicExpression, From, QueryIR, Select, Where } from "./ir.js"
 
 /**
@@ -248,14 +247,10 @@ function extractSourceWhereClauses(
   const groupedClauses = groupWhereClauses(analyzedClauses)
 
   // Only include single-source clauses that reference collections directly
-  // and can be converted to BasicExpression format for collection indexes
   for (const [sourceAlias, whereClause] of groupedClauses.singleSource) {
     // Check if this source alias corresponds to a collection reference
     if (isCollectionReference(query, sourceAlias)) {
-      // Check if the WHERE clause can be converted to collection-compatible format
-      if (isConvertibleToCollectionFilter(whereClause)) {
-        sourceWhereClauses.set(sourceAlias, whereClause)
-      }
+      sourceWhereClauses.set(sourceAlias, whereClause)
     }
   }
 

package/src/strategies/debounceStrategy.ts

@@ -1,4 +1,4 @@
-import { Debouncer } from "@tanstack/pacer/debouncer"
+import { LiteDebouncer } from "@tanstack/pacer-lite/lite-debouncer"
 import type { DebounceStrategy, DebounceStrategyOptions } from "./types"
 import type { Transaction } from "../transactions"
 
@@ -28,7 +28,7 @@ import type { Transaction } from "../transactions"
 export function debounceStrategy(
   options: DebounceStrategyOptions
 ): DebounceStrategy {
-  const debouncer = new Debouncer(
+  const debouncer = new LiteDebouncer(
     (callback: () => Transaction) => callback(),
     options
   )

package/src/strategies/queueStrategy.ts

@@ -1,4 +1,4 @@
-import { AsyncQueuer } from "@tanstack/pacer/async-queuer"
+import { LiteQueuer } from "@tanstack/pacer-lite/lite-queuer"
 import type { QueueStrategy, QueueStrategyOptions } from "./types"
 import type { Transaction } from "../transactions"
 
@@ -44,16 +44,29 @@ import type { Transaction } from "../transactions"
  * ```
  */
 export function queueStrategy(options?: QueueStrategyOptions): QueueStrategy {
-  const queuer = new AsyncQueuer<() => Transaction>(
-    async (fn) => {
-      const transaction = fn()
-      // Wait for the transaction to be persisted before processing next item
-      // Note: fn() already calls commit(), we just wait for it to complete
-      await transaction.isPersisted.promise
+  // Manual promise chaining to ensure async serialization
+  // LiteQueuer (unlike AsyncQueuer from @tanstack/pacer) lacks built-in async queue
+  // primitives and concurrency control. We compensate by manually chaining promises
+  // to ensure each transaction completes before the next one starts.
+  let processingChain = Promise.resolve()
+
+  const queuer = new LiteQueuer<() => Transaction>(
+    (fn) => {
+      // Chain each transaction to the previous one's completion
+      processingChain = processingChain
+        .then(async () => {
+          const transaction = fn()
+          // Wait for the transaction to be persisted before processing next item
+          await transaction.isPersisted.promise
+        })
+        .catch(() => {
+          // Errors are handled via transaction.isPersisted.promise and surfaced there.
+          // This catch prevents unhandled promise rejections from breaking the chain,
+          // ensuring subsequent transactions can still execute even if one fails.
+        })
     },
     {
-      concurrency: 1, // Process one at a time to ensure serialization
-      wait: options?.wait,
+      wait: options?.wait ?? 0,
       maxSize: options?.maxSize,
       addItemsTo: options?.addItemsTo ?? `back`, // Default FIFO: add to back
       getItemsFrom: options?.getItemsFrom ?? `front`, // Default FIFO: get from front

package/src/strategies/throttleStrategy.ts

@@ -1,4 +1,4 @@
-import { Throttler } from "@tanstack/pacer/throttler"
+import { LiteThrottler } from "@tanstack/pacer-lite/lite-throttler"
 import type { ThrottleStrategy, ThrottleStrategyOptions } from "./types"
 import type { Transaction } from "../transactions"
 
@@ -48,7 +48,7 @@ import type { Transaction } from "../transactions"
 export function throttleStrategy(
   options: ThrottleStrategyOptions
 ): ThrottleStrategy {
-  const throttler = new Throttler(
+  const throttler = new LiteThrottler(
     (callback: () => Transaction) => callback(),
     options
   )

package/src/types.ts

@@ -139,7 +139,26 @@ export type NonEmptyArray<T> = [T, ...Array<T>]
 export type TransactionWithMutations<
   T extends object = Record<string, unknown>,
   TOperation extends OperationType = OperationType,
-> = Transaction<T> & {
+> = Omit<Transaction<T>, `mutations`> & {
+  /**
+   * We must omit the `mutations` property from `Transaction<T>` before intersecting
+   * because TypeScript intersects property types when the same property appears on
+   * both sides of an intersection.
+   *
+   * Without `Omit`:
+   * - `Transaction<T>` has `mutations: Array<PendingMutation<T>>`
+   * - The intersection would create: `Array<PendingMutation<T>> & NonEmptyArray<PendingMutation<T, TOperation>>`
+   * - When mapping over this array, TypeScript widens `TOperation` from the specific literal
+   *   (e.g., `"delete"`) to the union `OperationType` (`"insert" | "update" | "delete"`)
+   * - This causes `PendingMutation<T, OperationType>` to evaluate the conditional type
+   *   `original: TOperation extends 'insert' ? {} : T` as `{} | T` instead of just `T`
+   *
+   * With `Omit`:
+   * - We remove `mutations` from `Transaction<T>` first
+   * - Then add back `mutations: NonEmptyArray<PendingMutation<T, TOperation>>`
+   * - TypeScript can properly narrow `TOperation` to the specific literal type
+   * - This ensures `mutation.original` is correctly typed as `T` (not `{} | T`) when mapping
+   */
   mutations: NonEmptyArray<PendingMutation<T, TOperation>>
 }