@tanstack/db 0.1.7 → 0.1.9

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

@@ -85,20 +85,20 @@ export class CollectionSubscriber<
       changes,
       this.collection.config.getKey
     )
-    if (sentChanges > 0 || !this.collectionConfigBuilder.isCollectionReady()) {
-      // Only run the graph if we sent any changes
-      // otherwise we may get into an infinite loop
-      // trying to load more data for the orderBy query
-      // when there's no more data in the collection
-      // EXCEPTION: if the collection is not yet ready
-      //            we need to run it even if there are no changes
-      //            in order for the collection to be marked as ready
-      this.collectionConfigBuilder.maybeRunGraph(
-        this.config,
-        this.syncState,
-        callback
-      )
-    }
+
+    // Do not provide the callback that loads more data
+    // if there's no more data to load
+    // otherwise we end up in an infinite loop trying to load more data
+    const dataLoader = sentChanges > 0 ? callback : undefined
+
+    // We need to call `maybeRunGraph` even if there's no data to load
+    // because we need to mark the collection as ready if it's not already
+    // and that's only done in `maybeRunGraph`
+    this.collectionConfigBuilder.maybeRunGraph(
+      this.config,
+      this.syncState,
+      dataLoader
+    )
   }
 
   // Wraps the sendChangesToPipeline function
@@ -229,7 +229,7 @@ export class CollectionSubscriber<
   private subscribeToOrderedChanges(
     whereExpression: BasicExpression<boolean> | undefined
   ) {
-    const { offset, limit, comparator } =
+    const { offset, limit, comparator, dataNeeded } =
       this.collectionConfigBuilder.optimizableOrderByCollections[
         this.collectionId
       ]!
@@ -245,11 +245,18 @@ export class CollectionSubscriber<
       // and filter out changes that are bigger than the biggest value we've sent so far
       // because they can't affect the topK
       const splittedChanges = splitUpdates(changes)
-      const filteredChanges = filterChangesSmallerOrEqualToMax(
-        splittedChanges,
-        comparator,
-        this.biggest
-      )
+      let filteredChanges = splittedChanges
+      if (dataNeeded!() === 0) {
+        // If the topK is full [..., maxSentValue] then we do not need to send changes > maxSentValue
+        // because they can never make it into the topK.
+        // However, if the topK isn't full yet, we need to also send changes > maxSentValue
+        // because they will make it into the topK
+        filteredChanges = filterChangesSmallerOrEqualToMax(
+          splittedChanges,
+          comparator,
+          this.biggest
+        )
+      }
       this.sendChangesToPipeline(
         filteredChanges,
         this.loadMoreIfNeeded.bind(this)
@@ -268,11 +275,19 @@ export class CollectionSubscriber<
   // This function is called by maybeRunGraph
   // after each iteration of the query pipeline
   // to ensure that the orderBy operator has enough data to work with
-  private loadMoreIfNeeded() {
-    const { dataNeeded } =
+  loadMoreIfNeeded() {
+    const orderByInfo =
       this.collectionConfigBuilder.optimizableOrderByCollections[
         this.collectionId
-      ]!
+      ]
+
+    if (!orderByInfo) {
+      // This query has no orderBy operator
+      // so there's no data to load, just return true
+      return true
+    }
+
+    const { dataNeeded } = orderByInfo
 
     if (!dataNeeded) {
       // This should never happen because the topK operator should always set the size callback
@@ -285,12 +300,15 @@ export class CollectionSubscriber<
     // `dataNeeded` probes the orderBy operator to see if it needs more data
     // if it needs more data, it returns the number of items it needs
     const n = dataNeeded()
+    let noMoreNextItems = false
     if (n > 0) {
-      this.loadNextItems(n)
+      const loadedItems = this.loadNextItems(n)
+      noMoreNextItems = loadedItems === 0
     }
 
     // Indicate that we're done loading data if we didn't need to load more data
-    return n === 0
+    // or there's no more data to load
+    return n === 0 || noMoreNextItems
   }
 
   private sendChangesToPipelineWithTracking(
@@ -322,6 +340,7 @@ export class CollectionSubscriber<
         return { type: `insert`, key, value: this.collection.get(key) }
       })
     this.sendChangesToPipelineWithTracking(nextInserts)
+    return nextInserts.length
   }
 
   private getWhereClauseFromAlias(

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)
+}