@powersync/web 0.0.0-dev-20251203144301 → 0.0.0-dev-20260112083235

package/src/db/PowerSyncDatabase.ts

@@ -15,22 +15,23 @@ import {
   type RequiredAdditionalConnectionOptions
 } from '@powersync/common';
 import { Mutex } from 'async-mutex';
-import { getNavigatorLocks } from '../shared/navigator';
-import { WebDBAdapter } from './adapters/WebDBAdapter';
-import { WASQLiteOpenFactory } from './adapters/wa-sqlite/WASQLiteOpenFactory';
+import { getNavigatorLocks } from '../shared/navigator.js';
+import { WebDBAdapter } from './adapters/WebDBAdapter.js';
+import { WASQLiteOpenFactory } from './adapters/wa-sqlite/WASQLiteOpenFactory.js';
 import {
   DEFAULT_WEB_SQL_FLAGS,
   ResolvedWebSQLOpenOptions,
   WebSQLFlags,
+  isServerSide,
   resolveWebSQLFlags
-} from './adapters/web-sql-flags';
-import { SSRStreamingSyncImplementation } from './sync/SSRWebStreamingSyncImplementation';
-import { SharedWebStreamingSyncImplementation } from './sync/SharedWebStreamingSyncImplementation';
-import { WebRemote } from './sync/WebRemote';
+} from './adapters/web-sql-flags.js';
+import { SSRStreamingSyncImplementation } from './sync/SSRWebStreamingSyncImplementation.js';
+import { SharedWebStreamingSyncImplementation } from './sync/SharedWebStreamingSyncImplementation.js';
+import { WebRemote } from './sync/WebRemote.js';
 import {
   WebStreamingSyncImplementation,
   WebStreamingSyncImplementationOptions
-} from './sync/WebStreamingSyncImplementation';
+} from './sync/WebStreamingSyncImplementation.js';
 
 export interface WebPowerSyncFlags extends WebSQLFlags {
   /**
@@ -169,6 +170,20 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     });
   }
 
+  protected async loadVersion(): Promise<void> {
+    if (isServerSide()) {
+      return;
+    }
+    return super.loadVersion();
+  }
+
+  protected async resolveOfflineSyncStatus() {
+    if (isServerSide()) {
+      return;
+    }
+    return super.resolveOfflineSyncStatus();
+  }
+
   protected generateBucketStorageAdapter(): BucketStorageAdapter {
     return new SqliteBucketStorage(this.database);
   }

package/src/db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.ts

@@ -9,7 +9,7 @@ import {
   WebPowerSyncDatabaseOptions,
   WebPowerSyncFlags,
   resolveWebPowerSyncFlags
-} from '../../db/PowerSyncDatabase';
+} from '../../db/PowerSyncDatabase.js';
 
 /**
  * {@link WebPowerSyncFlags}

package/src/db/adapters/AbstractWebSQLOpenFactory.ts

@@ -1,6 +1,6 @@
-import { type ILogger, createLogger, DBAdapter, SQLOpenFactory } from '@powersync/common';
-import { SSRDBAdapter } from './SSRDBAdapter';
-import { ResolvedWebSQLFlags, WebSQLOpenFactoryOptions, isServerSide, resolveWebSQLFlags } from './web-sql-flags';
+import { DBAdapter, type ILogger, SQLOpenFactory, createLogger } from '@powersync/common';
+import { SSRDBAdapter } from './SSRDBAdapter.js';
+import { ResolvedWebSQLFlags, WebSQLOpenFactoryOptions, isServerSide, resolveWebSQLFlags } from './web-sql-flags.js';
 
 export abstract class AbstractWebSQLOpenFactory implements SQLOpenFactory {
   protected resolvedFlags: ResolvedWebSQLFlags;

package/src/db/adapters/AsyncDatabaseConnection.ts

@@ -1,5 +1,5 @@
 import { BatchedUpdateNotification, QueryResult } from '@powersync/common';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 
 /**
  * @internal
@@ -17,18 +17,6 @@ export type ProxiedQueryResult = Omit<QueryResult, 'rows'> & {
  */
 export type OnTableChangeCallback = (event: BatchedUpdateNotification) => void;
 
-/**
- * Thrown when an underlying database connection is closed.
- * This is particularly relevant when worker connections are marked as closed while
- * operations are still in progress.
- */
-export class ConnectionClosedError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'ConnectionClosedError';
-  }
-}
-
 /**
  * @internal
  * An async Database connection which provides basic async SQL methods.

package/src/db/adapters/LockedAsyncDatabaseAdapter.ts

@@ -1,5 +1,6 @@
 import {
   BaseObserver,
+  ConnectionClosedError,
   DBAdapter,
   DBAdapterListener,
   DBGetUtils,
@@ -10,13 +11,13 @@ import {
   createLogger,
   type ILogger
 } from '@powersync/common';
-import { getNavigatorLocks } from '../../shared/navigator';
-import { AsyncDatabaseConnection, ConnectionClosedError } from './AsyncDatabaseConnection';
-import { SharedConnectionWorker, WebDBAdapter } from './WebDBAdapter';
-import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection';
-import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection';
-import { ResolvedWASQLiteOpenFactoryOptions } from './wa-sqlite/WASQLiteOpenFactory';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { AsyncDatabaseConnection } from './AsyncDatabaseConnection.js';
+import { SharedConnectionWorker, WebDBAdapter } from './WebDBAdapter.js';
+import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection.js';
+import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection.js';
+import { ResolvedWASQLiteOpenFactoryOptions } from './wa-sqlite/WASQLiteOpenFactory.js';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 
 /**
  * @internal
@@ -233,7 +234,14 @@ export class LockedAsyncDatabaseAdapter
    */
   async close() {
     this.closing = true;
-    this._disposeTableChangeListener?.();
+    /**
+     * Note that we obtain a reference to the callback to avoid calling the callback with `this` as the context.
+     * This is to avoid Comlink attempting to clone `this` when calling the method.
+     */
+    const dispose = this._disposeTableChangeListener;
+    if (dispose) {
+      dispose();
+    }
     this.pendingAbortControllers.forEach((controller) => controller.abort('Closed'));
     await this.baseDB?.close?.();
     this.closed = true;
@@ -305,23 +313,31 @@ export class LockedAsyncDatabaseAdapter
   protected async acquireLock(callback: () => Promise<any>, options?: { timeoutMs?: number }): Promise<any> {
     await this.waitForInitialized();
 
+    // The database is being opened in the background. Wait for it here.
+    if (this.databaseOpenPromise) {
+      await this.databaseOpenPromise;
+    }
+
     return this._acquireLock(async () => {
       let holdId: string | null = null;
       try {
-        // The database is being opened in the background. Wait for it here.
-        if (this.databaseOpenPromise) {
-          /**
-           * We can't await this since it uses the same lock as we're in now.
-           */
+        /**
+         * We can't await this since it uses the same lock as we're in now.
+         * If there is a pending open, this call will throw.
+         * If there is no pending open, but there is also no database - the open
+         * might have failed. We need to re-open the database.
+         */
+        if (this.databaseOpenPromise || !this._db) {
           throw new ConnectionClosedError('Connection is busy re-opening');
         }
 
         holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
         return await callback();
       } catch (ex) {
-        if (ex instanceof ConnectionClosedError || (ex instanceof Error && ex.name === 'NoModificationAllowedError')) {
+        if (ConnectionClosedError.MATCHES(ex)) {
           if (this.options.reOpenOnConnectionClosed && !this.databaseOpenPromise && !this.closing) {
             // Immediately re-open the database. We need to miss as little table updates as possible.
+            // Note, don't await this since it uses the same lock as we're in now.
             this.reOpenInternalDB();
           }
         }

package/src/db/adapters/WebDBAdapter.ts

@@ -1,5 +1,5 @@
 import { DBAdapter } from '@powersync/common';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 
 export type SharedConnectionWorker = {
   identifier: string;

package/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.ts

@@ -1,13 +1,12 @@
-import { BaseObserver } from '@powersync/common';
+import { BaseObserver, ConnectionClosedError } from '@powersync/common';
 import * as Comlink from 'comlink';
 import {
   AsyncDatabaseConnection,
-  ConnectionClosedError,
   OnTableChangeCallback,
   OpenAsyncDatabaseConnection,
   ProxiedQueryResult
-} from './AsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+} from './AsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 
 export type SharedConnectionWorker = {
   identifier: string;

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 { OPFSCoopSyncVFS } from '../../../worker/db/opfs';
-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
  */
@@ -124,10 +123,12 @@ export const DEFAULT_MODULE_FACTORIES = {
     } else {
       module = await SyncWASQLiteModuleFactory();
     }
+    // @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: vfs as any
+      vfs
     };
   }
 };
@@ -386,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 { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.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 { WASQLiteVFS } from './WASQLiteConnection.js';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
 
 /**
  * These flags are the same as {@link WebSQLFlags}.

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

@@ -1,17 +1,17 @@
 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 { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
+import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
+import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
+import { AsyncDatabaseConnection, OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection.js';
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
 import {
   DEFAULT_CACHE_SIZE_KB,
   ResolvedWebSQLOpenOptions,
   TemporaryStorageOption,
   WebSQLOpenFactoryOptions
-} from '../web-sql-flags';
-import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection';
+} from '../web-sql-flags.js';
+import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection.js';
 
 export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
   vfs?: WASQLiteVFS;

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

@@ -5,16 +5,16 @@ import {
   SyncStatusOptions
 } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { getNavigatorLocks } from '../../shared/navigator';
-import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
-import { ManualSharedSyncPayload, SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
-import { WorkerClient } from '../../worker/sync/WorkerClient';
-import { WebDBAdapter } from '../adapters/WebDBAdapter';
-import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption, resolveWebSQLFlags } from '../adapters/web-sql-flags';
+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';
+} from './WebStreamingSyncImplementation.js';
 
 /**
  * The shared worker will trigger methods on this side of the message port

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();
@@ -20,6 +20,7 @@ const OPEN_DB_LOCK = 'open-wasqlite-db';
 let nextClientId = 1;
 
 const openDBShared = async (options: WorkerDBOpenerOptions): Promise<AsyncDatabaseConnection> => {
+  // Prevent multiple simultaneous opens from causing race conditions
   return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
     const clientId = nextClientId++;
     const { dbFilename, logLevel } = options;

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