@powersync/web 1.30.0 → 1.32.0

package/src/db/adapters/wa-sqlite/WASQLiteConnection.ts

@@ -1,9 +1,8 @@
 import * as SQLite from '@journeyapps/wa-sqlite';
 import { BaseObserver, BatchedUpdateNotification } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../AsyncDatabaseConnection';
-import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory';
-
+import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../AsyncDatabaseConnection.js';
+import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
 /**
  * List of currently tested virtual filesystems
  */
@@ -126,9 +125,10 @@ export const DEFAULT_MODULE_FACTORIES = {
     }
     // @ts-expect-error The types for this static method are missing upstream
     const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
+    const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
     return {
       module,
-      vfs: await OPFSCoopSyncVFS.create(options.dbFileName, module)
+      vfs
     };
   }
 };
@@ -387,7 +387,15 @@ export class WASqliteConnection
 
   async close() {
     this.broadcastChannel?.close();
-    await this.sqliteAPI.close(this.dbP);
+    await this.acquireExecuteLock(async () => {
+      /**
+       * Running the close operation inside the same execute mutex prevents errors like:
+       * ```
+       * unable to close due to unfinalized statements or unfinished backups
+       * ```
+       */
+      await this.sqliteAPI.close(this.dbP);
+    });
   }
 
   async registerOnTableChange(callback: OnTableChangeCallback) {

package/src/db/adapters/wa-sqlite/WASQLiteDBAdapter.ts

@@ -1,17 +1,17 @@
 import { type PowerSyncOpenFactoryOptions } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase';
-import { OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
+import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase.js';
+import { OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection.js';
 import {
   DEFAULT_CACHE_SIZE_KB,
   ResolvedWebSQLOpenOptions,
   TemporaryStorageOption,
   WebSQLFlags
-} from '../web-sql-flags';
-import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
-import { WASQLiteVFS } from './WASQLiteConnection';
-import { WASQLiteOpenFactory } from './WASQLiteOpenFactory';
+} from '../web-sql-flags.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
+import { WASQLiteVFS } from './WASQLiteConnection.js';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
 
 /**
  * These flags are the same as {@link WebSQLFlags}.
@@ -44,7 +44,7 @@ export interface WASQLiteDBAdapterOptions extends Omit<PowerSyncOpenFactoryOptio
 /**
  * Adapter for WA-SQLite SQLite connections.
  */
-export class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+export class WASQLiteDBAdapter extends InternalWASQLiteDBAdapter {
   constructor(options: WASQLiteDBAdapterOptions) {
     super({
       name: options.dbFilename,

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

@@ -1,17 +1,17 @@
-import { type ILogLevel, DBAdapter } from '@powersync/common';
+import { DBAdapter, type ILogLevel } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database';
-import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
-import { AsyncDatabaseConnection, OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
+import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
+import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
+import { AsyncDatabaseConnection, OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
 import {
   DEFAULT_CACHE_SIZE_KB,
   ResolvedWebSQLOpenOptions,
   TemporaryStorageOption,
   WebSQLOpenFactoryOptions
-} from '../web-sql-flags';
-import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
-import { WASqliteConnection, WASQLiteVFS } from './WASQLiteConnection';
+} from '../web-sql-flags.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
+import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection.js';
 
 export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
   vfs?: WASQLiteVFS;
@@ -41,7 +41,7 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
   }
 
   protected openAdapter(): DBAdapter {
-    return new LockedAsyncDatabaseAdapter({
+    return new InternalWASQLiteDBAdapter({
       name: this.options.dbFilename,
       openConnection: () => this.openConnection(),
       debugMode: this.options.debugMode,

package/src/db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.ts

@@ -1,7 +1,7 @@
 import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions } from '@powersync/common';
-import { PowerSyncDatabase } from '../../../db/PowerSyncDatabase';
-import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory';
-import { WASQLiteOpenFactory } from './WASQLiteOpenFactory';
+import { PowerSyncDatabase } from '../../../db/PowerSyncDatabase.js';
+import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory.js';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
 
 /**
  * @deprecated {@link PowerSyncDatabase} can now be constructed directly

package/src/db/sync/SharedWebStreamingSyncImplementation.ts

@@ -2,20 +2,19 @@ import {
   PowerSyncConnectionOptions,
   PowerSyncCredentials,
   SubscribedStream,
-  SyncStatus,
   SyncStatusOptions
 } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
-import { ManualSharedSyncPayload, SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
-import { DEFAULT_CACHE_SIZE_KB, resolveWebSQLFlags, TemporaryStorageOption } from '../adapters/web-sql-flags';
-import { WebDBAdapter } from '../adapters/WebDBAdapter';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider.js';
+import { ManualSharedSyncPayload, SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation.js';
+import { WorkerClient } from '../../worker/sync/WorkerClient.js';
+import { WebDBAdapter } from '../adapters/WebDBAdapter.js';
+import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption, resolveWebSQLFlags } from '../adapters/web-sql-flags.js';
 import {
   WebStreamingSyncImplementation,
   WebStreamingSyncImplementationOptions
-} from './WebStreamingSyncImplementation';
-import { WorkerClient } from '../../worker/sync/WorkerClient';
-import { getNavigatorLocks } from '../../shared/navigator';
+} from './WebStreamingSyncImplementation.js';
 
 /**
  * The shared worker will trigger methods on this side of the message port
@@ -146,7 +145,25 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
       ).port;
     }
 
+    /**
+     * Pass along any sync status updates to this listener
+     */
+    this.clientProvider = new SharedSyncClientProvider(
+      this.webOptions,
+      (status) => {
+        this.updateSyncStatus(status);
+      },
+      options.db
+    );
+
     this.syncManager = Comlink.wrap<WorkerClient>(this.messagePort);
+    /**
+     * The sync worker will call this client provider when it needs
+     * to fetch credentials or upload data.
+     * This performs bi-directional method calling.
+     */
+    Comlink.expose(this.clientProvider, this.messagePort);
+
     this.syncManager.setLogLevel(this.logger.getLevel());
 
     this.triggerCrudUpload = this.syncManager.triggerCrudUpload;
@@ -157,10 +174,49 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
      * DB worker, but a port to the DB worker can be transferred to the
      * sync worker.
      */
+
+    this.isInitialized = this._init();
+  }
+
+  protected async _init() {
+    /**
+     * The general flow of initialization is:
+     *  - The client requests a unique navigator lock.
+     *    - Once the lock is acquired, we register the lock with the shared worker.
+     *    - The shared worker can then request the same lock. The client has been closed if the shared worker can acquire the lock.
+     *    - Once the shared worker knows the client's lock, we can guarentee that the shared worker will detect if the client has been closed.
+     *    - This makes the client safe for the shared worker to use.
+     *    - The client is only added to the SharedSyncImplementation once the lock has been registered.
+     *      This ensures we don't ever keep track of dead clients (tabs that closed before the lock was registered).
+     *    - The client side lock is held until the client is disposed.
+     *    - We resolve the top-level promise after the lock has been registered with the shared worker.
+     * - The client sends the params to the shared worker after locks have been registered.
+     */
+    await new Promise<void>((resolve) => {
+      // 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) {
+          return;
+        }
+        // Awaiting here ensures the worker is waiting for the lock
+        await this.syncManager.addLockBasedCloseSignal(lock!.name);
+
+        // The lock has been registered, we can continue with the initialization
+        resolve();
+
+        await new Promise<void>((r) => {
+          this.abortOnClose.signal.onabort = () => r();
+        });
+      });
+    });
+
     const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
     const flags = { ...this.webOptions.flags, workers: undefined };
 
-    this.isInitialized = this.syncManager.setParams(
+    await this.syncManager.setParams(
       {
         dbParams: this.dbAdapter.getConfiguration(),
         streamOptions: {
@@ -170,39 +226,8 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
           flags: flags
         }
       },
-      options.subscriptions
+      this.options.subscriptions
     );
-
-    /**
-     * Pass along any sync status updates to this listener
-     */
-    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.
-     * 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<void>((r) => {
-          this.abortOnClose.signal.onabort = () => r();
-        });
-      }
-    });
   }
 
   /**
@@ -231,8 +256,6 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
   async dispose(): Promise<void> {
     await this.waitForReady();
 
-    await super.dispose();
-
     await new Promise<void>((resolve) => {
       // Listen for the close acknowledgment from the worker
       this.messagePort.addEventListener('message', (event) => {
@@ -249,6 +272,9 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
       };
       this.messagePort.postMessage(closeMessagePayload);
     });
+
+    await super.dispose();
+
     this.abortOnClose.abort();
 
     // Release the proxy
@@ -263,12 +289,4 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
   updateSubscriptions(subscriptions: SubscribedStream[]): void {
     this.syncManager.updateSubscriptions(subscriptions);
   }
-
-  /**
-   * Used in tests to force a connection states
-   */
-  private async _testUpdateStatus(status: SyncStatus) {
-    await this.isInitialized;
-    return this.syncManager._testUpdateAllStatuses(status.toJSON());
-  }
 }

package/src/db/sync/WebRemote.ts

@@ -9,7 +9,7 @@ import {
   RemoteConnector
 } from '@powersync/common';
 
-import { getUserAgentInfo } from './userAgent';
+import { getUserAgentInfo } from './userAgent.js';
 
 /*
  * Depends on browser's implementation of global fetch.

package/src/db/sync/WebStreamingSyncImplementation.ts

@@ -4,8 +4,8 @@ import {
   LockOptions,
   LockType
 } from '@powersync/common';
-import { getNavigatorLocks } from '../../shared/navigator';
-import { ResolvedWebSQLOpenOptions, WebSQLFlags } from '../adapters/web-sql-flags';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { ResolvedWebSQLOpenOptions, WebSQLFlags } from '../adapters/web-sql-flags.js';
 
 export interface WebStreamingSyncImplementationOptions extends AbstractStreamingSyncImplementationOptions {
   flags?: WebSQLFlags;

package/src/index.ts

@@ -1,13 +1,13 @@
 export * from '@powersync/common';
-export * from './db/adapters/AsyncDatabaseConnection';
-export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory';
-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';
+export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js';
+export * from './db/adapters/AbstractWebSQLOpenFactory.js';
+export * from './db/adapters/AsyncDatabaseConnection.js';
+export * from './db/adapters/wa-sqlite/WASQLiteConnection.js';
+export * from './db/adapters/wa-sqlite/WASQLiteDBAdapter.js';
+export * from './db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
+export * from './db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.js';
+export * from './db/adapters/web-sql-flags.js';
+export * from './db/PowerSyncDatabase.js';
+export * from './db/sync/SharedWebStreamingSyncImplementation.js';
+export * from './db/sync/WebRemote.js';
+export * from './db/sync/WebStreamingSyncImplementation.js';

package/src/worker/db/SharedWASQLiteConnection.ts

@@ -3,8 +3,8 @@ import {
   AsyncDatabaseConnection,
   OnTableChangeCallback,
   ProxiedQueryResult
-} from '../../db/adapters/AsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
+} from '../../db/adapters/AsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
 
 /**
  * Keeps track of open DB connections and the clients which

package/src/worker/db/WASQLiteDB.worker.ts

@@ -5,11 +5,11 @@
 import '@journeyapps/wa-sqlite';
 import { createBaseLogger, createLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { AsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection';
-import { WorkerDBOpenerOptions } from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory';
-import { getNavigatorLocks } from '../../shared/navigator';
-import { SharedDBWorkerConnection, SharedWASQLiteConnection } from './SharedWASQLiteConnection';
-import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection';
+import { AsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection.js';
+import { WorkerDBOpenerOptions } from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { SharedDBWorkerConnection, SharedWASQLiteConnection } from './SharedWASQLiteConnection.js';
+import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection.js';
 
 const baseLogger = createBaseLogger();
 baseLogger.useDefaults();
@@ -17,7 +17,6 @@ const logger = createLogger('db-worker');
 
 const DBMap = new Map<string, SharedDBWorkerConnection>();
 const OPEN_DB_LOCK = 'open-wasqlite-db';
-
 let nextClientId = 1;
 
 const openDBShared = async (options: WorkerDBOpenerOptions): Promise<AsyncDatabaseConnection> => {

package/src/worker/db/WorkerWASQLiteConnection.ts

@@ -1,6 +1,6 @@
 import * as Comlink from 'comlink';
-import { OnTableChangeCallback } from '../../db/adapters/AsyncDatabaseConnection';
-import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+import { OnTableChangeCallback } from '../../db/adapters/AsyncDatabaseConnection.js';
+import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
 
 /**
  * A Small proxy wrapper around the WASqliteConnection.

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

@@ -1,6 +1,6 @@
 import * as Comlink from 'comlink';
-import { OpenAsyncDatabaseConnection } from '../..//db/adapters/AsyncDatabaseConnection';
-import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+import { OpenAsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection.js';
+import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
 
 /**
  * Opens a shared or dedicated worker which exposes opening of database connections

package/src/worker/sync/BroadcastLogger.ts

@@ -1,5 +1,5 @@
 import { type ILogger, type ILogLevel, LogLevel } from '@powersync/common';
-import { type WrappedSyncPort } from './SharedSyncImplementation';
+import { type WrappedSyncPort } from './SharedSyncImplementation.js';
 
 /**
  * Broadcasts logs to all clients