@powersync/web 0.0.0-dev-20240807140418 → 0.0.0-dev-20240815073141

package/lib/src/db/PowerSyncDatabase.js

@@ -118,4 +118,3 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
         }
     }
 }
-//# sourceMappingURL=PowerSyncDatabase.js.map

package/lib/src/db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js

@@ -24,4 +24,3 @@ export class AbstractWebPowerSyncDatabaseOpenFactory extends AbstractPowerSyncDa
         return new PowerSyncDatabase(options);
     }
 }
-//# sourceMappingURL=AbstractWebPowerSyncDatabaseOpenFactory.js.map

package/lib/src/db/adapters/AbstractWebSQLOpenFactory.js

@@ -28,4 +28,3 @@ export class AbstractWebSQLOpenFactory {
         return this.openAdapter();
     }
 }
-//# sourceMappingURL=AbstractWebSQLOpenFactory.js.map

package/lib/src/db/adapters/SSRDBAdapter.js

@@ -63,4 +63,3 @@ export class SSRDBAdapter extends BaseObserver {
         };
     }
 }
-//# sourceMappingURL=SSRDBAdapter.js.map

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

@@ -57,14 +57,14 @@ export class WASQLiteDBAdapter extends BaseObserver {
                 ? Comlink.wrap(this.options.workerPort)
                 : getWorkerDatabaseOpener(this.options.dbFilename, enableMultiTabs);
             this.methods = await dbOpener(this.options.dbFilename);
-            this.methods.registerOnTableChange(Comlink.proxy((opType, tableName, rowId) => {
-                this.iterateListeners((cb) => cb.tablesUpdated?.({ opType, table: tableName, rowId }));
+            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((opType, tableName, rowId) => {
-            this.iterateListeners((cb) => cb.tablesUpdated?.({ opType, table: tableName, rowId }));
+        this.methods.registerOnTableChange((event) => {
+            this.iterateListeners((cb) => cb.tablesUpdated?.(event));
         });
     }
     async execute(query, params) {
@@ -208,4 +208,3 @@ export class WASQLiteDBAdapter extends BaseObserver {
         };
     }
 }
-//# sourceMappingURL=WASQLiteDBAdapter.js.map

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

@@ -11,4 +11,3 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
         });
     }
 }
-//# sourceMappingURL=WASQLiteOpenFactory.js.map

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

@@ -19,4 +19,3 @@ export class WASQLitePowerSyncDatabaseOpenFactory extends AbstractWebPowerSyncDa
         return new PowerSyncDatabase(options);
     }
 }
-//# sourceMappingURL=WASQLitePowerSyncDatabaseOpenFactory.js.map

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

@@ -28,4 +28,3 @@ export function resolveWebSQLFlags(flags) {
     }
     return resolvedFlags;
 }
-//# sourceMappingURL=web-sql-flags.js.map

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

@@ -13,4 +13,3 @@ export class SSRStreamingSyncImplementation extends AbstractStreamingSyncImpleme
         return mutex.runExclusive(lockOptions.callback);
     }
 }
-//# sourceMappingURL=SSRWebStreamingSyncImplementation.js.map

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

@@ -1,8 +1,8 @@
+import { PowerSyncConnectionOptions, PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from './WebStreamingSyncImplementation';
-import { SharedSyncImplementation } from '../../worker/sync/SharedSyncImplementation';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
-import { PowerSyncConnectionOptions, PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
+import { SharedSyncImplementation } from '../../worker/sync/SharedSyncImplementation';
+import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from './WebStreamingSyncImplementation';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.

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

@@ -1,8 +1,8 @@
 import * as Comlink from 'comlink';
-import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation';
-import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
-import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
 import { openWorkerDatabasePort } from '../../worker/db/open-worker-database';
+import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
+import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
+import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.
@@ -122,6 +122,9 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
      */
     async connect(options) {
         await this.waitForReady();
+        // This is needed since a new tab won't have any reference to the
+        // shared worker sync implementation since that is only created on the first call to `connect`.
+        await this.disconnect();
         return this.syncManager.connect(options);
     }
     async disconnect() {
@@ -145,6 +148,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
         this.messagePort.postMessage(closeMessagePayload);
         // Release the proxy
         this.syncManager[Comlink.releaseProxy]();
+        this.messagePort.close();
     }
     async waitForReady() {
         return this.isInitialized;
@@ -156,4 +160,3 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
         return this.syncManager['_testUpdateAllStatuses'](status.toJSON());
     }
 }
-//# sourceMappingURL=SharedWebStreamingSyncImplementation.js.map

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

@@ -31,4 +31,3 @@ export class WebRemote extends AbstractRemote {
         return this._bson;
     }
 }
-//# sourceMappingURL=WebRemote.js.map

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

