@powersync/web 0.0.0-dev-20241119081147 → 0.0.0-dev-20241203152232

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

@@ -1,219 +1,44 @@
-import { BaseObserver } from '@powersync/common';
 import * as Comlink from 'comlink';
-import Logger from 'js-logger';
-import { _openDB } from '../../../shared/open-db';
-import { getWorkerDatabaseOpener, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database';
-import { resolveWebSQLFlags } from '../web-sql-flags';
-import { getNavigatorLocks } from '../../../shared/navigator';
+import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase';
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
+import { TemporaryStorageOption } from '../web-sql-flags';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory';
 /**
  * Adapter for WA-SQLite SQLite connections.
  */
-export class WASQLiteDBAdapter extends BaseObserver {
-    options;
-    initialized;
-    logger;
-    dbGetHelpers;
-    methods;
-    debugMode;
+export class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
     constructor(options) {
-        super();
-        this.options = options;
-        this.logger = Logger.get('WASQLite');
-        this.dbGetHelpers = null;
-        this.methods = null;
-        this.debugMode = options.debugMode ?? false;
-        if (this.debugMode) {
-            const originalExecute = this._execute.bind(this);
-            this._execute = async (sql, bindings) => {
-                const start = performance.now();
-                try {
-                    const r = await originalExecute(sql, bindings);
-                    performance.measure(`[SQL] ${sql}`, { start });
-                    return r;
+        super({
+            name: options.dbFilename,
+            openConnection: async () => {
+                const { workerPort, temporaryStorage } = options;
+                if (workerPort) {
+                    const remote = Comlink.wrap(workerPort);
+                    return new WorkerWrappedAsyncDatabaseConnection({
+                        remote,
+                        identifier: options.dbFilename,
+                        baseConnection: await remote({
+                            ...options,
+                            temporaryStorage: temporaryStorage ?? TemporaryStorageOption.MEMORY,
+                            flags: resolveWebPowerSyncFlags(options.flags)
+                        })
+                    });
                 }
-                catch (e) {
-                    performance.measure(`[SQL] [ERROR: ${e.message}] ${sql}`, { start });
-                    throw e;
-                }
-            };
-        }
-        this.initialized = this.init();
-        this.dbGetHelpers = this.generateDBHelpers({
-            execute: (query, params) => this.acquireLock(() => this._execute(query, params))
-        });
-    }
-    get name() {
-        return this.options.dbFilename;
-    }
-    get flags() {
-        return resolveWebSQLFlags(this.options.flags ?? {});
-    }
-    getWorker() { }
-    async init() {
-        const { enableMultiTabs, useWebWorker } = this.flags;
-        if (!enableMultiTabs) {
-            this.logger.warn('Multiple tabs are not enabled in this browser');
-        }
-        if (useWebWorker) {
-            const optionsDbWorker = this.options.worker;
-            const dbOpener = this.options.workerPort
-                ? Comlink.wrap(this.options.workerPort)
-                : typeof optionsDbWorker === 'function'
-                    ? Comlink.wrap(resolveWorkerDatabasePortFactory(() => optionsDbWorker({
-                        ...this.options,
-                        flags: this.flags
-                    })))
-                    : getWorkerDatabaseOpener(this.options.dbFilename, enableMultiTabs, optionsDbWorker);
-            this.methods = await dbOpener(this.options.dbFilename);
-            this.methods.registerOnTableChange(Comlink.proxy((event) => {
-                this.iterateListeners((cb) => cb.tablesUpdated?.(event));
-            }));
-            return;
-        }
-        this.methods = await _openDB(this.options.dbFilename, { useWebWorker: false });
-        this.methods.registerOnTableChange((event) => {
-            this.iterateListeners((cb) => cb.tablesUpdated?.(event));
-        });
-    }
-    async execute(query, params) {
-        return this.writeLock((ctx) => ctx.execute(query, params));
-    }
-    async executeBatch(query, params) {
-        return this.writeLock((ctx) => this._executeBatch(query, params));
-    }
-    /**
-     * Wraps the worker execute function, awaiting for it to be available
-     */
-    _execute = async (sql, bindings) => {
-        await this.initialized;
-        const result = await this.methods.execute(sql, bindings);
-        return {
-            ...result,
-            rows: {
-                ...result.rows,
-                item: (idx) => result.rows._array[idx]
-            }
-        };
-    };
-    /**
-     * Wraps the worker executeBatch function, awaiting for it to be available
-     */
-    _executeBatch = async (query, params) => {
-        await this.initialized;
-        const result = await this.methods.executeBatch(query, params);
-        return {
-            ...result,
-            rows: undefined
-        };
-    };
-    /**
-     * Attempts to close the connection.
-     * Shared workers might not actually close the connection if other
-     * tabs are still using it.
-     */
-    close() {
-        this.methods?.close?.();
-    }
-    async getAll(sql, parameters) {
-        await this.initialized;
-        return this.dbGetHelpers.getAll(sql, parameters);
-    }
-    async getOptional(sql, parameters) {
-        await this.initialized;
-        return this.dbGetHelpers.getOptional(sql, parameters);
-    }
-    async get(sql, parameters) {
-        await this.initialized;
-        return this.dbGetHelpers.get(sql, parameters);
-    }
-    async readLock(fn, options) {
-        await this.initialized;
-        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute })));
-    }
-    async writeLock(fn, options) {
-        await this.initialized;
-        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute })));
-    }
-    acquireLock(callback) {
-        return getNavigatorLocks().request(`db-lock-${this.options.dbFilename}`, callback);
-    }
-    async readTransaction(fn, options) {
-        return this.readLock(this.wrapTransaction(fn));
-    }
-    writeTransaction(fn, options) {
-        return this.writeLock(this.wrapTransaction(fn));
-    }
-    /**
-     * Wraps a lock context into a transaction context
-     */
-    wrapTransaction(cb) {
-        return async (tx) => {
-            await this._execute('BEGIN TRANSACTION');
-            let finalized = false;
-            const commit = async () => {
-                if (finalized) {
-                    return { rowsAffected: 0 };
-                }
-                finalized = true;
-                return this._execute('COMMIT');
-            };
-            const rollback = () => {
-                finalized = true;
-                return this._execute('ROLLBACK');
-            };
-            try {
-                const result = await cb({
-                    ...tx,
-                    commit,
-                    rollback
+                const openFactory = new WASQLiteOpenFactory({
+                    dbFilename: options.dbFilename,
+                    dbLocation: options.dbLocation,
+                    debugMode: options.debugMode,
+                    flags: options.flags,
+                    temporaryStorage,
+                    logger: options.logger,
+                    vfs: options.vfs,
+                    worker: options.worker
                 });
-                if (!finalized) {
-                    await commit();
-                }
-                return result;
-            }
-            catch (ex) {
-                this.logger.debug('Caught ex in transaction', ex);
-                try {
-                    await rollback();
-                }
-                catch (ex2) {
-                    // In rare cases, a rollback may fail.
-                    // Safe to ignore.
-                }
-                throw ex;
-            }
-        };
-    }
-    generateDBHelpers(tx) {
-        return {
-            ...tx,
-            /**
-             *  Execute a read-only query and return results
-             */
-            async getAll(sql, parameters) {
-                const res = await tx.execute(sql, parameters);
-                return res.rows?._array ?? [];
+                return openFactory.openConnection();
             },
-            /**
-             * Execute a read-only query and return the first result, or null if the ResultSet is empty.
-             */
-            async getOptional(sql, parameters) {
-                const res = await tx.execute(sql, parameters);
-                return res.rows?.item(0) ?? null;
-            },
-            /**
-             * Execute a read-only query and return the first result, error if the ResultSet is empty.
-             */
-            async get(sql, parameters) {
-                const res = await tx.execute(sql, parameters);
-                const first = res.rows?.item(0);
-                if (!first) {
-                    throw new Error('Result set is empty');
-                }
-                return first;
-            }
-        };
+            debugMode: options.debugMode,
+            logger: options.logger
+        });
     }
