@powersync/web 1.30.0 → 1.32.0

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

@@ -1,7 +1,7 @@
-import { BaseObserver, createLogger } from '@powersync/common';
-import { getNavigatorLocks } from '../..//shared/navigator';
-import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection';
-import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection';
+import { BaseObserver, ConnectionClosedError, createLogger } from '@powersync/common';
+import { getNavigatorLocks } from '../../shared/navigator.js';
+import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection.js';
+import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection.js';
 /**
  * @internal
  * Wraps a {@link AsyncDatabaseConnection} and provides exclusive locking functions in
@@ -19,6 +19,7 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     _config = null;
     pendingAbortControllers;
     requiresHolds;
+    databaseOpenPromise = null;
     closing;
     closed;
     constructor(options) {
@@ -68,22 +69,79 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     async init() {
         return this.initPromise;
     }
+    async openInternalDB() {
+        /**
+         * Execute opening of the db in a lock in order not to interfere with other operations.
+         */
+        return this._acquireLock(async () => {
+            // Dispose any previous table change listener.
+            this._disposeTableChangeListener?.();
+            this._disposeTableChangeListener = null;
+            this._db?.close().catch((ex) => this.logger.warn(`Error closing database before opening new instance`, ex));
+            const isReOpen = !!this._db;
+            this._db = null;
+            this._db = await this.options.openConnection();
+            await this._db.init();
+            this._config = await this._db.getConfig();
+            await this.registerOnChangeListener(this._db);
+            if (isReOpen) {
+                this.iterateListeners((cb) => cb.databaseReOpened?.());
+            }
+            /**
+             * This is only required for the long-lived shared IndexedDB connections.
+             */
+            this.requiresHolds = this._config.vfs == WASQLiteVFS.IDBBatchAtomicVFS;
+        });
+    }
+    _reOpen() {
+        this.databaseOpenPromise = this.openInternalDB().finally(() => {
+            this.databaseOpenPromise = null;
+        });
+        return this.databaseOpenPromise;
+    }
+    /**
+     * Re-opens the underlying database.
+     * Returns a pending operation if one is already in progress.
+     */
+    async reOpenInternalDB() {
+        if (!this.options.reOpenOnConnectionClosed) {
+            throw new Error(`Cannot re-open underlying database, reOpenOnConnectionClosed is not enabled`);
+        }
+        if (this.databaseOpenPromise) {
+            return this.databaseOpenPromise;
+        }
+        return this._reOpen();
+    }
     async _init() {
-        this._db = await this.options.openConnection();
-        await this._db.init();
-        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.
+         * For OPFS, we can see this open call sometimes fail due to NoModificationAllowedError.
+         * We should be able to recover from this by re-opening the database.
          */
-        this.requiresHolds = this._config.vfs == WASQLiteVFS.IDBBatchAtomicVFS;
+        const maxAttempts = 3;
+        for (let count = 0; count < maxAttempts; count++) {
+            try {
+                await this.openInternalDB();
+                break;
+            }
+            catch (ex) {
+                if (count == maxAttempts - 1) {
+                    throw ex;
+                }
+                this.logger.warn(`Attempt ${count + 1} of ${maxAttempts} to open database failed, retrying in 1 second...`, ex);
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
+        this.iterateListeners((cb) => cb.initialized?.());
     }
     getConfiguration() {
         if (!this._config) {
             throw new Error(`Cannot get config before initialization is completed`);
         }
-        return this._config;
+        return {
+            ...this._config,
+            // This can be overridden by the adapter later
+            requiresPersistentTriggers: false
+        };
     }
     async waitForInitialized() {
         // Awaiting this will expose errors on function calls like .execute etc
@@ -124,7 +182,14 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
      */
     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;
@@ -144,24 +209,23 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     async readLock(fn, options) {
         await this.waitForInitialized();
         return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })), {
-            timeoutMs: options?.timeoutMs
+            timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
         });
     }
     async writeLock(fn, options) {
         await this.waitForInitialized();
         return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })), {
-            timeoutMs: options?.timeoutMs
+            timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
         });
     }
