@kbve/droid 0.0.6 → 0.1.2

package/src/lib/gateway/strategies/SharedWorkerStrategy.ts

@@ -0,0 +1,278 @@
+// Strategy for desktop browsers with SharedWorker support
+
+import type {
+	ISupabaseStrategy,
+	SelectOptions,
+	SessionResponse,
+	WebSocketStatus,
+} from '../types';
+import { WorkerPool } from '../WorkerPool';
+import { getWorkerCommunication } from '../WorkerCommunication';
+
+/** Union of all possible messages arriving on the SharedWorker port. */
+interface SharedWorkerEvent {
+	id?: string;
+	type?: string;
+	ok?: boolean;
+	data?: unknown;
+	error?: string;
+	key?: string;
+	payload?: unknown;
+}
+
+/**
+ * SharedWorkerStrategy: Uses SharedWorker for WebSocket + DB Worker Pool
+ *
+ * Architecture:
+ * - SharedWorker handles WebSocket, auth, and realtime (cross-tab sharing)
+ * - Worker pool (3 workers) handles database operations (parallel execution)
+ * - BroadcastChannel connects SharedWorker to worker pool
+ *
+ * Best for: Desktop Chrome, Firefox, Edge
+ */
+export class SharedWorkerStrategy implements ISupabaseStrategy {
+	private worker?: SharedWorker;
+	private port?: MessagePort;
+	private workerPool?: WorkerPool;
+	private pending = new Map<
+		string,
+		{
+			resolve: (value: unknown) => void;
+			reject: (reason?: unknown) => void;
+		}
+	>();
+	private listeners = new Map<string, Set<(p: unknown) => void>>();
+	private comm = getWorkerCommunication();
+	private sharedWorkerUrl: string | URL;
+	private dbWorkerUrl: string | URL;
+	private poolSize: number;
+
+	constructor(
+		sharedWorkerUrl: string | URL,
+		dbWorkerUrl: string | URL,
+		poolSize = 3,
+	) {
+		this.sharedWorkerUrl = sharedWorkerUrl;
+		this.dbWorkerUrl = dbWorkerUrl;
+		this.poolSize = poolSize;
+
+		if (typeof window === 'undefined') return;
+		if (!('SharedWorker' in window)) {
+			throw new Error('SharedWorker not supported');
+		}
+	}
+
+	async init(
+		url: string,
+		anonKey: string,
+		options?: Record<string, unknown>,
+	): Promise<SessionResponse> {
+		console.log('[SharedWorkerStrategy] Initializing...');
+
+		this.worker = new SharedWorker(this.sharedWorkerUrl, {
+			type: 'module',
+			name: 'supabase-shared',
+		});
+		this.port = this.worker.port;
+		this.port.onmessage = (e: MessageEvent<SharedWorkerEvent>) =>
+			this.onMessage(e.data);
+		this.port.start();
+
+		this.workerPool = new WorkerPool({
+			size: this.poolSize,
+			workerUrl: this.dbWorkerUrl,
+		});
+		await this.workerPool.init();
+
+		const sharedWorkerInit = this.send<SessionResponse>('init', {
+			url,
+			anonKey,
+			options,
+		});
+
+		const poolInitPromises = Array.from({ length: this.poolSize }, () =>
+			this.workerPool?.send('init', { url, anonKey, options }),
+		);
+
+		await Promise.all([sharedWorkerInit, ...poolInitPromises]);
+
+		console.log(
+			`[SharedWorkerStrategy] Initialized (SharedWorker + ${this.poolSize} DB workers)`,
+		);
+
+		return sharedWorkerInit;
+	}
+
+	private onMessage(msg: SharedWorkerEvent) {
+		if (msg?.type === 'ready' || msg?.type === 'auth') {
+			this.emit(msg.type, msg);
+			return;
+		}
+		if (msg?.type === 'realtime' && msg.key) {
+			this.emit(`realtime:${msg.key}`, msg.payload);
+			return;
+		}
+		if (msg?.type === 'ws.message') {
+			this.emit('ws.message', msg.data);
+			return;
+		}
+		if (msg?.type === 'ws.status') {
+			this.emit('ws.status', msg);
+			return;
+		}
+
+		const { id, ok, data, error } = msg ?? {};
+		if (id && this.pending.has(id)) {
+			const pending = this.pending.get(id);
+			if (!pending) return;
+			const { resolve, reject } = pending;
+			this.pending.delete(id);
+			ok ? resolve(data) : reject(new Error(error));
+		}
+	}
+
+	private send<T>(type: string, payload?: unknown): Promise<T> {
+		const id = crypto.randomUUID();
+		return new Promise<T>((resolve, reject) => {
+			if (!this.port)
+				return reject(new Error('SharedWorker unavailable'));
+			this.pending.set(id, {
+				resolve: resolve as (value: unknown) => void,
+				reject,
+			});
+			this.port.postMessage({ id, type, payload });
+		});
+	}
+
+	on(event: string, callback: (payload: unknown) => void): () => void {
+		if (!this.listeners.has(event)) {
+			this.listeners.set(event, new Set());
+		}
+		this.listeners.get(event)?.add(callback);
+
+		return () => {
+			const set = this.listeners.get(event);
+			if (set) {
+				set.delete(callback);
+				if (set.size === 0) this.listeners.delete(event);
+			}
+		};
+	}
+
+	private emit(event: string, payload: unknown) {
+		this.listeners.get(event)?.forEach((cb) => cb(payload));
+	}
+
+	// Auth (via SharedWorker)
+	getSession(): Promise<SessionResponse> {
+		return this.send<SessionResponse>('getSession');
+	}
+
+	signInWithPassword(
+		email: string,
+		password: string,
+	): Promise<SessionResponse> {
+		return this.send<SessionResponse>('signInWithPassword', {
+			email,
+			password,
+		});
+	}
+
+	signOut(): Promise<void> {
+		return this.send('signOut');
+	}
+
+	// Database (via worker pool)
+	select(table: string, opts?: SelectOptions): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.select', { table, ...(opts ?? {}) });
+	}
+
+	insert(
+		table: string,
+		data: Record<string, unknown> | Record<string, unknown>[],
+	): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.insert', { table, data });
+	}
+
+	update(
+		table: string,
+		data: Record<string, unknown>,
+		match: Record<string, unknown>,
+	): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.update', { table, data, match });
+	}
+
+	upsert(
+		table: string,
+		data: Record<string, unknown> | Record<string, unknown>[],
+	): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.upsert', { table, data });
+	}
+
+	delete(table: string, match: Record<string, unknown>): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.delete', { table, match });
+	}
+
+	rpc(fn: string, args?: Record<string, unknown>): Promise<unknown> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('rpc', { fn, args });
+	}
+
+	// Realtime (via SharedWorker)
+	subscribePostgres(
+		key: string,
+		params: Record<string, unknown>,
+		callback: (payload: unknown) => void,
+	): () => void {
+		const off = this.on(`realtime:${key}`, callback);
+		this.send('realtime.subscribe', { key, params }).catch((e) => {
+			off();
+			console.error(e);
+		});
+		return () => {
+			off();
+			this.send('realtime.unsubscribe', { key }).catch(() => {
+				/* best-effort */
+			});
+		};
+	}
+
+	// WebSocket (via SharedWorker)
+	connectWebSocket(wsUrl?: string): Promise<WebSocketStatus> {
+		return this.send<WebSocketStatus>('ws.connect', { wsUrl });
+	}
+
+	disconnectWebSocket(): Promise<void> {
+		return this.send('ws.disconnect');
+	}
+
+	sendWebSocketMessage(data: unknown): Promise<void> {
+		return this.send('ws.send', { data });
+	}
+
+	getWebSocketStatus(): Promise<WebSocketStatus> {
+		return this.send<WebSocketStatus>('ws.status');
+	}
+
+	onWebSocketMessage(callback: (message: unknown) => void): () => void {
+		return this.on('ws.message', callback);
+	}
+
+	onWebSocketStatus(callback: (status: WebSocketStatus) => void): () => void {
+		return this.on('ws.status', (payload) =>
+			callback(payload as WebSocketStatus),
+		);
+	}
+
+	terminate() {
+		this.workerPool?.terminate();
+		this.comm.close();
+		this.listeners.clear();
+		this.pending.clear();
+	}
+}

