@tanstack/electron-db-sqlite-persistence 0.1.2

package/dist/cjs/renderer.cjs

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const dbSqlitePersistenceCore = require("@tanstack/db-sqlite-persistence-core");
+const electronCoordinator = require("./electron-coordinator.cjs");
+const protocol = require("./protocol.cjs");
+const DEFAULT_REQUEST_TIMEOUT_MS = 5e3;
+let nextRequestId = 1;
+function createRequestId() {
+  const requestId = nextRequestId;
+  nextRequestId++;
+  return `electron-persistence-${requestId}`;
+}
+function withTimeout(promise, timeoutMs, timeoutMessage) {
+  if (timeoutMs <= 0) {
+    return promise;
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(timeoutMessage));
+    }, timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+function assertValidResponse(response, request) {
+  if (response.v !== protocol.ELECTRON_PERSISTENCE_PROTOCOL_VERSION) {
+    throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+      `Unexpected electron persistence protocol version "${response.v}" in response`
+    );
+  }
+  if (response.requestId !== request.requestId) {
+    throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+      `Mismatched electron persistence response request id. Expected "${request.requestId}", received "${response.requestId}"`
+    );
+  }
+  if (response.method !== request.method) {
+    throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+      `Mismatched electron persistence response method. Expected "${request.method}", received "${response.method}"`
+    );
+  }
+}
+function createSerializableLoadSubsetOptions(subsetOptions) {
+  const { subscription: _subscription, ...serializableOptions } = subsetOptions;
+  return serializableOptions;
+}
+function createRendererRequestExecutor(options) {
+  const channel = options.channel ?? protocol.DEFAULT_ELECTRON_PERSISTENCE_CHANNEL;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  return async (method, collectionId, payload, resolution) => {
+    const request = {
+      v: protocol.ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+      requestId: createRequestId(),
+      collectionId,
+      method,
+      resolution,
+      payload
+    };
+    const response = await withTimeout(
+      options.invoke(channel, request),
+      timeoutMs,
+      `Electron persistence request timed out (method=${method}, collection=${collectionId}, timeoutMs=${timeoutMs})`
+    );
+    assertValidResponse(response, request);
+    if (!response.ok) {
+      const remoteError = new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+        `${response.error.name}: ${response.error.message}`
+      );
+      if (typeof response.error.stack === `string`) {
+        remoteError.stack = response.error.stack;
+      }
+      if (typeof response.error.code === `string`) {
+        remoteError.code = response.error.code;
+      }
+      throw remoteError;
+    }
+    return response.result;
+  };
+}
+function createResolvedRendererAdapter(executeRequest, resolution) {
+  return {
+    loadSubset: async (collectionId, subsetOptions, ctx) => {
+      const result = await executeRequest(
+        `loadSubset`,
+        collectionId,
+        {
+          options: createSerializableLoadSubsetOptions(subsetOptions),
+          ctx
+        },
+        resolution
+      );
+      return result;
+    },
+    applyCommittedTx: async (collectionId, tx) => {
+      await executeRequest(
+        `applyCommittedTx`,
+        collectionId,
+        {
+          tx
+        },
+        resolution
+      );
+    },
+    loadCollectionMetadata: async (collectionId) => {
+      return executeRequest(
+        `loadCollectionMetadata`,
+        collectionId,
+        {},
+        resolution
+      );
+    },
+    scanRows: async (collectionId, options) => {
+      const result = await executeRequest(
+        `scanRows`,
+        collectionId,
+        { options },
+        resolution
+      );
+      return result;
+    },
+    ensureIndex: async (collectionId, signature, spec) => {
+      await executeRequest(
+        `ensureIndex`,
+        collectionId,
+        {
+          signature,
+          spec
+        },
+        resolution
+      );
+    },
+    markIndexRemoved: async (collectionId, signature) => {
+      await executeRequest(
+        `markIndexRemoved`,
+        collectionId,
+        {
+          signature
+        },
+        resolution
+      );
+    },
+    pullSince: async (collectionId, fromRowVersion) => {
+      const result = await executeRequest(
+        `pullSince`,
+        collectionId,
+        {
+          fromRowVersion
+        },
+        resolution
+      );
+      return result;
+    },
+    getStreamPosition: async (collectionId) => {
+      return executeRequest(`getStreamPosition`, collectionId, {}, resolution);
+    }
+  };
+}
+function resolveInvoke(options) {
+  if (options.invoke) {
+    return options.invoke;
+  }
+  if (options.ipcRenderer) {
+    return (channel, request) => options.ipcRenderer.invoke(channel, request);
+  }
+  throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+    `Electron renderer persistence requires either invoke or ipcRenderer`
+  );
+}
+function createElectronSQLitePersistence(options) {
+  const invoke = resolveInvoke(options);
+  const coordinator = options.coordinator ?? new dbSqlitePersistenceCore.SingleProcessCoordinator();
+  const executeRequest = createRendererRequestExecutor({
+    invoke,
+    channel: options.channel,
+    timeoutMs: options.timeoutMs
+  });
+  const adapterCache = /* @__PURE__ */ new Map();
+  const getAdapterForCollection = (mode, schemaVersion) => {
+    const schemaVersionKey = schemaVersion === void 0 ? `schema:default` : `schema:${schemaVersion}`;
+    const cacheKey = `mode:${mode}|${schemaVersionKey}`;
+    const cachedAdapter = adapterCache.get(cacheKey);
+    if (cachedAdapter) {
+      return cachedAdapter;
+    }
+    const adapter = createResolvedRendererAdapter(executeRequest, {
+      mode,
+      schemaVersion
+    });
+    adapterCache.set(cacheKey, adapter);
+    if (coordinator instanceof electronCoordinator.ElectronCollectionCoordinator) {
+      coordinator.setAdapter(adapter);
+    }
+    return adapter;
+  };
+  const createCollectionPersistence = (mode, schemaVersion) => ({
+    adapter: getAdapterForCollection(
+      mode,
+      schemaVersion
+    ),
+    coordinator
+  });
+  const defaultPersistence = createCollectionPersistence(
+    `sync-absent`,
+    void 0
+  );
+  return {
+    ...defaultPersistence,
+    resolvePersistenceForCollection: ({ mode, schemaVersion }) => createCollectionPersistence(mode, schemaVersion),
+    // Backward compatible fallback for older callers.
+    resolvePersistenceForMode: (mode) => createCollectionPersistence(mode, void 0)
+  };
+}
+exports.createElectronSQLitePersistence = createElectronSQLitePersistence;
+//# sourceMappingURL=renderer.cjs.map

