@tanstack/electron-db-sqlite-persistence 0.1.35 → 0.2.2

package/src/index.ts

@@ -10,8 +10,19 @@ export type {
 } from './renderer'
 export { ElectronCollectionCoordinator } from './electron-coordinator'
 export type { ElectronCollectionCoordinatorOptions } from './electron-coordinator'
-export { persistedCollectionOptions } from '@tanstack/db-sqlite-persistence-core'
+export {
+  DuplicateRemoteSubsetOwnerError,
+  IndeterminateCommitError,
+  PersistedCollectionDurabilityError,
+  RemoteSubsetWireValueError,
+  persistedCollectionOptions,
+} from '@tanstack/db-sqlite-persistence-core'
 export type {
   PersistedCollectionCoordinator,
   PersistedCollectionPersistence,
+  IndeterminateCommitRequestType,
+  RemoteSubsetOwner,
+  RemoteSubsetWireExpression,
+  RemoteSubsetWireValue,
+  TransportedLoadSubsetOptions,
 } from '@tanstack/db-sqlite-persistence-core'

package/src/main.ts

@@ -120,6 +120,20 @@ async function executeRequestAgainstAdapter(
       }
     }
 
+    case `loadResumeSnapshot`: {
+      const result = await adapter.loadResumeSnapshot(
+        request.collectionId,
+        request.payload.ctx,
+      )
+      return {
+        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result,
+      }
+    }
+
     case `loadCollectionMetadata`: {
       if (!adapter.loadCollectionMetadata) {
         throw new InvalidPersistedCollectionConfigError(

package/src/protocol.ts

@@ -2,11 +2,12 @@ import type { LoadSubsetOptions } from '@tanstack/db'
 import type {
   PersistedCollectionMode,
   PersistedIndexSpec,
+  PersistedKeySetEvidence,
   PersistedTx,
   SQLitePullSinceResult,
 } from '@tanstack/db-sqlite-persistence-core'
 
-export const ELECTRON_PERSISTENCE_PROTOCOL_VERSION = 1 as const
+export const ELECTRON_PERSISTENCE_PROTOCOL_VERSION = 2 as const
 export const DEFAULT_ELECTRON_PERSISTENCE_CHANNEL = `tanstack-db:sqlite-persistence`
 
 export type ElectronPersistedRow = Record<string, unknown>
@@ -19,6 +20,7 @@ export type ElectronPersistenceResolution = {
 
 export type ElectronPersistenceMethod =
   | `loadSubset`
+  | `loadResumeSnapshot`
   | `loadCollectionMetadata`
   | `scanRows`
   | `applyCommittedTx`
@@ -32,6 +34,12 @@ export type ElectronPersistencePayloadMap = {
     options: LoadSubsetOptions
     ctx?: { requiredIndexSignatures?: ReadonlyArray<string> }
   }
+  loadResumeSnapshot: {
+    ctx?: {
+      requiredIndexSignatures?: ReadonlyArray<string>
+      includeRows?: boolean
+    }
+  }
   loadCollectionMetadata: {}
   scanRows: {
     options?: {
@@ -56,6 +64,19 @@ export type ElectronPersistencePayloadMap = {
 
 export type ElectronPersistenceResultMap = {
   loadSubset: Array<{ key: ElectronPersistedKey; value: ElectronPersistedRow }>
+  loadResumeSnapshot: {
+    rows: Array<{
+      key: ElectronPersistedKey
+      value: ElectronPersistedRow
+      metadata?: unknown
+    }>
+    keySet?: PersistedKeySetEvidence
+    collectionMetadata: Array<{ key: string; value: unknown }>
+    latestTerm: number
+    latestSeq: number
+    latestRowVersion: number
+    resetEpoch: number
+  }
   loadCollectionMetadata: Array<{ key: string; value: unknown }>
   scanRows: Array<{
     key: ElectronPersistedKey

package/src/renderer.ts

@@ -200,6 +200,20 @@ function createResolvedRendererAdapter(
         value: Record<string, unknown>
       }>
     },
+    loadResumeSnapshot: async (
+      collectionId: string,
+      ctx?: {
+        requiredIndexSignatures?: ReadonlyArray<string>
+        includeRows?: boolean
+      },
+    ) => {
+      return executeRequest(
+        `loadResumeSnapshot`,
+        collectionId,
+        { ctx },
+        resolution,
+      )
+    },
     applyCommittedTx: async (
       collectionId: string,
       tx: PersistedTx<Record<string, unknown>, string | number>,
@@ -359,35 +373,40 @@ export function createElectronSQLitePersistence(
       schemaVersion,
     })
     adapterCache.set(cacheKey, adapter)
-
-    // Wire the adapter into the coordinator so it can handle
-    // leader-side RPCs (applyCommittedTx, pullSince, getStreamPosition, etc.)
-    if (coordinator instanceof ElectronCollectionCoordinator) {
-      coordinator.setAdapter(adapter)
-    }
-
     return adapter
   }
 
   const createCollectionPersistence = (
+    collectionId: string | undefined,
     mode: PersistedCollectionMode,
     schemaVersion: number | undefined,
-  ): PersistedCollectionPersistence => ({
-    adapter: getAdapterForCollection(mode, schemaVersion),
-    coordinator,
-  })
+  ): PersistedCollectionPersistence => {
+    const adapter = getAdapterForCollection(mode, schemaVersion)
+    if (coordinator instanceof ElectronCollectionCoordinator) {
+      if (collectionId === undefined) {
+        coordinator.setAdapter(adapter)
+      } else {
+        coordinator.setAdapterForCollection(collectionId, adapter)
+      }
+    }
+    return { adapter, coordinator }
+  }
 
   const defaultPersistence = createCollectionPersistence(
+    undefined,
     `sync-absent`,
     undefined,
   )
+  if (coordinator instanceof ElectronCollectionCoordinator) {
+    coordinator.setAdapter(defaultPersistence.adapter)
+  }
 
   return {
     ...defaultPersistence,
-    resolvePersistenceForCollection: ({ mode, schemaVersion }) =>
-      createCollectionPersistence(mode, schemaVersion),
+    resolvePersistenceForCollection: ({ collectionId, mode, schemaVersion }) =>
+      createCollectionPersistence(collectionId, mode, schemaVersion),
     // Backward compatible fallback for older callers.
     resolvePersistenceForMode: (mode) =>
-      createCollectionPersistence(mode, undefined),
+      createCollectionPersistence(undefined, mode, undefined),
   }
 }