@firtoz/drizzle-indexeddb 0.6.2 → 2.0.0

package/src/proxy/idb-proxy-client.ts

@@ -1,341 +0,0 @@
-import type {
-	IDBDatabaseLike,
-	IDBCreator,
-	IndexInfo,
-	CreateStoreOptions,
-	CreateIndexOptions,
-	KeyRangeSpec,
-} from "../idb-types";
-import type { IDBProxyClientTransport } from "./idb-proxy-transport";
-import type {
-	IDBProxyRequest,
-	IDBProxyRequestBody,
-	IDBProxyResponse,
-	IDBProxySyncMessage,
-} from "./idb-proxy-types";
-import { generateRequestId, generateClientId } from "./idb-proxy-types";
-
-/**
- * Handler for sync messages from the server
- */
-export type SyncHandler = (message: IDBProxySyncMessage) => void;
-
-/**
- * A proxy implementation of IDBDatabaseLike that sends all operations
- * to a remote server via a transport layer.
- *
- * This is used by content scripts or other clients that don't have
- * direct access to IndexedDB (e.g., in a Chrome extension context).
- *
- * The client manages a "connection" (session) to the server.
- * The server manages the actual database lifecycle.
- *
- * When other clients modify data, the server broadcasts sync messages
- * which this client receives and can handle via onSync().
- */
-export class IDBProxyClient implements IDBDatabaseLike {
-	private _version: number = 0;
-	private _storeNames: string[] = [];
-	private _storeIndexes: Map<string, IndexInfo[]> = new Map();
-	private _connected: boolean = false;
-	private _clientId: string;
-	private _syncHandlers: Set<SyncHandler> = new Set();
-
-	constructor(
-		private dbName: string,
-		private transport: IDBProxyClientTransport,
-		clientId?: string,
-	) {
-		this._clientId = clientId ?? generateClientId();
-
-		// Listen for sync messages from server
-		this.transport.onSync((message) => {
-			// Only handle messages for this database
-			if (message.dbName === this.dbName) {
-				for (const handler of this._syncHandlers) {
-					handler(message);
-				}
-			}
-		});
-	}
-
-	/**
-	 * Get the unique client ID
-	 */
-	get clientId(): string {
-		return this._clientId;
-	}
-
-	/**
-	 * Register a handler for sync messages from other clients.
-	 * Returns an unsubscribe function.
-	 */
-	onSync(handler: SyncHandler): () => void {
-		this._syncHandlers.add(handler);
-		return () => {
-			this._syncHandlers.delete(handler);
-		};
-	}
-
-	/**
-	 * Connect to the server and fetch database metadata.
-	 * The server will ensure the database is open and migrated.
-	 */
-	async connect(): Promise<void> {
-		if (this._connected) {
-			return;
-		}
-
-		// Tell the server we want to connect to this database
-		const connectResponse = await this.sendRequest({ type: "connect" });
-
-		if (connectResponse.type === "error") {
-			throw new Error(connectResponse.error || "Failed to connect to database");
-		}
-
-		// Fetch metadata
-		const versionResponse = await this.sendRequest({ type: "getVersion" });
-		if (versionResponse.type === "success") {
-			this._version = versionResponse.data as number;
-		}
-
-		const storeNamesResponse = await this.sendRequest({
-			type: "getStoreNames",
-		});
-		if (storeNamesResponse.type === "success") {
-			this._storeNames = storeNamesResponse.data as string[];
-		}
-
-		this._connected = true;
-	}
-
-	/**
-	 * Disconnect from the server.
-	 * This is a no-op since clients are cached and reused.
-	 * The connection stays open for future use.
-	 */
-	disconnect(): void {
-		// Intentionally a no-op - clients are cached and reused
-	}
-
-	private async sendRequest(
-		request: IDBProxyRequestBody,
-	): Promise<IDBProxyResponse> {
-		const fullRequest: IDBProxyRequest = {
-			...request,
-			id: generateRequestId(),
-			clientId: this._clientId,
-			dbName: this.dbName,
-		};
-		return this.transport.sendRequest(fullRequest);
-	}
-
-	private handleResponse<T>(response: IDBProxyResponse): T {
-		if (response.type === "error") {
-			throw new Error(response.error || "Unknown server error");
-		}
-		return response.data as T;
-	}
-
-	get version(): number {
-		return this._version;
-	}
-
-	// =========================================================================
-	// Schema Operations - Cached locally, read-only for clients
-	// =========================================================================
-
-	hasStore(storeName: string): boolean {
-		return this._storeNames.includes(storeName);
-	}
-
-	getStoreNames(): string[] {
-		return [...this._storeNames];
-	}
-
-	createStore(_storeName: string, _options?: CreateStoreOptions): void {
-		throw new Error(
-			"Schema modifications not supported on proxy client. Use server-side migrations.",
-		);
-	}
-
-	deleteStore(_storeName: string): void {
-		throw new Error(
-			"Schema modifications not supported on proxy client. Use server-side migrations.",
-		);
-	}
-
-	createIndex(
-		_storeName: string,
-		_indexName: string,
-		_keyPath: string | string[],
-		_options?: CreateIndexOptions,
-	): void {
-		throw new Error(
-			"Schema modifications not supported on proxy client. Use server-side migrations.",
-		);
-	}
-
-	deleteIndex(_storeName: string, _indexName: string): void {
-		throw new Error(
-			"Schema modifications not supported on proxy client. Use server-side migrations.",
-		);
-	}
-
-	getStoreIndexes(storeName: string): IndexInfo[] {
-		const cached = this._storeIndexes.get(storeName);
-		if (cached) {
-			return cached;
-		}
-		return [];
-	}
-
-	/**
-	 * Async version to fetch indexes from server
-	 */
-	async fetchStoreIndexes(storeName: string): Promise<IndexInfo[]> {
-		const response = await this.sendRequest({
-			type: "getStoreIndexes",
-			storeName,
-		});
-		const indexes = this.handleResponse<IndexInfo[]>(response);
-		this._storeIndexes.set(storeName, indexes);
-		return indexes;
-	}
-
-	// =========================================================================
-	// Data Operations - All proxied to server
-	// =========================================================================
-
-	async getAll<T = unknown>(storeName: string): Promise<T[]> {
-		const response = await this.sendRequest({
-			type: "getAll",
-			storeName,
-		});
-		return this.handleResponse<T[]>(response);
-	}
-
-	async getAllByIndex<T = unknown>(
-		storeName: string,
-		indexName: string,
-		keyRange?: KeyRangeSpec,
-	): Promise<T[]> {
-		const response = await this.sendRequest({
-			type: "getAllByIndex",
-			storeName,
-			indexName,
-			keyRange,
-		});
-		return this.handleResponse<T[]>(response);
-	}
-
-	async get<T = unknown>(
-		storeName: string,
-		key: IDBValidKey,
-	): Promise<T | undefined> {
-		const response = await this.sendRequest({
-			type: "get",
-			storeName,
-			key,
-		});
-		return this.handleResponse<T | undefined>(response);
-	}
-
-	async add(storeName: string, items: unknown[]): Promise<void> {
-		const response = await this.sendRequest({
-			type: "add",
-			storeName,
-			items,
-		});
-		this.handleResponse<void>(response);
-	}
-
-	async put(storeName: string, items: unknown[]): Promise<void> {
-		const response = await this.sendRequest({
-			type: "put",
-			storeName,
-			items,
-		});
-		this.handleResponse<void>(response);
-	}
-
-	async delete(storeName: string, keys: IDBValidKey[]): Promise<void> {
-		const response = await this.sendRequest({
-			type: "delete",
-			storeName,
-			keys,
-		});
-		this.handleResponse<void>(response);
-	}
-
-	async clear(storeName: string): Promise<void> {
-		const response = await this.sendRequest({
-			type: "clear",
-			storeName,
-		});
-		this.handleResponse<void>(response);
-	}
-
-	/**
-	 * Close is an alias for disconnect.
-	 * Required by IDBDatabaseLike interface.
-	 */
-	close(): void {
-		this.disconnect();
-	}
-}
-
-/**
- * Creates an IDBCreator that returns proxy clients connected to a remote server.
- * Clients are cached by database name, so multiple calls return the same client.
- *
- * @param transport The transport to use for communication
- * @param onSync Optional handler called when any sync message is received
- *
- * @example
- * const dbCreator = createProxyIDbCreator(transport, (msg) => {
- *   console.log('Sync:', msg.type, msg.storeName);
- * });
- *
- * <DrizzleIndexedDBProvider dbCreator={dbCreator} ... />
- */
-export function createProxyIDbCreator(
-	transport: IDBProxyClientTransport,
-	onSync?: SyncHandler,
-): IDBCreator {
-	// Cache clients by database name - React may call dbCreator multiple times
-	const clientCache = new Map<string, IDBProxyClient>();
-	const connectingCache = new Map<string, Promise<IDBProxyClient>>();
-
-	return async (name: string): Promise<IDBDatabaseLike> => {
-		// Return cached client if already connected
-		const cached = clientCache.get(name);
-		if (cached) {
-			return cached;
-		}
-
-		// If currently connecting, wait for that connection
-		const connecting = connectingCache.get(name);
-		if (connecting) {
-			return connecting;
-		}
-
-		// Create new client and connect
-		const connectPromise = (async () => {
-			const proxy = new IDBProxyClient(name, transport);
-
-			// Register sync handler if provided
-			if (onSync) {
-				proxy.onSync(onSync);
-			}
-
-			await proxy.connect();
-			clientCache.set(name, proxy);
-			connectingCache.delete(name);
-			return proxy;
-		})();
-
-		connectingCache.set(name, connectPromise);
-		return connectPromise;
-	};
-}

