@tanstack/db-sqlite-persistence-core 0.2.16 → 0.2.18

package/dist/cjs/persisted.cjs

@@ -233,6 +233,8 @@ class PersistedCollectionRuntime {
     this.startupMetadataPromise = null;
     this.startPromise = null;
     this.internalApplyDepth = 0;
+    this.appliedReceiptSequence = 0;
+    this.pendingAppliedReceipts = /* @__PURE__ */ new Map();
     this.isHydrating = false;
     this.coordinatorUnsubscribe = null;
     this.indexAddedUnsubscribe = null;
@@ -247,7 +249,29 @@ class PersistedCollectionRuntime {
     this.localRowVersion = 0;
   }
   setSyncControls(syncControls) {
-    this.syncControls = syncControls;
+    const commit = syncControls.commit;
+    this.syncControls = {
+      ...syncControls,
+      commit: commit ? (signal) => this.trackAppliedReceipt(commit(signal)) : null
+    };
+  }
+  trackAppliedReceipt(receipt) {
+    const sequence = ++this.appliedReceiptSequence;
+    if (receipt === true) {
+      return true;
+    }
+    this.pendingAppliedReceipts.set(sequence, receipt);
+    const removeReceipt = () => this.pendingAppliedReceipts.delete(sequence);
+    void receipt.then(removeReceipt, removeReceipt);
+    return receipt;
+  }
+  async waitForAppliedReceiptsAfter(cursor) {
+    await Promise.all(
+      Array.from(
+        this.pendingAppliedReceipts,
+        ([sequence, receipt]) => sequence > cursor ? receipt : void 0
+      )
+    );
   }
   clearSyncControls() {
     this.syncControls = {
@@ -302,9 +326,11 @@ class PersistedCollectionRuntime {
     await this.bootstrapPersistedIndexes(indexBootstrapSnapshot);
     if (this.syncMode !== `on-demand`) {
       this.activeSubsets.set(this.getSubsetKey({}), {});
+      const appliedCursor = this.appliedReceiptSequence;
       await this.applyMutex.run(
         () => this.hydrateSubsetUnsafe({}, { requestRemoteEnsure: false })
       );
+      await this.waitForAppliedReceiptsAfter(appliedCursor);
     }
   }
   async loadStartupMetadataInternal() {
@@ -353,16 +379,18 @@ class PersistedCollectionRuntime {
   }
   async loadSubset(options, upstreamLoadSubset) {
     this.activeSubsets.set(this.getSubsetKey(options), options);
+    const appliedCursor = this.appliedReceiptSequence;
     await this.applyMutex.run(
       () => this.hydrateSubsetUnsafe(options, {
         requestRemoteEnsure: this.mode === `sync-present`
       })
     );
+    await this.waitForAppliedReceiptsAfter(appliedCursor);
     if (upstreamLoadSubset) {
       try {
         const maybePromise = upstreamLoadSubset(options);
         if (maybePromise instanceof Promise) {
-          maybePromise.catch((error) => {
+          await maybePromise.catch((error) => {
             console.warn(
               `Failed to load remote subset in persisted wrapper:`,
               error
@@ -485,6 +513,9 @@ class PersistedCollectionRuntime {
     }
     this.pendingRemoteSubsetEnsures.clear();
     this.activeSubsets.clear();
+    for (const transaction of this.queuedHydrationTransactions) {
+      transaction.rejectApplied?.(new db.SyncTransactionAbortedError());
+    }
     this.queuedHydrationTransactions.length = 0;
     this.queuedTxCommitted.length = 0;
     this.clearSyncControls();
@@ -492,7 +523,7 @@ class PersistedCollectionRuntime {
   withInternalApply(task) {
     this.internalApplyDepth++;
     try {
-      task();
+      return task();
     } finally {
       this.internalApplyDepth--;
     }
@@ -588,26 +619,41 @@ class PersistedCollectionRuntime {
       if (!transaction) {
         continue;
       }
-      await this.applyBufferedSyncTransactionUnsafe(transaction);
+      try {
+        await this.applyBufferedSyncTransactionUnsafe(transaction);
+      } catch (error) {
+        transaction.rejectApplied?.(error);
+        for (const abandoned of this.queuedHydrationTransactions) {
+          abandoned.rejectApplied?.(error);
+        }
+        this.queuedHydrationTransactions.length = 0;
+        throw error;
+      }
     }
   }
   async applyBufferedSyncTransactionUnsafe(transaction) {
-    if (!this.syncControls.begin || !this.syncControls.write || !this.syncControls.commit) {
+    if (transaction.signal?.aborted) {
+      transaction.rejectApplied?.(new db.SyncTransactionAbortedError());
+      return;
+    }
+    const { begin, write, commit, truncate, metadata } = this.syncControls;
+    if (!begin || !write || !commit) {
+      transaction.rejectApplied?.(new db.SyncTransactionAbortedError());
       return;
     }
     const applyToCollection = () => {
-      this.syncControls.begin?.();
+      begin();
       if (transaction.truncate) {
-        this.syncControls.truncate?.();
+        truncate?.();
       }
       for (const operation of transaction.operations) {
         if (operation.type === `delete`) {
-          this.syncControls.write?.({
+          write({
             type: `delete`,
             key: operation.key
           });
         } else {
-          this.syncControls.write?.({
+          write({
             type: `update`,
             value: operation.value,
             metadata: operation.metadata
@@ -616,26 +662,33 @@ class PersistedCollectionRuntime {
       }
       for (const [key, metadataWrite] of transaction.rowMetadataWrites) {
         if (metadataWrite.type === `delete`) {
-          this.syncControls.metadata?.row.delete(key);
+          metadata?.row.delete(key);
         } else {
-          this.syncControls.metadata?.row.set(key, metadataWrite.value);
+          metadata?.row.set(key, metadataWrite.value);
         }
       }
       for (const [key, metadataWrite] of transaction.collectionMetadataWrites) {
         if (metadataWrite.type === `delete`) {
-          this.syncControls.metadata?.collection.delete(key);
+          metadata?.collection.delete(key);
         } else {
-          this.syncControls.metadata?.collection.set(key, metadataWrite.value);
+          metadata?.collection.set(key, metadataWrite.value);
         }
       }
-      this.syncControls.commit?.();
+      return commit(transaction.signal);
     };
-    if (transaction.internal) {
-      this.withInternalApply(applyToCollection);
-      return;
+    try {
+      const applied = transaction.internal ? this.withInternalApply(applyToCollection) : applyToCollection();
+      if (applied !== true) {
+        await applied;
+      }
+      if (!transaction.internal) {
+        await this.persistAndBroadcastExternalSyncTransactionUnsafe(transaction);
+      }
+      transaction.resolveApplied?.();
+    } catch (error) {
+      transaction.rejectApplied?.(error);
+      throw error;
     }
-    applyToCollection();
-    await this.persistAndBroadcastExternalSyncTransactionUnsafe(transaction);
   }
   async persistAndBroadcastExternalSyncTransactionUnsafe(transaction) {
     if (transaction.internal) {
@@ -1452,37 +1505,53 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime) {
             params.truncate();
           }
         },
-        commit: () => {
+        commit: (signal) => {
           const openTransaction = transactionStack.pop();
           if (!openTransaction) {
-            params.commit();
-            return;
+            return params.commit(signal);
           }
           if (openTransaction.queuedBecauseHydrating) {
+            if (signal?.aborted) {
+              const aborted = Promise.reject(new db.SyncTransactionAbortedError());
+              void aborted.catch(() => void 0);
+              return aborted;
+            }
+            let resolveApplied;
+            let rejectApplied;
+            const applied2 = new Promise((resolve, reject) => {
+              resolveApplied = resolve;
+              rejectApplied = reject;
+            });
+            void applied2.catch(() => void 0);
             runtime.queueHydrationBufferedTransaction({
               operations: openTransaction.operations,
               rowMetadataWrites: openTransaction.rowMetadataWrites,
               collectionMetadataWrites: openTransaction.collectionMetadataWrites,
               truncate: openTransaction.truncate,
-              internal: openTransaction.internal
+              internal: openTransaction.internal,
+              signal,
+              resolveApplied,
+              rejectApplied
             });
-            return;
+            return applied2;
           }
-          params.commit();
+          const applied = params.commit(signal);
           if (!openTransaction.internal) {
-            void runtime.persistAndBroadcastExternalSyncTransaction({
-              operations: openTransaction.operations,
-              rowMetadataWrites: openTransaction.rowMetadataWrites,
-              collectionMetadataWrites: openTransaction.collectionMetadataWrites,
-              truncate: openTransaction.truncate,
-              internal: false
-            }).catch((error) => {
-              console.warn(
-                `Failed to persist wrapped sync transaction:`,
-                error
-              );
-            });
+            const persistAfterApplication = async () => {
+              if (applied !== true) await applied;
+              await runtime.persistAndBroadcastExternalSyncTransaction({
+                operations: openTransaction.operations,
+                rowMetadataWrites: openTransaction.rowMetadataWrites,
+                collectionMetadataWrites: openTransaction.collectionMetadataWrites,
+                truncate: openTransaction.truncate,
+                internal: false
+              });
+            };
+            const persisted = persistAfterApplication();
+            void persisted.catch(() => void 0);
+            return persisted;
           }
+          return applied;
         }
       };
       let sourceResult = {};