@powersync/web 0.0.0-dev-20250916075127 → 0.0.0-dev-20250922105207

package/lib/src/db/adapters/wa-sqlite/WASQLiteConnection.js

@@ -59,6 +59,7 @@ export const DEFAULT_MODULE_FACTORIES = {
     },
     [WASQLiteVFS.AccessHandlePoolVFS]: async (options) => {
         let module;
+        options.logger?.debug(`Opening VFS with options`, JSON.stringify(options));
         if (options.encryptionKey) {
             module = await MultiCipherSyncWASQLiteModuleFactory();
         }
@@ -67,9 +68,26 @@ export const DEFAULT_MODULE_FACTORIES = {
         }
         // @ts-expect-error The types for this static method are missing upstream
         const { AccessHandlePoolVFS } = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');
+        const vfs = new AccessHandlePoolVFS(options.dbFileName, module);
+        // Allow extra logs
+        const proxiedVFS = new Proxy(vfs, {
+            get(target, prop, receiver) {
+                const value = Reflect.get(target, prop, receiver);
+                // Only wrap methods, not properties
+                if (typeof value === 'function') {
+                    return function (...args) {
+                        options.logger?.debug(`VFS: Called ${String(prop)} with:`, args);
+                        return value.apply(vfs, args);
+                    };
+                }
+                return value;
+            }
+        });
+        await vfs.isReady();
+        // const vfs = await AccessHandlePoolVFS.create(options.dbFileName, module);
         return {
             module,
-            vfs: await AccessHandlePoolVFS.create(options.dbFileName, module)
+            vfs: proxiedVFS
         };
     },
     [WASQLiteVFS.OPFSCoopSyncVFS]: async (options) => {
@@ -142,7 +160,9 @@ export class WASqliteConnection extends BaseObserver {
     async openSQLiteAPI() {
         const { module, vfs } = await this._moduleFactory({
             dbFileName: this.options.dbFilename,
-            encryptionKey: this.options.encryptionKey
+            encryptionKey: this.options.encryptionKey,
+            debugMode: this.options.debugMode,
+            logger: this.options.logger
         });
         const sqlite3 = SQLite.Factory(module);
         sqlite3.vfs_register(vfs, true);
@@ -180,6 +200,7 @@ export class WASqliteConnection extends BaseObserver {
         }
     }
     async init() {
+        this.options.logger?.debug('Opening WASQLite connection for', this.options.dbFilename);
         this._sqliteAPI = await this.openSQLiteAPI();
         await this.openDB();
         this.registerBroadcastListeners();
@@ -277,6 +298,7 @@ export class WASqliteConnection extends BaseObserver {
         });
     }
     async close() {
+        this.options.logger?.debug('Closing WASQLite connection', this.options.dbFilename);
         this.broadcastChannel?.close();
         await this.sqliteAPI.close(this.dbP);
     }
@@ -325,6 +347,10 @@ export class WASqliteConnection extends BaseObserver {
         return results.flatMap((resultset) => resultset.rows.map((row) => resultset.columns.map((_, index) => row[index])));
     }
     async _execute(sql, bindings) {
+        // TODO, this might be redundant
+        if (this.options.debugMode) {
+            this.options.logger?.debug(`Executing SQL: ${sql}`);
+        }
         const results = [];
         for await (const stmt of this.sqliteAPI.statements(this.dbP, sql)) {
             let columns;

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.d.ts

@@ -9,7 +9,7 @@ export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
 export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOptions {
     vfs: WASQLiteVFS;
 }
-export interface WorkerDBOpenerOptions extends ResolvedWASQLiteOpenFactoryOptions {
+export interface WorkerDBOpenerOptions extends Omit<ResolvedWASQLiteOpenFactoryOptions, 'logger'> {
     logLevel: ILogLevel;
 }
 /**

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.js

@@ -52,8 +52,12 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
                     cacheSizeKb,
                     flags: this.resolvedFlags,
                     encryptionKey: encryptionKey,
-                    logLevel: this.logger.getLevel()
-                }),
+                    logLevel: this.logger.getLevel(),
+                    debugMode: this.options.debugMode
+                }, Comlink.proxy((event) => {
+                    // TODO
+                    this.logger[event.logLevel.toLocaleLowerCase()]('[DB Worker] ', ...event.messages);
+                })),
                 identifier: this.options.dbFilename,
                 onClose: () => {
                     if (workerPort instanceof Worker) {

package/lib/src/worker/db/LogHandler.d.ts

@@ -0,0 +1,12 @@
+import { BaseListener, BaseObserver } from '@powersync/common';
+export type LogEvent = {
+    loggerName: string;
+    logLevel: string;
+    messages: string[];
+};
+export interface LogHandlerListener extends BaseListener {
+    onLog: (event: LogEvent) => void;
+}
+export declare class LogHandler extends BaseObserver<LogHandlerListener> {
+    pushLog(entry: LogEvent): void;
+}

package/lib/src/worker/db/LogHandler.js

@@ -0,0 +1,6 @@
+import { BaseObserver } from '@powersync/common';
+export class LogHandler extends BaseObserver {
+    pushLog(entry) {
+        this.iterateListeners((l) => l.onLog?.(entry));
+    }
+}

package/lib/src/worker/db/WASQLiteDB.worker.js

@@ -2,21 +2,70 @@
  * Supports both shared and dedicated workers, based on how the worker is constructed (new SharedWorker vs new Worker()).
  */
 import '@journeyapps/wa-sqlite';
-import { createBaseLogger, createLogger } from '@powersync/common';
+import { createBaseLogger, createLogger, LogLevel } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
 import { getNavigatorLocks } from '../../shared/navigator';
-const baseLogger = createBaseLogger();
-baseLogger.useDefaults();
-const logger = createLogger('db-worker');
+import { LogHandler } from './LogHandler';
 const DBMap = new Map();
 const OPEN_DB_LOCK = 'open-wasqlite-db';
+function logToAll(logLevel, ...messages) {
+    for (const dbFilename of DBMap.keys()) {
+        logBroadcaster.pushLog({
+            loggerName: dbFilename,
+            logLevel,
+            messages
+        });
+    }
+}
 let nextClientId = 1;
+function logUnhandledException(error) {
+    const errorMessage = `
+  Name: ${error.name}
+  Cause: ${error.cause}
+  Message: ${error.message}
+  Stack: ${error.stack}`.trim();
+    logToAll(LogLevel.ERROR.name, 'Uncaught Exception in DB worker', errorMessage);
+}
+// Report unhandled exceptions to all loggers
+addEventListener('unhandledrejection', (event) => {
+    logUnhandledException(event.reason);
+});
+addEventListener('error', (event) => {
+    logUnhandledException(event.error);
+});
+addEventListener('unload', () => {
+    logToAll(LogLevel.INFO.name, 'DB worker is unloading');
+    Array.from(DBMap.values()).forEach(async (dbConnection) => {
+        const { db, clientIds } = dbConnection;
+        logToAll(LogLevel.INFO.name, `closing db with ids ${clientIds}`);
+        db.close();
+    });
+});
+const baseLogger = createBaseLogger();
+const logBroadcaster = new LogHandler();
+const defaultHandler = baseLogger.createDefaultHandler();
+const logHandler = (messages, context) => {
+    logBroadcaster.pushLog({
+        loggerName: context.name ?? 'unknown',
+        logLevel: context.level.name,
+        messages: messages.map((m) => String(m))
+    });
+    defaultHandler(messages, context);
+};
+baseLogger.useDefaults({
+    formatter: logHandler
+});
+const workerLogger = createLogger('db-worker');
 const openWorkerConnection = async (options) => {
     const connection = new WASqliteConnection(options);
     return {
         init: Comlink.proxy(() => connection.init()),
-        getConfig: Comlink.proxy(() => connection.getConfig()),
+        getConfig: Comlink.proxy(async () => {
+            // Can't send the logger over
+            const { logger, ...rest } = await connection.getConfig();
+            return rest;
+        }),
         close: Comlink.proxy(() => connection.close()),
         execute: Comlink.proxy(async (sql, params) => connection.execute(sql, params)),
         executeRaw: Comlink.proxy(async (sql, params) => connection.executeRaw(sql, params)),
@@ -27,15 +76,34 @@ const openWorkerConnection = async (options) => {
         })
     };
 };
-const openDBShared = async (options) => {
+const openDBShared = async (options, logHandler) => {
     // Prevent multiple simultaneous opens from causing race conditions
     return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
         const clientId = nextClientId++;
         const { dbFilename, logLevel } = options;
-        logger.setLevel(logLevel);
+        logToAll(`Worker opening DB connection for`, JSON.stringify(options));
+        // This updates the log level for the worker-level logger
+        // The DB connection logger will automatically track the main context logger
+        // since it passes logs to it.
+        workerLogger.setLevel(logLevel);
+        let disposeLogListener = logHandler
+            ? logBroadcaster.registerListener({
+                onLog: (event) => {
+                    if (event.loggerName !== dbFilename) {
+                        return;
+                    }
+                    logHandler(event);
+                }
+            })
+            : null;
         if (!DBMap.has(dbFilename)) {
             const clientIds = new Set();
-            const connection = await openWorkerConnection(options);
+            const logger = createLogger(dbFilename);
+            logger.debug(`Worker opened a new connection`);
+            const connection = await openWorkerConnection({
+                ...options,
+                logger
+            });
             await connection.init();
             DBMap.set(dbFilename, {
                 clientIds,
@@ -52,14 +120,15 @@ const openDBShared = async (options) => {
             }),
             close: Comlink.proxy(async () => {
                 const { clientIds } = dbEntry;
-                logger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
+                disposeLogListener?.();
+                workerLogger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
                 clientIds.delete(clientId);
                 if (clientIds.size == 0) {
-                    logger.debug(`Closing connection to ${dbFilename}.`);
+                    workerLogger.debug(`Closing connection to ${dbFilename}.`);
                     DBMap.delete(dbFilename);
                     return db.close?.();
                 }
-                logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
+                workerLogger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
                 return;
             })
         };
@@ -78,9 +147,3 @@ else {
     // A dedicated worker can be shared externally
     Comlink.expose(openDBShared);
 }
-addEventListener('unload', () => {
-    Array.from(DBMap.values()).forEach(async (dbConnection) => {
-        const { db } = dbConnection;
-        db.close?.();
-    });
-});