@@ -13,4 +13,3 @@ export class WebStreamingSyncImplementation extends AbstractStreamingSyncImpleme
         return navigator.locks.request(identifier, { signal: lockOptions.signal }, lockOptions.callback);
     }
 }
-//# sourceMappingURL=WebStreamingSyncImplementation.js.map

package/lib/src/index.js

@@ -9,4 +9,3 @@ export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory';
 export * from './db/adapters/web-sql-flags';
 export * from './db/adapters/AbstractWebSQLOpenFactory';
 export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory';
-//# sourceMappingURL=index.js.map

package/lib/src/shared/open-db.js

@@ -16,8 +16,19 @@ export async function _openDB(dbFileName, options = { useWebWorker: true }) {
      * Listeners are exclusive to the DB connection.
      */
     const listeners = new Map();
+    let updatedTables = new Set();
+    let updateTimer = null;
+    function fireUpdates() {
+        updateTimer = null;
+        const event = { tables: [...updatedTables], groupedUpdates: {}, rawUpdates: [] };
+        updatedTables.clear();
+        Array.from(listeners.values()).forEach((l) => l(event));
+    }
     sqlite3.register_table_onchange_hook(db, (opType, tableName, rowId) => {
-        Array.from(listeners.values()).forEach((l) => l(opType, tableName, rowId));
+        updatedTables.add(tableName);
+        if (updateTimer == null) {
+            updateTimer = setTimeout(fireUpdates, 0);
+        }
     });
     /**
      * This executes single SQL statements inside a requested lock.
@@ -179,4 +190,3 @@ export async function _openDB(dbFileName, options = { useWebWorker: true }) {
         close: () => sqlite3.close(db)
     };
 }
-//# sourceMappingURL=open-db.js.map

package/lib/src/shared/types.d.ts

@@ -1,4 +1,4 @@
-import type { QueryResult } from '@powersync/common';
+import type { BatchedUpdateNotification, QueryResult } from '@powersync/common';
 export type WASQLExecuteResult = Omit<QueryResult, 'rows'> & {
     rows: {
         _array: any[];
@@ -17,6 +17,6 @@ export type DBFunctionsInterface = {
 export type DBWorkerInterface = DBFunctionsInterface;
 export type WASQLiteExecuteMethod = (sql: string, params?: any[]) => Promise<WASQLExecuteResult>;
 export type WASQLiteExecuteBatchMethod = (sql: string, params?: any[]) => Promise<WASQLExecuteResult>;
-export type OnTableChangeCallback = (opType: number, tableName: string, rowId: number) => void;
+export type OnTableChangeCallback = (event: BatchedUpdateNotification) => void;
 export type OpenDB = (dbFileName: string) => DBWorkerInterface;
 export type SQLBatchTuple = [string] | [string, Array<any> | Array<Array<any>>];

package/lib/src/shared/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

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

@@ -47,4 +47,3 @@ addEventListener('unload', () => {
         db.close?.();
     });
 });
-//# sourceMappingURL=SharedWASQLiteDB.worker.js.map

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

@@ -1,4 +1,3 @@
 import * as Comlink from 'comlink';
 import { _openDB } from '../../shared/open-db';
 Comlink.expose(async (dbFileName) => Comlink.proxy(await _openDB(dbFileName)));
-//# sourceMappingURL=WASQLiteDB.worker.js.map

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

@@ -28,4 +28,3 @@ export function openWorkerDatabasePort(workerIdentifier, multipleTabs = true) {
 export function getWorkerDatabaseOpener(workerIdentifier, multipleTabs = true) {
     return Comlink.wrap(openWorkerDatabasePort(workerIdentifier, multipleTabs));
 }
-//# sourceMappingURL=open-worker-database.js.map

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

@@ -3,4 +3,3 @@
  */
 export class AbstractSharedSyncClientProvider {
 }
-//# sourceMappingURL=AbstractSharedSyncClientProvider.js.map

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

@@ -102,4 +102,3 @@ export class BroadcastLogger {
         return sanitizedParams;
     }
 }
-//# sourceMappingURL=BroadcastLogger.js.map

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