-    async refreshSchema() { }
 }

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

@@ -1,8 +1,20 @@
 import { DBAdapter } from '@powersync/common';
 import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
+import { AsyncDatabaseConnection } from '../AsyncDatabaseConnection';
+import { ResolvedWebSQLOpenOptions, WebSQLOpenFactoryOptions } from '../web-sql-flags';
+import { WASQLiteVFS } from './WASQLiteConnection';
+export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
+    vfs?: WASQLiteVFS;
+}
+export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOptions {
+    vfs: WASQLiteVFS;
+}
 /**
  * Opens a SQLite connection using WA-SQLite.
  */
 export declare class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
+    constructor(options: WASQLiteOpenFactoryOptions);
+    get waOptions(): WASQLiteOpenFactoryOptions;
     protected openAdapter(): DBAdapter;
+    openConnection(): Promise<AsyncDatabaseConnection>;
 }

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

@@ -1,13 +1,66 @@
-import { WASQLiteDBAdapter } from './WASQLiteDBAdapter';
+import * as Comlink from 'comlink';
+import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database';
 import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
+import { TemporaryStorageOption } from '../web-sql-flags';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
+import { WASqliteConnection, WASQLiteVFS } from './WASQLiteConnection';
 /**
  * Opens a SQLite connection using WA-SQLite.
  */
 export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
