@powersync/web 1.28.1 → 1.29.0

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powersync/web",
-    "version": "1.28.1",
+    "version": "1.29.0",
     "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.41.1"
+        "@powersync/common": "workspace:^1.43.0"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",

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

@@ -22,6 +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/LockedAsyncDatabaseAdapter.d.ts

@@ -1,4 +1,4 @@
-import { type ILogger, BaseObserver, DBAdapterListener, DBLockOptions, LockContext, QueryResult, Transaction } from '@powersync/common';
+import { BaseObserver, DBAdapterListener, DBLockOptions, LockContext, QueryResult, Transaction, type ILogger } from '@powersync/common';
 import { AsyncDatabaseConnection } from './AsyncDatabaseConnection';
 import { SharedConnectionWorker, WebDBAdapter } from './WebDBAdapter';
 import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
@@ -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) {
@@ -160,12 +167,20 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
                 this.pendingAbortControllers.delete(abortController);
             }, timeoutMs)
             : null;
-        return getNavigatorLocks().request(`db-lock-${this._dbIdentifier}`, { signal: abortController.signal }, () => {
+        return getNavigatorLocks().request(`db-lock-${this._dbIdentifier}`, { signal: abortController.signal }, async () => {
             this.pendingAbortControllers.delete(abortController);
             if (timoutId) {
                 clearTimeout(timoutId);
             }
-            return callback();
+            const holdId = this.requiresHolds ? await this.baseDB.markHold() : null;
+            try {
+                return await callback();
+            }
+            finally {
+                if (holdId) {
+                    await this.baseDB.releaseHold(holdId);
+                }
+            }
         });
     }
     async readTransaction(fn, options) {

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

@@ -34,6 +34,9 @@ export declare class WorkerWrappedAsyncDatabaseConnection<Config extends Resolve
      * throw on all outstanding promises and forbid new calls.
      */
     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

@@ -31,12 +31,23 @@ export class WorkerWrappedAsyncDatabaseConnection {
         // set.
         this.notifyRemoteClosed.abort();
     }
+    markHold() {
+        return this.withRemote(() => this.baseConnection.markHold());
+    }
+    releaseHold(holdId) {
+        return this.withRemote(() => this.baseConnection.releaseHold(holdId));
+    }
+    isAutoCommit() {
+        return this.withRemote(() => this.baseConnection.isAutoCommit());
+    }
     withRemote(workerPromise) {
         const controller = this.notifyRemoteClosed;
         if (controller) {
             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

@@ -23,6 +23,14 @@ export type WASQLiteBroadCastTableUpdateEvent = {
  */
 export type WASQLiteConnectionListener = {
     tablesUpdated: (event: BatchedUpdateNotification) => void;
+    /**
+     * Triggered when an active hold is overwritten by a new hold.
+     * This is most likely to happen when a shared connection has been closed
+     * without releasing the hold.
+     * This listener can be used to cleanup any resources associated with the previous hold.
+     * @param holdId - The id of the hold that has been overwritten.
+     */
+    holdOverwritten: (holdId: string) => Promise<void>;
 };
 /**
  * @internal
@@ -94,9 +102,23 @@ export declare class WASqliteConnection extends BaseObserver<WASQLiteConnectionL
      * notification loops.
      */
     protected connectionId: number;
+    protected _holdCounter: number;
+    protected _holdId: string | null;
     constructor(options: ResolvedWASQLiteOpenFactoryOptions);
+    /**
+     * Gets the id for the current hold.
+     * This can be used to check for invalid states.
+     */
+    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>;
     protected executeEncryptionPragma(): Promise<void>;
     protected openSQLiteAPI(): Promise<SQLiteAPI>;

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

@@ -107,6 +107,8 @@ export class WASqliteConnection extends BaseObserver {
      * notification loops.
      */
     connectionId;
+    _holdCounter;
+    _holdId;
     constructor(options) {
         super();
         this.options = options;
@@ -116,6 +118,15 @@ export class WASqliteConnection extends BaseObserver {
         this.connectionId = new Date().valueOf() + Math.random();
         this.statementMutex = new Mutex();
         this._moduleFactory = DEFAULT_MODULE_FACTORIES[this.options.vfs];
+        this._holdCounter = 0;
+        this._holdId = null;
+    }
+    /**
+     * Gets the id for the current hold.
+     * This can be used to check for invalid states.
+     */
+    get currentHoldId() {
+        return this._holdId;
     }
     get sqliteAPI() {
         if (!this._sqliteAPI) {
@@ -129,6 +140,27 @@ 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}`;
+        if (previousHoldId) {
+            await this.iterateAsyncListeners(async (cb) => cb.holdOverwritten?.(previousHoldId));
+        }
+        return this._holdId;
+    }
+    async releaseHold(holdId) {
+        if (holdId != this._holdId) {
+            throw new Error(`Invalid hold state, expected ${this._holdId} but got ${holdId}`);
+        }
+        this._holdId = null;
+    }
     async openDB() {
         this._dbP = await this.sqliteAPI.open_v2(this.options.dbFilename);
         return this._dbP;

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

@@ -0,0 +1,42 @@
+import { ILogger } from '@powersync/common';
+import { AsyncDatabaseConnection, OnTableChangeCallback, ProxiedQueryResult } from '../../db/adapters/AsyncDatabaseConnection';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
+/**
+ * Keeps track of open DB connections and the clients which
+ * are using it.
+ */
+export type SharedDBWorkerConnection = {
+    clientIds: Set<number>;
+    db: AsyncDatabaseConnection;
+};
+export type SharedWASQLiteConnectionOptions = {
+    dbMap: Map<string, SharedDBWorkerConnection>;
+    dbFilename: string;
+    clientId: number;
+    logger: ILogger;
+};
+export declare class SharedWASQLiteConnection implements AsyncDatabaseConnection {
+    protected options: SharedWASQLiteConnectionOptions;
+    protected isClosing: boolean;
+    protected activeHoldId: string | null;
+    constructor(options: SharedWASQLiteConnectionOptions);
+    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.
+     */
+    close(): Promise<void>;
+    protected withClosing<T>(action: () => Promise<T>): Promise<T>;
+    execute(sql: string, params?: any[]): Promise<ProxiedQueryResult>;
+    executeRaw(sql: string, params?: any[]): Promise<any[][]>;
+    executeBatch(sql: string, params?: any[] | undefined): Promise<ProxiedQueryResult>;
+    registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void>;
+    getConfig(): Promise<ResolvedWebSQLOpenOptions>;
+}

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

@@ -0,0 +1,90 @@
+export class SharedWASQLiteConnection {
+    options;
+    isClosing;
+    // Keeps track if this current hold if the shared connection has a hold
+    activeHoldId;
+    constructor(options) {
+        this.options = options;
+        // Add this client ID to the set of known clients
+        this.clientIds.add(options.clientId);
+        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
+    }
+    async markHold() {
+        this.activeHoldId = await this.connection.markHold();
+        return this.activeHoldId;
+    }
+    async releaseHold(id) {
+        try {
+            await this.connection.releaseHold(id);
+        }
+        finally {
+            this.activeHoldId = null;
+        }
+    }
+    async isAutoCommit() {
+        return this.connection.isAutoCommit();
+    }
+    /**
+     * Handles closing of a shared connection.
+     * The connection is only closed if there are no active clients using it.
+     */
+    async close() {
+        // This prevents further statements on this connection from being executed
+        this.isClosing = true;
+        const { clientIds, logger } = this;
+        const { clientId, dbFilename, dbMap } = this.options;
+        logger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
+        clientIds.delete(clientId);
+        if (this.activeHoldId) {
+            // 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}.`);
+            const connection = this.connection;
+            dbMap.delete(dbFilename);
+            await connection.close();
+            return;
+        }
+        logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
+        return;
+    }
+    async withClosing(action) {
+        if (this.isClosing) {
+            throw new Error('Connection is closing');
+        }
+        return action();
+    }
+    async execute(sql, params) {
+        return this.withClosing(() => this.connection.execute(sql, params));
+    }
+    async executeRaw(sql, params) {
+        return this.withClosing(() => this.connection.executeRaw(sql, params));
+    }
+    executeBatch(sql, params) {
+        return this.withClosing(() => this.connection.executeBatch(sql, params));
+    }
+    registerOnTableChange(callback) {
+        return this.connection.registerOnTableChange(callback);
+    }
+    getConfig() {
+        return this.connection.getConfig();
+    }
+}

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

@@ -4,29 +4,15 @@
 import '@journeyapps/wa-sqlite';
 import { createBaseLogger, createLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
 import { getNavigatorLocks } from '../../shared/navigator';
+import { SharedWASQLiteConnection } from './SharedWASQLiteConnection';
+import { WorkerWASQLiteConnection } from './WorkerWASQLiteConnection';
 const baseLogger = createBaseLogger();
 baseLogger.useDefaults();
 const logger = createLogger('db-worker');
 const DBMap = new Map();
 const OPEN_DB_LOCK = 'open-wasqlite-db';
 let nextClientId = 1;
-const openWorkerConnection = async (options) => {
-    const connection = new WASqliteConnection(options);
-    return {
-        init: Comlink.proxy(() => connection.init()),
-        getConfig: Comlink.proxy(() => connection.getConfig()),
-        close: Comlink.proxy(() => connection.close()),
-        execute: Comlink.proxy(async (sql, params) => connection.execute(sql, params)),
-        executeRaw: Comlink.proxy(async (sql, params) => connection.executeRaw(sql, params)),
-        executeBatch: Comlink.proxy(async (sql, params) => connection.executeBatch(sql, params)),
-        registerOnTableChange: Comlink.proxy(async (callback) => {
-            // Proxy the callback remove function
-            return Comlink.proxy(await connection.registerOnTableChange(callback));
-        })
-    };
-};
 const openDBShared = async (options) => {
     // Prevent multiple simultaneous opens from causing race conditions
     return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
@@ -35,35 +21,32 @@ const openDBShared = async (options) => {
         logger.setLevel(logLevel);
         if (!DBMap.has(dbFilename)) {
             const clientIds = new Set();
-            const connection = await openWorkerConnection(options);
+            // This format returns proxy objects for function callbacks
+            const connection = new WorkerWASQLiteConnection(options);
             await connection.init();
+            connection.registerListener({
+                holdOverwritten: async () => {
+                    /**
+                     * The previous hold has been overwritten, without being released.
+                     * we need to cleanup any resources associated with it.
+                     * We can perform a rollback to release any potential transactions that were started.
+                     */
+                    await connection.execute('ROLLBACK').catch(() => { });
+                }
+            });
             DBMap.set(dbFilename, {
                 clientIds,
                 db: connection
             });
         }
-        const dbEntry = DBMap.get(dbFilename);
-        dbEntry.clientIds.add(clientId);
-        const { db } = dbEntry;
-        const wrappedConnection = {
-            ...db,
-            init: Comlink.proxy(async () => {
-                // the init has been done automatically
-            }),
-            close: Comlink.proxy(async () => {
-                const { clientIds } = dbEntry;
-                logger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
-                clientIds.delete(clientId);
-                if (clientIds.size == 0) {
-                    logger.debug(`Closing connection to ${dbFilename}.`);
-                    DBMap.delete(dbFilename);
-                    return db.close?.();
-                }
-                logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
-                return;
-            })
-        };
-        return Comlink.proxy(wrappedConnection);
+        // Associates this clientId with the shared connection entry
+        const sharedConnection = new SharedWASQLiteConnection({
+            dbMap: DBMap,
+            dbFilename,
+            clientId,
+            logger
+        });
+        return Comlink.proxy(sharedConnection);
     });
 };
 // Check if we're in a SharedWorker context

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

@@ -0,0 +1,9 @@
+import { OnTableChangeCallback } from '../../db/adapters/AsyncDatabaseConnection';
+import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+/**
+ * A Small proxy wrapper around the WASqliteConnection.
+ * This ensures that certain return types are properly proxied.
+ */
+export declare class WorkerWASQLiteConnection extends WASqliteConnection {
+    registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void>;
+}

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

@@ -0,0 +1,12 @@
+import * as Comlink from 'comlink';
+import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+/**
+ * A Small proxy wrapper around the WASqliteConnection.
+ * This ensures that certain return types are properly proxied.
+ */
+export class WorkerWASQLiteConnection extends WASqliteConnection {
+    async registerOnTableChange(callback) {
+        // Proxy the callback remove function
+        return Comlink.proxy(await super.registerOnTableChange(callback));
+    }
+}

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;