-    async acquireLock(callback, options) {
-        await this.waitForInitialized();
+    async _acquireLock(callback, options) {
         if (this.closing) {
             throw new Error(`Cannot acquire lock, the database is closing`);
         }
         const abortController = new AbortController();
         this.pendingAbortControllers.add(abortController);
         const { timeoutMs } = options ?? {};
-        const timoutId = timeoutMs
+        const timeoutId = timeoutMs
             ? setTimeout(() => {
                 abortController.abort(`Timeout after ${timeoutMs}ms`);
                 this.pendingAbortControllers.delete(abortController);
@@ -169,19 +233,49 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
             : null;
         return getNavigatorLocks().request(`db-lock-${this._dbIdentifier}`, { signal: abortController.signal }, async () => {
             this.pendingAbortControllers.delete(abortController);
-            if (timoutId) {
-                clearTimeout(timoutId);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
             }
-            const holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
+            return await callback();
+        });
+    }
+    async acquireLock(callback, options) {
+        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 = null;
             try {
+                /**
+                 * 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 (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();
+                    }
+                }
+                throw ex;
+            }
             finally {
                 if (holdId) {
                     await this.baseDB.releaseHold(holdId);
                 }
             }
-        });
+        }, options);
     }
     async readTransaction(fn, options) {
         return this.readLock(this.wrapTransaction(fn));

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

@@ -1,9 +1,12 @@
 import { DBAdapter } from '@powersync/common';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 export type SharedConnectionWorker = {
     identifier: string;
     port: MessagePort;
 };
+export type WebDBAdapterConfiguration = ResolvedWebSQLOpenOptions & {
+    requiresPersistentTriggers: boolean;
+};
 export interface WebDBAdapter extends DBAdapter {
     /**
      * Get a MessagePort which can be used to share the internals of this connection.
@@ -13,5 +16,5 @@ export interface WebDBAdapter extends DBAdapter {
      * Get the config options used to open this connection.
      * This is useful for sharing connections.
      */
-    getConfiguration(): ResolvedWebSQLOpenOptions;
+    getConfiguration(): WebDBAdapterConfiguration;
 }

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

@@ -1,6 +1,7 @@
+import { BaseObserver } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { AsyncDatabaseConnection, OnTableChangeCallback, OpenAsyncDatabaseConnection, ProxiedQueryResult } from './AsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
+import { AsyncDatabaseConnection, OnTableChangeCallback, OpenAsyncDatabaseConnection, ProxiedQueryResult } from './AsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 export type SharedConnectionWorker = {
     identifier: string;
     port: MessagePort;
@@ -15,11 +16,14 @@ export type WrappedWorkerConnectionOptions<Config extends ResolvedWebSQLOpenOpti
     remote: Comlink.Remote<OpenAsyncDatabaseConnection<Config>>;
     onClose?: () => void;
 };
+export type WorkerWrappedAsyncDatabaseConnectionListener = {
+    closing: () => void;
+};
 /**
  * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
  * functions for worker listeners.
  */
-export declare class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> implements AsyncDatabaseConnection {
+export declare class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> extends BaseObserver<WorkerWrappedAsyncDatabaseConnectionListener> implements AsyncDatabaseConnection {
     protected options: WrappedWorkerConnectionOptions<Config>;
     protected lockAbortController: AbortController;
     protected notifyRemoteClosed: AbortController | undefined;

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

@@ -1,13 +1,15 @@
+import { BaseObserver, ConnectionClosedError } from '@powersync/common';
 import * as Comlink from 'comlink';
 /**
  * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
  * functions for worker listeners.
  */
-export class WorkerWrappedAsyncDatabaseConnection {
+export class WorkerWrappedAsyncDatabaseConnection extends BaseObserver {
     options;
     lockAbortController = new AbortController();
     notifyRemoteClosed;
     constructor(options) {
+        super();
         this.options = options;
         if (options.remoteCanCloseUnexpectedly) {
             this.notifyRemoteClosed = new AbortController();
@@ -40,17 +42,20 @@ export class WorkerWrappedAsyncDatabaseConnection {
     isAutoCommit() {
         return this.withRemote(() => this.baseConnection.isAutoCommit());
     }
-    withRemote(workerPromise) {
+    withRemote(workerPromise, fireActionOnAbort = false) {
         const controller = this.notifyRemoteClosed;
         if (controller) {
             return new Promise((resolve, reject) => {
                 if (controller.signal.aborted) {
-                    reject(new Error('Called operation on closed remote'));
-                    // Don't run the operation if we're going to reject
-                    return;
+                    reject(new ConnectionClosedError('Called operation on closed remote'));
+                    if (!fireActionOnAbort) {
+                        // Don't run the operation if we're going to reject
+                        // We might want to fire-and-forget the operation in some cases (like a close operation)
+                        return;
+                    }
                 }
                 function handleAbort() {
-                    reject(new Error('Remote peer closed with request in flight'));
+                    reject(new ConnectionClosedError('Remote peer closed with request in flight'));
                 }
                 function completePromise(action) {
                     controller.signal.removeEventListener('abort', handleAbort);
@@ -118,11 +123,13 @@ export class WorkerWrappedAsyncDatabaseConnection {
         // Abort any pending lock requests.
         this.lockAbortController.abort();
         try {
-            await this.withRemote(() => this.baseConnection.close());
+            // fire and forget the close operation
+            await this.withRemote(() => this.baseConnection.close(), true);
         }
         finally {
             this.options.remote[Comlink.releaseProxy]();
             this.options.onClose?.();
+            this.iterateListeners((l) => l.closing?.());
         }
     }
     execute(sql, params) {

package/lib/src/db/adapters/wa-sqlite/InternalWASQLiteDBAdapter.d.ts

@@ -0,0 +1,12 @@
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
+import { WebDBAdapterConfiguration } from '../WebDBAdapter.js';
+/**
+ * @internal
+ * An intermediary implementation of WASQLiteDBAdapter, which takes the same
+ * constructor arguments as {@link LockedAsyncDatabaseAdapter}, but provides some
+ * basic WA-SQLite specific functionality.
+ * This base class is used to avoid requiring overloading the constructor of {@link WASQLiteDBAdapter}
+ */
+export declare class InternalWASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+    getConfiguration(): WebDBAdapterConfiguration;
+}

package/lib/src/db/adapters/wa-sqlite/InternalWASQLiteDBAdapter.js

@@ -0,0 +1,19 @@
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
+import { WASQLiteVFS } from './WASQLiteConnection.js';
+/**
+ * @internal
+ * An intermediary implementation of WASQLiteDBAdapter, which takes the same
+ * constructor arguments as {@link LockedAsyncDatabaseAdapter}, but provides some
+ * basic WA-SQLite specific functionality.
+ * This base class is used to avoid requiring overloading the constructor of {@link WASQLiteDBAdapter}
+ */
+export class InternalWASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+    getConfiguration() {
+        // This is valid since we only handle WASQLite connections
+        const baseConfig = super.getConfiguration();
+        return {
+            ...super.getConfiguration(),
+            requiresPersistentTriggers: baseConfig.vfs == WASQLiteVFS.OPFSCoopSyncVFS || baseConfig.vfs == WASQLiteVFS.AccessHandlePoolVFS
+        };
+    }
+}

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

@@ -1,8 +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
  */

package/lib/src/db/adapters/wa-sqlite/WASQLiteConnection.js

@@ -82,9 +82,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
         };
     }
 };
@@ -310,7 +311,15 @@ export class WASqliteConnection extends BaseObserver {
     }
     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) {
         return this.registerListener({

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

@@ -1,7 +1,7 @@
 import { type PowerSyncOpenFactoryOptions } from '@powersync/common';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
-import { ResolvedWebSQLOpenOptions, TemporaryStorageOption, WebSQLFlags } from '../web-sql-flags';
-import { WASQLiteVFS } from './WASQLiteConnection';
+import { ResolvedWebSQLOpenOptions, TemporaryStorageOption, WebSQLFlags } from '../web-sql-flags.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
+import { WASQLiteVFS } from './WASQLiteConnection.js';
 /**
  * These flags are the same as {@link WebSQLFlags}.
  * This export is maintained only for API consistency
@@ -27,6 +27,6 @@ export interface WASQLiteDBAdapterOptions extends Omit<PowerSyncOpenFactoryOptio
 /**
  * Adapter for WA-SQLite SQLite connections.
  */
-export declare class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+export declare class WASQLiteDBAdapter extends InternalWASQLiteDBAdapter {
     constructor(options: WASQLiteDBAdapterOptions);
 }

package/lib/src/db/adapters/wa-sqlite/WASQLiteDBAdapter.js

@@ -1,13 +1,13 @@
 import * as Comlink from 'comlink';
-import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
-import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags';
-import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
-import { WASQLiteOpenFactory } from './WASQLiteOpenFactory';
+import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase.js';
+import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
 /**
  * Adapter for WA-SQLite SQLite connections.
  */
-export class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+export class WASQLiteDBAdapter extends InternalWASQLiteDBAdapter {
     constructor(options) {
         super({
             name: options.dbFilename,

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

@@ -1,8 +1,8 @@
-import { type ILogLevel, DBAdapter } from '@powersync/common';
-import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
-import { AsyncDatabaseConnection } from '../AsyncDatabaseConnection';
-import { ResolvedWebSQLOpenOptions, WebSQLOpenFactoryOptions } from '../web-sql-flags';
-import { WASQLiteVFS } from './WASQLiteConnection';
+import { DBAdapter, type ILogLevel } from '@powersync/common';
+import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
+import { AsyncDatabaseConnection } from '../AsyncDatabaseConnection.js';
+import { ResolvedWebSQLOpenOptions, WebSQLOpenFactoryOptions } from '../web-sql-flags.js';
+import { WASQLiteVFS } from './WASQLiteConnection.js';
 export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
     vfs?: WASQLiteVFS;
 }

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.js

@@ -1,10 +1,10 @@
 import * as Comlink from 'comlink';
-import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database';
-import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
-import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags';
-import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
-import { WASqliteConnection, WASQLiteVFS } from './WASQLiteConnection';
+import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
+import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
+import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
+import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
+import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection.js';
 /**
  * Opens a SQLite connection using WA-SQLite.
  */
@@ -18,7 +18,7 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
         return this.options;
     }
     openAdapter() {
-        return new LockedAsyncDatabaseAdapter({
+        return new InternalWASQLiteDBAdapter({
             name: this.options.dbFilename,
             openConnection: () => this.openConnection(),
             debugMode: this.options.debugMode,

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

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

package/lib/src/db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.js

@@ -1,6 +1,6 @@
-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
  * @example

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 { WebDBAdapter } from '../adapters/WebDBAdapter';
-import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from './WebStreamingSyncImplementation';
-import { WorkerClient } from '../../worker/sync/WorkerClient';
+import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider.js';
+import { WorkerClient } from '../../worker/sync/WorkerClient.js';
+import { WebDBAdapter } from '../adapters/WebDBAdapter.js';
+import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from './WebStreamingSyncImplementation.js';
 /**
  * The shared worker will trigger methods on this side of the message port
  * via this client provider.
@@ -17,7 +17,7 @@ declare class SharedSyncClientProvider extends AbstractSharedSyncClientProvider
     invalidateCredentials(): void;
     fetchCredentials(): Promise<PowerSyncCredentials | null>;
     uploadCrud(): Promise<void>;
-    get logger(): import("js-logger").ILogger | undefined;
+    get logger(): import("@powersync/common").ILogger | undefined;
     trace(...x: any[]): void;
     debug(...x: any[]): void;
     info(...x: any[]): void;
@@ -41,6 +41,7 @@ export declare class SharedWebStreamingSyncImplementation extends WebStreamingSy
     protected dbAdapter: WebDBAdapter;
     private abortOnClose;
     constructor(options: SharedWebStreamingSyncImplementationOptions);
+    protected _init(): Promise<void>;
     /**
      * Starts the sync process, this effectively acts as a call to
      * `connect` if not yet connected.
@@ -52,9 +53,5 @@ export declare class SharedWebStreamingSyncImplementation extends WebStreamingSy
     dispose(): Promise<void>;
     waitForReady(): Promise<void>;
     updateSubscriptions(subscriptions: SubscribedStream[]): void;
-    /**
-     * Used in tests to force a connection states
-     */
-    private _testUpdateStatus;
 }
 export {};