+    constructor(options) {
+        super(options);
+    }
+    get waOptions() {
+        // Cast to extended type
+        return this.options;
+    }
     openAdapter() {
-        return new WASQLiteDBAdapter({
-            ...this.options,
-            flags: this.resolvedFlags
+        return new LockedAsyncDatabaseAdapter({
+            name: this.options.dbFilename,
+            openConnection: () => this.openConnection(),
+            debugMode: this.options.debugMode,
+            logger: this.logger
         });
     }
+    async openConnection() {
+        const { enableMultiTabs, useWebWorker } = this.resolvedFlags;
+        const { vfs = WASQLiteVFS.IDBBatchAtomicVFS, temporaryStorage = TemporaryStorageOption.MEMORY } = this.waOptions;
+        if (!enableMultiTabs) {
+            this.logger.warn('Multiple tabs are not enabled in this browser');
+        }
+        if (useWebWorker) {
+            const optionsDbWorker = this.options.worker;
+            const workerPort = typeof optionsDbWorker == 'function'
+                ? resolveWorkerDatabasePortFactory(() => optionsDbWorker({
+                    ...this.options,
+                    temporaryStorage,
+                    flags: this.resolvedFlags
+                }))
+                : openWorkerDatabasePort(this.options.dbFilename, enableMultiTabs, optionsDbWorker, this.waOptions.vfs);
+            const workerDBOpener = Comlink.wrap(workerPort);
+            return new WorkerWrappedAsyncDatabaseConnection({
+                remote: workerDBOpener,
+                baseConnection: await workerDBOpener({
+                    dbFilename: this.options.dbFilename,
+                    vfs,
+                    temporaryStorage,
+                    flags: this.resolvedFlags
+                }),
+                identifier: this.options.dbFilename
+            });
+        }
+        else {
+            // Don't use a web worker
+            return new WASqliteConnection({
+                dbFilename: this.options.dbFilename,
+                dbLocation: this.options.dbLocation,
+                debugMode: this.options.debugMode,
+                vfs,
+                temporaryStorage,
+                flags: this.resolvedFlags
+            });
+        }
+    }
 }

package/lib/src/db/adapters/web-sql-flags.d.ts

@@ -1,4 +1,5 @@
 import { SQLOpenOptions } from '@powersync/common';
+import { ILogger } from 'js-logger';
 /**
  * Common settings used when creating SQL connections on web.
  */
@@ -33,6 +34,15 @@ export interface WebSQLFlags {
 export type ResolvedWebSQLFlags = Required<WebSQLFlags>;
 export interface ResolvedWebSQLOpenOptions extends SQLOpenOptions {
     flags: ResolvedWebSQLFlags;
+    /**
+     * Where to store SQLite temporary files. Defaults to 'MEMORY'.
+     * Setting this to `FILESYSTEM` can cause issues with larger queries or datasets.
+     */
+    temporaryStorage: TemporaryStorageOption;
+}
+export declare enum TemporaryStorageOption {
+    MEMORY = "memory",
+    FILESYSTEM = "file"
 }
 /**
  * Options for opening a Web SQL connection
@@ -46,6 +56,12 @@ export interface WebSQLOpenFactoryOptions extends SQLOpenOptions {
      * or a factory method that returns a worker.
      */
     worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => Worker | SharedWorker);
+    logger?: ILogger;
+    /**
+     * Where to store SQLite temporary files. Defaults to 'MEMORY'.
+     * Setting this to `FILESYSTEM` can cause issues with larger queries or datasets.
+     */
+    temporaryStorage?: TemporaryStorageOption;
 }
 export declare function isServerSide(): boolean;
 export declare const DEFAULT_WEB_SQL_FLAGS: ResolvedWebSQLFlags;

