@tanstack/electron-db-sqlite-persistence 0.1.2

package/dist/esm/main.d.ts

@@ -0,0 +1,12 @@
+import { PersistedCollectionPersistence } from '@tanstack/db-sqlite-persistence-core';
+import { ElectronPersistedKey, ElectronPersistedRow, ElectronPersistenceRequestEnvelope, ElectronPersistenceResponseEnvelope } from './protocol.js';
+export type ElectronIpcMainLike = {
+    handle: (channel: string, listener: (event: unknown, request: ElectronPersistenceRequestEnvelope) => Promise<ElectronPersistenceResponseEnvelope>) => void;
+    removeHandler?: (channel: string) => void;
+};
+export type ElectronSQLiteMainProcessOptions = {
+    persistence: PersistedCollectionPersistence<ElectronPersistedRow, ElectronPersistedKey>;
+    ipcMain: ElectronIpcMainLike;
+    channel?: string;
+};
+export declare function exposeElectronSQLitePersistence(options: ElectronSQLiteMainProcessOptions): () => void;

package/dist/esm/main.js

@@ -0,0 +1,213 @@
+import { InvalidPersistedCollectionConfigError } from "@tanstack/db-sqlite-persistence-core";
+import { DEFAULT_ELECTRON_PERSISTENCE_CHANNEL, ELECTRON_PERSISTENCE_PROTOCOL_VERSION } from "./protocol.js";
+function serializeError(error) {
+  const fallbackMessage = `Unknown electron persistence error`;
+  if (!(error instanceof Error)) {
+    return {
+      name: `Error`,
+      message: fallbackMessage,
+      code: void 0
+    };
+  }
+  const codedError = error;
+  return {
+    name: error.name || `Error`,
+    message: error.message || fallbackMessage,
+    stack: error.stack,
+    code: typeof codedError.code === `string` ? codedError.code : void 0
+  };
+}
+function createErrorResponse(request, error) {
+  return {
+    v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+    requestId: request.requestId,
+    method: request.method,
+    ok: false,
+    error: serializeError(error)
+  };
+}
+function assertValidRequest(request) {
+  if (request.v !== ELECTRON_PERSISTENCE_PROTOCOL_VERSION) {
+    throw new InvalidPersistedCollectionConfigError(
+      `Unsupported electron persistence protocol version "${request.v}"`
+    );
+  }
+  if (typeof request.requestId !== `string` || request.requestId.trim().length === 0) {
+    throw new InvalidPersistedCollectionConfigError(
+      `Electron persistence requestId cannot be empty`
+    );
+  }
+  if (typeof request.collectionId !== `string` || request.collectionId.trim().length === 0) {
+    throw new InvalidPersistedCollectionConfigError(
+      `Electron persistence collectionId cannot be empty`
+    );
+  }
+}
+async function executeRequestAgainstAdapter(request, adapter) {
+  switch (request.method) {
+    case `loadSubset`: {
+      const result = await adapter.loadSubset(
+        request.collectionId,
+        request.payload.options,
+        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(
+          `loadCollectionMetadata is not supported by the configured electron persistence adapter`
+        );
+      }
+      const result = await adapter.loadCollectionMetadata(request.collectionId);
+      return {
+        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result
+      };
+    }
+    case `scanRows`: {
+      if (!adapter.scanRows) {
+        throw new InvalidPersistedCollectionConfigError(
+          `scanRows is not supported by the configured electron persistence adapter`
+        );
+      }
+      const result = await adapter.scanRows(
+        request.collectionId,
+        request.payload.options
+      );
+      return {
+        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result
+      };
+    }
+    case `applyCommittedTx`: {
+      await adapter.applyCommittedTx(request.collectionId, request.payload.tx);
+      return {
+        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result: null
+      };
+    }
+    case `ensureIndex`: {
+      await adapter.ensureIndex(
+        request.collectionId,
+        request.payload.signature,
+        request.payload.spec
+      );
+      return {
+        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result: null
+      };
+    }
+    case `markIndexRemoved`: {
+      if (!adapter.markIndexRemoved) {
+        throw new InvalidPersistedCollectionConfigError(
+          `markIndexRemoved is not supported by the configured electron persistence adapter`
+        );
+      }
+      await adapter.markIndexRemoved(
+        request.collectionId,
+        request.payload.signature
+      );
+      return {
+        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result: null
+      };
+    }
+    case `pullSince`: {
+      if (!adapter.pullSince) {
+        throw new InvalidPersistedCollectionConfigError(
+          `pullSince is not supported by the configured electron persistence adapter`
+        );
+      }
+      const result = await adapter.pullSince(
+        request.collectionId,
+        request.payload.fromRowVersion
+      );
+      return {
+        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result
+      };
+    }
+    case `getStreamPosition`: {
+      if (!adapter.getStreamPosition) {
+        throw new InvalidPersistedCollectionConfigError(
+          `getStreamPosition is not supported by the configured electron persistence adapter`
+        );
+      }
+      const position = await adapter.getStreamPosition(request.collectionId);
+      return {
+        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result: position
+      };
+    }
+  }
+}
+function resolveModeAwarePersistence(persistence, request) {
+  const mode = request.resolution?.mode ?? `sync-absent`;
+  const schemaVersion = request.resolution?.schemaVersion;
+  const collectionAwarePersistence = persistence.resolvePersistenceForCollection?.({
+    collectionId: request.collectionId,
+    mode,
+    schemaVersion
+  });
+  if (collectionAwarePersistence) {
+    return collectionAwarePersistence;
+  }
+  const modeAwarePersistence = persistence.resolvePersistenceForMode?.(mode);
+  return modeAwarePersistence ?? persistence;
+}
+function exposeElectronSQLitePersistence(options) {
+  const channel = options.channel ?? DEFAULT_ELECTRON_PERSISTENCE_CHANNEL;
+  options.ipcMain.handle(
+    channel,
+    async (_event, request) => {
+      try {
+        assertValidRequest(request);
+        const modeAwarePersistence = resolveModeAwarePersistence(
+          options.persistence,
+          request
+        );
+        return await executeRequestAgainstAdapter(
+          request,
+          modeAwarePersistence.adapter
+        );
+      } catch (error) {
+        return createErrorResponse(request, error);
+      }
+    }
+  );
+  return () => {
+    options.ipcMain.removeHandler?.(channel);
+  };
+}
+export {
+  exposeElectronSQLitePersistence
+};
+//# sourceMappingURL=main.js.map

