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

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

@@ -22,8 +22,21 @@ export type OnTableChangeCallback = (event: BatchedUpdateNotification) => void;
 export interface AsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> {
     init(): Promise<void>;
     close(): Promise<void>;
+    /**
+     * Marks the connection as in-use by a certain actor.
+     * @returns A hold ID which can be used to release the hold.
+     */
     markHold(): Promise<string>;
+    /**
+     * Releases a hold on the connection.
+     * @param holdId The hold ID to release.
+     */
     releaseHold(holdId: string): Promise<void>;
+    /**
+     * Checks if the database connection is in autocommit mode.
+     * @returns true if in autocommit mode, false if in a transaction
+     */
+    isAutoCommit(): Promise<boolean>;
     execute(sql: string, params?: any[]): Promise<ProxiedQueryResult>;
     executeRaw(sql: string, params?: any[]): Promise<any[][]>;
     executeBatch(sql: string, params?: any[]): Promise<ProxiedQueryResult>;

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

@@ -36,6 +36,7 @@ export declare class WorkerWrappedAsyncDatabaseConnection<Config extends Resolve
     markRemoteClosed(): void;
     markHold(): Promise<string>;
     releaseHold(holdId: string): Promise<void>;
+    isAutoCommit(): Promise<boolean>;
     private withRemote;
     /**
      * Get a MessagePort which can be used to share the internals of this connection.

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

@@ -32,10 +32,13 @@ export class WorkerWrappedAsyncDatabaseConnection {
         this.notifyRemoteClosed.abort();
     }
     markHold() {
-        return this.baseConnection.markHold();
+        return this.withRemote(() => this.baseConnection.markHold());
     }
     releaseHold(holdId) {
-        return this.baseConnection.releaseHold(holdId);
+        return this.withRemote(() => this.baseConnection.releaseHold(holdId));
+    }
+    isAutoCommit() {
+        return this.baseConnection.isAutoCommit();
     }
     withRemote(workerPromise) {
         const controller = this.notifyRemoteClosed;
@@ -43,6 +46,8 @@ export class WorkerWrappedAsyncDatabaseConnection {
             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;
                 }
                 function handleAbort() {
                     reject(new Error('Remote peer closed with request in flight'));

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

@@ -112,6 +112,11 @@ export declare class WASqliteConnection extends BaseObserver<WASQLiteConnectionL
     get currentHoldId(): string | null;
     protected get sqliteAPI(): SQLiteAPI;
     protected get dbP(): number;
+    /**
+     * Checks if the database connection is in autocommit mode.
+     * @returns true if in autocommit mode, false if in a transaction
+     */
+    isAutoCommit(): Promise<boolean>;
     markHold(): Promise<string>;
     releaseHold(holdId: string): Promise<void>;
     protected openDB(): Promise<number>;

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

@@ -140,6 +140,13 @@ export class WASqliteConnection extends BaseObserver {
         }
         return this._dbP;
     }
