@tanstack/db-sqlite-persistence-core 0.2.19 → 0.2.21

package/dist/cjs/persisted.cjs

@@ -388,17 +388,12 @@ class PersistedCollectionRuntime {
     await this.waitForAppliedReceiptsAfter(appliedCursor);
     if (upstreamLoadSubset) {
       try {
-        const maybePromise = upstreamLoadSubset(options);
-        if (maybePromise instanceof Promise) {
-          await maybePromise.catch((error) => {
-            console.warn(
-              `Failed to load remote subset in persisted wrapper:`,
-              error
-            );
-            this.queueRemoteSubsetEnsure(options);
-          });
-        }
+        await upstreamLoadSubset(options);
       } catch (error) {
+        if (options.signal?.aborted || typeof error === `object` && error !== null && `name` in error && error.name === `AbortError`) {
+          this.pendingRemoteSubsetEnsures.delete(this.getSubsetKey(options));
+          throw error;
+        }
         console.warn(`Failed to trigger remote subset load:`, error);
         this.queueRemoteSubsetEnsure(options);
       }
@@ -406,6 +401,7 @@ class PersistedCollectionRuntime {
   }
   unloadSubset(options, upstreamUnloadSubset) {
     this.activeSubsets.delete(this.getSubsetKey(options));
+    this.pendingRemoteSubsetEnsures.delete(this.getSubsetKey(options));
     upstreamUnloadSubset?.(options);
   }
   async forceReloadSubset(options) {
@@ -965,7 +961,7 @@ class PersistedCollectionRuntime {
     return `opts:${stableSerialize(normalizeSubsetOptionsForKey(options))}`;
   }
   queueRemoteSubsetEnsure(options) {
-    if (this.mode !== `sync-present` || !this.persistence.coordinator.requestEnsureRemoteSubset) {
+    if (this.mode !== `sync-present` || !this.persistence.coordinator.requestEnsureRemoteSubset || this.activeSubsets.get(this.getSubsetKey(options)) !== options) {
       return;
     }
     this.pendingRemoteSubsetEnsures.set(this.getSubsetKey(options), options);
@@ -1299,23 +1295,7 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime) {
       const transactionStack = [];
       const getOpenTransaction = () => transactionStack[transactionStack.length - 1];
       let fullStartPromise = null;
-      const cancelledLoadKeys = /* @__PURE__ */ new Set();
-      const loadSubscriptionIds = /* @__PURE__ */ new WeakMap();
-      let nextLoadSubscriptionId = 0;
-      const getLoadKey = (options) => {
-        const subscription = options.subscription;
-        if (subscription && typeof subscription === `object`) {
-          const existingId = loadSubscriptionIds.get(subscription);
-          if (existingId) {
-            return `sub:${existingId}`;
-          }
-          nextLoadSubscriptionId++;
-          const nextId = String(nextLoadSubscriptionId);
-          loadSubscriptionIds.set(subscription, nextId);
-          return `sub:${nextId}`;
-        }
-        return `opts:${stableSerialize(normalizeSubsetOptionsForKey(options))}`;
-      };
+      const acquisitions = /* @__PURE__ */ new Map();
       runtime.setSyncControls({
         begin: params.begin,
         write: params.write,
@@ -1570,23 +1550,40 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime) {
       return {
         cleanup: () => {
           startupState.cleanedUp = true;
+          acquisitions.clear();
           sourceResult.cleanup?.();
           runtime.cleanup();
           runtime.clearSyncControls();
         },
         loadSubset: async (options) => {
-          const loadKey = getLoadKey(options);
-          cancelledLoadKeys.delete(loadKey);
+          const acquisition = { forwarded: false };
+          acquisitions.set(options, acquisition);
           await fullStartPromise;
           const resolvedSourceResult = await sourceResultPromise;
-          if (startupState.cleanedUp || cancelledLoadKeys.has(loadKey)) {
+          if (startupState.cleanedUp || acquisitions.get(options) !== acquisition) {
             return;
           }
-          await runtime.loadSubset(options, resolvedSourceResult.loadSubset);
+          return runtime.loadSubset(options, (loadOptions) => {
+            if (startupState.cleanedUp || acquisitions.get(options) !== acquisition) {
+              return true;
+            }
+            if (!resolvedSourceResult.loadSubset) return true;
+            acquisition.forwarded = true;
+            try {
+              return resolvedSourceResult.loadSubset(loadOptions);
+            } catch (error) {
+              acquisition.forwarded = false;
+              throw error;
+            }
+          });
         },
         unloadSubset: (options) => {
-          cancelledLoadKeys.add(getLoadKey(options));
-          runtime.unloadSubset(options, sourceResult.unloadSubset);
+          const acquisition = acquisitions.get(options);
+          acquisitions.delete(options);
+          runtime.unloadSubset(
+            options,
+            acquisition?.forwarded ? sourceResult.unloadSubset : void 0
+          );
         }
       };
     }