@tanstack/electron-db-sqlite-persistence 0.1.2

package/dist/cjs/electron-coordinator.d.cts

@@ -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 {};

package/dist/cjs/errors.d.cts

@@ -0,0 +1,33 @@
+import { ElectronPersistenceMethod, ElectronSerializedError } from './protocol.cjs';
+type ElectronPersistenceErrorOptions = {
+    code?: string;
+    cause?: unknown;
+};
+export declare class ElectronPersistenceError extends Error {
+    readonly code: string | undefined;
+    constructor(message: string, options?: ElectronPersistenceErrorOptions);
+}
+export declare class UnknownElectronPersistenceCollectionError extends ElectronPersistenceError {
+    readonly collectionId: string;
+    constructor(collectionId: string);
+}
+export declare class UnsupportedElectronPersistenceMethodError extends ElectronPersistenceError {
+    readonly method: ElectronPersistenceMethod;
+    readonly collectionId: string;
+    constructor(method: ElectronPersistenceMethod, collectionId: string);
+}
+export declare class ElectronPersistenceProtocolError extends ElectronPersistenceError {
+    constructor(message: string, options?: ElectronPersistenceErrorOptions);
+}
+export declare class ElectronPersistenceTimeoutError extends ElectronPersistenceError {
+    constructor(message: string);
+}
+export declare class ElectronPersistenceRpcError extends ElectronPersistenceError {
+    readonly method: ElectronPersistenceMethod;
+    readonly collectionId: string;
+    readonly requestId: string;
+    readonly remoteName: string;
+    constructor(method: ElectronPersistenceMethod, collectionId: string, requestId: string, serializedError: ElectronSerializedError);
+    static fromSerialized(method: ElectronPersistenceMethod, collectionId: string, requestId: string, serializedError: ElectronSerializedError): ElectronPersistenceRpcError;
+}
+export {};

