@powersync/web 1.12.2 → 1.13.0

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

package/lib/src/worker/db/open-worker-database.d.ts

@@ -1,13 +1,14 @@
 import * as Comlink from 'comlink';
-import type { OpenDB } from '../../shared/types';
+import { OpenAsyncDatabaseConnection } from '../..//db/adapters/AsyncDatabaseConnection';
+import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
 /**
  * Opens a shared or dedicated worker which exposes opening of database connections
  */
-export declare function openWorkerDatabasePort(workerIdentifier: string, multipleTabs?: boolean, worker?: string | URL): MessagePort | Worker;
+export declare function openWorkerDatabasePort(workerIdentifier: string, multipleTabs?: boolean, worker?: string | URL, vfs?: WASQLiteVFS): Worker | MessagePort;
 /**
  * @returns A function which allows for opening database connections inside
  * a worker.
  */
-export declare function getWorkerDatabaseOpener(workerIdentifier: string, multipleTabs?: boolean, worker?: string | URL): Comlink.Remote<OpenDB>;
-export declare function resolveWorkerDatabasePortFactory(worker: () => Worker | SharedWorker): MessagePort | Worker;
+export declare function getWorkerDatabaseOpener(workerIdentifier: string, multipleTabs?: boolean, worker?: string | URL): Comlink.Remote<OpenAsyncDatabaseConnection>;
+export declare function resolveWorkerDatabasePortFactory(worker: () => Worker | SharedWorker): Worker | MessagePort;
 export declare function isSharedWorker(worker: Worker | SharedWorker): worker is SharedWorker;

package/lib/src/worker/db/open-worker-database.js

@@ -1,10 +1,12 @@
 import * as Comlink from 'comlink';
+import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
 /**
  * Opens a shared or dedicated worker which exposes opening of database connections
  */
