@kbve/droid 0.0.6 → 0.1.1

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

@@ -0,0 +1,443 @@
+// Fallback strategy for browsers without worker support
+// Runs everything on the main thread
+
+import type {
+	SupabaseClient,
+	RealtimePostgresChangesFilter,
+} from '@supabase/supabase-js';
+import { REALTIME_POSTGRES_CHANGES_LISTEN_EVENT } from '@supabase/supabase-js';
+
+import type {
+	ISupabaseStrategy,
+	SelectOptions,
+	SessionResponse,
+	WebSocketStatus,
+} from '../types';
+
+/**
+ * DirectStrategy: Everything runs in main thread
+ *
+ * Architecture:
+ * - No workers, all operations on main thread
+ * - Uses Supabase client directly
+ * - Implements same interface as worker strategies
+ *
+ * Best for: Browsers without Worker/BroadcastChannel support, or emergency fallback
+ *
+ * Note: Requires `@supabase/supabase-js` to be available at runtime.
+ * This strategy dynamically imports it to avoid bundling Supabase in the main droid build.
+ */
+export class DirectStrategy implements ISupabaseStrategy {
+	private client: SupabaseClient | null = null;
+	private ws: WebSocket | null = null;
+	private wsReconnectTimer: ReturnType<typeof setTimeout> | null = null;
+	private wsReconnectAttempts = 0;
+	private wsHeartbeatTimer: ReturnType<typeof setInterval> | null = null;
+	private wsLastPongTime = 0;
+	private subscriptions = new Map<
+		string,
+		{ unsubscribe: () => Promise<void> | void }
+	>();
+	private listeners = new Map<string, Set<(payload: unknown) => void>>();
+
+	private readonly WS_MAX_RECONNECT_ATTEMPTS = 5;
+	private readonly WS_RECONNECT_DELAY_MS = 3000;
+	private readonly WS_HEARTBEAT_INTERVAL_MS = 30000;
+	private readonly WS_HEARTBEAT_TIMEOUT_MS = 60000;
+
+	async init(
+		url: string,
+		anonKey: string,
+		options?: Record<string, unknown>,
+	): Promise<SessionResponse> {
+		console.log('[DirectStrategy] Initializing...');
+
+		// Dynamic import to avoid bundling Supabase when not using DirectStrategy
+		const { createClient } = await import('@supabase/supabase-js');
+
+		const authOptions =
+			options?.['auth'] && typeof options['auth'] === 'object'
+				? (options['auth'] as Record<string, unknown>)
+				: {};
+
+		this.client = createClient(url, anonKey, {
+			...options,
+			auth: {
+				...authOptions,
+				autoRefreshToken: true,
+				persistSession: true,
+				detectSessionInUrl: false,
+			},
+		});
+
+		this.client.auth.onAuthStateChange((_event, session) => {
+			this.emit('auth', { session });
+		});
+
+		const {
+			data: { session },
+			error,
+		} = await this.client.auth.getSession();
+
+		if (error) {
+			console.error('[DirectStrategy] Session error:', error);
+		}
+
+		console.log('[DirectStrategy] Initialized');
+
+		return {
+			session: session as SessionResponse['session'],
+			user: (session?.user as unknown as Record<string, unknown>) || null,
+		};
+	}
+
+	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) => {
+			try {
+				cb(payload);
+			} catch (err) {
+				console.error(
+					`[DirectStrategy] Listener error for ${event}:`,
+					err,
+				);
+			}
+		});
+	}
+
+	// Auth
+	async getSession(): Promise<SessionResponse> {
+		if (!this.client) throw new Error('Client not initialized');
+		const { data, error } = await this.client.auth.getSession();
+		if (error) throw error;
+		return data as unknown as SessionResponse;
+	}
+
+	async signInWithPassword(
+		email: string,
+		password: string,
+	): Promise<SessionResponse> {
+		if (!this.client) throw new Error('Client not initialized');
+		const { data, error } = await this.client.auth.signInWithPassword({
+			email,
+			password,
+		});
+		if (error) throw error;
+		return data as unknown as SessionResponse;
+	}
+
+	async signOut(): Promise<void> {
+		if (!this.client) throw new Error('Client not initialized');
+		const { error } = await this.client.auth.signOut();
+		if (error) throw error;
+	}
+
+	// Database
+	async select(table: string, opts?: SelectOptions): Promise<unknown[]> {
+		if (!this.client) throw new Error('Client not initialized');
+		let query = this.client.from(table).select(opts?.columns || '*');
+		if (opts?.match) {
+			for (const [key, value] of Object.entries(opts.match)) {
+				query = query.eq(key, value);
+			}
+		}
+		if (opts?.limit) query = query.limit(opts.limit);
+		const { data, error } = await query;
+		if (error) throw error;
+		return data;
+	}
+
+	async insert(
+		table: string,
+		data: Record<string, unknown> | Record<string, unknown>[],
+	): Promise<unknown[]> {
+		if (!this.client) throw new Error('Client not initialized');
+		const { data: result, error } = await this.client
+			.from(table)
+			.insert(data)
+			.select();
+		if (error) throw error;
+		return result;
+	}
+
+	async update(
+		table: string,
+		data: Record<string, unknown>,
+		match: Record<string, unknown>,
+	): Promise<unknown[]> {
+		if (!this.client) throw new Error('Client not initialized');
+		let query = this.client.from(table).update(data);
+		for (const [key, value] of Object.entries(match)) {
+			query = query.eq(key, value);
+		}
+		const { data: result, error } = await query.select();
+		if (error) throw error;
+		return result;
+	}
+
+	async upsert(
+		table: string,
+		data: Record<string, unknown> | Record<string, unknown>[],
+	): Promise<unknown[]> {
+		if (!this.client) throw new Error('Client not initialized');
+		const { data: result, error } = await this.client
+			.from(table)
+			.upsert(data)
+			.select();
+		if (error) throw error;
+		return result;
+	}
+
+	async delete(
+		table: string,
+		match: Record<string, unknown>,
+	): Promise<unknown[]> {
+		if (!this.client) throw new Error('Client not initialized');
+		let query = this.client.from(table).delete();
+		for (const [key, value] of Object.entries(match)) {
+			query = query.eq(key, value);
+		}
+		const { data: result, error } = await query.select();
+		if (error) throw error;
+		return result;
+	}
+
+	async rpc(fn: string, args?: Record<string, unknown>): Promise<unknown> {
+		if (!this.client) throw new Error('Client not initialized');
+		const { data, error } = await this.client.rpc(fn, args || {});
+		if (error) throw error;
+		return data;
+	}
+
+	// Realtime
+	subscribePostgres(
+		key: string,
+		params: Record<string, unknown>,
+		callback: (payload: unknown) => void,
+	): () => void {
+		if (!this.client) throw new Error('Client not initialized');
+
+		const channel = this.client
+			.channel(key)
+			.on(
+				'postgres_changes',
+				params as RealtimePostgresChangesFilter<`${REALTIME_POSTGRES_CHANGES_LISTEN_EVENT}`>,
+				(payload: unknown) => {
+					this.emit(`realtime:${key}`, payload);
+				},
+			);
+
+		channel.subscribe();
+		this.subscriptions.set(key, {
+			unsubscribe: async () => {
+				await channel.unsubscribe();
+			},
+		});
+
+		const off = this.on(`realtime:${key}`, callback);
+
+		return () => {
+			off();
+			const sub = this.subscriptions.get(key);
+			if (sub) {
+				sub.unsubscribe();
+				this.subscriptions.delete(key);
+			}
+		};
+	}
+
+	// WebSocket
+	async connectWebSocket(wsUrl?: string): Promise<WebSocketStatus> {
+		if (
+			this.ws &&
+			(this.ws.readyState === WebSocket.CONNECTING ||
+				this.ws.readyState === WebSocket.OPEN)
+		) {
+			return this.getWebSocketStatus();
+		}
+
+		if (!this.client) throw new Error('Client not initialized');
+
+		const {
+			data: { session },
+			error,
+		} = await this.client.auth.getSession();
+		if (error || !session?.access_token) {
+			throw new Error('No active session');
+		}
+
+		const url = wsUrl || this.getDefaultWebSocketUrl();
+		const authenticatedUrl = `${url}?token=${encodeURIComponent(session.access_token)}`;
+
+		console.log('[DirectStrategy] Connecting to WebSocket:', url);
+		this.ws = new WebSocket(authenticatedUrl);
+
+		this.ws.onopen = () => {
+			this.wsReconnectAttempts = 0;
+			this.wsLastPongTime = Date.now();
+			this.startHeartbeat();
+			this.emit('ws.status', { status: 'connected', url });
+		};
+
+		this.ws.onmessage = (event) => {
+			try {
+				const message = JSON.parse(event.data as string) as Record<
+					string,
+					unknown
+				>;
+				if (message['type'] === 'pong') {
+					this.wsLastPongTime = Date.now();
+					return;
+				}
+				this.emit('ws.message', message);
+			} catch (error) {
+				console.error(
+					'[DirectStrategy] Failed to parse message:',
+					error,
+				);
+			}
+		};
+
+		this.ws.onerror = () => {
+			this.emit('ws.status', {
+				status: 'error',
+				error: 'Connection error',
+			});
+		};
+
+		this.ws.onclose = (event) => {
+			this.ws = null;
+			this.stopHeartbeat();
+			this.emit('ws.status', {
+				status: 'disconnected',
+				code: event.code,
+				reason: event.reason,
+			});
+
+			if (
+				event.code !== 1000 &&
+				this.wsReconnectAttempts < this.WS_MAX_RECONNECT_ATTEMPTS
+			) {
+				this.wsReconnectAttempts++;
+				this.wsReconnectTimer = setTimeout(() => {
+					this.connectWebSocket(wsUrl).catch(() => {
+						/* reconnect best-effort */
+					});
+				}, this.WS_RECONNECT_DELAY_MS);
+			}
+		};
+
+		return this.getWebSocketStatus();
+	}
+
+	async disconnectWebSocket(): Promise<void> {
+		if (this.wsReconnectTimer) {
+			clearTimeout(this.wsReconnectTimer);
+			this.wsReconnectTimer = null;
+		}
+		this.stopHeartbeat();
+		if (this.ws) {
+			this.ws.close(1000, 'Client request');
+			this.ws = null;
+			this.wsReconnectAttempts = 0;
+			this.emit('ws.status', { status: 'disconnected' });
+		}
+	}
+
+	async sendWebSocketMessage(data: unknown): Promise<void> {
+		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+			throw new Error('WebSocket not connected');
+		}
+		const message = typeof data === 'string' ? data : JSON.stringify(data);
+		this.ws.send(message);
+	}
+
+	async getWebSocketStatus(): Promise<WebSocketStatus> {
+		if (!this.ws) return { status: 'disconnected', readyState: null };
+		const readyStateMap: Record<number, WebSocketStatus['status']> = {
+			[WebSocket.CONNECTING]: 'connecting',
+			[WebSocket.OPEN]: 'connected',
+			[WebSocket.CLOSING]: 'disconnected',
+			[WebSocket.CLOSED]: 'disconnected',
+		};
+		return {
+			status: readyStateMap[this.ws.readyState] || 'disconnected',
+			readyState: this.ws.readyState,
+		};
+	}
+
+	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);
+	}
+
+	// Helpers
+	private getDefaultWebSocketUrl(): string {
+		if (typeof window === 'undefined') return 'ws://localhost:4321/ws';
+		const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+		const isLocalhost =
+			window.location.hostname === 'localhost' ||
+			window.location.hostname === '127.0.0.1';
+		const port = isLocalhost ? '4321' : window.location.port;
+		const host = window.location.hostname;
+		return `${protocol}//${host}${port ? ':' + port : ''}/ws`;
+	}
+
+	private startHeartbeat() {
+		this.stopHeartbeat();
+		this.wsHeartbeatTimer = setInterval(() => {
+			if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+				this.stopHeartbeat();
+				return;
+			}
+			if (
+				this.wsLastPongTime > 0 &&
+				Date.now() - this.wsLastPongTime > this.WS_HEARTBEAT_TIMEOUT_MS
+			) {
+				console.warn('[DirectStrategy] Heartbeat timeout');
+				this.stopHeartbeat();
+				this.ws.close(1001, 'Heartbeat timeout');
+				return;
+			}
+			try {
+				this.ws.send(JSON.stringify({ type: 'ping' }));
+			} catch (error) {
+				console.error(
+					'[DirectStrategy] Failed to send heartbeat:',
+					error,
+				);
+			}
+		}, this.WS_HEARTBEAT_INTERVAL_MS);
+	}
+
+	private stopHeartbeat() {
+		if (this.wsHeartbeatTimer) {
+			clearInterval(this.wsHeartbeatTimer);
+			this.wsHeartbeatTimer = null;
+		}
+	}
+
+	terminate() {
+		this.disconnectWebSocket();
+		this.subscriptions.forEach((sub) => sub.unsubscribe());
+		this.subscriptions.clear();
+		this.listeners.clear();
+	}
+}

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();
+	}
+}