@powersync/web 0.0.0-dev-20251119142638 → 0.0.0-dev-20251120085122

package/src/worker/db/SharedWASQLiteConnection.ts

@@ -34,6 +34,22 @@ export class SharedWASQLiteConnection implements AsyncDatabaseConnection {
     this.activeHoldId = null;
   }
 
+  protected get logger() {
+    return this.options.logger;
+  }
+
+  protected get dbEntry() {
+    return this.options.dbMap.get(this.options.dbFilename)!;
+  }
+
+  protected get connection() {
+    return this.dbEntry.db;
+  }
+
+  protected get clientIds() {
+    return this.dbEntry.clientIds;
+  }
+
   async init(): Promise<void> {
     // No-op since the connection is already initialized when it was created
   }
@@ -51,20 +67,8 @@ export class SharedWASQLiteConnection implements AsyncDatabaseConnection {
     }
   }
 
-  protected get logger() {
-    return this.options.logger;
-  }
-
-  protected get dbEntry() {
-    return this.options.dbMap.get(this.options.dbFilename)!;
-  }
-
-  protected get connection() {
-    return this.dbEntry.db;
-  }
-
-  protected get clientIds() {
-    return this.dbEntry.clientIds;
+  async isAutoCommit(): Promise<boolean> {
+    return this.connection.isAutoCommit();
   }
 
   /**
@@ -80,12 +84,11 @@ export class SharedWASQLiteConnection implements AsyncDatabaseConnection {
     clientIds.delete(clientId);
 
     if (this.activeHoldId) {
-      /**
-       * The hold hasn't been released, but we're closing now.
-       * We can proactively cleanup and release the hold.
-       */
-      await this.connection.execute('ROLLBACK').catch(() => {});
-      await this.connection.releaseHold(this.activeHoldId).catch(() => {});
+      // We can't cleanup here since we're not in a lock context.
+      // The cleanup will occur once a new hold is acquired.
+      this.logger.info(
+        `Hold ${this.activeHoldId} was still active when the connection was closed. Cleanup will occur once a new hold is acquired.`
+      );
     }
 
     if (clientIds.size == 0) {

package/src/worker/db/WASQLiteDB.worker.ts

@@ -9,7 +9,7 @@ import { AsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnecti
 import { WorkerDBOpenerOptions } from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory';
 import { getNavigatorLocks } from '../../shared/navigator';
 import { SharedDBWorkerConnection, SharedWASQLiteConnection } from './SharedWASQLiteConnection';
-import { WorkerWASQLiteConnection, proxyWASQLiteConnection } from './WorkerWASQLiteConnection';
+import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection';
 
 const baseLogger = createBaseLogger();
 baseLogger.useDefaults();
@@ -59,7 +59,7 @@ const openDBShared = async (options: WorkerDBOpenerOptions): Promise<AsyncDataba
       logger
     });
 
-    return proxyWASQLiteConnection(sharedConnection);
+    return Comlink.proxy(sharedConnection);
   });
 };
 

package/src/worker/db/WorkerWASQLiteConnection.ts

@@ -1,26 +1,11 @@
 import * as Comlink from 'comlink';
-import { AsyncDatabaseConnection, OnTableChangeCallback } from '../../db/adapters/AsyncDatabaseConnection';
+import { OnTableChangeCallback } from '../../db/adapters/AsyncDatabaseConnection';
 import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
 
 /**
- * Fully proxies a WASQLiteConnection to be used as an AsyncDatabaseConnection.
+ * A Small proxy wrapper around the WASqliteConnection.
+ * This ensures that certain return types are properly proxied.
  */
-export function proxyWASQLiteConnection(connection: AsyncDatabaseConnection): AsyncDatabaseConnection {
-  return Comlink.proxy({
-    init: Comlink.proxy(() => connection.init()),
-    close: Comlink.proxy(() => connection.close()),
-    markHold: Comlink.proxy(() => connection.markHold()),
-    releaseHold: Comlink.proxy((holdId: string) => connection.releaseHold(holdId)),
-    execute: Comlink.proxy((sql: string, params?: any[]) => connection.execute(sql, params)),
-    executeRaw: Comlink.proxy((sql: string, params?: any[]) => connection.executeRaw(sql, params)),
-    executeBatch: Comlink.proxy((sql: string, params?: any[]) => connection.executeBatch(sql, params)),
-    registerOnTableChange: Comlink.proxy((callback: OnTableChangeCallback) =>
-      connection.registerOnTableChange(callback)
-    ),
-    getConfig: Comlink.proxy(() => connection.getConfig())
-  });
-}
-
 export class WorkerWASQLiteConnection extends WASqliteConnection {
   async registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void> {
     // Proxy the callback remove function

package/src/worker/sync/SharedSyncImplementation.ts

@@ -1,10 +1,4 @@
 import {
-  type ILogger,
-  type ILogLevel,
-  type PowerSyncConnectionOptions,
-  type StreamingSyncImplementation,
-  type StreamingSyncImplementationListener,
-  type SyncStatusOptions,
   AbortOperation,
   BaseObserver,
   ConnectionManager,
@@ -13,7 +7,13 @@ import {
   PowerSyncBackendConnector,
   SqliteBucketStorage,
   SubscribedStream,
-  SyncStatus
+  SyncStatus,
+  type ILogger,
+  type ILogLevel,
+  type PowerSyncConnectionOptions,
+  type StreamingSyncImplementation,
+  type StreamingSyncImplementationListener,
+  type SyncStatusOptions
 } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import * as Comlink from 'comlink';
@@ -75,7 +75,7 @@ export type WrappedSyncPort = {
   clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
   db?: DBAdapter;
   currentSubscriptions: SubscribedStream[];
-  closeListeners: (() => void)[];
+  closeListeners: (() => void | Promise<void>)[];
 };
 
 /**
@@ -334,12 +334,15 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     }
 
     for (const closeListener of trackedPort.closeListeners) {
-      closeListener();
+      await closeListener();
     }
 
     if (this.dbAdapter && this.dbAdapter == trackedPort.db) {
       // Unconditionally close the connection because the database it's writing to has just been closed.
-      await this.connectionManager.disconnect();
+      // 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));
 
       // Clearing the adapter will result in a new one being opened in connect
       this.dbAdapter = null;
@@ -482,9 +485,9 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
           // that and ensure pending requests are aborted when the tab is closed.
           remoteCanCloseUnexpectedly: true
         });
-        lastClient.closeListeners.push(() => {
+        lastClient.closeListeners.push(async () => {
           this.logger.info('Aborting open connection because associated tab closed.');
-          wrapped.close();
+          await wrapped.close().catch((ex) => this.logger.warn('error closing database connection', ex));
           wrapped.markRemoteClosed();
         });