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

package/dist/esm/sqlite-core-adapter.d.ts

@@ -1,5 +1,5 @@
 import { LoadSubsetOptions } from '@tanstack/db';
-import { HydrationPersistenceAdapter, PersistedIndexSpec, PersistedKeySetEvidence, PersistedRowScanOptions, PersistedScannedRow, PersistedTx, PersistenceAdapter, ReplayableTxDelta, SQLiteDriver } from './persisted.js';
+import { CommittedTxAnchor, HydrationPersistenceAdapter, PersistedIndexSpec, PersistedKeySetEvidence, PersistedRowScanOptions, PersistedScannedRow, PersistedTx, PersistenceAdapter, ReconciledCommittedTx, ReplayableTxDelta, SQLiteDriver } from './persisted.js';
 type SQLiteCoreAdapterSchemaMismatchPolicy = `sync-present-reset` | `sync-absent-error` | `reset`;
 export type SQLiteCoreAdapterOptions = {
     driver: SQLiteDriver;
@@ -83,7 +83,10 @@ export declare class SQLiteCorePersistenceAdapter implements PersistenceAdapter
     }>;
     private loadResumeSnapshotUnscheduled;
     applyCommittedTx(collectionId: string, tx: PersistedTx): Promise<void>;
+    reconcileCommittedTx(collectionId: string, tx: PersistedTx, anchor: CommittedTxAnchor): Promise<ReconciledCommittedTx>;
     private applyCommittedTxUnscheduled;
+    private reconcileCommittedTxUnscheduled;
+    private applyCommittedTxInternal;
     loadCollectionMetadata(collectionId: string): Promise<Array<{
         key: string;
         value: unknown;
@@ -95,6 +98,12 @@ export declare class SQLiteCorePersistenceAdapter implements PersistenceAdapter
     private ensureIndexUnscheduled;
     markIndexRemoved(collectionId: string, signature: string): Promise<void>;
     private markIndexRemovedUnscheduled;
+    reserveLeadershipTerm(collectionId: string, observedTerm: number): Promise<{
+        latestTerm: number;
+        latestSeq: number;
+        latestRowVersion: number;
+    }>;
+    private reserveLeadershipTermUnscheduled;
     getStreamPosition(collectionId: string): Promise<{
         latestTerm: number;
         latestSeq: number;

package/dist/esm/sqlite-core-adapter.js

@@ -1,5 +1,6 @@
 import { IR, toBooleanPredicate, compileSingleRowExpression, compareTemporalValues } from "@tanstack/db";
 import { InvalidPersistedCollectionConfigError, InvalidPersistedStorageKeyEncodingError } from "./errors.js";
+import { isValidCommittedTxAnchor } from "./committed-tx-anchor.js";
 import { encodePersistedStorageKey, createPersistedTableName, decodePersistedStorageKey, SQLITE_DRIVER_SHARED_LOGICAL_SCHEDULING_KEY } from "./persisted.js";
 import { serializeSQLiteTemporal, sqliteTemporalIdentity, assertSQLiteBigIntInRange, sqliteTemporalKind, PERSISTED_TYPE_TAG, PERSISTED_VALUE_TAG, reviveSQLiteTemporal, serializeSQLiteBigInt } from "./sqlite-value.js";
 const REPLACEMENT_BATCH_SIZE = 125;
@@ -1088,6 +1089,7 @@ class SQLiteCorePersistenceAdapter {
       loadSubset: (collectionId, loadOptions, context) => this.loadSubsetUnscheduled(collectionId, loadOptions, context),
       loadResumeSnapshot: (collectionId, context) => 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) => this.scanRowsUnscheduled(collectionId, scanOptions),
       ensureIndex: (collectionId, signature, spec) => this.ensureIndexUnscheduled(collectionId, signature, spec),
@@ -1283,15 +1285,33 @@ class SQLiteCorePersistenceAdapter {
       () => this.applyCommittedTxUnscheduled(collectionId, tx)
     );
   }
+  reconcileCommittedTx(collectionId, tx, anchor) {
+    return this.runRegular(
+      () => this.reconcileCommittedTxUnscheduled(collectionId, tx, anchor)
+    );
+  }
   async applyCommittedTxUnscheduled(collectionId, tx) {
+    await this.applyCommittedTxInternal(collectionId, tx);
+  }
+  reconcileCommittedTxUnscheduled(collectionId, tx, anchor) {
+    if (!isValidCommittedTxAnchor(anchor)) {
+      throw new Error(
+        `Cannot reconcile a committed transaction without a valid durable anchor`
+      );
+    }
+    return this.applyCommittedTxInternal(collectionId, tx, anchor);
+  }
+  async applyCommittedTxInternal(collectionId, tx, anchor) {
     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(
         `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
@@ -1306,7 +1326,14 @@ class SQLiteCorePersistenceAdapter {
          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];
       if (!version) {
@@ -1319,8 +1346,34 @@ class SQLiteCorePersistenceAdapter {
           `Schema version mismatch for collection "${collectionId}": found ${version.schema_version}, expected ${this.schemaVersion}. Refusing to apply a committed transaction through a stale cached adapter.`
         );
       }
+      if (anchor) {
+        const sameResetEpoch = (version.reset_epoch ?? 0) === anchor.resetEpoch;
+        const matching = await transactionDriver.query(
+          `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
+          };
+        }
+        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;
       const nextRowVersion = Math.max(currentRowVersion + 1, tx.rowVersion);
@@ -1568,6 +1621,15 @@ class SQLiteCorePersistenceAdapter {
         ]
       );
       await this.pruneAppliedTxRows(collectionId, transactionDriver);
+      return {
+        kind: `applied-now`,
+        committed: {
+          term: tx.term,
+          seq: tx.seq,
+          rowVersion: nextRowVersion
+        },
+        latestRowVersion: nextRowVersion
+      };
     });
   }
   loadCollectionMetadata(collectionId) {
@@ -1732,6 +1794,31 @@ class SQLiteCorePersistenceAdapter {
       }
     });
   }
+  reserveLeadershipTerm(collectionId, observedTerm) {
+    return this.reserveLeadershipTermUnscheduled(collectionId, observedTerm);
+  }
+  async reserveLeadershipTermUnscheduled(collectionId, observedTerm) {
+    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) {
     return this.getStreamPositionUnscheduled(collectionId);
   }
@@ -2355,6 +2442,10 @@ class SQLiteCorePersistenceAdapter {
          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`