package/dist/cjs/index.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const main = require("./main.cjs");
+const renderer = require("./renderer.cjs");
+const electronCoordinator = require("./electron-coordinator.cjs");
+const dbSqlitePersistenceCore = require("@tanstack/db-sqlite-persistence-core");
+exports.exposeElectronSQLitePersistence = main.exposeElectronSQLitePersistence;
+exports.createElectronSQLitePersistence = renderer.createElectronSQLitePersistence;
+exports.ElectronCollectionCoordinator = electronCoordinator.ElectronCollectionCoordinator;
+Object.defineProperty(exports, "persistedCollectionOptions", {
+  enumerable: true,
+  get: () => dbSqlitePersistenceCore.persistedCollectionOptions
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

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

package/dist/cjs/index.d.cts

@@ -0,0 +1,8 @@
+export { exposeElectronSQLitePersistence } from './main.cjs';
+export type { ElectronIpcMainLike, ElectronSQLiteMainProcessOptions, } from './main.cjs';
+export { createElectronSQLitePersistence } from './renderer.cjs';
+export type { ElectronIpcRendererLike, ElectronSQLitePersistenceOptions, } from './renderer.cjs';
+export { ElectronCollectionCoordinator } from './electron-coordinator.cjs';
+export type { ElectronCollectionCoordinatorOptions } from './electron-coordinator.cjs';
+export { persistedCollectionOptions } from '@tanstack/db-sqlite-persistence-core';
+export type { PersistedCollectionCoordinator, PersistedCollectionPersistence, } from '@tanstack/db-sqlite-persistence-core';

package/dist/cjs/main.cjs

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const dbSqlitePersistenceCore = require("@tanstack/db-sqlite-persistence-core");
+const protocol = require("./protocol.cjs");
+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: protocol.ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+    requestId: request.requestId,
+    method: request.method,
+    ok: false,
+    error: serializeError(error)
+  };
+}
+function assertValidRequest(request) {
+  if (request.v !== protocol.ELECTRON_PERSISTENCE_PROTOCOL_VERSION) {
+    throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+      `Unsupported electron persistence protocol version "${request.v}"`
+    );
+  }
+  if (typeof request.requestId !== `string` || request.requestId.trim().length === 0) {
+    throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+      `Electron persistence requestId cannot be empty`
+    );
+  }
+  if (typeof request.collectionId !== `string` || request.collectionId.trim().length === 0) {
+    throw new dbSqlitePersistenceCore.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: protocol.ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result
+      };
+    }
+    case `loadCollectionMetadata`: {
+      if (!adapter.loadCollectionMetadata) {
+        throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+          `loadCollectionMetadata is not supported by the configured electron persistence adapter`
+        );
+      }
+      const result = await adapter.loadCollectionMetadata(request.collectionId);
+      return {
+        v: protocol.ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result
+      };
+    }
+    case `scanRows`: {
+      if (!adapter.scanRows) {
+        throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+          `scanRows is not supported by the configured electron persistence adapter`
+        );
+      }
+      const result = await adapter.scanRows(
+        request.collectionId,
+        request.payload.options
+      );
+      return {
+        v: protocol.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: protocol.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: protocol.ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result: null
+      };
+    }
+    case `markIndexRemoved`: {
+      if (!adapter.markIndexRemoved) {
+        throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+          `markIndexRemoved is not supported by the configured electron persistence adapter`
+        );
+      }
+      await adapter.markIndexRemoved(
+        request.collectionId,
+        request.payload.signature
+      );
+      return {
+        v: protocol.ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result: null
+      };
+    }
+    case `pullSince`: {
+      if (!adapter.pullSince) {
+        throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+          `pullSince is not supported by the configured electron persistence adapter`
+        );
+      }
+      const result = await adapter.pullSince(
+        request.collectionId,
+        request.payload.fromRowVersion
+      );
+      return {
+        v: protocol.ELECTRON_PERSISTENCE_PROTOCOL_VERSION,
+        requestId: request.requestId,
+        method: request.method,
+        ok: true,
+        result
+      };
+    }
+    case `getStreamPosition`: {
+      if (!adapter.getStreamPosition) {
+        throw new dbSqlitePersistenceCore.InvalidPersistedCollectionConfigError(
+          `getStreamPosition is not supported by the configured electron persistence adapter`
+        );
+      }
+      const position = await adapter.getStreamPosition(request.collectionId);
+      return {
+        v: protocol.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 ?? protocol.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);
+  };
+}
+exports.exposeElectronSQLitePersistence = exposeElectronSQLitePersistence;
+//# sourceMappingURL=main.cjs.map

package/dist/cjs/main.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.cjs","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":["ELECTRON_PERSISTENCE_PROTOCOL_VERSION","InvalidPersistedCollectionConfigError","DEFAULT_ELECTRON_PERSISTENCE_CHANNEL"],"mappings":"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"}

package/dist/cjs/main.d.cts

@@ -0,0 +1,12 @@
+import { PersistedCollectionPersistence } from '@tanstack/db-sqlite-persistence-core';
+import { ElectronPersistedKey, ElectronPersistedRow, ElectronPersistenceRequestEnvelope, ElectronPersistenceResponseEnvelope } from './protocol.cjs';
+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/cjs/protocol.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ELECTRON_PERSISTENCE_PROTOCOL_VERSION = 1;
+const DEFAULT_ELECTRON_PERSISTENCE_CHANNEL = `tanstack-db:sqlite-persistence`;
+exports.DEFAULT_ELECTRON_PERSISTENCE_CHANNEL = DEFAULT_ELECTRON_PERSISTENCE_CHANNEL;
+exports.ELECTRON_PERSISTENCE_PROTOCOL_VERSION = ELECTRON_PERSISTENCE_PROTOCOL_VERSION;
+//# sourceMappingURL=protocol.cjs.map

package/dist/cjs/protocol.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.cjs","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/cjs/protocol.d.cts

@@ -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 {};