@powersync/web 0.0.0-dev-20251129133952 → 0.0.0-dev-20251203144301

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

@@ -1,14 +1,16 @@
+import { BaseObserver } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { ConnectionClosedError } from './AsyncDatabaseConnection';
 /**
  * Wraps a provided instance of {@link AsyncDatabaseConnection}, providing necessary proxy
  * functions for worker listeners.
  */
-export class WorkerWrappedAsyncDatabaseConnection {
+export class WorkerWrappedAsyncDatabaseConnection extends BaseObserver {
     options;
     lockAbortController = new AbortController();
     notifyRemoteClosed;
     constructor(options) {
+        super();
         this.options = options;
         if (options.remoteCanCloseUnexpectedly) {
             this.notifyRemoteClosed = new AbortController();
@@ -41,14 +43,17 @@ export class WorkerWrappedAsyncDatabaseConnection {
     isAutoCommit() {
         return this.withRemote(() => this.baseConnection.isAutoCommit());
     }
-    withRemote(workerPromise) {
+    withRemote(workerPromise, fireActionOnAbort = false) {
         const controller = this.notifyRemoteClosed;
         if (controller) {
             return new Promise((resolve, reject) => {
                 if (controller.signal.aborted) {
                     reject(new ConnectionClosedError('Called operation on closed remote'));
-                    // Don't run the operation if we're going to reject
-                    return;
+                    if (!fireActionOnAbort) {
+                        // Don't run the operation if we're going to reject
+                        // We might want to fire-and-forget the operation in some cases (like a close operation)
+                        return;
+                    }
                 }
                 function handleAbort() {
                     reject(new ConnectionClosedError('Remote peer closed with request in flight'));
@@ -119,11 +124,13 @@ export class WorkerWrappedAsyncDatabaseConnection {
         // Abort any pending lock requests.
         this.lockAbortController.abort();
         try {
-            await this.withRemote(() => this.baseConnection.close());
+            // fire and forget the close operation
+            await this.withRemote(() => this.baseConnection.close(), true);
         }
         finally {
             this.options.remote[Comlink.releaseProxy]();
             this.options.onClose?.();
+            this.iterateListeners((l) => l.closing?.());
         }
     }
     execute(sql, params) {

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

@@ -1,6 +1,7 @@
 import * as SQLite from '@journeyapps/wa-sqlite';
 import { BaseObserver } from '@powersync/common';
 import { Mutex } from 'async-mutex';
+import { OPFSCoopSyncVFS } from '../../../worker/db/opfs';
 /**
  * List of currently tested virtual filesystems
  */
@@ -80,11 +81,10 @@ export const DEFAULT_MODULE_FACTORIES = {
         else {
             module = await SyncWASQLiteModuleFactory();
         }
-        // @ts-expect-error The types for this static method are missing upstream
-        const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
+        const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
         return {
             module,
-            vfs: await OPFSCoopSyncVFS.create(options.dbFileName, module)
+            vfs: vfs
         };
     }
 };

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.d.ts

@@ -1,4 +1,4 @@
-import { type ILogLevel, DBAdapter } from '@powersync/common';
+import { DBAdapter, type ILogLevel } from '@powersync/common';
 import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
 import { AsyncDatabaseConnection } from '../AsyncDatabaseConnection';
 import { ResolvedWebSQLOpenOptions, WebSQLOpenFactoryOptions } from '../web-sql-flags';

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

@@ -2,9 +2,9 @@ import * as Comlink from 'comlink';
 import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database';
 import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
 import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
-import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags';
 import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
-import { WASqliteConnection, WASQLiteVFS } from './WASQLiteConnection';
+import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags';
+import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection';
 /**
  * Opens a SQLite connection using WA-SQLite.
  */

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.d.ts

@@ -53,9 +53,5 @@ export declare class SharedWebStreamingSyncImplementation extends WebStreamingSy
     dispose(): Promise<void>;
     waitForReady(): Promise<void>;
     updateSubscriptions(subscriptions: SubscribedStream[]): void;
-    /**
-     * Used in tests to force a connection states
-     */
-    private _testUpdateStatus;
 }
 export {};

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

@@ -150,6 +150,8 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
          *    - The shared worker can then request the same lock. The client has been closed if the shared worker can acquire the lock.
          *    - Once the shared worker knows the client's lock, we can guarentee that the shared worker will detect if the client has been closed.
          *    - This makes the client safe for the shared worker to use.
+         *    - The client is only added to the SharedSyncImplementation once the lock has been registered.
+         *      This ensures we don't ever keep track of dead clients (tabs that closed before the lock was registered).
          *    - The client side lock is held until the client is disposed.
          *    - We resolve the top-level promise after the lock has been registered with the shared worker.
          * - The client sends the params to the shared worker after locks have been registered.
@@ -205,7 +207,6 @@ 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) => {
@@ -221,6 +222,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
             };
             this.messagePort.postMessage(closeMessagePayload);
         });
+        await super.dispose();
         this.abortOnClose.abort();
         // Release the proxy
         this.syncManager[Comlink.releaseProxy]();
@@ -232,11 +234,4 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
     updateSubscriptions(subscriptions) {
         this.syncManager.updateSubscriptions(subscriptions);
     }
-    /**
-     * Used in tests to force a connection states
-     */
-    async _testUpdateStatus(status) {
-        await this.isInitialized;
-        return this.syncManager._testUpdateAllStatuses(status.toJSON());
-    }
 }

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

@@ -14,7 +14,6 @@ const DBMap = new Map();
 const OPEN_DB_LOCK = 'open-wasqlite-db';
 let nextClientId = 1;
 const openDBShared = async (options) => {
-    // Prevent multiple simultaneous opens from causing race conditions
     return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
         const clientId = nextClientId++;
         const { dbFilename, logLevel } = options;

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

@@ -0,0 +1,96 @@
+import { FacadeVFS } from '@journeyapps/wa-sqlite/src/FacadeVFS.js';
+export declare class OPFSCoopSyncVFS extends FacadeVFS {
+    #private;
+    /** @type {Map<number, File>} */ mapIdToFile: Map<any, any>;
+    lastError: null;
+    log: null;
+    /** @type {Map<string, PersistentFile>} */ persistentFiles: Map<any, any>;
+    /** @type {Map<string, FileSystemSyncAccessHandle>} */ boundAccessHandles: Map<any, any>;
+    /** @type {Set<FileSystemSyncAccessHandle>} */ unboundAccessHandles: Set<unknown>;
+    /** @type {Set<string>} */ accessiblePaths: Set<unknown>;
+    releaser: null;
+    static create(name: any, module: any): Promise<OPFSCoopSyncVFS>;
+    constructor(name: any, module: any);
+    /**
+     * @param {string?} zName
+     * @param {number} fileId
+     * @param {number} flags
+     * @param {DataView} pOutFlags
+     * @returns {number}
+     */
+    jOpen(zName: any, fileId: any, flags: any, pOutFlags: any): 0 | 5 | 14;
+    /**
+     * @param {string} zName
+     * @param {number} syncDir
+     * @returns {number}
+     */
+    jDelete(zName: any, syncDir: any): 0 | 2570;
+    /**
+     * @param {string} zName
+     * @param {number} flags
+     * @param {DataView} pResOut
+     * @returns {number}
+     */
+    jAccess(zName: any, flags: any, pResOut: any): 0 | 3338;
+    /**
+     * @param {number} fileId
+     * @returns {number}
+     */
+    jClose(fileId: any): 0 | 4106;
+    /**
+     * @param {number} fileId
+     * @param {Uint8Array} pData
+     * @param {number} iOffset
+     * @returns {number}
+     */
+    jRead(fileId: any, pData: any, iOffset: any): 0 | 522 | 266;
+    /**
+     * @param {number} fileId
+     * @param {Uint8Array} pData
+     * @param {number} iOffset
+     * @returns {number}
+     */
+    jWrite(fileId: any, pData: any, iOffset: any): 0 | 778;
+    /**
+     * @param {number} fileId
+     * @param {number} iSize
+     * @returns {number}
+     */
+    jTruncate(fileId: any, iSize: any): 0 | 1546;
+    /**
+     * @param {number} fileId
+     * @param {number} flags
+     * @returns {number}
+     */
+    jSync(fileId: any, flags: any): 0 | 1034;
+    /**
+     * @param {number} fileId
+     * @param {DataView} pSize64
+     * @returns {number}
+     */
+    jFileSize(fileId: any, pSize64: any): 0 | 1802;
+    /**
+     * @param {number} fileId
+     * @param {number} lockType
+     * @returns {number}
+     */
+    jLock(fileId: any, lockType: any): 0 | 5;
+    /**
+     * @param {number} fileId
+     * @param {number} lockType
+     * @returns {number}
+     */
+    jUnlock(fileId: any, lockType: any): 0;
+    /**
+     * @param {number} fileId
+     * @param {number} op
+     * @param {DataView} pArg
+     * @returns {number|Promise<number>}
+     */
+    jFileControl(fileId: any, op: any, pArg: any): 10 | 12;
+    /**
+     * @param {Uint8Array} zBuf
+     * @returns
+     */
+    jGetLastError(zBuf: any): 0;
+}