-export function openWorkerDatabasePort(workerIdentifier, multipleTabs = true, worker = '') {
+export function openWorkerDatabasePort(workerIdentifier, multipleTabs = true, worker = '', vfs) {
+    const needsDedicated = vfs == WASQLiteVFS.AccessHandlePoolVFS || vfs == WASQLiteVFS.OPFSCoopSyncVFS;
     if (worker) {
-        return multipleTabs
+        return !needsDedicated && multipleTabs
             ? new SharedWorker(`${worker}`, {
                 /* @vite-ignore */
                 name: `shared-DB-worker-${workerIdentifier}`
@@ -21,7 +23,7 @@ export function openWorkerDatabasePort(workerIdentifier, multipleTabs = true, wo
          *  This enables multi tab support by default, but falls back if SharedWorker is not available
          *  (in the case of Android)
          */
-        return multipleTabs
+        return !needsDedicated && multipleTabs
             ? new SharedWorker(new URL('./WASQLiteDB.worker.js', import.meta.url), {
                 /* @vite-ignore */
                 name: `shared-DB-worker-${workerIdentifier}`,

package/lib/src/worker/sync/AbstractSharedSyncClientProvider.d.ts

@@ -6,6 +6,7 @@ export declare abstract class AbstractSharedSyncClientProvider {
     abstract fetchCredentials(): Promise<PowerSyncCredentials | null>;
     abstract uploadCrud(): Promise<void>;
     abstract statusChanged(status: SyncStatusOptions): void;
+    abstract getDBWorkerPort(): Promise<MessagePort>;
     abstract trace(...x: any[]): void;
     abstract debug(...x: any[]): void;
     abstract info(...x: any[]): void;

package/lib/src/worker/sync/SharedSyncImplementation.d.ts

@@ -2,6 +2,7 @@ import { type AbstractStreamingSyncImplementation, type LockOptions, type PowerS
 import * as Comlink from 'comlink';
 import { type ILogger } from 'js-logger';
 import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
 import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
 /**
  * Manual message events for shared sync clients
@@ -17,22 +18,36 @@ export type ManualSharedSyncPayload = {
     event: SharedSyncClientEvent;
     data: any;
 };
+/**
+ * @internal
+ */
 export type SharedSyncInitOptions = {
-    dbName: string;
     streamOptions: Omit<WebStreamingSyncImplementationOptions, 'adapter' | 'uploadCrud' | 'remote'>;
+    dbParams: ResolvedWebSQLOpenOptions;
 };
+/**
+ * @internal
+ */
 export interface SharedSyncImplementationListener extends StreamingSyncImplementationListener {
     initialized: () => void;
 }
+/**
+ * @internal
+ */
 export type WrappedSyncPort = {
     port: MessagePort;
     clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
+    db?: DBAdapter;
 };
+/**
+ * @internal
+ */
 export type RemoteOperationAbortController = {
     controller: AbortController;
     activePort: WrappedSyncPort;
 };
 /**
+ * @internal
  * Shared sync implementation which runs inside a shared webworker
  */
 export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImplementationListener> implements StreamingSyncImplementation {
@@ -45,6 +60,7 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     protected dbAdapter: DBAdapter | null;
     protected syncParams: SharedSyncInitOptions | null;
     protected logger: ILogger;
+    protected lastConnectOptions: PowerSyncConnectionOptions | undefined;
     syncStatus: SyncStatus;
     broadCastLogger: ILogger;
     constructor();
@@ -55,7 +71,7 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     /**
      * Configures the DBAdapter connection and a streaming sync client.
      */
-    init(dbWorkerPort: MessagePort, params: SharedSyncInitOptions): Promise<void>;
+    setParams(params: SharedSyncInitOptions): Promise<void>;
     dispose(): Promise<void | undefined>;
     /**
      * Connects to the PowerSync backend instance.
@@ -73,12 +89,13 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
      * Removes a message port client from this manager's managed
      * clients.
      */
-    removePort(port: MessagePort): void;
+    removePort(port: MessagePort): Promise<void>;
     triggerCrudUpload(): void;
     obtainLock<T>(lockOptions: LockOptions<T>): Promise<T>;
     hasCompletedSync(): Promise<boolean>;
     getWriteCheckpoint(): Promise<string>;
     protected generateStreamingImplementation(): WebStreamingSyncImplementation;
+    protected openInternalDB(): Promise<void>;
     /**
      * A method to update the all shared statuses for each
      * client.

package/lib/src/worker/sync/SharedSyncImplementation.js

@@ -4,9 +4,10 @@ import * as Comlink from 'comlink';
 import Logger from 'js-logger';
 import { WebRemote } from '../../db/sync/WebRemote';
 import { WebStreamingSyncImplementation } from '../../db/sync/WebStreamingSyncImplementation';
-import { WASQLiteDBAdapter } from '../../db/adapters/wa-sqlite/WASQLiteDBAdapter';
-import { BroadcastLogger } from './BroadcastLogger';
+import { LockedAsyncDatabaseAdapter } from '../../db/adapters/LockedAsyncDatabaseAdapter';
+import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection';
 import { getNavigatorLocks } from '../../shared/navigator';
+import { BroadcastLogger } from './BroadcastLogger';
 /**
  * Manual message events for shared sync clients
  */
@@ -19,6 +20,7 @@ export var SharedSyncClientEvent;
     SharedSyncClientEvent["CLOSE_CLIENT"] = "close-client";
 })(SharedSyncClientEvent || (SharedSyncClientEvent = {}));
 /**
+ * @internal
  * Shared sync implementation which runs inside a shared webworker
  */
 export class SharedSyncImplementation extends BaseObserver {
@@ -31,6 +33,7 @@ export class SharedSyncImplementation extends BaseObserver {
     dbAdapter;
     syncParams;
     logger;
+    lastConnectOptions;
     syncStatus;
     broadCastLogger;
     constructor() {
@@ -40,6 +43,7 @@ export class SharedSyncImplementation extends BaseObserver {
         this.syncParams = null;
         this.syncStreamClient = null;
         this.logger = Logger.get('shared-sync');
+        this.lastConnectOptions = undefined;
         this.isInitialized = new Promise((resolve) => {
             const callback = this.registerListener({
                 initialized: () => {
@@ -67,17 +71,11 @@ export class SharedSyncImplementation extends BaseObserver {
     /**
      * Configures the DBAdapter connection and a streaming sync client.
      */
-    async init(dbWorkerPort, params) {
-        if (this.dbAdapter) {
+    async setParams(params) {
+        if (this.syncParams) {
             // Cannot modify already existing sync implementation
             return;
         }
-        this.dbAdapter = new WASQLiteDBAdapter({
-            dbFilename: params.dbName,
-            workerPort: dbWorkerPort,
-            flags: { enableMultiTabs: true, useWebWorker: true },
-            logger: this.logger
-        });
         this.syncParams = params;
         if (params.streamOptions?.flags?.broadcastLogs) {
             this.logger = this.broadCastLogger;
@@ -86,6 +84,7 @@ export class SharedSyncImplementation extends BaseObserver {
             // Share any uncaught events on the broadcast logger
             this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
         };
+        await this.openInternalDB();
         this.iterateListeners((l) => l.initialized?.());
     }
     async dispose() {
@@ -104,6 +103,7 @@ export class SharedSyncImplementation extends BaseObserver {
         // This effectively queues connect and disconnect calls. Ensuring multiple tabs' requests are synchronized
         return getNavigatorLocks().request('shared-sync-connect', async () => {
             this.syncStreamClient = this.generateStreamingImplementation();
+            this.lastConnectOptions = options;
             this.syncStreamClient.registerListener({
                 statusChanged: (status) => {
                     this.updateAllStatuses(status.toJSON());
@@ -140,13 +140,16 @@ export class SharedSyncImplementation extends BaseObserver {
      * Removes a message port client from this manager's managed
      * clients.
      */
-    removePort(port) {
+    async removePort(port) {
         const index = this.ports.findIndex((p) => p.port == port);
         if (index < 0) {
             console.warn(`Could not remove port ${port} since it is not present in active ports.`);
             return;
         }
         const trackedPort = this.ports[index];
+        if (trackedPort.db) {
+            trackedPort.db.close();
+        }
         // Release proxy
         trackedPort.clientProvider[Comlink.releaseProxy]();
         this.ports.splice(index, 1);
@@ -159,6 +162,12 @@ export class SharedSyncImplementation extends BaseObserver {
                 abortController.controller.abort(new AbortOperation('Closing pending requests after client port is removed'));
             }
         });
+        if (this.dbAdapter == trackedPort.db && this.syncStreamClient) {
+            await this.disconnect();
+            // Ask for a new DB worker port handler
+            await this.openInternalDB();
+            await this.connect(this.lastConnectOptions);
+        }
     }
     triggerCrudUpload() {
         this.waitForReady().then(() => this.syncStreamClient?.triggerCrudUpload());
@@ -230,6 +239,26 @@ export class SharedSyncImplementation extends BaseObserver {
             logger: this.logger
         });
     }
+    async openInternalDB() {
+        const lastClient = this.ports[this.ports.length - 1];
+        const workerPort = await lastClient.clientProvider.getDBWorkerPort();
+        const remote = Comlink.wrap(workerPort);
+        const identifier = this.syncParams.dbParams.dbFilename;
+        const db = await remote(this.syncParams.dbParams);
+        const locked = new LockedAsyncDatabaseAdapter({
+            name: identifier,
+            openConnection: async () => {
+                return new WorkerWrappedAsyncDatabaseConnection({
+                    remote,
+                    baseConnection: db,
+                    identifier
+                });
+            },
+            logger: this.logger
+        });
+        await locked.init();
+        this.dbAdapter = lastClient.db = locked;
+    }
     /**
      * A method to update the all shared statuses for each
      * client.