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

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

@@ -1,5 +1,5 @@
 import { AbstractRemote, DEFAULT_REMOTE_LOGGER, FetchImplementationProvider } from '@powersync/common';
-import { getUserAgentInfo } from './userAgent';
+import { getUserAgentInfo } from './userAgent.js';
 /*
  * Depends on browser's implementation of global fetch.
  */

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

@@ -1,5 +1,5 @@
 import { AbstractStreamingSyncImplementation, AbstractStreamingSyncImplementationOptions, LockOptions } from '@powersync/common';
-import { ResolvedWebSQLOpenOptions, WebSQLFlags } from '../adapters/web-sql-flags';
+import { ResolvedWebSQLOpenOptions, WebSQLFlags } from '../adapters/web-sql-flags.js';
 export interface WebStreamingSyncImplementationOptions extends AbstractStreamingSyncImplementationOptions {
     flags?: WebSQLFlags;
     sync?: {

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

@@ -1,5 +1,5 @@
 import { AbstractStreamingSyncImplementation, LockType } from '@powersync/common';
-import { getNavigatorLocks } from '../../shared/navigator';
+import { getNavigatorLocks } from '../../shared/navigator.js';
 export class WebStreamingSyncImplementation extends AbstractStreamingSyncImplementation {
     constructor(options) {
         // Super will store and provide default values for options

package/lib/src/index.d.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/lib/src/index.js

@@ -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/lib/src/worker/db/SharedWASQLiteConnection.d.ts

@@ -1,6 +1,6 @@
 import { ILogger } from '@powersync/common';
-import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../../db/adapters/AsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
+import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../../db/adapters/AsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
 /**
  * Keeps track of open DB connections and the clients which
  * are using it.

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

@@ -4,9 +4,9 @@
 import '@journeyapps/wa-sqlite';
 import { createBaseLogger, createLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { getNavigatorLocks } from '../../shared/navigator';
-import { SharedWASQLiteConnection } from './SharedWASQLiteConnection';
-import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { SharedWASQLiteConnection } from './SharedWASQLiteConnection.js';
+import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection.js';
 const baseLogger = createBaseLogger();
 baseLogger.useDefaults();
 const logger = createLogger('db-worker');
@@ -14,6 +14,7 @@ const DBMap = new Map();
 const OPEN_DB_LOCK = 'open-wasqlite-db';
 let nextClientId = 1;
 const openDBShared = async (options) => {
+    // Prevent multiple simultaneous opens from causing race conditions
     return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
         const clientId = nextClientId++;
         const { dbFilename, logLevel } = options;

package/lib/src/worker/db/WorkerWASQLiteConnection.d.ts

@@ -1,5 +1,5 @@
-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.
  * This ensures that certain return types are properly proxied.

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

@@ -1,5 +1,5 @@
 import * as Comlink from 'comlink';
-import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection.js';
 /**
  * A Small proxy wrapper around the WASqliteConnection.
  * This ensures that certain return types are properly proxied.

package/lib/src/worker/db/open-worker-database.d.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/lib/src/worker/db/open-worker-database.js

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

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

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

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

@@ -1,10 +1,10 @@
 import { BaseObserver, ConnectionManager, DBAdapter, SubscribedStream, SyncStatus, type ILogLevel, type ILogger, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import * as Comlink from 'comlink';
-import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation';
-import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
-import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
+import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
+import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider.js';
 /**
  * @internal
  * Manual message events for shared sync clients

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

@@ -1,11 +1,11 @@
 import { AbortOperation, BaseObserver, ConnectionManager, SqliteBucketStorage, SyncStatus, createLogger } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import * as Comlink from 'comlink';
-import { WebRemote } from '../../db/sync/WebRemote';
-import { WebStreamingSyncImplementation } from '../../db/sync/WebStreamingSyncImplementation';
-import { LockedAsyncDatabaseAdapter } from '../../db/adapters/LockedAsyncDatabaseAdapter';
-import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection';
-import { BroadcastLogger } from './BroadcastLogger';
+import { WebRemote } from '../../db/sync/WebRemote.js';
+import { WebStreamingSyncImplementation } from '../../db/sync/WebStreamingSyncImplementation.js';
+import { LockedAsyncDatabaseAdapter } from '../../db/adapters/LockedAsyncDatabaseAdapter.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection.js';
+import { BroadcastLogger } from './BroadcastLogger.js';
 /**
  * @internal
  * Manual message events for shared sync clients
@@ -106,7 +106,8 @@ export class SharedSyncImplementation extends BaseObserver {
      */
     async getRandomWrappedPort() {
         return await this.portMutex.runExclusive(() => {
-            return this.ports[Math.floor(Math.random() * this.ports.length)];
+            const nonClosingPorts = this.ports.filter((p) => !p.isClosing);
+            return nonClosingPorts[Math.floor(Math.random() * nonClosingPorts.length)];
         });
     }
     async waitForStatus(status) {
@@ -181,6 +182,14 @@ export class SharedSyncImplementation extends BaseObserver {
                 // We may have missed some table updates while the database was closed.
                 // We can poke the crud in case we missed any updates.
                 this.connectionManager.syncStreamImplementation?.triggerCrudUpload();
+                /**
+                 * FIXME or IMPROVE ME
+                 * The Rust client implementation stores sync state on the connection level.
+                 * Reopening the database causes a state machine error which should cause the
+                 * StreamingSyncImplementation to reconnect. It would be nicer if we could trigger
+                 * this reconnect earlier.
+                 * This reconnect is not required for IndexedDB.
+                 */
             }
         });
         self.onerror = (event) => {
@@ -373,85 +382,77 @@ export class SharedSyncImplementation extends BaseObserver {
      * Opens a worker wrapped database connection. Using the last connected client port.
      */
     async openInternalDB() {
-        while (true) {
-            try {
-                const client = await this.getRandomWrappedPort();
-                if (!client) {
-                    // Should not really happen in practice
-                    throw new Error(`Could not open DB connection since no client is connected.`);
-                }
-                // Fail-safe timeout for opening a database connection.
-                const timeout = setTimeout(() => {
-                    abortController.abort();
-                }, 10_000);
-                /**
-                 * Handle cases where the client might close while opening a connection.
-                 */
-                const abortController = new AbortController();
-                const closeListener = () => {
-                    abortController.abort();
-                };
-                const removeCloseListener = () => {
-                    const index = client.closeListeners.indexOf(closeListener);
-                    if (index >= 0) {
-                        client.closeListeners.splice(index, 1);
-                    }
-                };
-                client.closeListeners.push(closeListener);
-                const workerPort = await withAbort({
-                    action: () => client.clientProvider.getDBWorkerPort(),
-                    signal: abortController.signal,
-                    cleanupOnAbort: (port) => {
-                        port.close();
-                    }
-                }).catch((ex) => {
-                    removeCloseListener();
-                    throw ex;
-                });
-                const remote = Comlink.wrap(workerPort);
-                const identifier = this.syncParams.dbParams.dbFilename;
-                /**
-                 * The open could fail if the tab is closed while we're busy opening the database.
-                 * This operation is typically executed inside an exclusive portMutex lock.
-                 * We typically execute the closeListeners using the portMutex in a different context.
-                 * We can't rely on the closeListeners to abort the operation if the tab is closed.
-                 */
-                const db = await withAbort({
-                    action: () => remote(this.syncParams.dbParams),
-                    signal: abortController.signal,
-                    cleanupOnAbort: (db) => {
-                        db.close();
-                    }
-                }).finally(() => {
-                    // We can remove the close listener here since we no longer need it past this point.
-                    removeCloseListener();
-                });
-                clearTimeout(timeout);
-                const wrapped = new WorkerWrappedAsyncDatabaseConnection({
-                    remote,
-                    baseConnection: db,
-                    identifier,
-                    // It's possible for this worker to outlive the client hosting the database for us. We need to be prepared for
-                    // that and ensure pending requests are aborted when the tab is closed.
-                    remoteCanCloseUnexpectedly: true
-                });
-                client.closeListeners.push(async () => {
-                    this.logger.info('Aborting open connection because associated tab closed.');
-                    /**
-                     * Don't await this close operation. It might never resolve if the tab is closed.
-                     * We mark the remote as closed first, this will reject any pending requests.
-                     * We then call close. The close operation is configured to fire-and-forget, the main promise will reject immediately.
-                     */
-                    wrapped.markRemoteClosed();
-                    wrapped.close().catch((ex) => this.logger.warn('error closing database connection', ex));
-                });
-                return wrapped;
+        const client = await this.getRandomWrappedPort();
+        if (!client) {
+            // Should not really happen in practice
+            throw new Error(`Could not open DB connection since no client is connected.`);
+        }
+        // Fail-safe timeout for opening a database connection.
+        const timeout = setTimeout(() => {
+            abortController.abort();
+        }, 10_000);
+        /**
+         * Handle cases where the client might close while opening a connection.
+         */
+        const abortController = new AbortController();
+        const closeListener = () => {
+            abortController.abort();
+        };
+        const removeCloseListener = () => {
+            const index = client.closeListeners.indexOf(closeListener);
+            if (index >= 0) {
+                client.closeListeners.splice(index, 1);
             }
-            catch (ex) {
-                this.logger.warn('Error opening internal DB', ex);
-                await new Promise((resolve) => setTimeout(resolve, 1000));
+        };
+        client.closeListeners.push(closeListener);
+        const workerPort = await withAbort({
+            action: () => client.clientProvider.getDBWorkerPort(),
+            signal: abortController.signal,
+            cleanupOnAbort: (port) => {
+                port.close();
             }
-        }
+        }).catch((ex) => {
+            removeCloseListener();
+            throw ex;
+        });
+        const remote = Comlink.wrap(workerPort);
+        const identifier = this.syncParams.dbParams.dbFilename;
+        /**
+         * The open could fail if the tab is closed while we're busy opening the database.
+         * This operation is typically executed inside an exclusive portMutex lock.
+         * We typically execute the closeListeners using the portMutex in a different context.
+         * We can't rely on the closeListeners to abort the operation if the tab is closed.
+         */
+        const db = await withAbort({
+            action: () => remote(this.syncParams.dbParams),
+            signal: abortController.signal,
+            cleanupOnAbort: (db) => {
+                db.close();
+            }
+        }).finally(() => {
+            // We can remove the close listener here since we no longer need it past this point.
+            removeCloseListener();
+        });
+        clearTimeout(timeout);
+        const wrapped = new WorkerWrappedAsyncDatabaseConnection({
+            remote,
+            baseConnection: db,
+            identifier,
+            // It's possible for this worker to outlive the client hosting the database for us. We need to be prepared for
+            // that and ensure pending requests are aborted when the tab is closed.
+            remoteCanCloseUnexpectedly: true
+        });
+        client.closeListeners.push(async () => {
+            this.logger.info('Aborting open connection because associated tab closed.');
+            /**
+             * Don't await this close operation. It might never resolve if the tab is closed.
+             * We mark the remote as closed first, this will reject any pending requests.
+             * We then call close. The close operation is configured to fire-and-forget, the main promise will reject immediately.
+             */
+            wrapped.markRemoteClosed();
+            wrapped.close().catch((ex) => this.logger.warn('error closing database connection', ex));
+        });
+        return wrapped;
     }
     /**
      * A method to update the all shared statuses for each

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

@@ -1,6 +1,6 @@
 import { createBaseLogger } from '@powersync/common';
-import { SharedSyncImplementation } from './SharedSyncImplementation';
-import { WorkerClient } from './WorkerClient';
+import { SharedSyncImplementation } from './SharedSyncImplementation.js';
+import { WorkerClient } from './WorkerClient.js';
 const _self = self;
 const logger = createBaseLogger();
 logger.useDefaults();

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

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

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

@@ -1,6 +1,6 @@
 import * as Comlink from 'comlink';
-import { getNavigatorLocks } from '../../shared/navigator';
-import { SharedSyncClientEvent } from './SharedSyncImplementation';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { SharedSyncClientEvent } from './SharedSyncImplementation.js';
 /**
  * A client to the shared sync worker.
  *