package/lib/src/db/adapters/web-sql-flags.js

@@ -1,3 +1,8 @@
+export var TemporaryStorageOption;
+(function (TemporaryStorageOption) {
+    TemporaryStorageOption["MEMORY"] = "memory";
+    TemporaryStorageOption["FILESYSTEM"] = "file";
+})(TemporaryStorageOption || (TemporaryStorageOption = {}));
 export function isServerSide() {
     return typeof window == 'undefined';
 }

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.d.ts

@@ -2,6 +2,7 @@ import { PowerSyncConnectionOptions, PowerSyncCredentials, SyncStatusOptions } f
 import * as Comlink from 'comlink';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
 import { SharedSyncImplementation } from '../../worker/sync/SharedSyncImplementation';
+import { WebDBAdapter } from '../adapters/WebDBAdapter';
 import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from './WebStreamingSyncImplementation';
 /**
  * The shared worker will trigger methods on this side of the message port
@@ -10,7 +11,9 @@ import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions }
 declare class SharedSyncClientProvider extends AbstractSharedSyncClientProvider {
     protected options: WebStreamingSyncImplementationOptions;
     statusChanged: (status: SyncStatusOptions) => void;
-    constructor(options: WebStreamingSyncImplementationOptions, statusChanged: (status: SyncStatusOptions) => void);
+    protected webDB: WebDBAdapter;
+    constructor(options: WebStreamingSyncImplementationOptions, statusChanged: (status: SyncStatusOptions) => void, webDB: WebDBAdapter);
+    getDBWorkerPort(): Promise<MessagePort>;
     fetchCredentials(): Promise<PowerSyncCredentials | null>;
     uploadCrud(): Promise<void>;
     get logger(): import("js-logger").ILogger | undefined;
@@ -23,12 +26,16 @@ declare class SharedSyncClientProvider extends AbstractSharedSyncClientProvider
     time(label: string): void;
     timeEnd(label: string): void;
 }
+export interface SharedWebStreamingSyncImplementationOptions extends WebStreamingSyncImplementationOptions {
+    db: WebDBAdapter;
+}
 export declare class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementation {
     protected syncManager: Comlink.Remote<SharedSyncImplementation>;
     protected clientProvider: SharedSyncClientProvider;
     protected messagePort: MessagePort;
     protected isInitialized: Promise<void>;
-    constructor(options: WebStreamingSyncImplementationOptions);
+    protected dbAdapter: WebDBAdapter;
+    constructor(options: SharedWebStreamingSyncImplementationOptions);
     /**
      * Starts the sync process, this effectively acts as a call to
      * `connect` if not yet connected.

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.js

@@ -1,9 +1,8 @@
 import * as Comlink from 'comlink';
-import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../worker/db/open-worker-database';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
 import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
+import { resolveWebSQLFlags, TemporaryStorageOption } from '../adapters/web-sql-flags';
 import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation';
-import { resolveWebSQLFlags } from '../adapters/web-sql-flags';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.
@@ -11,10 +10,16 @@ import { resolveWebSQLFlags } from '../adapters/web-sql-flags';
 class SharedSyncClientProvider extends AbstractSharedSyncClientProvider {
     options;
     statusChanged;
-    constructor(options, statusChanged) {
+    webDB;
+    constructor(options, statusChanged, webDB) {
         super();
         this.options = options;
         this.statusChanged = statusChanged;
+        this.webDB = webDB;
+    }
+    async getDBWorkerPort() {
+        const { port } = await this.webDB.shareConnection();
+        return Comlink.transfer(port, [port]);
     }
     async fetchCredentials() {
         const credentials = await this.options.remote.getCredentials();
@@ -73,8 +78,10 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
     clientProvider;
     messagePort;
     isInitialized;
+    dbAdapter;
     constructor(options) {
         super(options);
+        this.dbAdapter = options.db;
         /**
          * Configure or connect to the shared sync worker.
          * This worker will manage all syncing operations remotely.
@@ -82,6 +89,8 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
         const resolvedWorkerOptions = {
             ...options,
             dbFilename: this.options.identifier,
+            // TODO
+            temporaryStorage: TemporaryStorageOption.MEMORY,
             flags: resolveWebSQLFlags(options.flags)
         };
         const syncWorker = options.sync?.worker;
@@ -112,13 +121,9 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
          * sync worker.
          */
         const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
