@powersync/web 0.0.0-dev-20251119150914 → 0.0.0-dev-20251126195153

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powersync/web",
-    "version": "1.28.2",
+    "version": "1.29.1",
     "description": "PowerSync web SDK. Sync Postgres, MongoDB or MySQL with SQLite in your web app",
     "main": "lib/src/index.js",
     "types": "lib/src/index.d.ts",
@@ -62,7 +62,7 @@
     "license": "Apache-2.0",
     "peerDependencies": {
         "@journeyapps/wa-sqlite": "^1.3.2",
-        "@powersync/common": "workspace:^1.42.0"
+        "@powersync/common": "workspace:^1.43.1"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",

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

@@ -32,6 +32,11 @@ export interface AsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOption
      * @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/LockedAsyncDatabaseAdapter.d.ts

@@ -30,6 +30,7 @@ export declare class LockedAsyncDatabaseAdapter extends BaseObserver<LockedAsync
     protected _disposeTableChangeListener: (() => void) | null;
     private _config;
     protected pendingAbortControllers: Set<AbortController>;
+    protected requiresHolds: boolean | null;
     closing: boolean;
     closed: boolean;
     constructor(options: LockedAsyncDatabaseAdapterOptions);

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

@@ -1,6 +1,7 @@
 import { BaseObserver, createLogger } from '@powersync/common';
 import { getNavigatorLocks } from '../..//shared/navigator';
 import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection';
+import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection';
 /**
  * @internal
  * Wraps a {@link AsyncDatabaseConnection} and provides exclusive locking functions in
@@ -17,6 +18,7 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     _disposeTableChangeListener = null;
     _config = null;
     pendingAbortControllers;
+    requiresHolds;
     closing;
     closed;
     constructor(options) {
@@ -27,6 +29,7 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
         this.pendingAbortControllers = new Set();
         this.closed = false;
         this.closing = false;
+        this.requiresHolds = null;
         // Set the name if provided. We can query for the name if not available yet
         this.debugMode = options.debugMode ?? false;
         if (this.debugMode) {
@@ -71,6 +74,10 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
         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.
+         */
+        this.requiresHolds = this._config.vfs == WASQLiteVFS.IDBBatchAtomicVFS;
     }
     getConfiguration() {
         if (!this._config) {
@@ -165,12 +172,14 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
             if (timoutId) {
                 clearTimeout(timoutId);
             }
-            const holdId = await this.baseDB.markHold();
+            const holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
             try {
                 return await callback();
             }
             finally {
-                await this.baseDB.releaseHold(holdId);
+                if (holdId) {
+                    await this.baseDB.releaseHold(holdId);
+                }
             }
         });
     }

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.withRemote(() => 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.
@@ -58,6 +61,7 @@ export class SharedWASQLiteConnection {
             const connection = this.connection;
             dbMap.delete(dbFilename);
             await connection.close();
+            return;
         }
         logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
         return;

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();
+                    wrapped.close().catch((ex) => this.logger.warn('error closing database connection', ex));
                     wrapped.markRemoteClosed();
                 });
                 return wrapped;