@tanstack/db-sqlite-persistence-core 0.4.5 → 0.4.8

package/dist/cjs/committed-tx-anchor.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isValidCommittedTxAnchor(value) {
+  if (!value || typeof value !== `object`) return false;
+  const anchor = value;
+  return typeof anchor.latestRowVersion === `number` && Number.isSafeInteger(anchor.latestRowVersion) && anchor.latestRowVersion >= 0 && typeof anchor.resetEpoch === `number` && Number.isSafeInteger(anchor.resetEpoch) && anchor.resetEpoch >= 0;
+}
+exports.isValidCommittedTxAnchor = isValidCommittedTxAnchor;
+//# sourceMappingURL=committed-tx-anchor.cjs.map

package/dist/cjs/committed-tx-anchor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"committed-tx-anchor.cjs","sources":["../../src/committed-tx-anchor.ts"],"sourcesContent":["// RPC payloads and direct adapter calls can bypass TypeScript's anchor type.\nexport function isValidCommittedTxAnchor(value: unknown): boolean {\n  if (!value || typeof value !== `object`) return false\n  const anchor = value as Record<string, unknown>\n  return (\n    typeof anchor.latestRowVersion === `number` &&\n    Number.isSafeInteger(anchor.latestRowVersion) &&\n    anchor.latestRowVersion >= 0 &&\n    typeof anchor.resetEpoch === `number` &&\n    Number.isSafeInteger(anchor.resetEpoch) &&\n    anchor.resetEpoch >= 0\n  )\n}\n"],"names":[],"mappings":";;AACO,SAAS,yBAAyB,OAAyB;AAChE,MAAI,CAAC,SAAS,OAAO,UAAU,SAAU,QAAO;AAChD,QAAM,SAAS;AACf,SACE,OAAO,OAAO,qBAAqB,YACnC,OAAO,cAAc,OAAO,gBAAgB,KAC5C,OAAO,oBAAoB,KAC3B,OAAO,OAAO,eAAe,YAC7B,OAAO,cAAc,OAAO,UAAU,KACtC,OAAO,cAAc;AAEzB;;"}

package/dist/cjs/committed-tx-anchor.d.cts

@@ -0,0 +1 @@
+export declare function isValidCommittedTxAnchor(value: unknown): boolean;

package/dist/cjs/persisted.cjs

@@ -393,7 +393,7 @@ function isTxCommittedPayload(payload) {
     return false;
   }
   if (payload.requiresFullReload) {
-    return true;
+    return payload.reconciliationReload === void 0 || payload.reconciliationReload === true;
   }
   return Array.isArray(payload.changedRows) && Array.isArray(payload.deletedKeys) && (payload.rowMetadataMutations === void 0 || Array.isArray(payload.rowMetadataMutations)) && (payload.collectionMetadataMutations === void 0 || Array.isArray(payload.collectionMetadataMutations));
 }
