@tanstack/db 0.1.8 → 0.1.10

package/src/collection.ts

@@ -1,4 +1,5 @@
 import { withArrayChangeTracking, withChangeTracking } from "./proxy"
+import { deepEquals } from "./utils"
 import { SortedMap } from "./SortedMap"
 import {
   createSingleRowRefProxy,
@@ -1194,8 +1195,29 @@ export class CollectionImpl<
       }
     }
 
-    const hasTruncateSync = this.pendingSyncedTransactions.some(
-      (t) => t.truncate === true
+    // pending synced transactions could be either `committed` or still open.
+    // we only want to process `committed` transactions here
+    const {
+      committedSyncedTransactions,
+      uncommittedSyncedTransactions,
+      hasTruncateSync,
+    } = this.pendingSyncedTransactions.reduce(
+      (acc, t) => {
+        if (t.committed) {
+          acc.committedSyncedTransactions.push(t)
+          if (t.truncate === true) {
+            acc.hasTruncateSync = true
+          }
+        } else {
+          acc.uncommittedSyncedTransactions.push(t)
+        }
+        return acc
+      },
+      {
+        committedSyncedTransactions: [] as Array<PendingSyncedTransaction<T>>,
+        uncommittedSyncedTransactions: [] as Array<PendingSyncedTransaction<T>>,
+        hasTruncateSync: false,
+      }
     )
 
     if (!hasPersistingTransaction || hasTruncateSync) {
@@ -1204,7 +1226,7 @@ export class CollectionImpl<
 
       // First collect all keys that will be affected by sync operations
       const changedKeys = new Set<TKey>()
-      for (const transaction of this.pendingSyncedTransactions) {
+      for (const transaction of committedSyncedTransactions) {
         for (const operation of transaction.operations) {
           changedKeys.add(operation.key as TKey)
         }
@@ -1227,7 +1249,7 @@ export class CollectionImpl<
       const events: Array<ChangeMessage<T, TKey>> = []
       const rowUpdateMode = this.config.sync.rowUpdateMode || `partial`
 
-      for (const transaction of this.pendingSyncedTransactions) {
+      for (const transaction of committedSyncedTransactions) {
         // Handle truncate operations first
         if (transaction.truncate) {
           // TRUNCATE PHASE
@@ -1303,13 +1325,10 @@ export class CollectionImpl<
       // re-apply optimistic mutations on top of the fresh synced base. This ensures
       // the UI preserves local intent while respecting server rebuild semantics.
       // Ordering: deletes (above) -> server ops (just applied) -> optimistic upserts.
-      const hadTruncate = this.pendingSyncedTransactions.some(
-        (t) => t.truncate === true
-      )
-      if (hadTruncate) {
+      if (hasTruncateSync) {
         // Avoid duplicating keys that were inserted/updated by synced operations in this commit
         const syncedInsertedOrUpdatedKeys = new Set<TKey>()
-        for (const t of this.pendingSyncedTransactions) {
+        for (const t of committedSyncedTransactions) {
           for (const op of t.operations) {
             if (op.type === `insert` || op.type === `update`) {
               syncedInsertedOrUpdatedKeys.add(op.key as TKey)
@@ -1448,7 +1467,7 @@ export class CollectionImpl<
         const isRedundantSync =
           completedOp &&
           newVisibleValue !== undefined &&
-          this.deepEqual(completedOp.value, newVisibleValue)
+          deepEquals(completedOp.value, newVisibleValue)
 
         if (!isRedundantSync) {
           if (
@@ -1472,7 +1491,7 @@ export class CollectionImpl<
           } else if (
             previousVisibleValue !== undefined &&
             newVisibleValue !== undefined &&
-            !this.deepEqual(previousVisibleValue, newVisibleValue)
+            !deepEquals(previousVisibleValue, newVisibleValue)
           ) {
             events.push({
               type: `update`,
@@ -1495,7 +1514,7 @@ export class CollectionImpl<
       // End batching and emit all events (combines any batched events with sync events)
       this.emitEvents(events, true)
 
-      this.pendingSyncedTransactions = []
+      this.pendingSyncedTransactions = uncommittedSyncedTransactions
 
       // Clear the pre-sync state since sync operations are complete
       this.preSyncVisibleState.clear()
@@ -1715,29 +1734,6 @@ export class CollectionImpl<
     }
   }
 
-  private deepEqual(a: any, b: any): boolean {
-    if (a === b) return true
-    if (a == null || b == null) return false
-    if (typeof a !== typeof b) return false
-
-    if (typeof a === `object`) {
-      if (Array.isArray(a) !== Array.isArray(b)) return false
-
-      const keysA = Object.keys(a)
-      const keysB = Object.keys(b)
-      if (keysA.length !== keysB.length) return false
-
-      const keysBSet = new Set(keysB)
-      for (const key of keysA) {
-        if (!keysBSet.has(key)) return false
-        if (!this.deepEqual(a[key], b[key])) return false
-      }
-      return true
-    }
-
-    return false
-  }
-
   public validateData(
     data: unknown,
     type: `insert` | `update`,

package/src/proxy.ts

@@ -3,6 +3,8 @@
  * and provides a way to retrieve those changes.
  */
 
+import { deepEquals, isTemporal } from "./utils"
+
 /**
  * Simple debug utility that only logs when debug mode is enabled
  * Set DEBUG to true in localStorage to enable debug logging
@@ -133,6 +135,13 @@ function deepClone<T extends unknown>(
     return clone as unknown as T
   }
 
+  // Handle Temporal objects
+  if (isTemporal(obj)) {
+    // Temporal objects are immutable, so we can return them directly
+    // This preserves all their internal state correctly
+    return obj
+  }
+
   const clone = {} as Record<string | symbol, unknown>
   visited.set(obj as object, clone)
 
@@ -156,107 +165,6 @@ function deepClone<T extends unknown>(
   return clone as T
 }
 
-/**
- * Deep equality check that handles special types like Date, RegExp, Map, and Set
- */
-function deepEqual<T>(a: T, b: T): boolean {
-  // Handle primitive types
-  if (a === b) return true
-
-  // If either is null or not an object, they're not equal
-  if (
-    a === null ||
-    b === null ||
-    typeof a !== `object` ||
-    typeof b !== `object`
-  ) {
-    return false
-  }
-
-  // Handle Date objects
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime()
-  }
-
-  // Handle RegExp objects
-  if (a instanceof RegExp && b instanceof RegExp) {
-    return a.source === b.source && a.flags === b.flags
-  }
-
-  // Handle Map objects
-  if (a instanceof Map && b instanceof Map) {
-    if (a.size !== b.size) return false
-
-    const entries = Array.from(a.entries())
-    for (const [key, val] of entries) {
-      if (!b.has(key) || !deepEqual(val, b.get(key))) {
-        return false
-      }
-    }
-
-    return true
-  }
-
-  // Handle Set objects
-  if (a instanceof Set && b instanceof Set) {
-    if (a.size !== b.size) return false
-
-    // Convert to arrays for comparison
-    const aValues = Array.from(a)
-    const bValues = Array.from(b)
-
-    // Simple comparison for primitive values
-    if (aValues.every((val) => typeof val !== `object`)) {
-      return aValues.every((val) => b.has(val))
-    }
-
-    // For objects in sets, we need to do a more complex comparison
-    // This is a simplified approach and may not work for all cases
-    return aValues.length === bValues.length
-  }
-
-  // Handle arrays
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false
-
-    for (let i = 0; i < a.length; i++) {
-      if (!deepEqual(a[i], b[i])) return false
-    }
-
-    return true
-  }
-
-  // Handle TypedArrays
-  if (
-    ArrayBuffer.isView(a) &&
-    ArrayBuffer.isView(b) &&
-    !(a instanceof DataView) &&
-    !(b instanceof DataView)
-  ) {
-    const typedA = a as unknown as TypedArray
-    const typedB = b as unknown as TypedArray
-    if (typedA.length !== typedB.length) return false
-
-    for (let i = 0; i < typedA.length; i++) {
-      if (typedA[i] !== typedB[i]) return false
-    }
-
-    return true
-  }
-
-  // Handle plain objects
-  const keysA = Object.keys(a as object)
-  const keysB = Object.keys(b as object)
-
-  if (keysA.length !== keysB.length) return false
-
-  return keysA.every(
-    (key) =>
-      Object.prototype.hasOwnProperty.call(b, key) &&
-      deepEqual((a as any)[key], (b as any)[key])
-  )
-}
-
 let count = 0
 function getProxyCount() {
   count += 1
@@ -392,7 +300,7 @@ export function createChangeProxy<
         )
 
         // If the value is not equal to original, something is still changed
-        if (!deepEqual(currentValue, originalValue)) {
+        if (!deepEquals(currentValue, originalValue)) {
           debugLog(`Property ${String(prop)} is different, returning false`)
           return false
         }
@@ -411,7 +319,7 @@ export function createChangeProxy<
         const originalValue = (state.originalObject as any)[sym]
 
         // If the value is not equal to original, something is still changed
-        if (!deepEqual(currentValue, originalValue)) {
+        if (!deepEquals(currentValue, originalValue)) {
           debugLog(`Symbol property is different, returning false`)
           return false
         }
@@ -741,12 +649,13 @@ export function createChangeProxy<
           return value.bind(ptarget)
         }
 
-        // If the value is an object, create a proxy for it
+        // If the value is an object (but not Date, RegExp, or Temporal), create a proxy for it
         if (
           value &&
           typeof value === `object` &&
           !((value as any) instanceof Date) &&
-          !((value as any) instanceof RegExp)
+          !((value as any) instanceof RegExp) &&
+          !isTemporal(value)
         ) {
           // Create a parent reference for the nested object
           const nestedParent = {
@@ -779,11 +688,11 @@ export function createChangeProxy<
         )
 
         // Only track the change if the value is actually different
-        if (!deepEqual(currentValue, value)) {
+        if (!deepEquals(currentValue, value)) {
           // Check if the new value is equal to the original value
           // Important: Use the originalObject to get the true original value
           const originalValue = changeTracker.originalObject[prop as keyof T]
-          const isRevertToOriginal = deepEqual(value, originalValue)
+          const isRevertToOriginal = deepEquals(value, originalValue)
           debugLog(
             `value:`,
             value,

package/src/query/builder/index.ts

@@ -14,7 +14,6 @@ import type {
   BasicExpression,
   JoinClause,
   OrderBy,
-  OrderByClause,
   OrderByDirection,
   QueryIR,
 } from "../ir.js"
@@ -501,17 +500,23 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
                 : undefined,
           }
 
-    // Create the new OrderBy structure with expression and direction
-    const orderByClause: OrderByClause = {
-      expression: toExpression(result),
-      compareOptions: opts,
+    const makeOrderByClause = (res: any) => {
+      return {
+        expression: toExpression(res),
+        compareOptions: opts,
+      }
     }
 
+    // Create the new OrderBy structure with expression and direction
+    const orderByClauses = Array.isArray(result)
+      ? result.map((r) => makeOrderByClause(r))
+      : [makeOrderByClause(result)]
+
     const existingOrderBy: OrderBy = this.query.orderBy || []
 
     return new BaseQueryBuilder({
       ...this.query,
-      orderBy: [...existingOrderBy, orderByClause],
+      orderBy: [...existingOrderBy, ...orderByClauses],
     }) as any
   }
 

package/src/query/compiler/group-by.ts

@@ -130,7 +130,7 @@ export function processGroupBy(
     if (havingClauses && havingClauses.length > 0) {
       for (const havingClause of havingClauses) {
         const havingExpression = getHavingExpression(havingClause)
-        const transformedHavingClause = transformHavingClause(
+        const transformedHavingClause = replaceAggregatesByRefs(
           havingExpression,
           selectClause || {}
         )
@@ -265,7 +265,7 @@ export function processGroupBy(
   if (havingClauses && havingClauses.length > 0) {
     for (const havingClause of havingClauses) {
       const havingExpression = getHavingExpression(havingClause)
-      const transformedHavingClause = transformHavingClause(
+      const transformedHavingClause = replaceAggregatesByRefs(
         havingExpression,
         selectClause || {}
       )
@@ -367,11 +367,12 @@ function getAggregateFunction(aggExpr: Aggregate) {
 }
 
 /**
- * Transforms a HAVING clause to replace Agg expressions with references to computed values
+ * Transforms basic expressions and aggregates to replace Agg expressions with references to computed values
  */
-function transformHavingClause(
+export function replaceAggregatesByRefs(
   havingExpr: BasicExpression | Aggregate,
-  selectClause: Select
+  selectClause: Select,
+  resultAlias: string = `result`
 ): BasicExpression {
   switch (havingExpr.type) {
     case `agg`: {
@@ -380,7 +381,7 @@ function transformHavingClause(
       for (const [alias, selectExpr] of Object.entries(selectClause)) {
         if (selectExpr.type === `agg` && aggregatesEqual(aggExpr, selectExpr)) {
           // Replace with a reference to the computed aggregate
-          return new PropRef([`result`, alias])
+          return new PropRef([resultAlias, alias])
         }
       }
       // If no matching aggregate found in SELECT, throw error
@@ -392,7 +393,7 @@ function transformHavingClause(
       // Transform function arguments recursively
       const transformedArgs = funcExpr.args.map(
         (arg: BasicExpression | Aggregate) =>
-          transformHavingClause(arg, selectClause)
+          replaceAggregatesByRefs(arg, selectClause)
       )
       return new Func(funcExpr.name, transformedArgs)
     }
@@ -404,7 +405,7 @@ function transformHavingClause(
         const alias = refExpr.path[0]!
         if (selectClause[alias]) {
           // This is a reference to a SELECT alias, convert to result.alias
-          return new PropRef([`result`, alias])
+          return new PropRef([resultAlias, alias])
         }
       }
       // Return as-is for other refs

package/src/query/compiler/index.ts

@@ -259,6 +259,7 @@ export function compileQuery(
       rawQuery,
       pipeline,
       query.orderBy,
+      query.select || {},
       collections[mainCollectionId]!,
       optimizableOrderByCollections,
       query.limit,

package/src/query/compiler/order-by.ts

@@ -4,9 +4,10 @@ import { PropRef } from "../ir.js"
 import { ensureIndexForField } from "../../indexes/auto-index.js"
 import { findIndexForField } from "../../utils/index-optimization.js"
 import { compileExpression } from "./evaluators.js"
+import { replaceAggregatesByRefs } from "./group-by.js"
 import { followRef } from "./index.js"
 import type { CompiledSingleRowExpression } from "./evaluators.js"
-import type { OrderByClause, QueryIR } from "../ir.js"
+import type { OrderByClause, QueryIR, Select } from "../ir.js"
 import type { NamespacedAndKeyedStream, NamespacedRow } from "../../types.js"
 import type { IStreamBuilder, KeyValue } from "@tanstack/db-ivm"
 import type { BaseIndex } from "../../indexes/base-index.js"
@@ -33,16 +34,24 @@ export function processOrderBy(
   rawQuery: QueryIR,
   pipeline: NamespacedAndKeyedStream,
   orderByClause: Array<OrderByClause>,
+  selectClause: Select,
   collection: Collection,
   optimizableOrderByCollections: Record<string, OrderByOptimizationInfo>,
   limit?: number,
   offset?: number
 ): IStreamBuilder<KeyValue<unknown, [NamespacedRow, string]>> {
   // Pre-compile all order by expressions
-  const compiledOrderBy = orderByClause.map((clause) => ({
-    compiledExpression: compileExpression(clause.expression),
-    compareOptions: clause.compareOptions,
-  }))
+  const compiledOrderBy = orderByClause.map((clause) => {
+    const clauseWithoutAggregates = replaceAggregatesByRefs(
+      clause.expression,
+      selectClause,
+      `__select_results`
+    )
+    return {
+      compiledExpression: compileExpression(clauseWithoutAggregates),
+      compareOptions: clause.compareOptions,
+    }
+  })
 
   // Create a value extractor function for the orderBy operator
   const valueExtractor = (row: NamespacedRow & { __select_results?: any }) => {

package/src/query/live/collection-config-builder.ts

@@ -49,15 +49,11 @@ export class CollectionConfigBuilder<
     | undefined
 
   // Map of collection IDs to functions that load keys for that lazy collection
-  readonly lazyCollectionsCallbacks: Record<string, LazyCollectionCallbacks> =
-    {}
+  lazyCollectionsCallbacks: Record<string, LazyCollectionCallbacks> = {}
   // Set of collection IDs that are lazy collections
   readonly lazyCollections = new Set<string>()
   // Set of collection IDs that include an optimizable ORDER BY clause
-  readonly optimizableOrderByCollections: Record<
-    string,
-    OrderByOptimizationInfo
-  > = {}
+  optimizableOrderByCollections: Record<string, OrderByOptimizationInfo> = {}
 
   constructor(
     private readonly config: LiveQueryCollectionConfig<TContext, TResult>
@@ -168,6 +164,11 @@ export class CollectionConfigBuilder<
       this.inputsCache = undefined
       this.pipelineCache = undefined
       this.collectionWhereClausesCache = undefined
+
+      // Reset lazy collection state
+      this.lazyCollections.clear()
+      this.optimizableOrderByCollections = {}
+      this.lazyCollectionsCallbacks = {}
     }
   }
 

package/src/utils.ts

@@ -2,8 +2,14 @@
  * Generic utility functions
  */
 
+interface TypedArray {
+  length: number
+  [index: number]: number
+}
+
 /**
  * Deep equality function that compares two values recursively
+ * Handles primitives, objects, arrays, Date, RegExp, Map, Set, TypedArrays, and Temporal objects
  *
  * @param a - First value to compare
  * @param b - Second value to compare
@@ -14,6 +20,8 @@
  * deepEquals({ a: 1, b: 2 }, { b: 2, a: 1 }) // true (property order doesn't matter)
  * deepEquals([1, { x: 2 }], [1, { x: 2 }]) // true
  * deepEquals({ a: 1 }, { a: 2 }) // false
+ * deepEquals(new Date('2023-01-01'), new Date('2023-01-01')) // true
+ * deepEquals(new Map([['a', 1]]), new Map([['a', 1]])) // true
  * ```
  */
 export function deepEquals(a: any, b: any): boolean {
@@ -37,6 +45,102 @@ function deepEqualsInternal(
   // Handle different types
   if (typeof a !== typeof b) return false
 
+  // Handle Date objects
+  if (a instanceof Date) {
+    if (!(b instanceof Date)) return false
+    return a.getTime() === b.getTime()
+  }
+
+  // Handle RegExp objects
+  if (a instanceof RegExp) {
+    if (!(b instanceof RegExp)) return false
+    return a.source === b.source && a.flags === b.flags
+  }
+
+  // Handle Map objects - only if both are Maps
+  if (a instanceof Map) {
+    if (!(b instanceof Map)) return false
+    if (a.size !== b.size) return false
+
+    // Check for circular references
+    if (visited.has(a)) {
+      return visited.get(a) === b
+    }
+    visited.set(a, b)
+
+    const entries = Array.from(a.entries())
+    const result = entries.every(([key, val]) => {
+      return b.has(key) && deepEqualsInternal(val, b.get(key), visited)
+    })
+
+    visited.delete(a)
+    return result
+  }
+
+  // Handle Set objects - only if both are Sets
+  if (a instanceof Set) {
+    if (!(b instanceof Set)) return false
+    if (a.size !== b.size) return false
+
+    // Check for circular references
+    if (visited.has(a)) {
+      return visited.get(a) === b
+    }
+    visited.set(a, b)
+
+    // Convert to arrays for comparison
+    const aValues = Array.from(a)
+    const bValues = Array.from(b)
+
+    // Simple comparison for primitive values
+    if (aValues.every((val) => typeof val !== `object`)) {
+      visited.delete(a)
+      return aValues.every((val) => b.has(val))
+    }
+
+    // For objects in sets, we need to do a more complex comparison
+    // This is a simplified approach and may not work for all cases
+    const result = aValues.length === bValues.length
+    visited.delete(a)
+    return result
+  }
+
+  // Handle TypedArrays
+  if (
+    ArrayBuffer.isView(a) &&
+    ArrayBuffer.isView(b) &&
+    !(a instanceof DataView) &&
+    !(b instanceof DataView)
+  ) {
+    const typedA = a as unknown as TypedArray
+    const typedB = b as unknown as TypedArray
+    if (typedA.length !== typedB.length) return false
+
+    for (let i = 0; i < typedA.length; i++) {
+      if (typedA[i] !== typedB[i]) return false
+    }
+
+    return true
+  }
+
+  // Handle Temporal objects
+  // Check if both are Temporal objects of the same type
+  if (isTemporal(a) && isTemporal(b)) {
+    const aTag = getStringTag(a)
+    const bTag = getStringTag(b)
+
+    // If they're different Temporal types, they're not equal
+    if (aTag !== bTag) return false
+
+    // Use Temporal's built-in equals method if available
+    if (typeof a.equals === `function`) {
+      return a.equals(b)
+    }
+
+    // Fallback to toString comparison for other types
+    return a.toString() === b.toString()
+  }
+
   // Handle arrays
   if (Array.isArray(a)) {
     if (!Array.isArray(b) || a.length !== b.length) return false
@@ -84,3 +188,24 @@ function deepEqualsInternal(
   // For primitives that aren't strictly equal
   return false
 }
+
+const temporalTypes = [
+  `Temporal.Duration`,
+  `Temporal.Instant`,
+  `Temporal.PlainDate`,
+  `Temporal.PlainDateTime`,
+  `Temporal.PlainMonthDay`,
+  `Temporal.PlainTime`,
+  `Temporal.PlainYearMonth`,
+  `Temporal.ZonedDateTime`,
+]
+
+function getStringTag(a: any): any {
+  return a[Symbol.toStringTag]
+}
+
+/** Checks if the value is a Temporal object by checking for the Temporal brand */
+export function isTemporal(a: any): boolean {
+  const tag = getStringTag(a)
+  return typeof tag === `string` && temporalTypes.includes(tag)
+}