@powersync/web 1.28.1 → 1.29.0

package/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.ts

@@ -60,12 +60,26 @@ export class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLO
     this.notifyRemoteClosed!.abort();
   }
 
+  markHold(): Promise<string> {
+    return this.withRemote(() => this.baseConnection.markHold());
+  }
+
+  releaseHold(holdId: string): Promise<void> {
+    return this.withRemote(() => this.baseConnection.releaseHold(holdId));
+  }
+
+  isAutoCommit(): Promise<boolean> {
+    return this.withRemote(() => this.baseConnection.isAutoCommit());
+  }
+
   private withRemote<T>(workerPromise: () => Promise<T>): Promise<T> {
     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() {

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,30 @@ export class WASqliteConnection
     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(): Promise<boolean> {
+    return this.sqliteAPI.get_autocommit(this.dbP) != 0;
+  }
+
+  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,131 @@
+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;
+  }
+
+  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
+  }
+
+  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;
+    }
+  }
+
+  async isAutoCommit(): Promise<boolean> {
+    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(): 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) {
+      // 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;
+  }
+
+  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 } 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 Comlink.proxy(sharedConnection);
   });
 };
 

package/src/worker/db/WorkerWASQLiteConnection.ts

@@ -0,0 +1,14 @@
+import * as Comlink from 'comlink';
+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 class WorkerWASQLiteConnection extends WASqliteConnection {
+  async registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void> {
+    // Proxy the callback remove function
+    return Comlink.proxy(await super.registerOnTableChange(callback));
+  }
+}

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();
         });