@@ -459,6 +459,7 @@ class PersistedCollectionRuntime {
     this.latestTerm = 0;
     this.latestSeq = 0;
     this.latestRowVersion = 0;
+    this.publicRowVersion = 0;
     this.localTerm = 1;
     this.localSeq = 0;
     this.localRowVersion = 0;
@@ -1136,6 +1137,8 @@ class PersistedCollectionRuntime {
     this.lifecycleGeneration++;
     this.persistedReadiness?.set({ status: `loading` });
     this.startupSettled = false;
+    this.publicRowVersion = 0;
+    this.resetTermFence = void 0;
     this.hydratedDemands.clear();
     this.startupMetadataPromise = null;
     this.startPromise = null;
@@ -1180,6 +1183,7 @@ class PersistedCollectionRuntime {
   }
   async hydrateSubsetUnsafe(options, config, adapter) {
     let rowsLoaded = false;
+    let boundRowVersion;
     let replayFailure;
     const resetSequence = this.resetSequence;
     this.hydrationSequence++;
@@ -1199,6 +1203,7 @@ class PersistedCollectionRuntime {
           if (config.lifecycleGeneration !== this.lifecycleGeneration) return;
           if (resetSequence !== this.resetSequence) return;
           this.bindResumeSnapshotEvidence(snapshot);
+          boundRowVersion = snapshot.latestRowVersion;
         } else {
           rows = await this.loadSubsetRowsUnsafe(options, adapter);
         }
@@ -1211,6 +1216,12 @@ class PersistedCollectionRuntime {
           }
           const applied = this.applyRowsToCollection(rows);
           await db.whenSyncAccepted(applied);
+          if (boundRowVersion !== void 0) {
+            this.publicRowVersion = Math.max(
+              this.publicRowVersion,
+              boundRowVersion
+            );
+          }
         }
       } finally {
         if (this.activeHydrationContext === hydrationContext && this.hydratingGeneration === config.lifecycleGeneration) {
@@ -1374,7 +1385,9 @@ class PersistedCollectionRuntime {
   }
   isExpectedResumeGeneration(generation) {
     const expected = this.persistedResumeGeneration;
-    return expected !== void 0 && expected.latestTerm === generation.latestTerm && expected.latestSeq === generation.latestSeq && expected.latestRowVersion === generation.latestRowVersion && expected.resetEpoch === generation.resetEpoch;
+    return expected !== void 0 && expected.latestRowVersion === generation.latestRowVersion && expected.resetEpoch === generation.resetEpoch && (expected.latestTerm === generation.latestTerm && expected.latestSeq === generation.latestSeq || // A no-write election reserves a new term at sequence zero. It does
+    // not change the persisted rows or the source resume cursor.
+    generation.latestTerm > expected.latestTerm && generation.latestSeq === 0);
   }
   bindResumeSnapshotEvidence(snapshot) {
     const generation = this.getResumeSnapshotGeneration(snapshot);
@@ -1416,6 +1429,27 @@ class PersistedCollectionRuntime {
       return this.syncControls.commit?.() ?? true;
     });
   }
+  matchesCollectionSnapshot(rows, collectionMetadata) {
+    if (!this.collection || !this.syncControls.metadata) return false;
+    const base = this.collection.base;
+    if (base.size !== rows.size) return false;
+    for (const [key, row] of rows) {
+      if (!base.has(key) || !db.equalPersistedSnapshotValues(base.get(key), row.value) || !db.equalPersistedSnapshotValues(
+        this.syncControls.metadata.row.get(key),
+        row.metadata
+      )) {
+        return false;
+      }
+    }
+    const currentMetadata = this.syncControls.metadata.collection.list();
+    if (currentMetadata.length !== collectionMetadata.length) return false;
+    const expectedMetadata = new Map(
+      collectionMetadata.map(({ key, value }) => [key, value])
+    );
+    return currentMetadata.every(
+      ({ key, value }) => expectedMetadata.has(key) && db.equalPersistedSnapshotValues(expectedMetadata.get(key), value)
+    );
+  }
   async flushQueuedHydrationTransactionsUnsafe(adapter) {
     let operationFailure;
     while (this.queuedHydrationTransactions.length > 0) {
@@ -1500,16 +1534,55 @@ class PersistedCollectionRuntime {
     if (!transaction.truncate && transaction.operations.length === 0 && transaction.rowMetadataWrites.size === 0 && transaction.collectionMetadataWrites.size === 0) {
       return;
     }
+    const anchor = this.persistedResumeGeneration && {
+      latestRowVersion: this.latestRowVersion,
+      resetEpoch: this.persistedResumeGeneration.resetEpoch
+    };
     const streamPosition = this.nextLocalStreamPosition();
     const tx = this.createPersistedTxFromOperations(transaction, streamPosition);
-    const response = await this.persistence.coordinator.requestApplyCommittedTx(
-      this.collectionId,
-      tx,
-      // A hydration-scoped adapter is already inside the shared scheduler.
-      // Ordinary source commits pass no scoped adapter so the coordinator
-      // enters that scheduler before taking the database-wide writer lock.
-      scopedAdapter
-    );
+    let response;
+    try {
+      response = await this.persistence.coordinator.requestApplyCommittedTx(
+        this.collectionId,
+        tx,
+        // A hydration-scoped adapter is already inside the shared scheduler.
+        // Ordinary source commits enter it before taking the writer lock.
+        scopedAdapter
+      );
+    } catch (error) {
+      if (!(error instanceof errors.IndeterminateCommitError) || !anchor || !this.persistence.coordinator.reconcileCommittedTx) {
+        throw error;
+      }
+      let reconciled;
+      try {
+        reconciled = await this.persistence.coordinator.reconcileCommittedTx(
+          this.collectionId,
+          tx,
+          anchor,
+          scopedAdapter
+        );
+      } catch (reconcileError) {
+        if (reconcileError instanceof errors.PersistedCollectionDurabilityError) {
+          throw reconcileError;
+        }
+        throw error;
+      }
+      if (!reconciled.ok) {
+        if (reconciled.code === `PERSISTENCE_ERROR`) {
+          throw new errors.PersistedCollectionDurabilityError(
+            `Failed to reconcile collection "${this.collectionId}": ${reconciled.error}`,
+            {
+              cause: reconciled,
+              code: reconciled.sourceCode ?? reconciled.code,
+              path: reconciled.path
+            }
+          );
+        }
+        throw error;
+      }
+      this.recordDurableSourceCommit(transaction, reconciled.committed);
+      return;
+    }
     if (!response.ok) {
       if (response.code === `PERSISTENCE_ERROR`) {
         const error = new errors.PersistedCollectionDurabilityError(
@@ -1526,18 +1599,24 @@ class PersistedCollectionRuntime {
         `failed to apply external sync transaction through coordinator: ${response.error}`
       );
     }
+    this.recordDurableSourceCommit(transaction, {
+      term: response.term,
+      seq: response.seq,
+      rowVersion: response.latestRowVersion
+    });
+  }
+  recordDurableSourceCommit(transaction, position) {
     if (transaction.lifecycleGeneration !== this.lifecycleGeneration) return;
-    this.observeStreamPosition(
-      response.term,
-      response.seq,
-      response.latestRowVersion
-    );
+    this.observeStreamPosition(position.term, position.seq, position.rowVersion);
+    if (position.rowVersion === this.publicRowVersion + 1) {
+      this.publicRowVersion = position.rowVersion;
+    }
     if (transaction.expectedResumeGenerationOwner === this.resumeGenerationOwner && this.persistedResumeGeneration !== void 0) {
       this.persistedResumeGeneration = {
         ...this.persistedResumeGeneration,
-        latestTerm: response.term,
-        latestSeq: response.seq,
-        latestRowVersion: response.latestRowVersion
+        latestTerm: position.term,
+        latestSeq: position.seq,
+        latestRowVersion: position.rowVersion
       };
     }
   }
@@ -1900,9 +1979,17 @@ class PersistedCollectionRuntime {
     }
     if (isCollectionResetPayload(payload)) {
       void this.applyMutex.run(async () => {
-        await this.runInHydrationScope(
-          (adapter) => this.truncateAndReloadUnsafe(adapter, lifecycleGeneration)
-        );
+        await this.runInHydrationScope(async (adapter) => {
+          await this.truncateAndReloadUnsafe(adapter, lifecycleGeneration);
+          await this.rebaseDurableStreamFromSnapshotUnsafe(
+            adapter,
+            lifecycleGeneration
+          );
+          if (lifecycleGeneration === this.lifecycleGeneration) {
+            this.publicRowVersion = 0;
+            this.resetTermFence = this.latestTerm;
+          }
+        });
         if (lifecycleGeneration === this.lifecycleGeneration) {
           await this.flushQueuedTxCommittedUnsafe();
         }
@@ -1925,21 +2012,42 @@ class PersistedCollectionRuntime {
   }
   async processCommittedTxUnsafe(txCommitted, lifecycleGeneration = this.lifecycleGeneration) {
     if (lifecycleGeneration !== this.lifecycleGeneration) return;
-    if (txCommitted.term < this.latestTerm) {
-      return;
+    if (this.resetTermFence !== void 0) {
+      if (txCommitted.term <= this.resetTermFence) {
+        await this.runInHydrationScope(
+          (adapter) => this.reloadActiveSubsetsUnsafe(adapter)
+        );
+        return;
+      }
     }
-    if (txCommitted.term === this.latestTerm && txCommitted.seq <= this.latestSeq) {
+    if (txCommitted.requiresFullReload && txCommitted.reconciliationReload) {
+      await this.invalidateFromCommittedTxUnsafe(
+        txCommitted,
+        this.persistence.adapter
+      );
+      if (lifecycleGeneration === this.lifecycleGeneration) {
+        this.observeStreamPosition(
+          txCommitted.term,
+          txCommitted.seq,
+          txCommitted.latestRowVersion
+        );
+        this.publicRowVersion = Math.max(
+          this.publicRowVersion,
+          txCommitted.latestRowVersion
+        );
+        await this.flushQueuedTxCommittedUnsafe();
+      }
       return;
     }
+    if (txCommitted.latestRowVersion <= this.publicRowVersion) return;
+    const observedButUnpublished = txCommitted.term < this.latestTerm || txCommitted.term === this.latestTerm && txCommitted.seq <= this.latestSeq;
     const hasGapInCurrentTerm = txCommitted.term === this.latestTerm && txCommitted.seq > this.latestSeq + 1;
     const hasGapAcrossTerms = txCommitted.term > this.latestTerm && txCommitted.seq > 1;
-    const hasGap = hasGapInCurrentTerm || hasGapAcrossTerms;
+    const hasGap = observedButUnpublished || txCommitted.latestRowVersion > this.publicRowVersion + 1 || hasGapInCurrentTerm || hasGapAcrossTerms;
     if (hasGap) {
       await this.recoverFromSeqGapUnsafe(lifecycleGeneration);
       if (lifecycleGeneration !== this.lifecycleGeneration) return;
-      if (txCommitted.term < this.latestTerm || txCommitted.term === this.latestTerm && txCommitted.seq <= this.latestSeq) {
-        return;
-      }
+      if (txCommitted.latestRowVersion <= this.publicRowVersion) return;
     }
     this.observeStreamPosition(
       txCommitted.term,
@@ -1951,9 +2059,27 @@ class PersistedCollectionRuntime {
       this.persistence.adapter
     );
     if (lifecycleGeneration === this.lifecycleGeneration) {
+      this.publicRowVersion = Math.max(
+        this.publicRowVersion,
+        txCommitted.latestRowVersion
+      );
       await this.flushQueuedTxCommittedUnsafe();
     }
   }
+  async rebaseDurableStreamFromSnapshotUnsafe(adapter, lifecycleGeneration) {
+    if (lifecycleGeneration !== this.lifecycleGeneration) return;
+    const snapshot = await adapter.loadResumeSnapshot(this.collectionId, {
+      includeRows: false
+    });
+    if (lifecycleGeneration !== this.lifecycleGeneration) return;
+    this.latestRowVersion = snapshot.latestRowVersion;
+    this.localRowVersion = snapshot.latestRowVersion;
+    this.observeStreamPosition(
+      snapshot.latestTerm,
+      snapshot.latestSeq,
+      snapshot.latestRowVersion
+    );
+  }
   async recoverFromSeqGapUnsafe(lifecycleGeneration) {
     if (lifecycleGeneration !== this.lifecycleGeneration) return;
     if (this.persistence.coordinator.pullSince && this.latestRowVersion >= 0) {
@@ -1961,7 +2087,7 @@ class PersistedCollectionRuntime {
       try {
         pullResponse = await this.persistence.coordinator.pullSince(
           this.collectionId,
-          this.latestRowVersion
+          this.publicRowVersion
         );
       } catch (error) {
         console.warn(`Failed pullSince recovery attempt:`, error);
@@ -1978,6 +2104,10 @@ class PersistedCollectionRuntime {
             await this.runInHydrationScope(
               (adapter) => this.reloadActiveSubsetsUnsafe(adapter)
             );
+            this.publicRowVersion = Math.max(
+              this.publicRowVersion,
+              pullResponse.latestRowVersion
+            );
             return;
           }
           const deltas = pullResponse.deltas;
@@ -1985,6 +2115,10 @@ class PersistedCollectionRuntime {
             await this.runInHydrationScope(
               (adapter) => this.reloadActiveSubsetsUnsafe(adapter)
             );
+            this.publicRowVersion = Math.max(
+              this.publicRowVersion,
+              pullResponse.latestRowVersion
+            );
             return;
           }
           await this.runInHydrationScope(async (adapter) => {
@@ -2008,13 +2142,21 @@ class PersistedCollectionRuntime {
               if (lifecycleGeneration !== this.lifecycleGeneration) return;
             }
           });
+          this.publicRowVersion = Math.max(
+            this.publicRowVersion,
+            pullResponse.latestRowVersion
+          );
           return;
         }
       }
     }
     if (lifecycleGeneration !== this.lifecycleGeneration) return;
     await this.runInHydrationScope(
-      (adapter) => this.truncateAndReloadUnsafe(adapter, lifecycleGeneration)
+      (adapter) => this.reloadActiveSubsetsUnsafe(adapter)
+    );
+    this.publicRowVersion = Math.max(
+      this.publicRowVersion,
+      this.latestRowVersion
     );
     if (this.mode === `sync-present`) {
       for (const options of this.activeSubsets.values()) {
@@ -2038,12 +2180,12 @@ class PersistedCollectionRuntime {
     await this.reloadActiveSubsetsUnsafe(adapter);
   }
   async invalidateFromCommittedTxUnsafe(txCommitted, adapter) {
-    const reloadActiveSubsets = () => this.runInHydrationScope(
-      (scopedAdapter) => this.reloadActiveSubsetsUnsafe(scopedAdapter),
+    const reloadActiveSubsets = (skipUnchangedReplace = false) => this.runInHydrationScope(
+      (scopedAdapter) => this.reloadActiveSubsetsUnsafe(scopedAdapter, skipUnchangedReplace),
       adapter
     );
     if (txCommitted.requiresFullReload) {
-      await reloadActiveSubsets();
+      await reloadActiveSubsets(txCommitted.reconciliationReload === true);
       return;
     }
     const changedKeyCount = txCommitted.changedRows.length + txCommitted.deletedKeys.length;
@@ -2107,7 +2249,7 @@ class PersistedCollectionRuntime {
     });
     await db.whenSyncAccepted(applied);
   }
-  async reloadActiveSubsetsUnsafe(adapter) {
+  async reloadActiveSubsetsUnsafe(adapter, skipUnchangedReplace = false) {
     const lifecycleGeneration = this.lifecycleGeneration;
     const truncateGeneration = this.sourceTruncateGeneration;
     const activeSubsetOptions = this.activeSubsets.size > 0 ? Array.from(this.activeSubsets.values()) : [{}];
@@ -2133,15 +2275,29 @@ class PersistedCollectionRuntime {
       for (const key of mergedRows.keys()) {
         hydrationContext.suppliedRowKeys.add(key);
       }
-      const applied = this.replaceCollectionSnapshot(
-        Array.from(mergedRows.entries()).map(([key, row]) => ({
-          key,
-          value: row.value,
-          metadata: row.metadata
-        })),
-        collectionMetadata
-      );
-      await db.whenSyncAccepted(applied);
+      if (skipUnchangedReplace && this.matchesCollectionSnapshot(mergedRows, collectionMetadata)) {
+        const orphanKeys = this.collection?._syncedRowMetadataKeysOutsideBase() ?? [];
+        if (orphanKeys.length > 0) {
+          const applied = this.withInternalApply(() => {
+            this.syncControls.begin?.();
+            for (const key of orphanKeys) {
+              this.syncControls.metadata?.row.delete(key);
+            }
+            return this.syncControls.commit?.() ?? true;
+          });
+          await db.whenSyncAccepted(applied);
+        }
+      } else {
+        const applied = this.replaceCollectionSnapshot(
+          Array.from(mergedRows.entries()).map(([key, row]) => ({
+            key,
+            value: row.value,
+            metadata: row.metadata
+          })),
+          collectionMetadata
+        );
+        await db.whenSyncAccepted(applied);
+      }
     } finally {
       if (this.activeHydrationContext === hydrationContext && this.hydratingGeneration === lifecycleGeneration) {
         this.hydratingGeneration = null;