Spaces:
Running
Running
| import sqlite3InitModule from '@sqlite.org/sqlite-wasm'; | |
| import { | |
| BrowserSQLiteOpenOptions, | |
| BrowserSQLiteRequest, | |
| BrowserSQLiteResponse, | |
| } from './browser-sqlite-protocol'; | |
| type WorkerScope = { | |
| postMessage(message: BrowserSQLiteResponse): void; | |
| addEventListener(type: 'message', listener: (event: MessageEvent<BrowserSQLiteRequest>) => void): void; | |
| }; | |
| export type BrowserSQLiteWorkerOptions = Readonly<{ | |
| scope?: WorkerScope; | |
| /** Bundler-resolved URL for @sqlite.org/sqlite-wasm/sqlite3.wasm. */ | |
| wasmUrl?: string; | |
| }>; | |
| type SQLiteDatabase = { | |
| exec(options: Record<string, unknown>): unknown; | |
| exec(sql: string): unknown; | |
| changes(total?: boolean): number; | |
| close(): void; | |
| }; | |
| type SQLiteModule = { | |
| oo1: { | |
| DB: new (filename?: string, flags?: string) => SQLiteDatabase; | |
| OpfsDb?: new (filename: string, flags?: string) => SQLiteDatabase; | |
| }; | |
| }; | |
| /** | |
| * Installs the TeaQL SQLite/WASM RPC loop in the current dedicated worker. | |
| * Call this once from an application-owned worker entry point. | |
| */ | |
| export function startBrowserSQLiteWorker(options: BrowserSQLiteWorkerOptions = {}): void { | |
| const scope = options.scope ?? globalThis as unknown as WorkerScope; | |
| let sqlitePromise: Promise<SQLiteModule> | undefined; | |
| let database: SQLiteDatabase | undefined; | |
| let openOptions: Required<BrowserSQLiteOpenOptions> | undefined; | |
| let tail: Promise<void> = Promise.resolve(); | |
| const sqlite = (): Promise<SQLiteModule> => { | |
| if (!sqlitePromise) { | |
| const initialize = sqlite3InitModule as unknown as ( | |
| config?: { locateFile(file: string): string }, | |
| ) => Promise<SQLiteModule>; | |
| sqlitePromise = initialize(options.wasmUrl | |
| ? { locateFile: (file: string) => file.endsWith('.wasm') ? options.wasmUrl! : file } | |
| : undefined); | |
| } | |
| return sqlitePromise; | |
| }; | |
| const open = async (options: BrowserSQLiteOpenOptions = {}): Promise<void> => { | |
| database?.close(); | |
| const storage = options.storage ?? 'memory'; | |
| const databaseName = options.databaseName ?? 'teaql-browser.sqlite3'; | |
| const module = await sqlite(); | |
| if (storage === 'opfs') { | |
| if (!module.oo1.OpfsDb) { | |
| const error = new Error( | |
| 'OPFS SQLite is unavailable. Serve COOP/COEP headers and use a compatible browser.', | |
| ); | |
| error.name = 'BrowserSQLiteStorageUnavailableError'; | |
| throw error; | |
| } | |
| database = new module.oo1.OpfsDb(`/${databaseName}`, 'c'); | |
| } else { | |
| database = new module.oo1.DB(':memory:', 'ct'); | |
| } | |
| openOptions = { storage, databaseName }; | |
| database.exec('PRAGMA foreign_keys = ON'); | |
| }; | |
| const requireDatabase = (): SQLiteDatabase => { | |
| if (!database) throw new Error('Browser SQLite database is not open'); | |
| return database; | |
| }; | |
| const query = (sql: string, values: unknown[] = []): unknown => { | |
| if (typeof sql !== 'string' || !sql.trim()) throw new TypeError('SQL is required'); | |
| if (!Array.isArray(values)) throw new TypeError('SQL bind values must be an array'); | |
| const db = requireDatabase(); | |
| const rows = db.exec({ | |
| sql, | |
| bind: values, | |
| rowMode: 'object', | |
| returnValue: 'resultRows', | |
| }) as unknown[]; | |
| const mutation = /^\s*(?:insert|update|delete|replace)\b/i.test(sql); | |
| return { rows, rowCount: rows.length || (mutation ? Number(db.changes()) : 0) }; | |
| }; | |
| const reset = async (): Promise<void> => { | |
| const db = requireDatabase(); | |
| db.exec('PRAGMA foreign_keys = OFF'); | |
| const rows = db.exec({ | |
| sql: "SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%'", | |
| rowMode: 'object', | |
| returnValue: 'resultRows', | |
| }) as Array<{ name: unknown }>; | |
| for (const row of rows) { | |
| const name = String(row.name).replace(/"/g, '""'); | |
| db.exec(`DROP TABLE IF EXISTS "${name}"`); | |
| } | |
| db.exec('PRAGMA foreign_keys = ON'); | |
| if (!openOptions) throw new Error('Browser SQLite database is not open'); | |
| }; | |
| scope.addEventListener('message', event => { | |
| const request = event.data; | |
| if (!request || request.type !== 'teaql-browser-sqlite-request') return; | |
| tail = tail.then(async () => { | |
| try { | |
| let result: unknown; | |
| if (request.operation === 'open') result = await open(request.payload as BrowserSQLiteOpenOptions); | |
| else if (request.operation === 'query') { | |
| result = query(String(request.payload?.sql ?? ''), (request.payload?.values ?? []) as unknown[]); | |
| } else if (request.operation === 'reset') result = await reset(); | |
| else if (request.operation === 'close') { database?.close(); database = undefined; } | |
| else throw new Error(`Unsupported Browser SQLite operation: ${String(request.operation)}`); | |
| scope.postMessage({ | |
| type: 'teaql-browser-sqlite-response', requestId: request.requestId, result, | |
| }); | |
| } catch (value) { | |
| const error = value instanceof Error ? value : new Error(String(value)); | |
| scope.postMessage({ | |
| type: 'teaql-browser-sqlite-response', requestId: request.requestId, | |
| error: { | |
| name: error.name, | |
| message: error.message, | |
| code: (error as Error & { code?: string }).code, | |
| }, | |
| }); | |
| } | |
| }); | |
| }); | |
| } | |