@powersync/web 1.24.0 → 1.25.0

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powersync/web",
-    "version": "1.24.0",
+    "version": "1.25.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",
@@ -61,7 +61,7 @@
     "license": "Apache-2.0",
     "peerDependencies": {
         "@journeyapps/wa-sqlite": "^1.2.6",
-        "@powersync/common": "workspace:^1.34.0"
+        "@powersync/common": "workspace:^1.35.0"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",

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

@@ -1,6 +1,7 @@
 import { BatchedUpdateNotification, QueryResult } from '@powersync/common';
 import { ResolvedWebSQLOpenOptions } from './web-sql-flags';
 /**
+ * @internal
  * Proxied query result does not contain a function for accessing row values
  */
 export type ProxiedQueryResult = Omit<QueryResult, 'rows'> & {
@@ -9,6 +10,9 @@ export type ProxiedQueryResult = Omit<QueryResult, 'rows'> & {
         length: number;
     };
 };
+/**
+ * @internal
+ */
 export type OnTableChangeCallback = (event: BatchedUpdateNotification) => void;
 /**
  * @internal
@@ -24,4 +28,7 @@ export interface AsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOption
     registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void>;
     getConfig(): Promise<Config>;
 }
+/**
+ * @internal
+ */
 export type OpenAsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> = (config: Config) => AsyncDatabaseConnection;

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

@@ -29,6 +29,9 @@ export declare class LockedAsyncDatabaseAdapter extends BaseObserver<LockedAsync
     private _db;
     protected _disposeTableChangeListener: (() => void) | null;
     private _config;
+    protected pendingAbortControllers: Set<AbortController>;
+    closing: boolean;
+    closed: boolean;
     constructor(options: LockedAsyncDatabaseAdapterOptions);
     protected get baseDB(): AsyncDatabaseConnection<ResolvedWebSQLOpenOptions>;
     get name(): string;
@@ -63,7 +66,9 @@ export declare class LockedAsyncDatabaseAdapter extends BaseObserver<LockedAsync
     get<T>(sql: string, parameters?: any[] | undefined): Promise<T>;
     readLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions | undefined): Promise<T>;
     writeLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions | undefined): Promise<T>;
-    protected acquireLock(callback: () => Promise<any>): Promise<any>;
+    protected acquireLock(callback: () => Promise<any>, options?: {
+        timeoutMs?: number;
+    }): Promise<any>;
     readTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions | undefined): Promise<T>;
     writeTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions | undefined): Promise<T>;
     private generateDBHelpers;

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

@@ -16,11 +16,17 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     _db = null;
     _disposeTableChangeListener = null;
     _config = null;
+    pendingAbortControllers;
+    closing;
+    closed;
     constructor(options) {
         super();
         this.options = options;
         this._dbIdentifier = options.name;
         this.logger = options.logger ?? createLogger(`LockedAsyncDatabaseAdapter - ${this._dbIdentifier}`);
+        this.pendingAbortControllers = new Set();
+        this.closed = false;
+        this.closing = false;
         // Set the name if provided. We can query for the name if not available yet
         this.debugMode = options.debugMode ?? false;
         if (this.debugMode) {
@@ -110,8 +116,11 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
      * tabs are still using it.
      */
     async close() {
+        this.closing = true;
         this._disposeTableChangeListener?.();
+        this.pendingAbortControllers.forEach((controller) => controller.abort('Closed'));
         await this.baseDB?.close?.();
+        this.closed = true;
     }
     async getAll(sql, parameters) {
         await this.waitForInitialized();
@@ -127,14 +136,37 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     }
     async readLock(fn, options) {
         await this.waitForInitialized();
-        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })));
+        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })), {
+            timeoutMs: options?.timeoutMs
+        });
     }
     async writeLock(fn, options) {
         await this.waitForInitialized();
-        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })));
+        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })), {
+            timeoutMs: options?.timeoutMs
+        });
     }
-    acquireLock(callback) {
-        return getNavigatorLocks().request(`db-lock-${this._dbIdentifier}`, callback);
+    async acquireLock(callback, options) {
+        await this.waitForInitialized();
+        if (this.closing) {
+            throw new Error(`Cannot acquire lock, the database is closing`);
+        }
+        const abortController = new AbortController();
+        this.pendingAbortControllers.add(abortController);
+        const { timeoutMs } = options ?? {};
+        const timoutId = timeoutMs
+            ? setTimeout(() => {
+                abortController.abort(`Timeout after ${timeoutMs}ms`);
+                this.pendingAbortControllers.delete(abortController);
+            }, timeoutMs)
+            : null;
+        return getNavigatorLocks().request(`db-lock-${this._dbIdentifier}`, { signal: abortController.signal }, () => {
+            this.pendingAbortControllers.delete(abortController);
+            if (timoutId) {
+                clearTimeout(timoutId);
+            }
+            return callback();
+        });
     }
     async readTransaction(fn, options) {
         return this.readLock(this.wrapTransaction(fn));

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.js

@@ -168,6 +168,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
     }
     async dispose() {
         await this.waitForReady();
+        await super.dispose();
         await new Promise((resolve) => {
             // Listen for the close acknowledgment from the worker
             this.messagePort.addEventListener('message', (event) => {

package/lib/src/index.d.ts

@@ -1,4 +1,5 @@
 export * from '@powersync/common';
+export * from './db/adapters/AsyncDatabaseConnection';
 export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory';
 export * from './db/adapters/AbstractWebSQLOpenFactory';
 export * from './db/adapters/wa-sqlite/WASQLiteConnection';

package/lib/src/index.js

@@ -1,4 +1,5 @@
 export * from '@powersync/common';
+export * from './db/adapters/AsyncDatabaseConnection';
 export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory';
 export * from './db/adapters/AbstractWebSQLOpenFactory';
 export * from './db/adapters/wa-sqlite/WASQLiteConnection';

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

@@ -354,8 +354,7 @@ export class SharedSyncImplementation extends BaseObserver {
      */
     async _testUpdateAllStatuses(status) {
         if (!this.connectionManager.syncStreamImplementation) {
-            // This is just for testing purposes
-            this.connectionManager.syncStreamImplementation = this.generateStreamingImplementation();
+            throw new Error('Cannot update status without a sync stream implementation');
         }
         // Only assigning, don't call listeners for this test
         this.connectionManager.syncStreamImplementation.syncStatus = new SyncStatus(status);