@powersync/web 0.0.0-dev-20251120085122 → 0.0.0-dev-20251127205344

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powersync/web",
-    "version": "1.28.2",
+    "version": "1.29.1",
     "description": "PowerSync web SDK. Sync Postgres, MongoDB or MySQL with SQLite in your web app",
     "main": "lib/src/index.js",
     "types": "lib/src/index.d.ts",
@@ -62,7 +62,7 @@
     "license": "Apache-2.0",
     "peerDependencies": {
         "@journeyapps/wa-sqlite": "^1.3.2",
-        "@powersync/common": "workspace:^1.42.0"
+        "@powersync/common": "workspace:^1.43.1"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",

package/lib/src/db/adapters/LockedAsyncDatabaseAdapter.d.ts

@@ -30,6 +30,7 @@ export declare class LockedAsyncDatabaseAdapter extends BaseObserver<LockedAsync
     protected _disposeTableChangeListener: (() => void) | null;
     private _config;
     protected pendingAbortControllers: Set<AbortController>;
+    protected requiresHolds: boolean | null;
     closing: boolean;
     closed: boolean;
     constructor(options: LockedAsyncDatabaseAdapterOptions);

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

@@ -1,6 +1,7 @@
 import { BaseObserver, createLogger } from '@powersync/common';
 import { getNavigatorLocks } from '../..//shared/navigator';
 import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection';
+import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection';
 /**
  * @internal
  * Wraps a {@link AsyncDatabaseConnection} and provides exclusive locking functions in
@@ -17,6 +18,7 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     _disposeTableChangeListener = null;
     _config = null;
     pendingAbortControllers;
+    requiresHolds;
     closing;
     closed;
     constructor(options) {
@@ -27,6 +29,7 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
         this.pendingAbortControllers = new Set();
         this.closed = false;
         this.closing = false;
+        this.requiresHolds = null;
         // Set the name if provided. We can query for the name if not available yet
         this.debugMode = options.debugMode ?? false;
         if (this.debugMode) {
@@ -71,6 +74,10 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
         this._config = await this._db.getConfig();
         await this.registerOnChangeListener(this._db);
         this.iterateListeners((cb) => cb.initialized?.());
+        /**
+         * This is only required for the long-lived shared IndexedDB connections.
+         */
+        this.requiresHolds = this._config.vfs == WASQLiteVFS.IDBBatchAtomicVFS;
     }
     getConfiguration() {
         if (!this._config) {
@@ -165,12 +172,14 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
             if (timoutId) {
                 clearTimeout(timoutId);
             }
-            const holdId = await this.baseDB.markHold();
+            const holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
             try {
                 return await callback();
             }
             finally {
-                await this.baseDB.releaseHold(holdId);
+                if (holdId) {
+                    await this.baseDB.releaseHold(holdId);
+                }
             }
         });
     }

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

