@tanstack/db 0.5.5 → 0.5.7

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

@@ -406,6 +406,16 @@ export class CollectionConfigBuilder<
       return Array.from(deps)
     })()
 
+    // Ensure dependent builders are actually scheduled in this context so that
+    // dependency edges always point to a real job (or a deduped no-op if already scheduled).
+    if (contextId) {
+      for (const dep of dependentBuilders) {
+        if (typeof dep.scheduleGraphRun === `function`) {
+          dep.scheduleGraphRun(undefined, { contextId })
+        }
+      }
+    }
+
     // We intentionally scope deduplication to the builder instance. Each instance
     // owns caches and compiled pipelines, so sharing work across instances that
     // merely reuse the same string id would execute the wrong builder's graph.
@@ -451,6 +461,13 @@ export class CollectionConfigBuilder<
     this.pendingGraphRuns.delete(contextId)
   }
 
+  /**
+   * Returns true if this builder has a pending graph run for the given context.
+   */
+  hasPendingGraphRun(contextId: SchedulerContextId): boolean {
+    return this.pendingGraphRuns.has(contextId)
+  }
+
   /**
    * Executes a pending graph run. Called by the scheduler when dependencies are satisfied.
    * Clears the pending state BEFORE execution so that any re-schedules during the run

package/src/scheduler.ts

@@ -25,6 +25,18 @@ interface SchedulerContextState {
   completed: Set<unknown>
 }
 
+interface PendingAwareJob {
+  hasPendingGraphRun: (contextId: SchedulerContextId) => boolean
+}
+
+function isPendingAwareJob(dep: any): dep is PendingAwareJob {
+  return (
+    typeof dep === `object` &&
+    dep !== null &&
+    typeof dep.hasPendingGraphRun === `function`
+  )
+}
+
 /**
  * Scoped scheduler that coalesces work by context and job.
  *
@@ -119,7 +131,19 @@ export class Scheduler {
         if (deps) {
           ready = true
           for (const dep of deps) {
-            if (dep !== jobId && !completed.has(dep)) {
+            if (dep === jobId) continue
+
+            const depHasPending =
+              isPendingAwareJob(dep) && dep.hasPendingGraphRun(contextId)
+
+            // Treat dependencies as blocking if the dep has a pending run in this
+            // context or if it's enqueued and not yet complete. If the dep is
+            // neither pending nor enqueued, consider it satisfied to avoid deadlocks
+            // on lazy sources that never schedule work.
+            if (
+              (jobs.has(dep) && !completed.has(dep)) ||
+              (!jobs.has(dep) && depHasPending)
+            ) {
               ready = false
               break
             }