@powersync/web 0.0.0-dev-20251127205344 → 0.0.0-dev-20251129133952

package/src/db/adapters/LockedAsyncDatabaseAdapter.ts

@@ -11,7 +11,7 @@ import {
   type ILogger
 } from '@powersync/common';
 import { getNavigatorLocks } from '../..//shared/navigator';
-import { AsyncDatabaseConnection } from './AsyncDatabaseConnection';
+import { AsyncDatabaseConnection, ConnectionClosedError } from './AsyncDatabaseConnection';
 import { SharedConnectionWorker, WebDBAdapter } from './WebDBAdapter';
 import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection';
 import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection';
@@ -26,10 +26,16 @@ export interface LockedAsyncDatabaseAdapterOptions {
   openConnection: () => Promise<AsyncDatabaseConnection>;
   debugMode?: boolean;
   logger?: ILogger;
+  defaultLockTimeoutMs?: number;
+  reOpenOnConnectionClosed?: boolean;
 }
 
 export type LockedAsyncDatabaseAdapterListener = DBAdapterListener & {
   initialized?: () => void;
+  /**
+   * Fired when the database is re-opened after being closed.
+   */
+  databaseReOpened?: () => void;
 };
 
 /**
@@ -51,6 +57,8 @@ export class LockedAsyncDatabaseAdapter
   private _config: ResolvedWebSQLOpenOptions | null = null;
   protected pendingAbortControllers: Set<AbortController>;
   protected requiresHolds: boolean | null;
+  protected requiresReOpen: boolean;
+  protected databaseOpenPromise: Promise<void> | null = null;
 
   closing: boolean;
   closed: boolean;
@@ -63,6 +71,7 @@ export class LockedAsyncDatabaseAdapter
     this.closed = false;
     this.closing = false;
     this.requiresHolds = null;
+    this.requiresReOpen = false;
     // Set the name if provided. We can query for the name if not available yet
     this.debugMode = options.debugMode ?? false;
     if (this.debugMode) {
@@ -105,18 +114,31 @@ export class LockedAsyncDatabaseAdapter
     return this.initPromise;
   }
 
-  protected async _init() {
+  protected async openInternalDB() {
+    // Dispose any previous table change listener.
+    this._disposeTableChangeListener?.();
+    this._disposeTableChangeListener = null;
+
+    const isReOpen = !!this._db;
+
     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?.());
+    if (isReOpen) {
+      this.iterateListeners((cb) => cb.databaseReOpened?.());
+    }
     /**
      * This is only required for the long-lived shared IndexedDB connections.
      */
     this.requiresHolds = (this._config as ResolvedWASQLiteOpenFactoryOptions).vfs == WASQLiteVFS.IDBBatchAtomicVFS;
   }
 
+  protected async _init() {
+    await this.openInternalDB();
+    this.iterateListeners((cb) => cb.initialized?.());
+  }
+
   getConfiguration(): ResolvedWebSQLOpenOptions {
     if (!this._config) {
       throw new Error(`Cannot get config before initialization is completed`);
@@ -196,7 +218,7 @@ export class LockedAsyncDatabaseAdapter
     return this.acquireLock(
       async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })),
       {
-        timeoutMs: options?.timeoutMs
+        timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
       }
     );
   }
@@ -206,7 +228,7 @@ export class LockedAsyncDatabaseAdapter
     return this.acquireLock(
       async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })),
       {
-        timeoutMs: options?.timeoutMs
+        timeoutMs: options?.timeoutMs ?? this.options.defaultLockTimeoutMs
       }
     );
   }
@@ -222,7 +244,7 @@ export class LockedAsyncDatabaseAdapter
     this.pendingAbortControllers.add(abortController);
     const { timeoutMs } = options ?? {};
 