@@ -38,7 +38,7 @@ export class WorkerWrappedAsyncDatabaseConnection {
         return this.withRemote(() => this.baseConnection.releaseHold(holdId));
     }
     isAutoCommit() {
-        return this.baseConnection.isAutoCommit();
+        return this.withRemote(() => this.baseConnection.isAutoCommit());
     }
     withRemote(workerPromise) {
         const controller = this.notifyRemoteClosed;

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

@@ -1,9 +1,9 @@
 import { PowerSyncConnectionOptions, PowerSyncCredentials, SubscribedStream, SyncStatusOptions } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
+import { WorkerClient } from '../../worker/sync/WorkerClient';
 import { WebDBAdapter } from '../adapters/WebDBAdapter';
 import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from './WebStreamingSyncImplementation';
-import { WorkerClient } from '../../worker/sync/WorkerClient';
 /**
  * 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,9 +1,9 @@
 import * as Comlink from 'comlink';
+import { getNavigatorLocks } from '../../shared/navigator';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
 import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
-import { DEFAULT_CACHE_SIZE_KB, resolveWebSQLFlags, TemporaryStorageOption } from '../adapters/web-sql-flags';
+import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption, resolveWebSQLFlags } from '../adapters/web-sql-flags';
 import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation';
-import { getNavigatorLocks } from '../../shared/navigator';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.
@@ -130,6 +130,19 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
          */
         const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
         const flags = { ...this.webOptions.flags, workers: undefined };
+        // Request a random lock until this client is disposed. The name of the lock is sent to the shared worker, which
+        // will also attempt to acquire it. Since the lock is returned when the tab is closed, this allows the share worker
+        // to free resources associated with this tab.
+        // We take hold of this lock as soon-as-possible in order to cater for potentially closed tabs.
+        getNavigatorLocks().request(`tab-close-signal-${crypto.randomUUID()}`, async (lock) => {
+            if (!this.abortOnClose.signal.aborted) {
+                // Awaiting here ensures the worker is waiting for the lock
+                await this.syncManager.addLockBasedCloseSignal(lock.name);
+                await new Promise((r) => {
+                    this.abortOnClose.signal.onabort = () => r();
+                });
+            }
+        });
         this.isInitialized = this.syncManager.setParams({
             dbParams: this.dbAdapter.getConfiguration(),
             streamOptions: {
@@ -151,17 +164,6 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
          * This performs bi-directional method calling.
          */
         Comlink.expose(this.clientProvider, this.messagePort);
-        // Request a random lock until this client is disposed. The name of the lock is sent to the shared worker, which
-        // will also attempt to acquire it. Since the lock is returned when the tab is closed, this allows the share worker
-        // to free resources associated with this tab.
-        getNavigatorLocks().request(`tab-close-signal-${crypto.randomUUID()}`, async (lock) => {
-            if (!this.abortOnClose.signal.aborted) {
-                this.syncManager.addLockBasedCloseSignal(lock.name);
-                await new Promise((r) => {
-                    this.abortOnClose.signal.onabort = () => r();
-                });
-            }
-        });
     }
     /**
      * Starts the sync process, this effectively acts as a call to

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

@@ -61,6 +61,7 @@ export class SharedWASQLiteConnection {
             const connection = this.connection;
             dbMap.delete(dbFilename);
             await connection.close();
+            return;
         }
         logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
         return;

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

@@ -218,6 +218,20 @@ export class SharedSyncImplementation extends BaseObserver {
                 }
             });
             const shouldReconnect = !!this.connectionManager.syncStreamImplementation && this.ports.length > 0;
+            /**
+             * If the current database adapter is the one that is being closed, we need to disconnect from the backend.
+             * We can disconnect in the portMutex lock. This ensures the disconnect is not affected by potential other
+             * connect operations coming from other tabs.
+             */
+            if (this.dbAdapter && this.dbAdapter == trackedPort.db) {
+                this.logger.debug(`Disconnecting due to closed database: should reconnect: ${shouldReconnect}`);
+                this.dbAdapter = null;
+                // Unconditionally close the connection because the database it's writing to has just been closed.
+                // The connection has been closed previously, this might throw. We should be able to ignore it.
+                await this.connectionManager
+                    .disconnect()
+                    .catch((ex) => this.logger.warn('Error while disconnecting. Will attempt to reconnect.', ex));
+            }
             return {
                 shouldReconnect,
                 trackedPort
@@ -230,17 +244,8 @@ export class SharedSyncImplementation extends BaseObserver {
         for (const closeListener of trackedPort.closeListeners) {
             await closeListener();
         }
-        if (this.dbAdapter && this.dbAdapter == trackedPort.db) {
-            // Unconditionally close the connection because the database it's writing to has just been closed.
-            // The connection has been closed previously, this might throw. We should be able to ignore it.
-            await this.connectionManager
-                .disconnect()
-                .catch((ex) => this.logger.warn('Error while disconnecting. Will attempt to reconnect.', ex));
-            // Clearing the adapter will result in a new one being opened in connect
-            this.dbAdapter = null;
-            if (shouldReconnect) {
-                await this.connectionManager.connect(CONNECTOR_PLACEHOLDER, this.lastConnectOptions ?? {});
-            }
+        if (shouldReconnect) {
+            await this.connectionManager.connect(CONNECTOR_PLACEHOLDER, this.lastConnectOptions ?? {});
         }
         // Re-index subscriptions, the subscriptions of the removed port would no longer be considered.
         this.collectActiveSubscriptions();
@@ -366,7 +371,12 @@ export class SharedSyncImplementation extends BaseObserver {
                 });
                 lastClient.closeListeners.push(async () => {
                     this.logger.info('Aborting open connection because associated tab closed.');
-                    await wrapped.close().catch((ex) => this.logger.warn('error closing database connection', ex));
+                    /**
+                     * Don't await this close operation. It might never resolve if the tab is closed.
+                     * We run the close operation first, before marking the remote as closed. This gives the database some chance
+                     * to close the connection.
+                     */
+                    wrapped.close().catch((ex) => this.logger.warn('error closing database connection', ex));
                     wrapped.markRemoteClosed();
                 });
                 return wrapped;

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

@@ -1,5 +1,5 @@
-import { SharedSyncImplementation, SharedSyncInitOptions } from './SharedSyncImplementation';
 import { ILogLevel, PowerSyncConnectionOptions, SubscribedStream, SyncStatusOptions } from '@powersync/common';
+import { SharedSyncImplementation, SharedSyncInitOptions } from './SharedSyncImplementation';
 /**
  * A client to the shared sync worker.
  *

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

@@ -1,6 +1,6 @@
 import * as Comlink from 'comlink';
-import { SharedSyncClientEvent } from './SharedSyncImplementation';
 import { getNavigatorLocks } from '../../shared/navigator';
+import { SharedSyncClientEvent } from './SharedSyncImplementation';
 /**
  * A client to the shared sync worker.
  *
@@ -14,6 +14,7 @@ export class WorkerClient {
     constructor(sync, port) {
         this.sync = sync;
         this.port = port;
+        Comlink.expose(this, this.port);
     }
     async initialize() {
         /**
@@ -27,7 +28,6 @@ export class WorkerClient {
             }
         });
         this.resolvedPort = await this.sync.addPort(this.port);
-        Comlink.expose(this, this.port);
     }
     async removePort() {
         if (this.resolvedPort) {