package/dist/cjs/renderer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.cjs","sources":["../../src/renderer.ts"],"sourcesContent":["import {\n  InvalidPersistedCollectionConfigError,\n  SingleProcessCoordinator,\n} from '@tanstack/db-sqlite-persistence-core'\nimport { ElectronCollectionCoordinator } from './electron-coordinator'\nimport {\n  DEFAULT_ELECTRON_PERSISTENCE_CHANNEL,\n  ELECTRON_PERSISTENCE_PROTOCOL_VERSION,\n} from './protocol'\nimport type {\n  PersistedCollectionCoordinator,\n  PersistedCollectionMode,\n  PersistedCollectionPersistence,\n  PersistedIndexSpec,\n  PersistedTx,\n  SQLitePullSinceResult,\n} from '@tanstack/db-sqlite-persistence-core'\nimport type {\n  ElectronPersistedKey,\n  ElectronPersistedRow,\n  ElectronPersistenceInvoke,\n  ElectronPersistenceMethod,\n  ElectronPersistencePayloadMap,\n  ElectronPersistenceRequest,\n  ElectronPersistenceRequestEnvelope,\n  ElectronPersistenceResolution,\n  ElectronPersistenceResponseEnvelope,\n  ElectronPersistenceResultMap,\n} from './protocol'\nimport type { LoadSubsetOptions } from '@tanstack/db'\n\nconst DEFAULT_REQUEST_TIMEOUT_MS = 5_000\nlet nextRequestId = 1\n\nfunction createRequestId(): string {\n  const requestId = nextRequestId\n  nextRequestId++\n  return `electron-persistence-${requestId}`\n}\n\nfunction withTimeout<T>(\n  promise: Promise<T>,\n  timeoutMs: number,\n  timeoutMessage: string,\n): Promise<T> {\n  if (timeoutMs <= 0) {\n    return promise\n  }\n\n  return new Promise<T>((resolve, reject) => {\n    const timer = setTimeout(() => {\n      reject(new InvalidPersistedCollectionConfigError(timeoutMessage))\n    }, timeoutMs)\n\n    promise.then(\n      (value) => {\n        clearTimeout(timer)\n        resolve(value)\n      },\n      (error: unknown) => {\n        clearTimeout(timer)\n        reject(error)\n      },\n    )\n  })\n}\n\nfunction assertValidResponse(\n  response: ElectronPersistenceResponseEnvelope,\n  request: ElectronPersistenceRequestEnvelope,\n): void {\n  if (response.v !== ELECTRON_PERSISTENCE_PROTOCOL_VERSION) {\n    throw new InvalidPersistedCollectionConfigError(\n      `Unexpected electron persistence protocol version \"${response.v}\" in response`,\n    )\n  }\n\n  if (response.requestId !== request.requestId) {\n    throw new InvalidPersistedCollectionConfigError(\n      `Mismatched electron persistence response request id. Expected \"${request.requestId}\", received \"${response.requestId}\"`,\n    )\n  }\n\n  if (response.method !== request.method) {\n    throw new InvalidPersistedCollectionConfigError(\n      `Mismatched electron persistence response method. Expected \"${request.method}\", received \"${response.method}\"`,\n    )\n  }\n}\n\nfunction createSerializableLoadSubsetOptions(\n  subsetOptions: LoadSubsetOptions,\n): LoadSubsetOptions {\n  const { subscription: _subscription, ...serializableOptions } = subsetOptions\n  return serializableOptions\n}\n\ntype RendererRequestExecutor = <TMethod extends ElectronPersistenceMethod>(\n  method: TMethod,\n  collectionId: string,\n  payload: ElectronPersistencePayloadMap[TMethod],\n  resolution?: ElectronPersistenceResolution,\n) => Promise<ElectronPersistenceResultMap[TMethod]>\n\nfunction createRendererRequestExecutor(options: {\n  invoke: ElectronPersistenceInvoke\n  channel?: string\n  timeoutMs?: number\n}): RendererRequestExecutor {\n  const channel = options.channel ?? DEFAULT_ELECTRON_PERSISTENCE_CHANNEL\n  const timeoutMs = options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS\n\n  return async <TMethod extends ElectronPersistenceMethod>(\n    method: TMethod,\n    collectionId: string,\n    payload: ElectronPersistencePayloadMap[TMethod],\n    resolution?: ElectronPersistenceResolution,\n  ) => {\n    const request = {\n      v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,\n      requestId: createRequestId(),\n      collectionId,\n      method,\n      resolution,\n      payload,\n    } as ElectronPersistenceRequest\n\n    const response = await withTimeout(\n      options.invoke(channel, request),\n      timeoutMs,\n      `Electron persistence request timed out (method=${method}, collection=${collectionId}, timeoutMs=${timeoutMs})`,\n    )\n    assertValidResponse(response, request)\n\n    if (!response.ok) {\n      const remoteError = new InvalidPersistedCollectionConfigError(\n        `${response.error.name}: ${response.error.message}`,\n      )\n      if (typeof response.error.stack === `string`) {\n        remoteError.stack = response.error.stack\n      }\n      if (typeof response.error.code === `string`) {\n        ;(remoteError as Error & { code?: string }).code = response.error.code\n      }\n      throw remoteError\n    }\n\n    return response.result as ElectronPersistenceResultMap[TMethod]\n  }\n}\n\ntype ElectronRendererResolvedAdapter<\n  T extends object,\n  TKey extends string | number = string | number,\n> = PersistedCollectionPersistence<T, TKey>[`adapter`] & {\n  loadCollectionMetadata: (\n    collectionId: string,\n  ) => Promise<Array<{ key: string; value: unknown }>>\n  scanRows: (\n    collectionId: string,\n    options?: { metadataOnly?: boolean },\n  ) => Promise<Array<{ key: TKey; value: T; metadata?: unknown }>>\n  pullSince: (\n    collectionId: string,\n    fromRowVersion: number,\n  ) => Promise<SQLitePullSinceResult<TKey>>\n  getStreamPosition: (collectionId: string) => Promise<{\n    latestTerm: number\n    latestSeq: number\n    latestRowVersion: number\n  }>\n}\n\nfunction createResolvedRendererAdapter<\n  T extends object,\n  TKey extends string | number = string | number,\n>(\n  executeRequest: RendererRequestExecutor,\n  resolution?: ElectronPersistenceResolution,\n): ElectronRendererResolvedAdapter<T, TKey> {\n  return {\n    loadSubset: async (\n      collectionId: string,\n      subsetOptions: LoadSubsetOptions,\n      ctx?: { requiredIndexSignatures?: ReadonlyArray<string> },\n    ) => {\n      const result = await executeRequest(\n        `loadSubset`,\n        collectionId,\n        {\n          options: createSerializableLoadSubsetOptions(subsetOptions),\n          ctx,\n        },\n        resolution,\n      )\n\n      return result as Array<{ key: TKey; value: T }>\n    },\n    applyCommittedTx: async (\n      collectionId: string,\n      tx: PersistedTx<T, TKey>,\n    ): Promise<void> => {\n      await executeRequest(\n        `applyCommittedTx`,\n        collectionId,\n        {\n          tx: tx as PersistedTx<ElectronPersistedRow, ElectronPersistedKey>,\n        },\n        resolution,\n      )\n    },\n    loadCollectionMetadata: async (\n      collectionId: string,\n    ): Promise<Array<{ key: string; value: unknown }>> => {\n      return executeRequest(\n        `loadCollectionMetadata`,\n        collectionId,\n        {},\n        resolution,\n      )\n    },\n    scanRows: async (\n      collectionId: string,\n      options?: { metadataOnly?: boolean },\n    ): Promise<Array<{ key: TKey; value: T; metadata?: unknown }>> => {\n      const result = await executeRequest(\n        `scanRows`,\n        collectionId,\n        { options },\n        resolution,\n      )\n      return result as Array<{ key: TKey; value: T; metadata?: unknown }>\n    },\n    ensureIndex: async (\n      collectionId: string,\n      signature: string,\n      spec: PersistedIndexSpec,\n    ): Promise<void> => {\n      await executeRequest(\n        `ensureIndex`,\n        collectionId,\n        {\n          signature,\n          spec,\n        },\n        resolution,\n      )\n    },\n    markIndexRemoved: async (\n      collectionId: string,\n      signature: string,\n    ): Promise<void> => {\n      await executeRequest(\n        `markIndexRemoved`,\n        collectionId,\n        {\n          signature,\n        },\n        resolution,\n      )\n    },\n    pullSince: async (\n      collectionId: string,\n      fromRowVersion: number,\n    ): Promise<SQLitePullSinceResult<TKey>> => {\n      const result = await executeRequest(\n        `pullSince`,\n        collectionId,\n        {\n          fromRowVersion,\n        },\n        resolution,\n      )\n      return result as SQLitePullSinceResult<TKey>\n    },\n    getStreamPosition: async (\n      collectionId: string,\n    ): Promise<{\n      latestTerm: number\n      latestSeq: number\n      latestRowVersion: number\n    }> => {\n      return executeRequest(`getStreamPosition`, collectionId, {}, resolution)\n    },\n  }\n}\n\nexport type ElectronIpcRendererLike = {\n  invoke: (\n    channel: string,\n    request: ElectronPersistenceRequestEnvelope,\n  ) => Promise<ElectronPersistenceResponseEnvelope>\n}\n\nexport type ElectronSQLitePersistenceOptions = {\n  invoke?: ElectronPersistenceInvoke\n  ipcRenderer?: ElectronIpcRendererLike\n  channel?: string\n  timeoutMs?: number\n  coordinator?: PersistedCollectionCoordinator\n}\n\nfunction resolveInvoke(\n  options: ElectronSQLitePersistenceOptions,\n): ElectronPersistenceInvoke {\n  if (options.invoke) {\n    return options.invoke\n  }\n\n  if (options.ipcRenderer) {\n    return (channel, request) => options.ipcRenderer!.invoke(channel, request)\n  }\n\n  throw new InvalidPersistedCollectionConfigError(\n    `Electron renderer persistence requires either invoke or ipcRenderer`,\n  )\n}\n\nexport function createElectronSQLitePersistence<\n  T extends object,\n  TKey extends string | number = string | number,\n>(\n  options: ElectronSQLitePersistenceOptions,\n): PersistedCollectionPersistence<T, TKey> {\n  const invoke = resolveInvoke(options)\n  const coordinator = options.coordinator ?? new SingleProcessCoordinator()\n  const executeRequest = createRendererRequestExecutor({\n    invoke,\n    channel: options.channel,\n    timeoutMs: options.timeoutMs,\n  })\n  const adapterCache = new Map<\n    string,\n    ElectronRendererResolvedAdapter<Record<string, unknown>, string | number>\n  >()\n\n  const getAdapterForCollection = (\n    mode: PersistedCollectionMode,\n    schemaVersion: number | undefined,\n  ) => {\n    const schemaVersionKey =\n      schemaVersion === undefined ? `schema:default` : `schema:${schemaVersion}`\n    const cacheKey = `mode:${mode}|${schemaVersionKey}`\n    const cachedAdapter = adapterCache.get(cacheKey)\n    if (cachedAdapter) {\n      return cachedAdapter\n    }\n\n    const adapter = createResolvedRendererAdapter<\n      Record<string, unknown>,\n      string | number\n    >(executeRequest, {\n      mode,\n      schemaVersion,\n    })\n    adapterCache.set(cacheKey, adapter)\n\n    // Wire the adapter into the coordinator so it can handle\n    // leader-side RPCs (applyCommittedTx, pullSince, getStreamPosition, etc.)\n    if (coordinator instanceof ElectronCollectionCoordinator) {\n      coordinator.setAdapter(adapter)\n    }\n\n    return adapter\n  }\n\n  const createCollectionPersistence = (\n    mode: PersistedCollectionMode,\n    schemaVersion: number | undefined,\n  ): PersistedCollectionPersistence<T, TKey> => ({\n    adapter: getAdapterForCollection(\n      mode,\n      schemaVersion,\n    ) as unknown as PersistedCollectionPersistence<T, TKey>[`adapter`],\n    coordinator,\n  })\n\n  const defaultPersistence = createCollectionPersistence(\n    `sync-absent`,\n    undefined,\n  )\n\n  return {\n    ...defaultPersistence,\n    resolvePersistenceForCollection: ({ mode, schemaVersion }) =>\n      createCollectionPersistence(mode, schemaVersion),\n    // Backward compatible fallback for older callers.\n    resolvePersistenceForMode: (mode) =>\n      createCollectionPersistence(mode, undefined),\n  }\n}\n"],"names":["InvalidPersistedCollectionConfigError","ELECTRON_PERSISTENCE_PROTOCOL_VERSION","DEFAULT_ELECTRON_PERSISTENCE_CHANNEL","SingleProcessCoordinator","ElectronCollectionCoordinator"],"mappings":"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"}

package/dist/cjs/renderer.d.cts

@@ -0,0 +1,13 @@
+import { PersistedCollectionCoordinator, PersistedCollectionPersistence } from '@tanstack/db-sqlite-persistence-core';
+import { ElectronPersistenceInvoke, ElectronPersistenceRequestEnvelope, ElectronPersistenceResponseEnvelope } from './protocol.cjs';
+export type ElectronIpcRendererLike = {
+    invoke: (channel: string, request: ElectronPersistenceRequestEnvelope) => Promise<ElectronPersistenceResponseEnvelope>;
+};
+export type ElectronSQLitePersistenceOptions = {
+    invoke?: ElectronPersistenceInvoke;
+    ipcRenderer?: ElectronIpcRendererLike;
+    channel?: string;
+    timeoutMs?: number;
+    coordinator?: PersistedCollectionCoordinator;
+};
+export declare function createElectronSQLitePersistence<T extends object, TKey extends string | number = string | number>(options: ElectronSQLitePersistenceOptions): PersistedCollectionPersistence<T, TKey>;

package/dist/esm/electron-coordinator.d.ts

@@ -0,0 +1,67 @@
+import { ApplyLocalMutationsResponse, PersistedCollectionCoordinator, PersistedIndexSpec, PersistedMutationEnvelope, PersistenceAdapter, ProtocolEnvelope, PullSinceResponse } from '@tanstack/db-sqlite-persistence-core';
+import { LoadSubsetOptions } from '@tanstack/db';
+type AdapterWithPullSince = PersistenceAdapter<Record<string, unknown>, string | number> & {
+    pullSince?: (collectionId: string, fromRowVersion: number) => Promise<{
+        latestRowVersion: number;
+        requiresFullReload: true;
+    } | {
+        latestRowVersion: number;
+        requiresFullReload: false;
+        changedKeys: Array<string | number>;
+        deletedKeys: Array<string | number>;
+    }>;
+    getStreamPosition?: (collectionId: string) => Promise<{
+        latestTerm: number;
+        latestSeq: number;
+        latestRowVersion: number;
+    }>;
+};
+export type ElectronCollectionCoordinatorOptions = {
+    dbName: string;
+    adapter?: AdapterWithPullSince;
+};
+export declare class ElectronCollectionCoordinator implements PersistedCollectionCoordinator {
+    private readonly nodeId;
+    private readonly dbName;
+    private adapter;
+    private readonly channel;
+    private readonly collections;
+    private readonly pendingRPCs;
+    private readonly appliedEnvelopeIds;
+    private disposed;
+    /** Method indirection to prevent TypeScript from narrowing `disposed` across awaits */
+    private isDisposed;
+    private requireAdapter;
+    constructor(options: ElectronCollectionCoordinatorOptions);
+    /**
+     * Set or replace the persistence adapter used for leader-side RPC handling.
+     * Called by `createElectronSQLitePersistence` to wire the internally-created
+     * adapter into the coordinator.
+     */
+    setAdapter(adapter: AdapterWithPullSince): void;
+    getNodeId(): string;
+    subscribe(collectionId: string, onMessage: (message: ProtocolEnvelope<unknown>) => void): () => void;
+    publish(_collectionId: string, message: ProtocolEnvelope<unknown>): void;
+    isLeader(collectionId: string): boolean;
+    ensureLeadership(collectionId: string): Promise<void>;
+    requestEnsureRemoteSubset(collectionId: string, options: LoadSubsetOptions): Promise<void>;
+    requestEnsurePersistedIndex(collectionId: string, signature: string, spec: PersistedIndexSpec): Promise<void>;
+    requestApplyLocalMutations(collectionId: string, mutations: Array<PersistedMutationEnvelope>): Promise<ApplyLocalMutationsResponse>;
+    pullSince(collectionId: string, fromRowVersion: number): Promise<PullSinceResponse>;
+    dispose(): void;
+    private ensureCollectionState;
+    private acquireLeadership;
+    private releaseLeadership;
+    private emitHeartbeat;
+    private onChannelMessage;
+    private sendRPC;
+    private sendRPCOnce;
+    private handleRPCRequest;
+    private handleEnsureRemoteSubset;
+    private handleEnsurePersistedIndex;
+    private handleApplyLocalMutations;
+    private handlePullSince;
+    private withWriterLock;
+    private pruneAppliedEnvelopeIds;
+}
+export {};