+    /**
+     * Checks if the database connection is in autocommit mode.
+     * @returns true if in autocommit mode, false if in a transaction
+     */
+    async isAutoCommit() {
+        return this.sqliteAPI.get_autocommit(this.dbP) != 0;
+    }
     async markHold() {
         const previousHoldId = this._holdId;
         this._holdId = `${++this._holdCounter}`;

package/lib/src/worker/db/SharedWASQLiteConnection.d.ts

@@ -20,13 +20,14 @@ export declare class SharedWASQLiteConnection implements AsyncDatabaseConnection
     protected isClosing: boolean;
     protected activeHoldId: string | null;
     constructor(options: SharedWASQLiteConnectionOptions);
-    init(): Promise<void>;
-    markHold(): Promise<string>;
-    releaseHold(id: string): Promise<void>;
     protected get logger(): ILogger;
     protected get dbEntry(): SharedDBWorkerConnection;
     protected get connection(): AsyncDatabaseConnection<ResolvedWebSQLOpenOptions>;
     protected get clientIds(): Set<number>;
+    init(): Promise<void>;
+    markHold(): Promise<string>;
+    releaseHold(id: string): Promise<void>;
+    isAutoCommit(): Promise<boolean>;
     /**
      * Handles closing of a shared connection.
      * The connection is only closed if there are no active clients using it.

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

@@ -10,6 +10,18 @@ export class SharedWASQLiteConnection {
         this.isClosing = false;
         this.activeHoldId = null;
     }
+    get logger() {
+        return this.options.logger;
+    }
+    get dbEntry() {
+        return this.options.dbMap.get(this.options.dbFilename);
+    }
+    get connection() {
+        return this.dbEntry.db;
+    }
+    get clientIds() {
+        return this.dbEntry.clientIds;
+    }
     async init() {
         // No-op since the connection is already initialized when it was created
     }
@@ -25,17 +37,8 @@ export class SharedWASQLiteConnection {
             this.activeHoldId = null;
         }
     }
-    get logger() {
-        return this.options.logger;
-    }
-    get dbEntry() {
-        return this.options.dbMap.get(this.options.dbFilename);
-    }
-    get connection() {
-        return this.dbEntry.db;
-    }
-    get clientIds() {
-        return this.dbEntry.clientIds;
+    async isAutoCommit() {
+        return this.connection.isAutoCommit();
     }
     /**
      * Handles closing of a shared connection.
@@ -49,12 +52,9 @@ export class SharedWASQLiteConnection {
         logger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
         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) {
             logger.debug(`Closing connection to ${this.options}.`);

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

@@ -6,7 +6,7 @@ import { createBaseLogger, createLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { getNavigatorLocks } from '../../shared/navigator';
 import { SharedWASQLiteConnection } from './SharedWASQLiteConnection';
-import { WorkerWASQLiteConnection, proxyWASQLiteConnection } from './WorkerWASQLiteConnection';
+import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection';
 const baseLogger = createBaseLogger();
 baseLogger.useDefaults();
 const logger = createLogger('db-worker');
@@ -46,7 +46,7 @@ const openDBShared = async (options) => {
             clientId,
             logger
         });
-        return proxyWASQLiteConnection(sharedConnection);
+        return Comlink.proxy(sharedConnection);
     });
 };
 // Check if we're in a SharedWorker context

package/lib/src/worker/db/WorkerWASQLiteConnection.d.ts

@@ -1,9 +1,9 @@
-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 declare function proxyWASQLiteConnection(connection: AsyncDatabaseConnection): AsyncDatabaseConnection;
 export declare class WorkerWASQLiteConnection extends WASqliteConnection {
     registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void>;
 }

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

@@ -1,21 +1,9 @@
 import * as Comlink from 'comlink';
 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) {
-    return Comlink.proxy({
-        init: Comlink.proxy(() => connection.init()),
-        close: Comlink.proxy(() => connection.close()),
-        markHold: Comlink.proxy(() => connection.markHold()),
-        releaseHold: Comlink.proxy((holdId) => connection.releaseHold(holdId)),
-        execute: Comlink.proxy((sql, params) => connection.execute(sql, params)),
-        executeRaw: Comlink.proxy((sql, params) => connection.executeRaw(sql, params)),
-        executeBatch: Comlink.proxy((sql, params) => connection.executeBatch(sql, params)),
-        registerOnTableChange: Comlink.proxy((callback) => connection.registerOnTableChange(callback)),
-        getConfig: Comlink.proxy(() => connection.getConfig())
-    });
-}
 export class WorkerWASQLiteConnection extends WASqliteConnection {
     async registerOnTableChange(callback) {
         // Proxy the callback remove function

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

@@ -1,4 +1,4 @@
-import { type ILogger, type ILogLevel, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions, BaseObserver, ConnectionManager, DBAdapter, SubscribedStream, SyncStatus } from '@powersync/common';
+import { BaseObserver, ConnectionManager, DBAdapter, SubscribedStream, 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';
 import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation';
@@ -44,7 +44,7 @@ export type WrappedSyncPort = {
     clientProvider: Comlink.Remote<AbstractSharedSyncClientProvider>;
     db?: DBAdapter;
     currentSubscriptions: SubscribedStream[];
-    closeListeners: (() => void)[];
+    closeListeners: (() => void | Promise<void>)[];
 };
 /**
  * @internal

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

@@ -228,11 +228,14 @@ export class SharedSyncImplementation extends BaseObserver {
             return () => { };
         }
         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;
             if (shouldReconnect) {
@@ -361,9 +364,9 @@ export class SharedSyncImplementation extends BaseObserver {
                     // 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();
                 });
                 return wrapped;