package/src/lib/gateway/strategies/WebWorkerStrategy.ts

@@ -0,0 +1,278 @@
+// Strategy for browsers without SharedWorker (Android, Safari)
+
+import type {
+	BroadcastEvent,
+	ISupabaseStrategy,
+	SelectOptions,
+	SessionResponse,
+	WebSocketStatus,
+} from '../types';
+import { WorkerPool } from '../WorkerPool';
+import { getWorkerCommunication } from '../WorkerCommunication';
+
+/**
+ * WebWorkerStrategy: Uses dedicated WebSocket worker + DB Worker Pool
+ *
+ * Architecture:
+ * - Dedicated WebSocket worker handles WebSocket, auth, and realtime (no cross-tab)
+ * - Worker pool (3 workers) handles database operations (parallel execution)
+ * - BroadcastChannel connects WebSocket worker to worker pool
+ *
+ * Best for: Android, Safari, browsers without SharedWorker
+ */
+export class WebWorkerStrategy implements ISupabaseStrategy {
+	private wsWorker?: Worker;
+	private workerPool?: WorkerPool;
+	private pending = new Map<
+		string,
+		{
+			resolve: (value: unknown) => void;
+			reject: (reason?: unknown) => void;
+		}
+	>();
+	private listeners = new Map<string, Set<(p: unknown) => void>>();
+	private comm = getWorkerCommunication();
+	private wsWorkerUrl: string | URL;
+	private dbWorkerUrl: string | URL;
+	private poolSize: number;
+
+	constructor(
+		wsWorkerUrl: string | URL,
+		dbWorkerUrl: string | URL,
+		poolSize = 3,
+	) {
+		this.wsWorkerUrl = wsWorkerUrl;
+		this.dbWorkerUrl = dbWorkerUrl;
+		this.poolSize = poolSize;
+
+		if (typeof window === 'undefined') return;
+		if (!('Worker' in window)) {
+			throw new Error('Worker not supported');
+		}
+	}
+
+	async init(
+		url: string,
+		anonKey: string,
+		options?: Record<string, unknown>,
+	): Promise<SessionResponse> {
+		console.log('[WebWorkerStrategy] Initializing...');
+
+		this.wsWorker = new Worker(this.wsWorkerUrl, {
+			type: 'module',
+			name: 'websocket-worker',
+		});
+		this.wsWorker.onmessage = (e) => this.onMessage(e.data);
+		this.wsWorker.onerror = (err) =>
+			console.error('[WebWorkerStrategy] WebSocket worker error:', err);
+
+		this.workerPool = new WorkerPool({
+			size: this.poolSize,
+			workerUrl: this.dbWorkerUrl,
+		});
+		await this.workerPool.init();
+
+		const wsWorkerInit = this.send<SessionResponse>('init', {
+			url,
+			anonKey,
+			options,
+		});
+
+		const poolInitPromises = Array.from({ length: this.poolSize }, () =>
+			this.workerPool?.send('init', { url, anonKey, options }),
+		);
+
+		await Promise.all([wsWorkerInit, ...poolInitPromises]);
+
+		console.log(
+			`[WebWorkerStrategy] Initialized (WebSocket worker + ${this.poolSize} DB workers)`,
+		);
+
+		return wsWorkerInit;
+	}
+
+	private onMessage(msg: unknown) {
+		const message = msg as
+			| (BroadcastEvent & {
+					id?: string;
+					ok?: boolean;
+					data?: unknown;
+					error?: string;
+					key?: string;
+			  })
+			| null
+			| undefined;
+		if (message?.type === 'ready' || message?.type === 'auth') {
+			this.emit(message.type, message);
+			return;
+		}
+		if (message?.type === 'realtime' && message.key) {
+			this.emit(`realtime:${message.key}`, message.payload);
+			return;
+		}
+		if (message?.type === 'ws.message') {
+			this.emit('ws.message', message.data);
+			return;
+		}
+		if (message?.type === 'ws.status') {
+			this.emit('ws.status', message);
+			return;
+		}
+
+		const id = message?.id;
+		const ok = message?.ok;
+		const data = message?.data;
+		const error = message?.error;
+		if (id && this.pending.has(id)) {
+			const pending = this.pending.get(id);
+			if (!pending) return;
+			const { resolve, reject } = pending;
+			this.pending.delete(id);
+			ok ? resolve(data) : reject(new Error(error));
+		}
+	}
+
+	private send<T>(type: string, payload?: unknown): Promise<T> {
+		const id = crypto.randomUUID();
+		return new Promise<T>((resolve, reject) => {
+			if (!this.wsWorker)
+				return reject(new Error('WebSocket worker unavailable'));
+			this.pending.set(id, {
+				resolve: resolve as (value: unknown) => void,
+				reject,
+			});
+			this.wsWorker.postMessage({ id, type, payload });
+		});
+	}
+
+	on(event: string, callback: (payload: unknown) => void): () => void {
+		if (!this.listeners.has(event)) {
+			this.listeners.set(event, new Set());
+		}
+		this.listeners.get(event)?.add(callback);
+
+		return () => {
+			const set = this.listeners.get(event);
+			if (set) {
+				set.delete(callback);
+				if (set.size === 0) this.listeners.delete(event);
+			}
+		};
+	}
+
+	private emit(event: string, payload: unknown) {
+		this.listeners.get(event)?.forEach((cb) => cb(payload));
+	}
+
+	// Auth (via WebSocket worker)
+	getSession(): Promise<SessionResponse> {
+		return this.send<SessionResponse>('getSession');
+	}
+
+	signInWithPassword(
+		email: string,
+		password: string,
+	): Promise<SessionResponse> {
+		return this.send<SessionResponse>('signInWithPassword', {
+			email,
+			password,
+		});
+	}
+
+	signOut(): Promise<void> {
+		return this.send('signOut');
+	}
+
+	// Database (via worker pool)
+	select(table: string, opts?: SelectOptions): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.select', { table, ...(opts ?? {}) });
+	}
+
+	insert(
+		table: string,
+		data: Record<string, unknown> | Record<string, unknown>[],
+	): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.insert', { table, data });
+	}
+
+	update(
+		table: string,
+		data: Record<string, unknown>,
+		match: Record<string, unknown>,
+	): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.update', { table, data, match });
+	}
+
+	upsert(
+		table: string,
+		data: Record<string, unknown> | Record<string, unknown>[],
+	): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.upsert', { table, data });
+	}
+
+	delete(table: string, match: Record<string, unknown>): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.delete', { table, match });
+	}
+
+	rpc(fn: string, args?: Record<string, unknown>): Promise<unknown> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('rpc', { fn, args });
+	}
+
+	// Realtime (via WebSocket worker)
+	subscribePostgres(
+		key: string,
+		params: Record<string, unknown>,
+		callback: (payload: unknown) => void,
+	): () => void {
+		const off = this.on(`realtime:${key}`, callback);
+		this.send('realtime.subscribe', { key, params }).catch((e) => {
+			off();
+			console.error(e);
+		});
+		return () => {
+			off();
+			this.send('realtime.unsubscribe', { key }).catch(() => {
+				/* best-effort */
+			});
+		};
+	}
+
+	// WebSocket (via dedicated worker)
+	connectWebSocket(wsUrl?: string): Promise<WebSocketStatus> {
+		return this.send<WebSocketStatus>('ws.connect', { wsUrl });
+	}
+
+	disconnectWebSocket(): Promise<void> {
+		return this.send('ws.disconnect');
+	}
+
+	sendWebSocketMessage(data: unknown): Promise<void> {
+		return this.send('ws.send', { data });
+	}
+
+	getWebSocketStatus(): Promise<WebSocketStatus> {
+		return this.send<WebSocketStatus>('ws.status');
+	}
+
+	onWebSocketMessage(callback: (message: unknown) => void): () => void {
+		return this.on('ws.message', callback);
+	}
+
+	onWebSocketStatus(callback: (status: WebSocketStatus) => void): () => void {
+		return this.on('ws.status', callback as (payload: unknown) => void);
+	}
+
+	terminate() {
+		this.wsWorker?.terminate();
+		this.workerPool?.terminate();
+		this.comm.close();
+		this.listeners.clear();
+		this.pending.clear();
+	}
+}

