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

package/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.ts

@@ -60,6 +60,14 @@ export class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLO
     this.notifyRemoteClosed!.abort();
   }
 
+  markHold(): Promise<string> {
+    return this.baseConnection.markHold();
+  }
+
+  releaseHold(holdId: string): Promise<void> {
+    return this.baseConnection.releaseHold(holdId);
+  }
+
   private withRemote<T>(workerPromise: () => Promise<T>): Promise<T> {
     const controller = this.notifyRemoteClosed;
     if (controller) {

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

@@ -26,6 +26,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>;
 };
 
 /**
@@ -148,6 +156,9 @@ export class WASqliteConnection
    */
   protected connectionId: number;
 
+  protected _holdCounter: number;
+  protected _holdId: string | null;
+
   constructor(protected options: ResolvedWASQLiteOpenFactoryOptions) {
     super();
     this.updatedTables = new Set();
@@ -156,6 +167,16 @@ export class WASqliteConnection
     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;
   }
 
   protected get sqliteAPI() {
@@ -172,6 +193,22 @@ export class WASqliteConnection
     return this._dbP;
   }
 
+  async markHold(): Promise<string> {
+    const previousHoldId = this._holdId;
+    this._holdId = `${++this._holdCounter}`;
+    if (previousHoldId) {
+      await this.iterateAsyncListeners(async (cb) => cb.holdOverwritten?.(previousHoldId));
+    }
+    return this._holdId;
+  }
+
+  async releaseHold(holdId: string): Promise<void> {
+    if (holdId != this._holdId) {
+      throw new Error(`Invalid hold state, expected ${this._holdId} but got ${holdId}`);
+    }
+    this._holdId = null;
+  }
+
   protected async openDB() {
     this._dbP = await this.sqliteAPI.open_v2(this.options.dbFilename);
     return this._dbP;

package/src/worker/db/SharedWASQLiteConnection.ts

@@ -0,0 +1,127 @@
+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 class SharedWASQLiteConnection implements AsyncDatabaseConnection {
+  protected isClosing: boolean;
+  // Keeps track if this current hold if the shared connection has a hold
+  protected activeHoldId: string | null;
+
+  constructor(protected options: SharedWASQLiteConnectionOptions) {
+    // Add this client ID to the set of known clients
+    this.clientIds.add(options.clientId);
+    this.isClosing = false;
+    this.activeHoldId = null;
+  }
+
+  async init(): Promise<void> {
+    // No-op since the connection is already initialized when it was created
+  }
+
+  async markHold(): Promise<string> {
+    this.activeHoldId = await this.connection.markHold();
+    return this.activeHoldId;
+  }
+
+  async releaseHold(id: string): Promise<void> {
+    try {
+      await this.connection.releaseHold(id);
+    } finally {
+      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;
+  }
+
+  /**
+   * Handles closing of a shared connection.
+   * The connection is only closed if there are no active clients using it.
+   */
+  async close(): Promise<void> {
+    // 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) {
+      /**
+       * 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(() => {});
+    }
+
+    if (clientIds.size == 0) {
+      logger.debug(`Closing connection to ${this.options}.`);
+      const connection = this.connection;
+      dbMap.delete(dbFilename);
+      await connection.close();
+    }
+    logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
+    return;
+  }
+
+  protected async withClosing<T>(action: () => Promise<T>) {
+    if (this.isClosing) {
+      throw new Error('Connection is closing');
+    }
+    return action();
+  }
+
+  async execute(sql: string, params?: any[]): Promise<ProxiedQueryResult> {
+    return this.withClosing(() => this.connection.execute(sql, params));
+  }
+
+  async executeRaw(sql: string, params?: any[]): Promise<any[][]> {
+    return this.withClosing(() => this.connection.executeRaw(sql, params));
+  }
+
+  executeBatch(sql: string, params?: any[] | undefined): Promise<ProxiedQueryResult> {
+    return this.withClosing(() => this.connection.executeBatch(sql, params));
+  }
+
+  registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void> {
+    return this.connection.registerOnTableChange(callback);
+  }
+
+  getConfig(): Promise<ResolvedWebSQLOpenOptions> {
+    return this.connection.getConfig();
+  }
+}

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

@@ -6,47 +6,20 @@ import '@journeyapps/wa-sqlite';
 import { createBaseLogger, createLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { AsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection';
-import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
-import {
-  ResolvedWASQLiteOpenFactoryOptions,
-  WorkerDBOpenerOptions
-} from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory';
+import { WorkerDBOpenerOptions } from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory';
 import { getNavigatorLocks } from '../../shared/navigator';
+import { SharedDBWorkerConnection, SharedWASQLiteConnection } from './SharedWASQLiteConnection';
+import { WorkerWASQLiteConnection, proxyWASQLiteConnection } from './WorkerWASQLiteConnection';
 
 const baseLogger = createBaseLogger();
 baseLogger.useDefaults();
 const logger = createLogger('db-worker');
 
-/**
- * Keeps track of open DB connections and the clients which
- * are using it.
- */
-type SharedDBWorkerConnection = {
-  clientIds: Set<number>;
-  db: AsyncDatabaseConnection;
-};
-
 const DBMap = new Map<string, SharedDBWorkerConnection>();
 const OPEN_DB_LOCK = 'open-wasqlite-db';
 
 let nextClientId = 1;
 
-const openWorkerConnection = async (options: ResolvedWASQLiteOpenFactoryOptions): Promise<AsyncDatabaseConnection> => {
-  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: string, params?: any[]) => connection.execute(sql, params)),
-    executeRaw: Comlink.proxy(async (sql: string, params?: any[]) => connection.executeRaw(sql, params)),
-    executeBatch: Comlink.proxy(async (sql: string, params?: any[]) => 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: WorkerDBOpenerOptions): Promise<AsyncDatabaseConnection> => {
   // Prevent multiple simultaneous opens from causing race conditions
   return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
@@ -57,38 +30,36 @@ const openDBShared = async (options: WorkerDBOpenerOptions): Promise<AsyncDataba
 
     if (!DBMap.has(dbFilename)) {
       const clientIds = new Set<number>();
-      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;
-      })
-    };
+    // Associates this clientId with the shared connection entry
+    const sharedConnection = new SharedWASQLiteConnection({
+      dbMap: DBMap,
+      dbFilename,
+      clientId,
+      logger
+    });
 
-    return Comlink.proxy(wrappedConnection);
+    return proxyWASQLiteConnection(sharedConnection);
   });
 };
 

package/src/worker/db/WorkerWASQLiteConnection.ts

@@ -0,0 +1,29 @@
+import * as Comlink from 'comlink';
+import { AsyncDatabaseConnection, OnTableChangeCallback } from '../../db/adapters/AsyncDatabaseConnection';
+import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+
+/**
+ * Fully proxies a WASQLiteConnection to be used as an AsyncDatabaseConnection.
+ */
+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
+    return Comlink.proxy(await super.registerOnTableChange(callback));
+  }
+}