@powersync/web 0.0.0-dev-20260414110516 → 0.0.0-dev-20260504100448

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

@@ -49,7 +49,6 @@ export declare class SharedWebStreamingSyncImplementation extends WebStreamingSy
     connect(options?: PowerSyncConnectionOptions): Promise<void>;
     disconnect(): Promise<void>;
     getWriteCheckpoint(): Promise<string>;
-    hasCompletedSync(): Promise<boolean>;
     dispose(): Promise<void>;
     waitForReady(): Promise<void>;
     updateSubscriptions(subscriptions: SubscribedStream[]): void;

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

@@ -187,9 +187,6 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
         await this.waitForReady();
         return this.syncManager.getWriteCheckpoint();
     }
-    async hasCompletedSync() {
-        return this.syncManager.hasCompletedSync();
-    }
     async dispose() {
         await this.waitForReady();
         await new Promise((resolve) => {

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

@@ -1,9 +1,7 @@
-import { AbstractRemote, AbstractRemoteOptions, BSONImplementation, ILogger, RemoteConnector } from '@powersync/common';
+import { AbstractRemote, AbstractRemoteOptions, ILogger, RemoteConnector } from '@powersync/common';
 export declare class WebRemote extends AbstractRemote {
     protected connector: RemoteConnector;
     protected logger: ILogger;
-    private _bson;
     constructor(connector: RemoteConnector, logger?: ILogger, options?: Partial<AbstractRemoteOptions>);
     getUserAgent(): string;
-    getBSON(): Promise<BSONImplementation>;
 }

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

@@ -11,7 +11,6 @@ class WebFetchProvider extends FetchImplementationProvider {
 export class WebRemote extends AbstractRemote {
     connector;
     logger;
-    _bson;
     constructor(connector, logger = DEFAULT_REMOTE_LOGGER, options) {
         super(connector, logger, {
             ...(options ?? {}),
@@ -30,15 +29,4 @@ export class WebRemote extends AbstractRemote {
         }
         return ua.join(' ');
     }
-    async getBSON() {
-        if (this._bson) {
-            return this._bson;
-        }
-        /**
-         * Dynamic import to be used only when needed.
-         */
-        const { BSON } = await import('bson');
-        this._bson = BSON;
-        return this._bson;
-    }
 }

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

@@ -49,7 +49,10 @@ export class MultiDatabaseServer {
             const { dbFilename } = options;
             let server = this.activeDatabases.get(dbFilename);
             if (server == null) {
-                const needsNavigatorLocks = !isSharedWorker;
+                // We don't need navigator locks for shared workers because all queries run in this shared worker exclusively.
+                // For read-only connections, we use a VFS that supports concurrent reads (so a single lock on the connection is
+                // fine).
+                const needsNavigatorLocks = !(isSharedWorker || options.isReadOnly);
                 const connection = new RawSqliteConnection(options);
                 const withSafeConcurrency = new ConcurrentSqliteConnection(connection, needsNavigatorLocks);
                 // Initializing the RawSqliteConnection will run some pragmas that might write to the database file, so we want

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

@@ -1,10 +1,10 @@
 import * as Comlink from 'comlink';
-import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/vfs.js';
+import { vfsRequiresDedicatedWorkers } from '../../db/adapters/wa-sqlite/vfs.js';
 /**
  * Opens a shared or dedicated worker which exposes opening of database connections
  */
 export function openWorkerDatabasePort(workerIdentifier, multipleTabs = true, worker = '', vfs) {
-    const needsDedicated = vfs == WASQLiteVFS.AccessHandlePoolVFS || vfs == WASQLiteVFS.OPFSCoopSyncVFS;
+    const needsDedicated = vfs && vfsRequiresDedicatedWorkers(vfs);
     if (worker) {
         return !needsDedicated && multipleTabs
             ? new SharedWorker(`${worker}`, {

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

@@ -73,7 +73,6 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     broadCastLogger: ILogger;
     protected readonly database: DBAdapter;
     constructor();
-    get lastSyncedAt(): Date | undefined;
     get isConnected(): boolean;
     /**
      * Gets the last client port which we know is safe from unexpected closes.
@@ -119,7 +118,6 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
      */
     removePort(port: WrappedSyncPort): Promise<() => void>;
     triggerCrudUpload(): void;
-    hasCompletedSync(): Promise<boolean>;
     getWriteCheckpoint(): Promise<string>;
     protected withSyncImplementation<T>(callback: (sync: StreamingSyncImplementation) => Promise<T>): Promise<T>;
     protected generateStreamingImplementation(): WebStreamingSyncImplementation;

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

@@ -77,9 +77,6 @@ export class SharedSyncImplementation extends BaseObserver {
             logger: this.logger
         });
     }
-    get lastSyncedAt() {
-        return this.connectionManager.syncStreamImplementation?.lastSyncedAt;
-    }
     get isConnected() {
         return this.connectionManager.syncStreamImplementation?.isConnected ?? false;
     }
@@ -245,11 +242,6 @@ export class SharedSyncImplementation extends BaseObserver {
             sync.triggerCrudUpload();
         });
     }
-    async hasCompletedSync() {
-        return this.withSyncImplementation(async (sync) => {
-            return sync.hasCompletedSync();
-        });
-    }
     async getWriteCheckpoint() {
         return this.withSyncImplementation(async (sync) => {
             return sync.getWriteCheckpoint();
@@ -467,14 +459,10 @@ export class SharedSyncImplementation extends BaseObserver {
                     // We can poke the crud in case we missed any updates.
                     const impl = sharedSync.connectionManager.syncStreamImplementation;
                     impl?.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.
-                     */
+                    // The Rust client implementation stores sync state on the connection level. Reopening the database causes a
+                    // disruption of the connection state and forces us to reconnect. We want to do that as soon as possible to
+                    // minimize downtime.
+                    impl?.markConnectionMayHaveChanged();
                 }
             }
             async readLock(fn, options) {

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

@@ -24,7 +24,6 @@ export declare class WorkerClient {
     triggerCrudUpload(): void;
     setParams(params: SharedSyncInitOptions, subscriptions: SubscribedStream[]): Promise<void>;
     getWriteCheckpoint(): Promise<string>;
-    hasCompletedSync(): Promise<boolean>;
     connect(options?: PowerSyncConnectionOptions): Promise<void>;
     updateSubscriptions(subscriptions: SubscribedStream[]): void;
     disconnect(): Promise<void>;

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

@@ -67,9 +67,6 @@ export class WorkerClient {
     getWriteCheckpoint() {
         return this.sync.getWriteCheckpoint();
     }
-    hasCompletedSync() {
-        return this.sync.hasCompletedSync();
-    }
     connect(options) {
         return this.sync.connect(options);
     }