package/dist/esm/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sources":["../../src/main.ts"],"sourcesContent":["import { InvalidPersistedCollectionConfigError } from '@tanstack/db-sqlite-persistence-core'\nimport {\n  DEFAULT_ELECTRON_PERSISTENCE_CHANNEL,\n  ELECTRON_PERSISTENCE_PROTOCOL_VERSION,\n} from './protocol'\nimport type {\n  PersistedCollectionPersistence,\n  PersistenceAdapter,\n  SQLitePullSinceResult,\n} from '@tanstack/db-sqlite-persistence-core'\nimport type {\n  ElectronPersistedKey,\n  ElectronPersistedRow,\n  ElectronPersistenceRequestEnvelope,\n  ElectronPersistenceResponseEnvelope,\n  ElectronSerializedError,\n} from './protocol'\n\ntype ElectronMainPersistenceAdapter = PersistenceAdapter<\n  ElectronPersistedRow,\n  ElectronPersistedKey\n> & {\n  loadCollectionMetadata?: (\n    collectionId: string,\n  ) => Promise<Array<{ key: string; value: unknown }>>\n  scanRows?: (\n    collectionId: string,\n    options?: { metadataOnly?: boolean },\n  ) => Promise<\n    Array<{\n      key: ElectronPersistedKey\n      value: ElectronPersistedRow\n      metadata?: unknown\n    }>\n  >\n  pullSince?: (\n    collectionId: string,\n    fromRowVersion: number,\n  ) => Promise<SQLitePullSinceResult<ElectronPersistedKey>>\n  getStreamPosition?: (collectionId: string) => Promise<{\n    latestTerm: number\n    latestSeq: number\n    latestRowVersion: number\n  }>\n}\n\nfunction serializeError(error: unknown): ElectronSerializedError {\n  const fallbackMessage = `Unknown electron persistence error`\n\n  if (!(error instanceof Error)) {\n    return {\n      name: `Error`,\n      message: fallbackMessage,\n      code: undefined,\n    }\n  }\n\n  const codedError = error as Error & { code?: unknown }\n  return {\n    name: error.name || `Error`,\n    message: error.message || fallbackMessage,\n    stack: error.stack,\n    code: typeof codedError.code === `string` ? codedError.code : undefined,\n  }\n}\n\nfunction createErrorResponse(\n  request: ElectronPersistenceRequestEnvelope,\n  error: unknown,\n): ElectronPersistenceResponseEnvelope {\n  return {\n    v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,\n    requestId: request.requestId,\n    method: request.method,\n    ok: false,\n    error: serializeError(error),\n  }\n}\n\nfunction assertValidRequest(request: ElectronPersistenceRequestEnvelope): void {\n  if (request.v !== ELECTRON_PERSISTENCE_PROTOCOL_VERSION) {\n    throw new InvalidPersistedCollectionConfigError(\n      `Unsupported electron persistence protocol version \"${request.v}\"`,\n    )\n  }\n\n  if (\n    typeof request.requestId !== `string` ||\n    request.requestId.trim().length === 0\n  ) {\n    throw new InvalidPersistedCollectionConfigError(\n      `Electron persistence requestId cannot be empty`,\n    )\n  }\n\n  if (\n    typeof request.collectionId !== `string` ||\n    request.collectionId.trim().length === 0\n  ) {\n    throw new InvalidPersistedCollectionConfigError(\n      `Electron persistence collectionId cannot be empty`,\n    )\n  }\n}\n\nasync function executeRequestAgainstAdapter(\n  request: ElectronPersistenceRequestEnvelope,\n  adapter: ElectronMainPersistenceAdapter,\n): Promise<ElectronPersistenceResponseEnvelope> {\n  switch (request.method) {\n    case `loadSubset`: {\n      const result = await adapter.loadSubset(\n        request.collectionId,\n        request.payload.options,\n        request.payload.ctx,\n      )\n      return {\n        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,\n        requestId: request.requestId,\n        method: request.method,\n        ok: true,\n        result,\n      }\n    }\n\n    case `loadCollectionMetadata`: {\n      if (!adapter.loadCollectionMetadata) {\n        throw new InvalidPersistedCollectionConfigError(\n          `loadCollectionMetadata is not supported by the configured electron persistence adapter`,\n        )\n      }\n      const result = await adapter.loadCollectionMetadata(request.collectionId)\n      return {\n        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,\n        requestId: request.requestId,\n        method: request.method,\n        ok: true,\n        result,\n      }\n    }\n\n    case `scanRows`: {\n      if (!adapter.scanRows) {\n        throw new InvalidPersistedCollectionConfigError(\n          `scanRows is not supported by the configured electron persistence adapter`,\n        )\n      }\n      const result = await adapter.scanRows(\n        request.collectionId,\n        request.payload.options,\n      )\n      return {\n        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,\n        requestId: request.requestId,\n        method: request.method,\n        ok: true,\n        result,\n      }\n    }\n\n    case `applyCommittedTx`: {\n      await adapter.applyCommittedTx(request.collectionId, request.payload.tx)\n      return {\n        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,\n        requestId: request.requestId,\n        method: request.method,\n        ok: true,\n        result: null,\n      }\n    }\n\n    case `ensureIndex`: {\n      await adapter.ensureIndex(\n        request.collectionId,\n        request.payload.signature,\n        request.payload.spec,\n      )\n      return {\n        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,\n        requestId: request.requestId,\n        method: request.method,\n        ok: true,\n        result: null,\n      }\n    }\n\n    case `markIndexRemoved`: {\n      if (!adapter.markIndexRemoved) {\n        throw new InvalidPersistedCollectionConfigError(\n          `markIndexRemoved is not supported by the configured electron persistence adapter`,\n        )\n      }\n      await adapter.markIndexRemoved(\n        request.collectionId,\n        request.payload.signature,\n      )\n      return {\n        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,\n        requestId: request.requestId,\n        method: request.method,\n        ok: true,\n        result: null,\n      }\n    }\n\n    case `pullSince`: {\n      if (!adapter.pullSince) {\n        throw new InvalidPersistedCollectionConfigError(\n          `pullSince is not supported by the configured electron persistence adapter`,\n        )\n      }\n      const result = await adapter.pullSince(\n        request.collectionId,\n        request.payload.fromRowVersion,\n      )\n      return {\n        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,\n        requestId: request.requestId,\n        method: request.method,\n        ok: true,\n        result,\n      }\n    }\n\n    case `getStreamPosition`: {\n      if (!adapter.getStreamPosition) {\n        throw new InvalidPersistedCollectionConfigError(\n          `getStreamPosition is not supported by the configured electron persistence adapter`,\n        )\n      }\n      const position = await adapter.getStreamPosition(request.collectionId)\n      return {\n        v: ELECTRON_PERSISTENCE_PROTOCOL_VERSION,\n        requestId: request.requestId,\n        method: request.method,\n        ok: true,\n        result: position,\n      }\n    }\n  }\n}\n\nfunction resolveModeAwarePersistence(\n  persistence: PersistedCollectionPersistence<\n    ElectronPersistedRow,\n    ElectronPersistedKey\n  >,\n  request: ElectronPersistenceRequestEnvelope,\n): PersistedCollectionPersistence<ElectronPersistedRow, ElectronPersistedKey> {\n  const mode = request.resolution?.mode ?? `sync-absent`\n  const schemaVersion = request.resolution?.schemaVersion\n  const collectionAwarePersistence =\n    persistence.resolvePersistenceForCollection?.({\n      collectionId: request.collectionId,\n      mode,\n      schemaVersion,\n    })\n  if (collectionAwarePersistence) {\n    return collectionAwarePersistence\n  }\n\n  const modeAwarePersistence = persistence.resolvePersistenceForMode?.(mode)\n  return modeAwarePersistence ?? persistence\n}\n\nexport type ElectronIpcMainLike = {\n  handle: (\n    channel: string,\n    listener: (\n      event: unknown,\n      request: ElectronPersistenceRequestEnvelope,\n    ) => Promise<ElectronPersistenceResponseEnvelope>,\n  ) => void\n  removeHandler?: (channel: string) => void\n}\n\nexport type ElectronSQLiteMainProcessOptions = {\n  persistence: PersistedCollectionPersistence<\n    ElectronPersistedRow,\n    ElectronPersistedKey\n  >\n  ipcMain: ElectronIpcMainLike\n  channel?: string\n}\n\nexport function exposeElectronSQLitePersistence(\n  options: ElectronSQLiteMainProcessOptions,\n): () => void {\n  const channel = options.channel ?? DEFAULT_ELECTRON_PERSISTENCE_CHANNEL\n  options.ipcMain.handle(\n    channel,\n    async (\n      _event,\n      request: ElectronPersistenceRequestEnvelope,\n    ): Promise<ElectronPersistenceResponseEnvelope> => {\n      try {\n        assertValidRequest(request)\n        const modeAwarePersistence = resolveModeAwarePersistence(\n          options.persistence,\n          request,\n        )\n        return await executeRequestAgainstAdapter(\n          request,\n          modeAwarePersistence.adapter,\n        )\n      } catch (error) {\n        return createErrorResponse(request, error)\n      }\n    },\n  )\n\n  return () => {\n    options.ipcMain.removeHandler?.(channel)\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/protocol.d.ts

@@ -0,0 +1,104 @@
+import { LoadSubsetOptions } from '@tanstack/db';
+import { PersistedCollectionMode, PersistedIndexSpec, PersistedTx, SQLitePullSinceResult } from '@tanstack/db-sqlite-persistence-core';
+export declare const ELECTRON_PERSISTENCE_PROTOCOL_VERSION: 1;
+export declare const DEFAULT_ELECTRON_PERSISTENCE_CHANNEL = "tanstack-db:sqlite-persistence";
+export type ElectronPersistedRow = Record<string, unknown>;
+export type ElectronPersistedKey = string | number;
+export type ElectronPersistenceResolution = {
+    mode: PersistedCollectionMode;
+    schemaVersion?: number;
+};
+export type ElectronPersistenceMethod = `loadSubset` | `loadCollectionMetadata` | `scanRows` | `applyCommittedTx` | `ensureIndex` | `markIndexRemoved` | `pullSince` | `getStreamPosition`;
+export type ElectronPersistencePayloadMap = {
+    loadSubset: {
+        options: LoadSubsetOptions;
+        ctx?: {
+            requiredIndexSignatures?: ReadonlyArray<string>;
+        };
+    };
+    loadCollectionMetadata: {};
+    scanRows: {
+        options?: {
+            metadataOnly?: boolean;
+        };
+    };
+    applyCommittedTx: {
+        tx: PersistedTx<ElectronPersistedRow, ElectronPersistedKey>;
+    };
+    ensureIndex: {
+        signature: string;
+        spec: PersistedIndexSpec;
+    };
+    markIndexRemoved: {
+        signature: string;
+    };
+    pullSince: {
+        fromRowVersion: number;
+    };
+    getStreamPosition: {};
+};
+export type ElectronPersistenceResultMap = {
+    loadSubset: Array<{
+        key: ElectronPersistedKey;
+        value: ElectronPersistedRow;
+    }>;
+    loadCollectionMetadata: Array<{
+        key: string;
+        value: unknown;
+    }>;
+    scanRows: Array<{
+        key: ElectronPersistedKey;
+        value: ElectronPersistedRow;
+        metadata?: unknown;
+    }>;
+    applyCommittedTx: null;
+    ensureIndex: null;
+    markIndexRemoved: null;
+    pullSince: SQLitePullSinceResult<ElectronPersistedKey>;
+    getStreamPosition: {
+        latestTerm: number;
+        latestSeq: number;
+        latestRowVersion: number;
+    };
+};
+export type ElectronSerializedError = {
+    name: string;
+    message: string;
+    stack?: string;
+    code?: string;
+};
+export type ElectronPersistenceRequestByMethod = {
+    [Method in ElectronPersistenceMethod]: {
+        v: number;
+        requestId: string;
+        collectionId: string;
+        resolution?: ElectronPersistenceResolution;
+        method: Method;
+        payload: ElectronPersistencePayloadMap[Method];
+    };
+};
+export type ElectronPersistenceRequest<TMethod extends ElectronPersistenceMethod = ElectronPersistenceMethod> = ElectronPersistenceRequestByMethod[TMethod];
+export type ElectronPersistenceRequestEnvelope = ElectronPersistenceRequestByMethod[ElectronPersistenceMethod];
+type ElectronPersistenceSuccessResponseByMethod = {
+    [Method in ElectronPersistenceMethod]: {
+        v: number;
+        requestId: string;
+        method: Method;
+        ok: true;
+        result: ElectronPersistenceResultMap[Method];
+    };
+};
+type ElectronPersistenceErrorResponseByMethod = {
+    [Method in ElectronPersistenceMethod]: {
+        v: number;
+        requestId: string;
+        method: Method;
+        ok: false;
+        error: ElectronSerializedError;
+    };
+};
+export type ElectronPersistenceResponse<TMethod extends ElectronPersistenceMethod = ElectronPersistenceMethod> = ElectronPersistenceSuccessResponseByMethod[TMethod] | ElectronPersistenceErrorResponseByMethod[TMethod];
+export type ElectronPersistenceResponseEnvelope = ElectronPersistenceResponse<ElectronPersistenceMethod>;
+export type ElectronPersistenceRequestHandler = (request: ElectronPersistenceRequestEnvelope) => Promise<ElectronPersistenceResponseEnvelope>;
+export type ElectronPersistenceInvoke = (channel: string, request: ElectronPersistenceRequestEnvelope) => Promise<ElectronPersistenceResponseEnvelope>;
+export {};

package/dist/esm/protocol.js

@@ -0,0 +1,7 @@
+const ELECTRON_PERSISTENCE_PROTOCOL_VERSION = 1;
+const DEFAULT_ELECTRON_PERSISTENCE_CHANNEL = `tanstack-db:sqlite-persistence`;
+export {
+  DEFAULT_ELECTRON_PERSISTENCE_CHANNEL,
+  ELECTRON_PERSISTENCE_PROTOCOL_VERSION
+};
+//# sourceMappingURL=protocol.js.map

package/dist/esm/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sources":["../../src/protocol.ts"],"sourcesContent":["import type { LoadSubsetOptions } from '@tanstack/db'\nimport type {\n  PersistedCollectionMode,\n  PersistedIndexSpec,\n  PersistedTx,\n  SQLitePullSinceResult,\n} from '@tanstack/db-sqlite-persistence-core'\n\nexport const ELECTRON_PERSISTENCE_PROTOCOL_VERSION = 1 as const\nexport const DEFAULT_ELECTRON_PERSISTENCE_CHANNEL = `tanstack-db:sqlite-persistence`\n\nexport type ElectronPersistedRow = Record<string, unknown>\nexport type ElectronPersistedKey = string | number\n\nexport type ElectronPersistenceResolution = {\n  mode: PersistedCollectionMode\n  schemaVersion?: number\n}\n\nexport type ElectronPersistenceMethod =\n  | `loadSubset`\n  | `loadCollectionMetadata`\n  | `scanRows`\n  | `applyCommittedTx`\n  | `ensureIndex`\n  | `markIndexRemoved`\n  | `pullSince`\n  | `getStreamPosition`\n\nexport type ElectronPersistencePayloadMap = {\n  loadSubset: {\n    options: LoadSubsetOptions\n    ctx?: { requiredIndexSignatures?: ReadonlyArray<string> }\n  }\n  loadCollectionMetadata: {}\n  scanRows: {\n    options?: {\n      metadataOnly?: boolean\n    }\n  }\n  applyCommittedTx: {\n    tx: PersistedTx<ElectronPersistedRow, ElectronPersistedKey>\n  }\n  ensureIndex: {\n    signature: string\n    spec: PersistedIndexSpec\n  }\n  markIndexRemoved: {\n    signature: string\n  }\n  pullSince: {\n    fromRowVersion: number\n  }\n  getStreamPosition: {}\n}\n\nexport type ElectronPersistenceResultMap = {\n  loadSubset: Array<{ key: ElectronPersistedKey; value: ElectronPersistedRow }>\n  loadCollectionMetadata: Array<{ key: string; value: unknown }>\n  scanRows: Array<{\n    key: ElectronPersistedKey\n    value: ElectronPersistedRow\n    metadata?: unknown\n  }>\n  applyCommittedTx: null\n  ensureIndex: null\n  markIndexRemoved: null\n  pullSince: SQLitePullSinceResult<ElectronPersistedKey>\n  getStreamPosition: {\n    latestTerm: number\n    latestSeq: number\n    latestRowVersion: number\n  }\n}\n\nexport type ElectronSerializedError = {\n  name: string\n  message: string\n  stack?: string\n  code?: string\n}\n\nexport type ElectronPersistenceRequestByMethod = {\n  [Method in ElectronPersistenceMethod]: {\n    v: number\n    requestId: string\n    collectionId: string\n    resolution?: ElectronPersistenceResolution\n    method: Method\n    payload: ElectronPersistencePayloadMap[Method]\n  }\n}\n\nexport type ElectronPersistenceRequest<\n  TMethod extends ElectronPersistenceMethod = ElectronPersistenceMethod,\n> = ElectronPersistenceRequestByMethod[TMethod]\n\nexport type ElectronPersistenceRequestEnvelope =\n  ElectronPersistenceRequestByMethod[ElectronPersistenceMethod]\n\ntype ElectronPersistenceSuccessResponseByMethod = {\n  [Method in ElectronPersistenceMethod]: {\n    v: number\n    requestId: string\n    method: Method\n    ok: true\n    result: ElectronPersistenceResultMap[Method]\n  }\n}\n\ntype ElectronPersistenceErrorResponseByMethod = {\n  [Method in ElectronPersistenceMethod]: {\n    v: number\n    requestId: string\n    method: Method\n    ok: false\n    error: ElectronSerializedError\n  }\n}\n\nexport type ElectronPersistenceResponse<\n  TMethod extends ElectronPersistenceMethod = ElectronPersistenceMethod,\n> =\n  | ElectronPersistenceSuccessResponseByMethod[TMethod]\n  | ElectronPersistenceErrorResponseByMethod[TMethod]\n\nexport type ElectronPersistenceResponseEnvelope =\n  ElectronPersistenceResponse<ElectronPersistenceMethod>\n\nexport type ElectronPersistenceRequestHandler = (\n  request: ElectronPersistenceRequestEnvelope,\n) => Promise<ElectronPersistenceResponseEnvelope>\n\nexport type ElectronPersistenceInvoke = (\n  channel: string,\n  request: ElectronPersistenceRequestEnvelope,\n) => Promise<ElectronPersistenceResponseEnvelope>\n"],"names":[],"mappings":"AAQO,MAAM,wCAAwC;AAC9C,MAAM,uCAAuC;"}

package/dist/esm/renderer.d.ts

@@ -0,0 +1,13 @@
+import { PersistedCollectionCoordinator, PersistedCollectionPersistence } from '@tanstack/db-sqlite-persistence-core';
+import { ElectronPersistenceInvoke, ElectronPersistenceRequestEnvelope, ElectronPersistenceResponseEnvelope } from './protocol.js';
+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/renderer.js

@@ -0,0 +1,221 @@
+import { SingleProcessCoordinator, InvalidPersistedCollectionConfigError } from "@tanstack/db-sqlite-persistence-core";
+import { ElectronCollectionCoordinator } from "./electron-coordinator.js";
+import { DEFAULT_ELECTRON_PERSISTENCE_CHANNEL, ELECTRON_PERSISTENCE_PROTOCOL_VERSION } from "./protocol.js";
+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 InvalidPersistedCollectionConfigError(timeoutMessage));
+    }, timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+function assertValidResponse(response, request) {
+  if (response.v !== ELECTRON_PERSISTENCE_PROTOCOL_VERSION) {
+    throw new InvalidPersistedCollectionConfigError(
+      `Unexpected electron persistence protocol version "${response.v}" in response`
+    );
+  }
+  if (response.requestId !== request.requestId) {
+    throw new InvalidPersistedCollectionConfigError(
+      `Mismatched electron persistence response request id. Expected "${request.requestId}", received "${response.requestId}"`
+    );
+  }
+  if (response.method !== request.method) {
+    throw new 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 ?? DEFAULT_ELECTRON_PERSISTENCE_CHANNEL;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  return async (method, collectionId, payload, resolution) => {
+    const request = {
+      v: 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 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 InvalidPersistedCollectionConfigError(
+    `Electron renderer persistence requires either invoke or ipcRenderer`
+  );
+}
+function createElectronSQLitePersistence(options) {
+  const invoke = resolveInvoke(options);
+  const coordinator = options.coordinator ?? new 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 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)
+  };
+}
+export {
+  createElectronSQLitePersistence
+};
+//# sourceMappingURL=renderer.js.map

package/dist/esm/renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.js","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":[],"mappings":"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"}