-        const dbWorker = options.database?.options?.worker;
-        const dbOpenerPort = typeof dbWorker === 'function'
-            ? resolveWorkerDatabasePortFactory(() => dbWorker(resolvedWorkerOptions))
-            : openWorkerDatabasePort(this.options.identifier, true, dbWorker);
         const flags = { ...this.webOptions.flags, workers: undefined };
-        this.isInitialized = this.syncManager.init(Comlink.transfer(dbOpenerPort, [dbOpenerPort]), {
-            dbName: this.options.identifier,
+        this.isInitialized = this.syncManager.setParams({
+            dbParams: this.dbAdapter.getConfiguration(),
             streamOptions: {
                 crudUploadThrottleMs,
                 identifier,
@@ -131,7 +136,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
          */
         this.clientProvider = new SharedSyncClientProvider(this.webOptions, (status) => {
             this.iterateListeners((l) => this.updateSyncStatus(status));
-        });
+        }, options.db);
         /**
          * The sync worker will call this client provider when it needs
          * to fetch credentials or upload data.
@@ -180,6 +185,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
      * Used in tests to force a connection states
      */
     async _testUpdateStatus(status) {
+        await this.isInitialized;
         return this.syncManager['_testUpdateAllStatuses'](status.toJSON());
     }
 }

package/lib/src/db/sync/WebStreamingSyncImplementation.d.ts

@@ -2,11 +2,6 @@ import { AbstractStreamingSyncImplementation, AbstractStreamingSyncImplementatio
 import { ResolvedWebSQLOpenOptions, WebSQLFlags } from '../adapters/web-sql-flags';
 export interface WebStreamingSyncImplementationOptions extends AbstractStreamingSyncImplementationOptions {
     flags?: WebSQLFlags;
-    database?: {
-        options: {
-            worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => Worker | SharedWorker);
-        };
-    };
     sync?: {
         worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => SharedWorker);
     };

package/lib/src/index.d.ts

@@ -1,11 +1,12 @@
 export * from '@powersync/common';
-export * from './db/PowerSyncDatabase';
-export * from './db/sync/WebRemote';
-export * from './db/sync/WebStreamingSyncImplementation';
-export * from './db/sync/SharedWebStreamingSyncImplementation';
-export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter';
-export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory';
 export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory';
-export * from './db/adapters/web-sql-flags';
 export * from './db/adapters/AbstractWebSQLOpenFactory';
+export * from './db/adapters/wa-sqlite/WASQLiteConnection';
+export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter';
 export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory';
+export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory';
+export * from './db/adapters/web-sql-flags';
+export * from './db/PowerSyncDatabase';
+export * from './db/sync/SharedWebStreamingSyncImplementation';
+export * from './db/sync/WebRemote';
+export * from './db/sync/WebStreamingSyncImplementation';

package/lib/src/index.js

@@ -1,11 +1,12 @@
 export * from '@powersync/common';
-export * from './db/PowerSyncDatabase';
-export * from './db/sync/WebRemote';
-export * from './db/sync/WebStreamingSyncImplementation';
-export * from './db/sync/SharedWebStreamingSyncImplementation';
-export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter';
-export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory';
 export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory';
-export * from './db/adapters/web-sql-flags';
 export * from './db/adapters/AbstractWebSQLOpenFactory';
+export * from './db/adapters/wa-sqlite/WASQLiteConnection';
+export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter';
 export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory';
+export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory';
+export * from './db/adapters/web-sql-flags';
+export * from './db/PowerSyncDatabase';
+export * from './db/sync/SharedWebStreamingSyncImplementation';
+export * from './db/sync/WebRemote';
+export * from './db/sync/WebStreamingSyncImplementation';

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

@@ -3,46 +3,63 @@
  */
 import '@journeyapps/wa-sqlite';
 import * as Comlink from 'comlink';
-import { _openDB } from '../../shared/open-db';
+import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
 import { getNavigatorLocks } from '../../shared/navigator';
 const DBMap = new Map();
 const OPEN_DB_LOCK = 'open-wasqlite-db';
 let nextClientId = 1;
-const openDBShared = async (dbFileName) => {
+const openWorkerConnection = async (options) => {
+    const connection = new WASqliteConnection(options);
+    return {
+        init: Comlink.proxy(() => connection.init()),
+        getConfig: Comlink.proxy(() => connection.getConfig()),
+        close: Comlink.proxy(() => connection.close()),
+        execute: Comlink.proxy(async (sql, params) => connection.execute(sql, params)),
+        executeBatch: Comlink.proxy(async (sql, params) => connection.executeBatch(sql, params)),
+        registerOnTableChange: Comlink.proxy(async (callback) => {
+            // Proxy the callback remove function
+            return Comlink.proxy(await connection.registerOnTableChange(callback));
+        })
+    };
+};
+const openDBShared = async (options) => {
     // Prevent multiple simultaneous opens from causing race conditions
     return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
         const clientId = nextClientId++;
-        if (!DBMap.has(dbFileName)) {
+        const { dbFilename } = options;
+        if (!DBMap.has(dbFilename)) {
             const clientIds = new Set();
-            const connection = await _openDB(dbFileName);
-            DBMap.set(dbFileName, {
+            const connection = await openWorkerConnection(options);
+            await connection.init();
+            DBMap.set(dbFilename, {
                 clientIds,
                 db: connection
             });
         }
-        const dbEntry = DBMap.get(dbFileName);
+        const dbEntry = DBMap.get(dbFilename);
         dbEntry.clientIds.add(clientId);
         const { db } = dbEntry;
         const wrappedConnection = {
             ...db,
+            init: Comlink.proxy(() => {
+                // the init has been done automatically
+            }),
             close: Comlink.proxy(() => {
                 const { clientIds } = dbEntry;
+                console.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
                 clientIds.delete(clientId);
                 if (clientIds.size == 0) {
-                    console.debug(`Closing connection to ${dbFileName}.`);
-                    DBMap.delete(dbFileName);
+                    console.debug(`Closing connection to ${dbFilename}.`);
+                    DBMap.delete(dbFilename);
                     return db.close?.();
                 }
-                console.debug(`Connection to ${dbFileName} not closed yet due to active clients.`);
+                console.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
+                return;
             })
         };
         return Comlink.proxy(wrappedConnection);
     });
 };
-const openDBDedicated = async (dbFileName) => {
-    const connection = await _openDB(dbFileName);
-    return Comlink.proxy(connection);
-};
 // Check if we're in a SharedWorker context
 if (typeof SharedWorkerGlobalScope !== 'undefined') {
     const _self = self;
@@ -51,13 +68,14 @@ if (typeof SharedWorkerGlobalScope !== 'undefined') {
         console.debug('Exposing shared db on port', port);
         Comlink.expose(openDBShared, port);
     };
-    addEventListener('unload', () => {
-        Array.from(DBMap.values()).forEach(async (dbConnection) => {
-            const db = await dbConnection.db;
-            db.close?.();
-        });
-    });
 }
 else {
-    Comlink.expose(openDBDedicated);
+    // A dedicated worker can be shared externally
+    Comlink.expose(openDBShared);
 }
+addEventListener('unload', () => {
+    Array.from(DBMap.values()).forEach(async (dbConnection) => {
+        const { db } = dbConnection;
+        db.close?.();
+    });
+});