@@ -1,7 +1,7 @@
+import { type AbstractStreamingSyncImplementation, type LockOptions, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions, BaseObserver, DBAdapter, SyncStatus } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { type ILogger } from 'js-logger';
-import { type AbstractStreamingSyncImplementation, type StreamingSyncImplementation, type LockOptions, type StreamingSyncImplementationListener, type SyncStatusOptions, type PowerSyncConnectionOptions, BaseObserver, SyncStatus } from '@powersync/common';
-import { WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation';
+import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation';
 import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
 /**
  * Manual message events for shared sync clients
@@ -37,11 +37,14 @@ export type RemoteOperationAbortController = {
  */
 export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImplementationListener> implements StreamingSyncImplementation {
     protected ports: WrappedSyncPort[];
-    protected syncStreamClient?: AbstractStreamingSyncImplementation;
+    protected syncStreamClient: AbstractStreamingSyncImplementation | null;
     protected isInitialized: Promise<void>;
     protected statusListener?: () => void;
     protected fetchCredentialsController?: RemoteOperationAbortController;
     protected uploadDataController?: RemoteOperationAbortController;
+    protected dbAdapter: DBAdapter | null;
+    protected syncParams: SharedSyncInitOptions | null;
+    protected logger: ILogger;
     syncStatus: SyncStatus;
     broadCastLogger: ILogger;
     constructor();
@@ -75,6 +78,7 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     obtainLock<T>(lockOptions: LockOptions<T>): Promise<T>;
     hasCompletedSync(): Promise<boolean>;
     getWriteCheckpoint(): Promise<string>;
+    protected generateStreamingImplementation(): WebStreamingSyncImplementation;
     /**
      * A method to update the all shared statuses for each
      * client.

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

@@ -1,9 +1,9 @@
+import { AbortOperation, BaseObserver, SqliteBucketStorage, SyncStatus } from '@powersync/common';
+import { Mutex } from 'async-mutex';
 import * as Comlink from 'comlink';
 import Logger from 'js-logger';
-import { BaseObserver, SqliteBucketStorage, SyncStatus, AbortOperation } from '@powersync/common';
-import { WebStreamingSyncImplementation } from '../../db/sync/WebStreamingSyncImplementation';
-import { Mutex } from 'async-mutex';
 import { WebRemote } from '../../db/sync/WebRemote';
+import { WebStreamingSyncImplementation } from '../../db/sync/WebStreamingSyncImplementation';
 import { WASQLiteDBAdapter } from '../../db/adapters/wa-sqlite/WASQLiteDBAdapter';
 import { BroadcastLogger } from './BroadcastLogger';
 /**
@@ -27,11 +27,18 @@ export class SharedSyncImplementation extends BaseObserver {
     statusListener;
     fetchCredentialsController;
     uploadDataController;
+    dbAdapter;
+    syncParams;
+    logger;
     syncStatus;
     broadCastLogger;
     constructor() {
         super();
         this.ports = [];
+        this.dbAdapter = null;
+        this.syncParams = null;
+        this.syncStreamClient = null;
+        this.logger = Logger.get('shared-sync');
         this.isInitialized = new Promise((resolve) => {
             const callback = this.registerListener({
                 initialized: () => {
@@ -60,74 +67,24 @@ export class SharedSyncImplementation extends BaseObserver {
      * Configures the DBAdapter connection and a streaming sync client.
      */
     async init(dbWorkerPort, params) {
-        if (this.syncStreamClient) {
+        if (this.dbAdapter) {
             // Cannot modify already existing sync implementation
             return;
         }
-        const logger = params.streamOptions?.flags?.broadcastLogs ? this.broadCastLogger : Logger.get('shared-sync');
+        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;
+        }
         self.onerror = (event) => {
             // Share any uncaught events on the broadcast logger
-            logger.error('Uncaught exception in PowerSync shared sync worker', event);
+            this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
         };
-        this.syncStreamClient = new WebStreamingSyncImplementation({
-            adapter: new SqliteBucketStorage(new WASQLiteDBAdapter({
-                dbFilename: params.dbName,
-                workerPort: dbWorkerPort,
-                flags: { enableMultiTabs: true, useWebWorker: true },
-                logger
-            }), new Mutex(), logger),
-            remote: new WebRemote({
-                fetchCredentials: async () => {
-                    const lastPort = this.ports[this.ports.length - 1];
-                    return new Promise(async (resolve, reject) => {
-                        const abortController = new AbortController();
-                        this.fetchCredentialsController = {
-                            controller: abortController,
-                            activePort: lastPort
-                        };
-                        abortController.signal.onabort = reject;
-                        try {
-                            resolve(await lastPort.clientProvider.fetchCredentials());
-                        }
-                        catch (ex) {
-                            reject(ex);
-                        }
-                        finally {
-                            this.fetchCredentialsController = undefined;
-                        }
-                    });
-                }
-            }),
-            uploadCrud: async () => {
-                const lastPort = this.ports[this.ports.length - 1];
-                return new Promise(async (resolve, reject) => {
-                    const abortController = new AbortController();
-                    this.uploadDataController = {
-                        controller: abortController,
-                        activePort: lastPort
-                    };
-                    // Resolving will make it retry
-                    abortController.signal.onabort = () => resolve();
-                    try {
-                        resolve(await lastPort.clientProvider.uploadCrud());
-                    }
-                    catch (ex) {
-                        reject(ex);
-                    }
-                    finally {
-                        this.uploadDataController = undefined;
-                    }
-                });
-            },
-            ...params.streamOptions,
-            // Logger cannot be transferred just yet
-            logger
-        });
-        this.syncStreamClient.registerListener({
-            statusChanged: (status) => {
-                this.updateAllStatuses(status.toJSON());
-            }
-        });
         this.iterateListeners((l) => l.initialized?.());
     }
     async dispose() {
@@ -144,12 +101,24 @@ export class SharedSyncImplementation extends BaseObserver {
     async connect(options) {
         await this.waitForReady();
         // This effectively queues connect and disconnect calls. Ensuring multiple tabs' requests are synchronized
-        return navigator.locks.request('shared-sync-connect', () => this.syncStreamClient?.connect(options));
+        return navigator.locks.request('shared-sync-connect', async () => {
+            this.syncStreamClient = this.generateStreamingImplementation();
+            this.syncStreamClient.registerListener({
+                statusChanged: (status) => {
+                    this.updateAllStatuses(status.toJSON());
+                }
+            });
+            await this.syncStreamClient.connect(options);
+        });
     }
     async disconnect() {
         await this.waitForReady();
         // This effectively queues connect and disconnect calls. Ensuring multiple tabs' requests are synchronized
-        return navigator.locks.request('shared-sync-connect', () => this.syncStreamClient?.disconnect());
+        return navigator.locks.request('shared-sync-connect', async () => {
+            await this.syncStreamClient?.disconnect();
+            await this.syncStreamClient?.dispose();
+            this.syncStreamClient = null;
+        });
     }
     /**
      * Adds a new client tab's message port to the list of connected ports
@@ -205,6 +174,61 @@ export class SharedSyncImplementation extends BaseObserver {
         await this.waitForReady();
         return this.syncStreamClient.getWriteCheckpoint();
     }
+    generateStreamingImplementation() {
+        // This should only be called after initialization has completed
+        const syncParams = this.syncParams;
+        // Create a new StreamingSyncImplementation for each connect call. This is usually done is all SDKs.
+        return new WebStreamingSyncImplementation({
+            adapter: new SqliteBucketStorage(this.dbAdapter, new Mutex(), this.logger),
+            remote: new WebRemote({
+                fetchCredentials: async () => {
+                    const lastPort = this.ports[this.ports.length - 1];
+                    return new Promise(async (resolve, reject) => {
+                        const abortController = new AbortController();
+                        this.fetchCredentialsController = {
+                            controller: abortController,
+                            activePort: lastPort
+                        };
+                        abortController.signal.onabort = reject;
+                        try {
+                            console.log('calling the last port client provider for credentials');
+                            resolve(await lastPort.clientProvider.fetchCredentials());
+                        }
+                        catch (ex) {
+                            reject(ex);
+                        }
+                        finally {
+                            this.fetchCredentialsController = undefined;
+                        }
+                    });
+                }
+            }),
+            uploadCrud: async () => {
+                const lastPort = this.ports[this.ports.length - 1];
+                return new Promise(async (resolve, reject) => {
+                    const abortController = new AbortController();
+                    this.uploadDataController = {
+                        controller: abortController,
+                        activePort: lastPort
+                    };
+                    // Resolving will make it retry
+                    abortController.signal.onabort = () => resolve();
+                    try {
+                        resolve(await lastPort.clientProvider.uploadCrud());
+                    }
+                    catch (ex) {
+                        reject(ex);
+                    }
+                    finally {
+                        this.uploadDataController = undefined;
+                    }
+                });
+            },
+            ...syncParams.streamOptions,
+            // Logger cannot be transferred just yet
+            logger: this.logger
+        });
+    }
     /**
      * A method to update the all shared statuses for each
      * client.
@@ -219,11 +243,11 @@ export class SharedSyncImplementation extends BaseObserver {
      */
     _testUpdateAllStatuses(status) {
         if (!this.syncStreamClient) {
-            console.warn('no stream client has been initialized yet');
+            // This is just for testing purposes
+            this.syncStreamClient = this.generateStreamingImplementation();
         }
         // Only assigning, don't call listeners for this test
         this.syncStreamClient.syncStatus = new SyncStatus(status);
         this.updateAllStatuses(status);
     }
 }
-//# sourceMappingURL=SharedSyncImplementation.js.map

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

@@ -20,4 +20,3 @@ _self.onconnect = function (event) {
     Comlink.expose(sharedSyncImplementation, port);
     sharedSyncImplementation.addPort(port);
 };
-//# sourceMappingURL=SharedSyncImplementation.worker.js.map