package/src/lib/gateway/types.ts

@@ -0,0 +1,139 @@
+// Shared types for all gateway strategies
+
+export interface SupabaseConfig {
+	url: string;
+	anonKey: string;
+	options?: Record<string, unknown>;
+}
+
+export interface Session {
+	access_token: string;
+	refresh_token: string;
+	user: Record<string, unknown>;
+	expires_at?: number;
+}
+
+export interface SessionResponse {
+	session: Session | null;
+	user?: Record<string, unknown>;
+}
+
+export interface WebSocketStatus {
+	status: 'connected' | 'disconnected' | 'connecting' | 'error';
+	readyState: number | null;
+	error?: string;
+}
+
+// Unified API that all strategies must implement
+export interface ISupabaseStrategy {
+	// Lifecycle
+	init(
+		url: string,
+		anonKey: string,
+		options?: Record<string, unknown>,
+	): Promise<SessionResponse>;
+
+	// Event handling
+	on(event: string, callback: (payload: unknown) => void): () => void;
+
+	// Auth
+	getSession(): Promise<SessionResponse>;
+	signInWithPassword(
+		email: string,
+		password: string,
+	): Promise<SessionResponse>;
+	signOut(): Promise<void>;
+
+	// Database
+	select(table: string, opts?: SelectOptions): Promise<unknown[]>;
+	insert(
+		table: string,
+		data: Record<string, unknown> | Record<string, unknown>[],
+	): Promise<unknown[]>;
+	update(
+		table: string,
+		data: Record<string, unknown>,
+		match: Record<string, unknown>,
+	): Promise<unknown[]>;
+	upsert(
+		table: string,
+		data: Record<string, unknown> | Record<string, unknown>[],
+	): Promise<unknown[]>;
+	delete(table: string, match: Record<string, unknown>): Promise<unknown[]>;
+	rpc(fn: string, args?: Record<string, unknown>): Promise<unknown>;
+
+	// Realtime
+	subscribePostgres(
+		key: string,
+		params: Record<string, unknown>,
+		callback: (payload: unknown) => void,
+	): () => void;
+
+	// WebSocket
+	connectWebSocket(wsUrl?: string): Promise<WebSocketStatus>;
+	disconnectWebSocket(): Promise<void>;
+	sendWebSocketMessage(data: unknown): Promise<void>;
+	getWebSocketStatus(): Promise<WebSocketStatus>;
+	onWebSocketMessage(callback: (message: unknown) => void): () => void;
+	onWebSocketStatus(callback: (status: WebSocketStatus) => void): () => void;
+
+	// Cleanup
+	terminate(): void;
+}
+
+export interface SelectOptions {
+	columns?: string;
+	match?: Record<string, unknown>;
+	limit?: number;
+}
+
+// Worker communication messages
+export interface WorkerMessage {
+	id: string;
+	type: string;
+	payload?: unknown;
+}
+
+export interface WorkerResponse {
+	id: string;
+	ok: boolean;
+	data?: unknown;
+	error?: string;
+}
+
+// BroadcastChannel event types
+export interface BroadcastEvent {
+	type:
+		| 'auth'
+		| 'ws.message'
+		| 'ws.status'
+		| 'realtime'
+		| 'ready'
+		| 'worker-error';
+	data?: unknown;
+	key?: string;
+	payload?: unknown;
+}
+
+// Strategy types
+export type StrategyType = 'shared-worker' | 'web-worker' | 'direct';
+
+// Browser capabilities
+export interface BrowserCapabilities {
+	hasSharedWorker: boolean;
+	hasWorker: boolean;
+	hasBroadcastChannel: boolean;
+	isAndroid: boolean;
+	isSafari: boolean;
+}
+
+// Gateway configuration
+export interface GatewayConfig {
+	workerUrls?: {
+		sharedWorker?: string | URL;
+		dbWorker?: string | URL;
+		webSocketWorker?: string | URL;
+	};
+	forceStrategy?: StrategyType;
+	poolSize?: number;
+}