P2-01: add SQLite WASM OPFS project worker

src/facade/persistenceWorker.ts

@@ -0,0 +1,107 @@
+import sqlite3InitModule, { type Database, type Sqlite3Static } from '@sqlite.org/sqlite-wasm'
+import { PROJECT_SCHEMA_MIGRATIONS, PROJECT_SCHEMA_VERSION } from './projectSchema'
+import type { DocumentSnapshot, ModelTreeItem, PersistenceCapabilities } from './types'
+
+type PersistenceRequest =
+  | { id: number; type: 'initialize' }
+  | { id: number; type: 'save-document'; document: DocumentSnapshot }
+  | { id: number; type: 'load-document'; documentId: string }
+  | { id: number; type: 'dispose' }
+
+type PersistenceResponse =
+  | { id: number; ok: true; type: 'initialized'; capabilities: PersistenceCapabilities }
+  | { id: number; ok: true; type: 'saved'; documentId: string; documentVersion: number; persistedAt: number; mode: PersistenceCapabilities['mode'] }
+  | { id: number; ok: true; type: 'loaded'; document: DocumentSnapshot | null }
+  | { id: number; ok: true; type: 'disposed' }
+  | { id: number; ok: false; error: string }
+
+type WorkerScope = {
+  postMessage(message: PersistenceResponse): void
+  onmessage: ((event: MessageEvent<PersistenceRequest>) => void) | null
+}
+
+const workerScope = globalThis as unknown as WorkerScope
+let sqlite3: Sqlite3Static | undefined
+let database: Database | undefined
+let capabilities: PersistenceCapabilities = { mode: 'unavailable', sqliteWasm: false, opfs: false, schemaVersion: PROJECT_SCHEMA_VERSION, reason: 'SQLite WASM has not been initialized.' }
+
+const cloneTree = (tree: ModelTreeItem[]) => tree.map((item) => ({ ...item, children: item.children ? [...item.children] : undefined }))
+
+const initialize = async (): Promise<PersistenceCapabilities> => {
+  if (database) return capabilities
+  sqlite3 = await sqlite3InitModule()
+  const opfsAvailable = Boolean(sqlite3.oo1.OpfsDb)
+  try {
+    database = opfsAvailable ? new sqlite3.oo1.OpfsDb('/bitbybit-project.sqlite3') : new sqlite3.oo1.DB(':memory:', 'c')
+    capabilities = { mode: opfsAvailable ? 'sqlite-opfs' : 'sqlite-memory', sqliteWasm: true, opfs: opfsAvailable, schemaVersion: PROJECT_SCHEMA_VERSION, reason: opfsAvailable ? undefined : 'OPFS VFS is unavailable; persistence is transient until export.' }
+  } catch (error) {
+    database = new sqlite3.oo1.DB(':memory:', 'c')
+    capabilities = { mode: 'sqlite-memory', sqliteWasm: true, opfs: false, schemaVersion: PROJECT_SCHEMA_VERSION, reason: error instanceof Error ? `OPFS initialization failed: ${error.message}` : 'OPFS initialization failed.' }
+  }
+  database.exec('PRAGMA foreign_keys = ON; CREATE TABLE IF NOT EXISTS schema_migrations (version INTEGER PRIMARY KEY, applied_at INTEGER NOT NULL);')
+  database.exec('BEGIN;')
+  try {
+    for (const migration of PROJECT_SCHEMA_MIGRATIONS) {
+      const applied = database.exec({ sql: 'SELECT version FROM schema_migrations WHERE version = ?', bind: [migration.version], returnValue: 'resultRows' }) as unknown[]
+      if (applied.length === 0) {
+        database.exec(migration.sql)
+        database.exec({ sql: 'INSERT INTO schema_migrations(version, applied_at) VALUES(?, ?)', bind: [migration.version, Date.now()] })
+      }
+    }
+    database.exec('COMMIT;')
+  } catch (error) {
+    database.exec('ROLLBACK;')
+    throw error
+  }
+  return capabilities
+}
+
+const saveDocument = (document: DocumentSnapshot) => {
+  if (!database) throw new Error('Persistence database is not initialized.')
+  const now = Date.now()
+  database.exec('BEGIN;')
+  try {
+    database.exec({ sql: 'INSERT INTO projects(id, name, schema_version, created_at, updated_at) VALUES(?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET name=excluded.name, schema_version=excluded.schema_version, updated_at=excluded.updated_at', bind: [document.id, document.label, PROJECT_SCHEMA_VERSION, now, now] })
+    database.exec({ sql: 'INSERT INTO documents(id, project_id, label, version, dirty, read_only, units) VALUES(?, ?, ?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET label=excluded.label, version=excluded.version, dirty=excluded.dirty, read_only=excluded.read_only, units=excluded.units', bind: [document.id, document.id, document.label, document.version, document.dirty ? 1 : 0, document.readOnly ? 1 : 0, document.units] })
+    database.exec({ sql: 'DELETE FROM objects WHERE document_id = ?', bind: [document.id] })
+    const parentByChild = new Map<string, string>()
+    for (const item of document.tree) for (const childId of item.children || []) parentByChild.set(childId, item.id)
+    document.tree.forEach((item, ordinal) => database?.exec({ sql: 'INSERT INTO objects(id, document_id, parent_id, label, object_type, state, detail, children_json, ordinal) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)', bind: [item.id, document.id, parentByChild.get(item.id) || null, item.label, item.type, item.state || null, item.detail || null, JSON.stringify(item.children || []), ordinal] }))
+    database.exec('COMMIT;')
+  } catch (error) {
+    database.exec('ROLLBACK;')
+    throw error
+  }
+  return { documentId: document.id, documentVersion: document.version, persistedAt: now, mode: capabilities.mode }
+}
+
+const loadDocument = (documentId: string): DocumentSnapshot | null => {
+  if (!database) throw new Error('Persistence database is not initialized.')
+  const documents = database.exec({ sql: 'SELECT id, label, version, dirty, read_only, units FROM documents WHERE id = ?', bind: [documentId], rowMode: 'object', returnValue: 'resultRows' }) as Array<Record<string, string | number>>
+  const row = documents[0]
+  if (!row) return null
+  const objects = database.exec({ sql: 'SELECT id, label, object_type, state, detail, children_json FROM objects WHERE document_id = ? ORDER BY ordinal', bind: [documentId], rowMode: 'object', returnValue: 'resultRows' }) as Array<Record<string, string | number | null>>
+  return {
+    id: String(row.id),
+    label: String(row.label),
+    version: Number(row.version),
+    dirty: Boolean(row.dirty),
+    readOnly: Boolean(row.read_only),
+    units: String(row.units),
+    tree: objects.map((object) => ({ id: String(object.id), label: String(object.label), type: String(object.object_type) as ModelTreeItem['type'], state: object.state ? String(object.state) as ModelTreeItem['state'] : undefined, detail: object.detail ? String(object.detail) : undefined, children: object.children_json ? JSON.parse(String(object.children_json)) as string[] : undefined })),
+  }
+}
+
+const handle = async (request: PersistenceRequest): Promise<PersistenceResponse> => {
+  try {
+    if (request.type === 'initialize') return { id: request.id, ok: true, type: 'initialized', capabilities: await initialize() }
+    if (request.type === 'dispose') { database?.close(); database = undefined; return { id: request.id, ok: true, type: 'disposed' } }
+    await initialize()
+    if (request.type === 'save-document') { const result = saveDocument(request.document); return { id: request.id, ok: true, type: 'saved', ...result } }
+    return { id: request.id, ok: true, type: 'loaded', document: loadDocument(request.documentId) }
+  } catch (error) {
+    return { id: request.id, ok: false, error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+workerScope.onmessage = (event) => { void handle(event.data).then((response) => workerScope.postMessage(response)) }