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

package/README.md

@@ -260,12 +260,20 @@ source publication and its durable suffix. A source may mark a transaction
 optimistic layer. The wrapper still gives that transaction one FIFO turn and
 writes its durable suffix before admitting the next source turn.
 
-The wrapper deliberately rejects schedules that would require a second
-ordering mechanism. An `immediate` source transaction cannot enter while an
-earlier normal source publication is waiting, and a source transaction cannot
-cross a hydration cycle. These cases throw
-`InvalidPersistedCollectionConfigError` instead of reordering data or waiting
-in a dependency cycle.
+Persisted rows establish a baseline for newer changes from the sync adapter.
+Once an ordinary sync transaction is accepted at `commit()`, queued reads of
+that baseline cannot revoke acceptance. This includes subset reads and rereads
+requested by coordinator reset or full-reload notifications. This rule assumes
+a compatible baseline; it does not authorize using an invalidated resume point.
+A truncate replay replaces earlier source rows in the same sync run. Sync
+transactions ordered after that replacement apply to the replacement.
+
+An `immediate` sync transaction cannot enter while an earlier normal source
+publication is waiting. The wrapper also currently rejects a sync transaction
+that remains open across another persistence read. These admission restrictions
+throw `InvalidPersistedCollectionConfigError`; an internal wait after accepted
+`commit()` is not an admission failure. The open-transaction restriction is
+separate from the accepted-transaction precedence rule.
 
 ### Atomic resume snapshots
 

package/dist/cjs/index.cjs

@@ -37,10 +37,15 @@ exports.PERSISTED_VALUE_TAG = sqliteValue.PERSISTED_VALUE_TAG;
 exports.SQLITE_BIGINT_MAX = sqliteValue.SQLITE_BIGINT_MAX;
 exports.SQLITE_BIGINT_MIN = sqliteValue.SQLITE_BIGINT_MIN;
 exports.assertSQLiteBigIntInRange = sqliteValue.assertSQLiteBigIntInRange;
+exports.reviveSQLiteTemporal = sqliteValue.reviveSQLiteTemporal;
 exports.serializeSQLiteBigInt = sqliteValue.serializeSQLiteBigInt;
+exports.serializeSQLiteTemporal = sqliteValue.serializeSQLiteTemporal;
+exports.sqliteTemporalIdentity = sqliteValue.sqliteTemporalIdentity;
+exports.sqliteTemporalKind = sqliteValue.sqliteTemporalKind;
 exports.RemoteSubsetWireValueError = remoteSubsetWire.RemoteSubsetWireValueError;
 exports.toProcessLocalLoadSubsetOptions = remoteSubsetWire.toProcessLocalLoadSubsetOptions;
 exports.toTransportedLoadSubsetOptions = remoteSubsetWire.toTransportedLoadSubsetOptions;