-    const timoutId = timeoutMs
+    const timeoutId = timeoutMs
       ? setTimeout(() => {
           abortController.abort(`Timeout after ${timeoutMs}ms`);
           this.pendingAbortControllers.delete(abortController);
@@ -234,12 +256,35 @@ export class LockedAsyncDatabaseAdapter
       { 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;
+        let holdId: string | null = null;
         try {
+          // The database is being opened in the background. Wait for it here.
+          if (this.databaseOpenPromise) {
+            try {
+              await this.databaseOpenPromise;
+            } catch (ex) {
+              // This will cause a retry of opening the database.
+              const wrappedError = new ConnectionClosedError('Could not open database');
+              wrappedError.cause = ex;
+              throw wrappedError;
+            }
+          }
+
+          holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
           return await callback();
+        } catch (ex) {
+          if (ex instanceof ConnectionClosedError) {
+            if (this.options.reOpenOnConnectionClosed && !this.databaseOpenPromise && !this.closing) {
+              // Immediately re-open the database. We need to miss as little table updates as possible.
+              this.databaseOpenPromise = this.openInternalDB().finally(() => {
+                this.databaseOpenPromise = null;
+              });
+            }
+          }
+          throw ex;
         } finally {
           if (holdId) {
             await this.baseDB.releaseHold(holdId);

package/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.ts

@@ -1,6 +1,7 @@
 import * as Comlink from 'comlink';
 import {
   AsyncDatabaseConnection,
+  ConnectionClosedError,
   OnTableChangeCallback,
   OpenAsyncDatabaseConnection,
   ProxiedQueryResult
@@ -77,13 +78,13 @@ export class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLO
     if (controller) {
       return new Promise((resolve, reject) => {
         if (controller.signal.aborted) {
-          reject(new Error('Called operation on closed remote'));
+          reject(new ConnectionClosedError('Called operation on closed remote'));
           // Don't run the operation if we're going to reject
           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: () => void) {

package/src/db/sync/SharedWebStreamingSyncImplementation.ts

@@ -146,7 +146,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,25 +175,47 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
      * DB worker, but a port to the DB worker can be transferred to the
      * sync worker.
      */
-    const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
-    const flags = { ...this.webOptions.flags, workers: undefined };
 
-    // 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) {
+    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 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();
         });
-      }
+      });
     });
 
-    this.isInitialized = this.syncManager.setParams(
+    const { crudUploadThrottleMs, identifier, retryDelayMs } = this.options;
+    const flags = { ...this.webOptions.flags, workers: undefined };
+
+    await this.syncManager.setParams(
       {
         dbParams: this.dbAdapter.getConfiguration(),
         streamOptions: {
@@ -185,26 +225,8 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
           flags: flags
         }
       },
-      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
+      this.options.subscriptions
     );
-
-    /**
-     * 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);
   }
 
   /**

package/src/worker/sync/SharedSyncImplementation.ts

@@ -2,14 +2,14 @@ import {
   AbortOperation,
   BaseObserver,
   ConnectionManager,
-  createLogger,
   DBAdapter,
   PowerSyncBackendConnector,
   SqliteBucketStorage,
   SubscribedStream,
   SyncStatus,
-  type ILogger,
+  createLogger,
   type ILogLevel,
+  type ILogger,
   type PowerSyncConnectionOptions,
   type StreamingSyncImplementation,
   type StreamingSyncImplementationListener,
@@ -25,8 +25,8 @@ import {
 
 import { OpenAsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection';
 import { LockedAsyncDatabaseAdapter } from '../../db/adapters/LockedAsyncDatabaseAdapter';
-import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
 import { WorkerWrappedAsyncDatabaseConnection } from '../../db/adapters/WorkerWrappedAsyncDatabaseConnection';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
 import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
 import { BroadcastLogger } from './BroadcastLogger';
 
@@ -76,6 +76,11 @@ export type WrappedSyncPort = {
   db?: DBAdapter;
   currentSubscriptions: SubscribedStream[];
   closeListeners: (() => void | Promise<void>)[];
+  /**
+   * If we can use Navigator locks to detect if the client has closed.
+   */
+  isProtectedFromClose: boolean;
+  isClosing: boolean;
 };
 
 /**
@@ -106,7 +111,6 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
   protected fetchCredentialsController?: RemoteOperationAbortController;
   protected uploadDataController?: RemoteOperationAbortController;
 
-  protected dbAdapter: DBAdapter | null;
   protected syncParams: SharedSyncInitOptions | null;
   protected logger: ILogger;
   protected lastConnectOptions: PowerSyncConnectionOptions | undefined;
@@ -116,11 +120,11 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
   protected connectionManager: ConnectionManager;
   syncStatus: SyncStatus;
   broadCastLogger: ILogger;
+  protected distributedDB: DBAdapter | null;
 
   constructor() {
     super();
     this.ports = [];
-    this.dbAdapter = null;
     this.syncParams = null;
     this.logger = createLogger('shared-sync');
     this.lastConnectOptions = undefined;
@@ -135,29 +139,27 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       });
     });
 
+    // Should be configured once we get params
+    this.distributedDB = null;
+
     this.syncStatus = new SyncStatus({});
     this.broadCastLogger = new BroadcastLogger(this.ports);
 
     this.connectionManager = new ConnectionManager({
       createSyncImplementation: async () => {
-        return this.portMutex.runExclusive(async () => {
-          await this.waitForReady();
-          if (!this.dbAdapter) {
-            await this.openInternalDB();
-          }
+        await this.waitForReady();
 
-          const sync = this.generateStreamingImplementation();
-          const onDispose = sync.registerListener({
-            statusChanged: (status) => {
-              this.updateAllStatuses(status.toJSON());
-            }
-          });
-
-          return {
-            sync,
-            onDispose
-          };
+        const sync = this.generateStreamingImplementation();
+        const onDispose = sync.registerListener({
+          statusChanged: (status) => {
+            this.updateAllStatuses(status.toJSON());
+          }
         });
+
+        return {
+          sync,
+          onDispose
+        };
       },
       logger: this.logger
     });
@@ -171,6 +173,19 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     return this.connectionManager.syncStreamImplementation?.isConnected ?? false;
   }
 
+  /**
+   * Gets the last client port which we know is safe from unexpected closes.
+   */
+  protected get lastWrappedPort(): WrappedSyncPort | undefined {
+    // Find the last port which is protected from close
+    for (let i = this.ports.length - 1; i >= 0; i--) {
+      if (this.ports[i].isProtectedFromClose && !this.ports[i].isClosing) {
+        return this.ports[i];
+      }
+    }
+    return;
+  }
+
   async waitForStatus(status: SyncStatusOptions): Promise<void> {
     return this.withSyncImplementation(async (sync) => {
       return sync.waitForStatus(status);
@@ -219,11 +234,6 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       this.collectActiveSubscriptions();
       if (this.syncParams) {
         // Cannot modify already existing sync implementation params
-        // But we can ask for a DB adapter, if required, at this point.
-
-        if (!this.dbAdapter) {
-          await this.openInternalDB();
-        }
         return;
       }
 
@@ -233,15 +243,31 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
         this.logger = this.broadCastLogger;
       }
 
+      const lockedAdapter = new LockedAsyncDatabaseAdapter({
+        name: params.dbParams.dbFilename,
+        openConnection: async () => {
+          // Gets a connection from the clients when a new connection is requested.
+          return await this.openInternalDB();
+        },
+        logger: this.logger,
+        reOpenOnConnectionClosed: true
+      });
+      this.distributedDB = lockedAdapter;
+      await lockedAdapter.init();
+
+      lockedAdapter.registerListener({
+        databaseReOpened: () => {
+          // 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();
+        }
+      });
+
       self.onerror = (event) => {
         // Share any uncaught events on the broadcast logger
         this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
       };
 
-      if (!this.dbAdapter) {
-        await this.openInternalDB();
-      }
-
       this.iterateListeners((l) => l.initialized?.());
     });
   }
@@ -276,7 +302,9 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
         port,
         clientProvider: Comlink.wrap<AbstractSharedSyncClientProvider>(port),
         currentSubscriptions: [],
-        closeListeners: []
+        closeListeners: [],
+        isProtectedFromClose: false,
+        isClosing: false
       } satisfies WrappedSyncPort;
       this.ports.push(portProvider);
 
@@ -295,14 +323,17 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
    * clients.
    */
   async removePort(port: WrappedSyncPort) {
+    // Ports might be removed faster than we can process them.
+    port.isClosing = true;
+
     // Remove the port within a mutex context.
     // Warns if the port is not found. This should not happen in practice.
     // We return early if the port is not found.
-    const { trackedPort, shouldReconnect } = await this.portMutex.runExclusive(async () => {
+    return await this.portMutex.runExclusive(async () => {
       const index = this.ports.findIndex((p) => p == port);
       if (index < 0) {
         this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
-        return {};
+        return () => {};
       }
 
       const trackedPort = this.ports[index];
@@ -321,47 +352,15 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
         }
       });
 
-      const shouldReconnect = !!this.connectionManager.syncStreamImplementation && this.ports.length > 0;
-
-      /**
-       * If the current database adapter is the one that is being closed, we need to disconnect from the backend.
-       * We can disconnect in the portMutex lock. This ensures the disconnect is not affected by potential other
-       * connect operations coming from other tabs.
-       */
-      if (this.dbAdapter && this.dbAdapter == trackedPort.db) {
-        this.logger.debug(`Disconnecting due to closed database: should reconnect: ${shouldReconnect}`);
-        this.dbAdapter = null;
-        // Unconditionally close the connection because the database it's writing to has just been closed.
-        // The connection has been closed previously, this might throw. We should be able to ignore it.
-        await this.connectionManager
-          .disconnect()
-          .catch((ex) => this.logger.warn('Error while disconnecting. Will attempt to reconnect.', ex));
+      // Close the worker wrapped database connection, we can't accurately rely on this connection
+      for (const closeListener of trackedPort.closeListeners) {
+        await closeListener();
       }
 
-      return {
-        shouldReconnect,
-        trackedPort
-      };
-    });
-
-    if (!trackedPort) {
-      // We could not find the port to remove
-      return () => {};
-    }
-
-    for (const closeListener of trackedPort.closeListeners) {
-      await closeListener();
-    }
-
-    if (shouldReconnect) {
-      await this.connectionManager.connect(CONNECTOR_PLACEHOLDER, this.lastConnectOptions ?? {});
-    }
-
-    // Re-index subscriptions, the subscriptions of the removed port would no longer be considered.
-    this.collectActiveSubscriptions();
+      this.collectActiveSubscriptions();
 
-    // Release proxy
-    return () => trackedPort.clientProvider[Comlink.releaseProxy]();
+      return () => trackedPort.clientProvider[Comlink.releaseProxy]();
+    });
   }
 
   triggerCrudUpload() {
@@ -406,11 +405,14 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     const syncParams = this.syncParams!;
     // Create a new StreamingSyncImplementation for each connect call. This is usually done is all SDKs.
     return new WebStreamingSyncImplementation({
-      adapter: new SqliteBucketStorage(this.dbAdapter!, this.logger),
+      adapter: new SqliteBucketStorage(this.distributedDB!, this.logger),
       remote: new WebRemote(
         {
           invalidateCredentials: async () => {
-            const lastPort = this.ports[this.ports.length - 1];
+            const lastPort = this.lastWrappedPort;
+            if (!lastPort) {
+              throw new Error('No client port found to invalidate credentials');
+            }
             try {
               this.logger.log('calling the last port client provider to invalidate credentials');
               lastPort.clientProvider.invalidateCredentials();
@@ -419,7 +421,10 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
             }
           },
           fetchCredentials: async () => {
-            const lastPort = this.ports[this.ports.length - 1];
+            const lastPort = this.lastWrappedPort;
+            if (!lastPort) {
+              throw new Error('No client port found to fetch credentials');
+            }
             return new Promise(async (resolve, reject) => {
               const abortController = new AbortController();
               this.fetchCredentialsController = {
@@ -442,7 +447,10 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
         this.logger
       ),
       uploadCrud: async () => {
-        const lastPort = this.ports[this.ports.length - 1];
+        const lastPort = this.lastWrappedPort;
+        if (!lastPort) {
+          throw new Error('No client port found to upload crud');
+        }
 
         return new Promise(async (resolve, reject) => {
           const abortController = new AbortController();
@@ -469,19 +477,57 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     });
   }
 
+  /**
+   * Opens a worker wrapped database connection. Using the last connected client port.
+   */
   protected async openInternalDB() {
-    const lastClient = this.ports[this.ports.length - 1];
-    if (!lastClient) {
-      // Should not really happen in practice
-      throw new Error(`Could not open DB connection since no client is connected.`);
-    }
-    const workerPort = await lastClient.clientProvider.getDBWorkerPort();
-    const remote = Comlink.wrap<OpenAsyncDatabaseConnection>(workerPort);
-    const identifier = this.syncParams!.dbParams.dbFilename;
-    const db = await remote(this.syncParams!.dbParams);
-    const locked = new LockedAsyncDatabaseAdapter({
-      name: identifier,
-      openConnection: async () => {
+    while (true) {
+      try {
+        const lastClient = this.lastWrappedPort;
+        if (!lastClient) {
+          // Should not really happen in practice
+          throw new Error(`Could not open DB connection since no client is connected.`);
+        }
+
+        /**
+         * Handle cases where the client might close while opening a connection.
+         */
+        const abortController = new AbortController();
+        const closeListener = () => {
+          abortController.abort();
+        };
+
+        const removeCloseListener = () => {
+          const index = lastClient.closeListeners.indexOf(closeListener);
+          if (index >= 0) {
+            lastClient.closeListeners.splice(index, 1);
+          }
+        };
+
+        lastClient.closeListeners.push(closeListener);
+
+        const workerPort = await withAbort(
+          () => lastClient.clientProvider.getDBWorkerPort(),
+          abortController.signal
+        ).catch((ex) => {
+          removeCloseListener();
+          throw ex;
+        });
+
+        const remote = Comlink.wrap<OpenAsyncDatabaseConnection>(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(() => remote(this.syncParams!.dbParams), abortController.signal).finally(() => {
+          // We can remove the close listener here since we no longer need it past this point.
+          removeCloseListener();
+        });
+
         const wrapped = new WorkerWrappedAsyncDatabaseConnection({
           remote,
           baseConnection: db,
@@ -502,11 +548,11 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
         });
 
         return wrapped;
-      },
-      logger: this.logger
-    });
-    await locked.init();
-    this.dbAdapter = lastClient.db = locked;
+      } catch (ex) {
+        this.logger.warn('Error opening internal DB', ex);
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+    }
   }
 
   /**
@@ -531,3 +577,31 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     this.updateAllStatuses(status);
   }
 }
+
+/**
+ * Runs the action with an abort controller.
+ */
+function withAbort<T>(action: () => Promise<T>, signal: AbortSignal): Promise<T> {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(new AbortOperation('Operation aborted by abort controller'));
+      return;
+    }
+
+    function handleAbort() {
+      signal.removeEventListener('abort', handleAbort);
+      reject(new AbortOperation('Operation aborted by abort controller'));
+    }
+
+    signal.addEventListener('abort', handleAbort, { once: true });
+
+    function completePromise(action: () => void) {
+      signal.removeEventListener('abort', handleAbort);
+      action();
+    }
+
+    action()
+      .then((data) => completePromise(() => resolve(data)))
+      .catch((e) => completePromise(() => reject(e)));
+  });
+}