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

package/src/sqlite-core-adapter.ts

@@ -8,6 +8,7 @@ import {
   InvalidPersistedCollectionConfigError,
   InvalidPersistedStorageKeyEncodingError,
 } from './errors'
+import { isValidCommittedTxAnchor } from './committed-tx-anchor'
 import {
   SQLITE_DRIVER_SHARED_LOGICAL_SCHEDULING_KEY,
   createPersistedTableName,
@@ -26,6 +27,7 @@ import {
 } from './sqlite-value'
 import type { LoadSubsetOptions } from '@tanstack/db'
 import type {
+  CommittedTxAnchor,
   HydrationPersistenceAdapter,
   PersistedIndexSpec,
   PersistedKeySetEvidence,
@@ -33,6 +35,7 @@ import type {
   PersistedScannedRow,
   PersistedTx,
   PersistenceAdapter,
+  ReconciledCommittedTx,
   ReplayableTxDelta,
   SQLiteDriver,
 } from './persisted'
@@ -1713,6 +1716,8 @@ export class SQLiteCorePersistenceAdapter implements PersistenceAdapter {
         this.loadResumeSnapshotUnscheduled(collectionId, context),
       applyCommittedTx: (collectionId, tx) =>
         this.applyCommittedTxUnscheduled(collectionId, tx),
+      reconcileCommittedTx: (collectionId, tx, anchor) =>
+        this.reconcileCommittedTxUnscheduled(collectionId, tx, anchor),
       loadCollectionMetadata: (collectionId) =>
         this.loadCollectionMetadataUnscheduled(collectionId),
       scanRows: (collectionId, scanOptions) =>
@@ -2006,24 +2011,58 @@ export class SQLiteCorePersistenceAdapter implements PersistenceAdapter {
     )
   }
 
+  reconcileCommittedTx(
+    collectionId: string,
+    tx: PersistedTx,
+    anchor: CommittedTxAnchor,
+  ): Promise<ReconciledCommittedTx> {
+    return this.runRegular(() =>
+      this.reconcileCommittedTxUnscheduled(collectionId, tx, anchor),
+    )
+  }
+
   private async applyCommittedTxUnscheduled(
     collectionId: string,
     tx: PersistedTx,
   ): Promise<void> {
+    await this.applyCommittedTxInternal(collectionId, tx)
+  }
+
+  private reconcileCommittedTxUnscheduled(
+    collectionId: string,
+    tx: PersistedTx,
+    anchor: CommittedTxAnchor,
+  ): Promise<ReconciledCommittedTx> {
+    if (!isValidCommittedTxAnchor(anchor)) {
+      throw new Error(
+        `Cannot reconcile a committed transaction without a valid durable anchor`,
+      )
+    }
+    return this.applyCommittedTxInternal(collectionId, tx, anchor)
+  }
+
+  private async applyCommittedTxInternal(
+    collectionId: string,
+    tx: PersistedTx,
+    anchor?: CommittedTxAnchor,
+  ): Promise<ReconciledCommittedTx> {
     const tableMapping = await this.ensureCollectionReady(collectionId)
     const collectionTableSql = quoteIdentifier(tableMapping.tableName)
     const tombstoneTableSql = quoteIdentifier(tableMapping.tombstoneTableName)
 
-    await this.runInTransaction(async (transactionDriver) => {
+    return this.runInTransaction(async (transactionDriver) => {
       const versionRows = await transactionDriver.query<{
         latest_row_version: number
         key_set_evidence_available: number
         schema_version: number
         already_applied: number
+        reset_epoch: number | null
       }>(
         `SELECT
            latest_row_version,
            key_set_evidence_available,
+           (SELECT reset_epoch FROM collection_reset_epoch
+            WHERE collection_id = ? LIMIT 1) AS reset_epoch,
            (
              SELECT schema_version
              FROM collection_registry
@@ -2038,7 +2077,14 @@ export class SQLiteCorePersistenceAdapter implements PersistenceAdapter {
          FROM collection_version
          WHERE collection_id = ?
          LIMIT 1`,
-        [collectionId, collectionId, tx.term, tx.seq, collectionId],
+        [
+          collectionId,
+          collectionId,
+          collectionId,
+          tx.term,
+          tx.seq,
+          collectionId,
+        ],
       )
       const version = versionRows[0]
 
@@ -2055,8 +2101,47 @@ export class SQLiteCorePersistenceAdapter implements PersistenceAdapter {
         )
       }
 
+      if (anchor) {
+        const sameResetEpoch = (version.reset_epoch ?? 0) === anchor.resetEpoch
+        const matching = await transactionDriver.query<{
+          term: number
+          seq: number
+          row_version: number
+        }>(
+          `SELECT term, seq, row_version FROM applied_tx
+           WHERE collection_id = ? AND tx_id = ? LIMIT 2`,
+          [collectionId, tx.txId],
+        )
+        if (matching.length > 1) return { kind: `unknown` }
+        if (matching[0]) {
+          if (
+            matching[0].row_version <= anchor.latestRowVersion ||
+            !sameResetEpoch
+          ) {
+            return { kind: `unknown` }
+          }
+          return {
+            kind: `already-applied`,
+            committed: {
+              term: matching[0].term,
+              seq: matching[0].seq,
+              rowVersion: matching[0].row_version,
+            },
+            latestRowVersion: version.latest_row_version,
+          }
+        }
+        // A different durable write may have superseded this source row or
+        // its opaque cursor. Absence alone cannot authorize late application.
+        if (
+          version.latest_row_version !== anchor.latestRowVersion ||
+          !sameResetEpoch
+        ) {
+          return { kind: `unknown` }
+        }
+      }
+
       if (version.already_applied === 1) {
-        return
+        return { kind: `unknown` }
       }
 
       const currentRowVersion = version.latest_row_version
@@ -2366,6 +2451,15 @@ export class SQLiteCorePersistenceAdapter implements PersistenceAdapter {
       )
 
       await this.pruneAppliedTxRows(collectionId, transactionDriver)
+      return {
+        kind: `applied-now`,
+        committed: {
+          term: tx.term,
+          seq: tx.seq,
+          rowVersion: nextRowVersion,
+        },
+        latestRowVersion: nextRowVersion,
+      }
     })
   }
 
@@ -2588,6 +2682,48 @@ export class SQLiteCorePersistenceAdapter implements PersistenceAdapter {
     })
   }
 
+  reserveLeadershipTerm(
+    collectionId: string,
+    observedTerm: number,
+  ): Promise<{
+    latestTerm: number
+    latestSeq: number
+    latestRowVersion: number
+  }> {
+    // Election may run while hydration waits for its first writer route.
+    return this.reserveLeadershipTermUnscheduled(collectionId, observedTerm)
+  }
+
+  private async reserveLeadershipTermUnscheduled(
+    collectionId: string,
+    observedTerm: number,
+  ): Promise<{
+    latestTerm: number
+    latestSeq: number
+    latestRowVersion: number
+  }> {
+    await this.ensureCollectionReady(collectionId)
+    return this.runInTransaction(async (transactionDriver) => {
+      await this.assertCurrentSchemaVersion(
+        collectionId,
+        transactionDriver,
+        `reserve a leadership term`,
+      )
+      await transactionDriver.run(
+        `INSERT INTO leader_term (collection_id, latest_term)
+         VALUES (?, ? + 1)
+         ON CONFLICT(collection_id) DO UPDATE SET
+           latest_term = MAX(leader_term.latest_term, ?) + 1`,
+        [collectionId, observedTerm, observedTerm],
+      )
+      const [position, latestRowVersion] = await Promise.all([
+        this.readStreamPosition(collectionId, transactionDriver),
+        this.readLatestRowVersion(collectionId, transactionDriver),
+      ])
+      return { ...position, latestRowVersion }
+    })
+  }
+
   getStreamPosition(collectionId: string): Promise<{
     latestTerm: number
     latestSeq: number
@@ -3397,6 +3533,10 @@ export class SQLiteCorePersistenceAdapter implements PersistenceAdapter {
          PRIMARY KEY (collection_id, term, seq)
        )`,
     )
+    await this.driver.exec(
+      `CREATE INDEX IF NOT EXISTS idx_applied_tx_collection_tx_id
+       ON applied_tx (collection_id, tx_id)`,
+    )
     try {
       await this.driver.exec(
         `ALTER TABLE applied_tx ADD COLUMN replay_json TEXT`,