+exports.validateRemoteSubsetOptions = remoteSubsetWire.validateRemoteSubsetOptions;
 Object.defineProperty(exports, "safeRandomUUID", {
   enumerable: true,
   get: () => db.safeRandomUUID

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/persisted.cjs

@@ -178,8 +178,8 @@ class SingleProcessCoordinator {
   setAdapterForCollection(collectionId, adapter) {
     this.collectionAdapters.set(collectionId, adapter);
   }
-  async requestApplyCommittedTx(collectionId, tx) {
-    const adapter = this.collectionAdapters.get(collectionId);
+  async requestApplyCommittedTx(collectionId, tx, scopedAdapter) {
+    const adapter = scopedAdapter ?? this.collectionAdapters.get(collectionId);
     if (!adapter) {
       throw new errors.InvalidPersistedCollectionConfigError(
         `SingleProcessCoordinator has no persistence adapter configured for collection "${collectionId}"`
@@ -335,6 +335,8 @@ function toStableSerializable(value) {
     case `undefined`:
       return void 0;
   }
+  const temporal = sqliteValue.serializeSQLiteTemporal(value);
+  if (temporal) return temporal;
   if (value instanceof Date) {
     return value.toISOString();
   }
@@ -747,7 +749,6 @@ class PersistedCollectionRuntime {
     await this.hydrateSubsetUnsafe(
       baseline,
       {
-        requestRemoteEnsure: false,
         lifecycleGeneration,
         bindKeySetEvidence: true
       },
@@ -830,6 +831,7 @@ class PersistedCollectionRuntime {
     const subsetKey = this.getSubsetKey(options);
     const truncateGeneration = this.sourceTruncateGeneration;
     const routeRemoteDemandDuringHydration = this.canRouteRemoteDemandThroughCoordinator();
+    if (routeRemoteDemandDuringHydration) remoteSubsetWire.validateRemoteSubsetOptions(options);
     this.activeSubsets.set(subsetKey, options);
     const appliedCursor = this.appliedReceiptSequence;
     try {
@@ -839,7 +841,6 @@ class PersistedCollectionRuntime {
             (adapter) => this.hydrateSubsetUnsafe(
               options,
               {
-                requestRemoteEnsure: this.mode === `sync-present` && !routeRemoteDemandDuringHydration,
                 lifecycleGeneration,
                 requestLocalLoadFailure: true,
                 rejectBufferedReplayFailure: true
@@ -855,6 +856,9 @@ class PersistedCollectionRuntime {
       });
       if (lifecycleGeneration !== this.lifecycleGeneration) return;
       await this.waitForAppliedReceiptsAfter(appliedCursor);
+      if (!routeRemoteDemandDuringHydration && this.canRouteRemoteDemandThroughCoordinator()) {
+        remoteSubsetWire.validateRemoteSubsetOptions(options);
+      }
     } catch (error) {
       if (this.activeSubsets.get(subsetKey) === options) {
         this.activeSubsets.delete(subsetKey);
@@ -964,7 +968,6 @@ class PersistedCollectionRuntime {
         (adapter) => this.hydrateSubsetUnsafe(
           options,
           {
-            requestRemoteEnsure: false,
             lifecycleGeneration,
             rejectBufferedReplayFailure: true
           },
@@ -1217,9 +1220,6 @@ class PersistedCollectionRuntime {
       if (config.lifecycleGeneration !== this.lifecycleGeneration) return;
       replayFailure = await this.flushQueuedHydrationTransactionsUnsafe(adapter);
       if (config.lifecycleGeneration !== this.lifecycleGeneration) return;
-      if (config.requestRemoteEnsure && !replayFailure) {
-        this.queueRemoteSubsetEnsure(options);
-      }
     } catch (error) {
       if (config.requestLocalLoadFailure && !rowsLoaded) {
         this.hydratingGeneration = config.lifecycleGeneration;
@@ -1812,6 +1812,7 @@ class PersistedCollectionRuntime {
     }
     const subsetKey = this.getSubsetKey(options);
     if (this.activeSubsets.get(subsetKey) !== options) return;
+    remoteSubsetWire.validateRemoteSubsetOptions(options);
     this.pendingRemoteSubsetEnsures.set(subsetKey, options);
     void this.flushPendingRemoteSubsetEnsures();
   }
@@ -2214,8 +2215,8 @@ class PersistedCollectionRuntime {
     await this.requestCoordinatorPersistedIndex(indexMetadata, completedLocally);
   }
   async ensureLocalPersistedIndex(indexMetadata, adapter) {
-    const spec = this.buildPersistedIndexSpec(indexMetadata);
     try {
+      const spec = this.buildPersistedIndexSpec(indexMetadata);
       await adapter.ensureIndex(
         this.collectionId,
         indexMetadata.signature,
@@ -2228,8 +2229,8 @@ class PersistedCollectionRuntime {
     }
   }
   async requestCoordinatorPersistedIndex(indexMetadata, completedLocally) {
-    const spec = this.buildPersistedIndexSpec(indexMetadata);
     try {
+      const spec = this.buildPersistedIndexSpec(indexMetadata);
       await this.persistence.coordinator.requestEnsurePersistedIndex(
         this.collectionId,
         indexMetadata.signature,
@@ -2837,6 +2838,7 @@ function createWrappedSyncConfig(sourceSyncConfig, runtime, persistedReadiness)
             settleRuntimeTransaction(openTransaction, applied2);
             return visibleAfterDurable(openTransaction, applied2);
           }
+          openTransaction.hydrationSequence = void 0;
           let applied;
           try {
             applied = runtime.applyHydrationBufferedTransaction(transaction);