package/src/proxy/idb-proxy-server.ts

@@ -1,313 +0,0 @@
-import type { IDBDatabaseLike, IDBCreator } from "../idb-types";
-import { defaultIDBCreator } from "../native-idb-database";
-import type { IDBProxyServerTransport } from "./idb-proxy-transport";
-import type { IDBProxyRequest, IDBProxyResponse } from "./idb-proxy-types";
-
-/**
- * Options for creating an IDB proxy server
- */
-export interface IDBProxyServerOptions {
-	/**
-	 * Transport to receive requests from clients
-	 */
-	transport: IDBProxyServerTransport;
-
-	/**
-	 * Optional custom IDB creator (uses native IndexedDB by default)
-	 */
-	dbCreator?: IDBCreator;
-
-	/**
-	 * Called when a database needs to be initialized (first client connects).
-	 * Use this to run migrations before the database is used.
-	 */
-	onDatabaseInit?: (dbName: string, db: IDBDatabaseLike) => Promise<void>;
-
-	/**
-	 * Enable debug logging
-	 */
-	debug?: boolean;
-}
-
-/**
- * IDB Proxy Server - Handles requests from proxy clients and performs
- * actual IndexedDB operations.
- *
- * The server manages database lifecycle:
- * - Databases are opened on first client connection
- * - Databases stay open for all clients to share
- * - Databases are only closed when the server stops
- *
- * When data is mutated, the server broadcasts sync messages to all other
- * clients so they can update their local state.
- *
- * @example
- * const server = new IDBProxyServer({
- *   transport: createChromeExtensionServerTransport(),
- *   onDatabaseInit: async (dbName) => {
- *     await migrateIndexedDBWithFunctions(dbName, migrations);
- *   }
- * });
- * server.start();
- */
-export class IDBProxyServer {
-	private databases: Map<string, IDBDatabaseLike> = new Map();
-	private pendingDatabases: Map<string, Promise<void>> = new Map();
-	private dbCreator: IDBCreator;
-	private debug: boolean;
-
-	constructor(private options: IDBProxyServerOptions) {
-		this.dbCreator = options.dbCreator ?? defaultIDBCreator;
-		this.debug = options.debug ?? false;
-	}
-
-	/**
-	 * Start listening for requests from clients
-	 */
-	start(): void {
-		this.options.transport.onRequest(async (request) => {
-			return this.handleRequest(request);
-		});
-
-		if (this.debug) {
-			console.log("[IDBProxyServer] Started");
-		}
-	}
-
-	/**
-	 * Stop the server and close all databases
-	 */
-	stop(): void {
-		for (const [name, db] of this.databases.entries()) {
-			db.close();
-			if (this.debug) {
-				console.log(`[IDBProxyServer] Closed database "${name}"`);
-			}
-		}
-		this.databases.clear();
-		this.options.transport.dispose?.();
-
-		if (this.debug) {
-			console.log("[IDBProxyServer] Stopped");
-		}
-	}
-
-	/**
-	 * Handle an incoming request from a client
-	 */
-	private async handleRequest(
-		request: IDBProxyRequest,
-	): Promise<IDBProxyResponse> {
-		if (this.debug) {
-			console.log(
-				"[IDBProxyServer] Request:",
-				request.type,
-				request.dbName,
-				"from",
-				request.clientId,
-			);
-		}
-
-		try {
-			const result = await this.processRequest(request);
-			return { id: request.id, type: "success", data: result };
-		} catch (error) {
-			let errorMessage: string;
-			if (error instanceof Error) {
-				errorMessage = error.message || error.name || "Unknown error";
-				console.error("[IDBProxyServer] Error:", error.stack || error);
-			} else {
-				errorMessage = String(error) || "Unknown error";
-				console.error("[IDBProxyServer] Error:", error);
-			}
-			return { id: request.id, type: "error", error: errorMessage };
-		}
-	}
-
-	/**
-	 * Process a request and return the result
-	 */
-	private async processRequest(request: IDBProxyRequest): Promise<unknown> {
-		switch (request.type) {
-			case "connect":
-				await this.ensureDatabase(request.dbName);
-				return { connected: true };
-
-			case "disconnect":
-				return { disconnected: true };
-
-			case "getVersion":
-				return (await this.getDatabase(request.dbName)).version;
-
-			case "hasStore":
-				return (await this.getDatabase(request.dbName)).hasStore(
-					request.storeName,
-				);
-
-			case "getStoreNames":
-				return (await this.getDatabase(request.dbName)).getStoreNames();
-
-			case "getStoreIndexes":
-				return (await this.getDatabase(request.dbName)).getStoreIndexes(
-					request.storeName,
-				);
-
-			case "getAll":
-				return (await this.getDatabase(request.dbName)).getAll(
-					request.storeName,
-				);
-
-			case "getAllByIndex":
-				return (await this.getDatabase(request.dbName)).getAllByIndex(
-					request.storeName,
-					request.indexName,
-					request.keyRange,
-				);
-
-			case "get":
-				return (await this.getDatabase(request.dbName)).get(
-					request.storeName,
-					request.key,
-				);
-
-			case "add": {
-				const db = await this.getDatabase(request.dbName);
-				await db.add(request.storeName, request.items);
-				// Broadcast to other clients
-				this.options.transport.broadcast(
-					{
-						type: "sync:add",
-						dbName: request.dbName,
-						storeName: request.storeName,
-						items: request.items,
-					},
-					request.clientId,
-				);
-				return undefined;
-			}
-
-			case "put": {
-				const db = await this.getDatabase(request.dbName);
-				await db.put(request.storeName, request.items);
-				// Broadcast to other clients
-				this.options.transport.broadcast(
-					{
-						type: "sync:put",
-						dbName: request.dbName,
-						storeName: request.storeName,
-						items: request.items,
-					},
-					request.clientId,
-				);
-				return undefined;
-			}
-
-			case "delete": {
-				const db = await this.getDatabase(request.dbName);
-				await db.delete(request.storeName, request.keys);
-				// Broadcast to other clients
-				this.options.transport.broadcast(
-					{
-						type: "sync:delete",
-						dbName: request.dbName,
-						storeName: request.storeName,
-						keys: request.keys,
-					},
-					request.clientId,
-				);
-				return undefined;
-			}
-
-			case "clear": {
-				const db = await this.getDatabase(request.dbName);
-				await db.clear(request.storeName);
-				// Broadcast to other clients
-				this.options.transport.broadcast(
-					{
-						type: "sync:truncate",
-						dbName: request.dbName,
-						storeName: request.storeName,
-					},
-					request.clientId,
-				);
-				return undefined;
-			}
-
-			default:
-				throw new Error(
-					`Unknown request type: ${(request as { type: string }).type}`,
-				);
-		}
-	}
-
-	/**
-	 * Get a database, opening it if needed
-	 */
-	private async getDatabase(dbName: string): Promise<IDBDatabaseLike> {
-		await this.ensureDatabase(dbName);
-		// biome-ignore lint/style/noNonNullAssertion: ensureDatabase guarantees it exists
-		return this.databases.get(dbName)!;
-	}
-
-	/**
-	 * Ensure a database is open and initialized.
-	 * Handles concurrent connection requests by having them wait for the same promise.
-	 */
-	private async ensureDatabase(dbName: string): Promise<void> {
-		// Already open
-		if (this.databases.has(dbName)) {
-			return;
-		}
-
-		// Currently being opened - wait for it
-		const pending = this.pendingDatabases.get(dbName);
-		if (pending) {
-			await pending;
-			return;
-		}
-
-		// Start opening
-		if (this.debug) {
-			console.log(`[IDBProxyServer] Opening database "${dbName}"`);
-		}
-
-		const openPromise = (async () => {
-			const db = await this.dbCreator(dbName);
-
-			if (!db) {
-				throw new Error(
-					`dbCreator returned null/undefined for database "${dbName}"`,
-				);
-			}
-
-			this.databases.set(dbName, db);
-
-			if (this.options.onDatabaseInit) {
-				await this.options.onDatabaseInit(dbName, db);
-			}
-
-			if (this.debug) {
-				console.log(`[IDBProxyServer] Database "${dbName}" ready`);
-			}
-		})();
-
-		this.pendingDatabases.set(dbName, openPromise);
-
-		try {
-			await openPromise;
-		} finally {
-			this.pendingDatabases.delete(dbName);
-		}
-	}
-}
-
-/**
- * Convenience function to create and start a proxy server
- */
-export function createProxyServer(
-	options: IDBProxyServerOptions,
-): IDBProxyServer {
-	const server = new IDBProxyServer(options);
-	server.start();
-	return server;
-}