fix: multiple tabs reconnect retry delay (#839)

Author: stevensJourney

.changeset/blue-chairs-cross.md

@@ -0,0 +1,5 @@
+---
+'@powersync/web': patch
+---
+
+Fixed issue where reconnecting after a disconnect would delay reconnection by a period of retryDelayMs

packages/web/src/db/adapters/LockedAsyncDatabaseAdapter.ts

@@ -151,13 +151,15 @@ export class LockedAsyncDatabaseAdapter
    * Returns a pending operation if one is already in progress.
    */
   async reOpenInternalDB(): Promise<void> {
-    if (!this.options.reOpenOnConnectionClosed) {
-      throw new Error(`Cannot re-open underlying database, reOpenOnConnectionClosed is not enabled`);
-    }
-    if (this.databaseOpenPromise) {
+    if (this.closing || !this.options.reOpenOnConnectionClosed) {
+      // No-op
+      return;
+    } else if (this.databaseOpenPromise) {
+      // Already busy opening
       return this.databaseOpenPromise;
+    } else {
+      return this._reOpen();
     }
-    return this._reOpen();
   }
 
   protected async _init() {
@@ -317,9 +319,17 @@ 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.
+    // The database is being (re)opened in the background. Wait for it here.
     if (this.databaseOpenPromise) {
       await this.databaseOpenPromise;
+    } else if (!this._db) {
+      /**
+       * The database is not open anymore, we might need to re-open it.
+       * Typically, _db, can be `null` if we tried to reOpen the database, but failed to succeed in re-opening.
+       * This can happen when disconnecting the client.
+       * Note: It is safe to re-enter this method multiple times.
+       */
+      await this.reOpenInternalDB();
     }
 
     return this._acquireLock(async () => {
@@ -339,11 +349,9 @@ export class LockedAsyncDatabaseAdapter
         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();
-          }
+          // 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 {

packages/web/tests/multiple_instances.test.ts

@@ -90,6 +90,35 @@ describe('Multiple Instances', { sequential: true }, () => {
     }
   );
 
+  sharedMockSyncServiceTest('should re-open database immediately on reconnect', async ({ context }) => {
+    // Connect the database
+    const { database, mockService } = context;
+    await context.connect();
+    expect(database.currentStatus.connected).true;
+
+    // Disconnect after connecting
+    await database.disconnect();
+
+    const pendingRequests = await mockService.getPendingRequests();
+    expect(pendingRequests.length).eq(0);
+
+    // Reconnect
+    database.connect(context.connector);
+
+    // A pending request should be made quickly. There should not be any retry delay
+    await vi.waitFor(
+      async () => {
+        const pendingRequests = await mockService.getPendingRequests();
+        expect(pendingRequests.length).eq(1);
+        // Once we get the request, we can reject it
+        await mockService.createResponse(pendingRequests[0].id, 401, {});
+        await mockService.completeResponse(pendingRequests[0].id);
+      },
+      // The timeout here is shorter than the retry delay, we must get a request before the retry delay
+      { timeout: 500 }
+    );
+  });
+
   it('should maintain DB connections if instances call close', async () => {
     /**
      * The shared webworker should use the same DB connection for both instances.