@tanstack/db 0.2.2 → 0.2.4

package/src/collection.ts

@@ -395,13 +395,14 @@ export class CollectionImpl<
         const callbacks = [...this.onFirstReadyCallbacks]
         this.onFirstReadyCallbacks = []
         callbacks.forEach((callback) => callback())
-
-        // to notify subscribers (like LiveQueryCollection) that the collection is ready
-        if (this.changeListeners.size > 0) {
-          this.emitEmptyReadyEvent()
-        }
       }
     }
+
+    // Always notify dependents when markReady is called, after status is set
+    // This ensures live queries get notified when their dependencies become ready
+    if (this.changeListeners.size > 0) {
+      this.emitEmptyReadyEvent()
+    }
   }
 
   public id = ``
@@ -1270,6 +1271,13 @@ export class CollectionImpl<
           this.syncedData.clear()
           this.syncedMetadata.clear()
           this.syncedKeys.clear()
+
+          // 3) Clear currentVisibleState for truncated keys to ensure subsequent operations
+          //    are compared against the post-truncate state (undefined) rather than pre-truncate state
+          //    This ensures that re-inserted keys are emitted as INSERT events, not UPDATE events
+          for (const key of changedKeys) {
+            currentVisibleState.delete(key)
+          }
         }
 
         for (const operation of transaction.operations) {

package/src/query/builder/types.ts

@@ -500,20 +500,20 @@ export type Ref<T = any> = {
   [K in keyof T]: IsNonExactOptional<T[K]> extends true
     ? IsNonExactNullable<T[K]> extends true
       ? // Both optional and nullable
-        NonNullable<T[K]> extends Record<string, any>
+        IsPlainObject<NonNullable<T[K]>> extends true
         ? Ref<NonNullable<T[K]>> | undefined
         : RefLeaf<NonNullable<T[K]>> | undefined
       : // Optional only
-        NonUndefined<T[K]> extends Record<string, any>
+        IsPlainObject<NonUndefined<T[K]>> extends true
         ? Ref<NonUndefined<T[K]>> | undefined
         : RefLeaf<NonUndefined<T[K]>> | undefined
     : IsNonExactNullable<T[K]> extends true
       ? // Nullable only
-        NonNull<T[K]> extends Record<string, any>
+        IsPlainObject<NonNull<T[K]>> extends true
         ? Ref<NonNull<T[K]>> | null
         : RefLeaf<NonNull<T[K]>> | null
       : // Required
-        T[K] extends Record<string, any>
+        IsPlainObject<T[K]> extends true
         ? Ref<T[K]>
         : RefLeaf<T[K]>
 } & RefLeaf<T>
@@ -825,3 +825,48 @@ export type WithResult<TContext extends Context, TResult> = Prettify<
 export type Prettify<T> = {
   [K in keyof T]: T[K]
 } & {}
+
+/**
+ * IsPlainObject - Utility type to check if T is a plain object
+ */
+type IsPlainObject<T> = T extends unknown
+  ? T extends object
+    ? T extends ReadonlyArray<any>
+      ? false
+      : T extends JsBuiltIns
+        ? false
+        : true
+    : false
+  : false
+
+/**
+ * JsBuiltIns - List of JavaScript built-ins
+ */
+type JsBuiltIns =
+  | ArrayBuffer
+  | ArrayBufferLike
+  | AsyncGenerator<any, any, any>
+  | BigInt64Array
+  | BigUint64Array
+  | DataView
+  | Date
+  | Error
+  | Float32Array
+  | Float64Array
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  | Function
+  | Generator<any, any, any>
+  | Int16Array
+  | Int32Array
+  | Int8Array
+  | Map<any, any>
+  | Promise<any>
+  | RegExp
+  | Set<any>
+  | string
+  | Uint16Array
+  | Uint32Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | WeakMap<any, any>
+  | WeakSet<any>

package/src/query/compiler/joins.ts

@@ -243,7 +243,7 @@ function processJoin(
       const activePipelineWithLoading: IStreamBuilder<
         [key: unknown, [originalKey: string, namespacedRow: NamespacedRow]]
       > = activePipeline.pipe(
-        tap(([joinKey, _]) => {
+        tap((data) => {
           if (deoptimized) {
             return
           }
@@ -270,10 +270,11 @@ function processJoin(
 
           const { loadKeys, loadInitialState } = collectionCallbacks
 
-          if (index && index.supports(`eq`)) {
+          if (index && index.supports(`in`)) {
             // Use the index to fetch the PKs of the rows in the lazy collection
             // that match this row from the active collection based on the value of the joinKey
-            const matchingKeys = index.lookup(`eq`, joinKey)
+            const joinKeys = data.getInner().map(([[joinKey]]) => joinKey)
+            const matchingKeys = index.lookup(`in`, joinKeys)
             // Inform the lazy collection that those keys need to be loaded
             loadKeys(matchingKeys)
           } else {

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

@@ -138,6 +138,7 @@ export class CollectionSubscriber<
     keys: Iterable<string | number>,
     filterFn: (item: object) => boolean
   ) {
+    const changes: Array<ChangeMessage<any, string | number>> = []
     for (const key of keys) {
       // Only load the key once
       if (this.sentKeys.has(key)) continue
@@ -145,9 +146,12 @@ export class CollectionSubscriber<
       const value = this.collection.get(key)
       if (value !== undefined && filterFn(value)) {
         this.sentKeys.add(key)
-        this.sendChangesToPipeline([{ type: `insert`, key, value }])
+        changes.push({ type: `insert`, key, value })
       }
     }
+    if (changes.length > 0) {
+      this.sendChangesToPipeline(changes)
+    }
   }
 
   private subscribeToAllChanges(