@powersync/web 2.5.0 → 2.6.0

package/dist/index.react_native_web.js

@@ -139,6 +139,35 @@ var WASQLiteVFS;
 function vfsRequiresDedicatedWorkers(vfs) {
     return vfs != WASQLiteVFS.IDBBatchAtomicVFS && vfs != WASQLiteVFS.InMemoryVfs;
 }
+/**
+ * Whether the VFS can keep its files in a Storage Bucket, see {@link WebSpecificOpenOptions.storageBucket}.
+ */
+function vfsSupportsStorageBuckets(vfs) {
+    return (vfs == WASQLiteVFS.OPFSCoopSyncVFS || vfs == WASQLiteVFS.OPFSWriteAheadVFS || vfs == WASQLiteVFS.AccessHandlePoolVFS);
+}
+/**
+ * Options for an OPFS-based VFS that keep its files in the named Storage Bucket, see
+ * {@link WebSpecificOpenOptions.storageBucket}. Without a bucket name, no options: the VFS uses the root of the
+ * origin private file system.
+ *
+ * @internal
+ */
+function vfsOptionsForStorageBucket(storageBucket, storageBuckets = navigator.storageBuckets) {
+    if (storageBucket == null) {
+        return {};
+    }
+    if (storageBuckets == null) {
+        throw new Error(`The 'storageBucket' option needs the Storage Buckets API (navigator.storageBuckets), which this browser does not have. Check for it before setting the option.`);
+    }
+    return {
+        // Called by the VFS each time it needs its root directory. Opening the bucket again creates it when the
+        // browser deleted it with the rest of the site's data.
+        getRoot: () => storageBuckets.open(storageBucket).then((bucket) => bucket.getDirectory()),
+        // Keeps the locks and channels of a file apart from those of a file of the same name in another bucket.
+        // Bucket names cannot contain ':', so the names of two buckets never overlap.
+        prefix: `${storageBucket}:`
+    };
+}
 async function asyncModuleFactory(encryptionKey) {
     if (encryptionKey) {
         const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs');
@@ -162,7 +191,7 @@ async function syncModuleFactory(encryptionKey) {
 /**
  * @internal
  */
-async function loadModuleAndVfs({ vfs, filename, encryptionKey }) {
+async function loadModuleAndVfs({ vfs, filename, encryptionKey, storageBucket }) {
     let moduleFactory = syncModuleFactory;
     let resolveVfs;
     switch (vfs) {
@@ -178,19 +207,19 @@ async function loadModuleAndVfs({ vfs, filename, encryptionKey }) {
         case WASQLiteVFS.AccessHandlePoolVFS: {
             // @ts-expect-error The types for this import are missing upstream
             const { AccessHandlePoolVFS } = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');
-            resolveVfs = (module) => AccessHandlePoolVFS.create(filename, module);
+            resolveVfs = (module) => AccessHandlePoolVFS.create(filename, module, vfsOptionsForStorageBucket(storageBucket));
             break;
         }
         case WASQLiteVFS.OPFSCoopSyncVFS: {
             // @ts-expect-error The types for this import are missing upstream
             const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
-            resolveVfs = (module) => OPFSCoopSyncVFS.create(filename, module);
+            resolveVfs = (module) => OPFSCoopSyncVFS.create(filename, module, vfsOptionsForStorageBucket(storageBucket));
             break;
         }
         case WASQLiteVFS.OPFSWriteAheadVFS: {
             // @ts-expect-error The types for this import are missing upstream
             const { OPFSWriteAheadVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js');
-            resolveVfs = (module) => OPFSWriteAheadVFS.create(filename, module, {});
+            resolveVfs = (module) => OPFSWriteAheadVFS.create(filename, module, vfsOptionsForStorageBucket(storageBucket));
             break;
         }
         case WASQLiteVFS.InMemoryVfs: {
@@ -439,6 +468,11 @@ function resolveAndValidateOptions(options) {
     if (vfsRequiresDedicatedWorkers(resolved.vfs) && !resolved.useWebWorker) {
         throw new Error(`Invalid configuration: The 'useWebWorker' flag must be true when using an OPFS-based VFS (${resolved.vfs}).`);
     }
+    if (resolved.storageBucket != null) {
+        if (!vfsSupportsStorageBuckets(resolved.vfs)) {
+            throw new Error(`Invalid configuration: The 'storageBucket' option needs an OPFS-based VFS, which ${resolved.vfs} is not.`);
+        }
+    }
     return resolved;
 }
 
@@ -530,9 +564,14 @@ class RawSqliteConnection {
         const sqlite3 = Factory(module);
         sqlite3.vfs_register(vfs, true);
         /**
-         * Register the PowerSync core SQLite extension
+         * Register the PowerSync core and additional statically linked extensions
          */
-        module.ccall('powersync_init_static', 'int', []);
+        for (const name of ['powersync_init_static', ...(this.options.additionalInitializationFunctions ?? [])]) {
+            const result = module.ccall(name, 'int', []);
+            if (result !== 0) {
+                throw new Error(`SQLite extension initializer ${name} failed with code ${result}`);
+            }
+        }
         /**
          * Create the multiple cipher vfs if an encryption key is provided
          */
@@ -1421,7 +1460,7 @@ class WASQLiteOpenFactory {
         return this.openAdapter();
     }
     async openConnection() {
-        const { enableMultiTabs, useWebWorker, vfs, dbFilename, encryptionKey, temporaryStorage, cacheSizeKb, preparedStatementsCache } = this.options;
+        const { enableMultiTabs, useWebWorker, vfs, dbFilename, encryptionKey, temporaryStorage, cacheSizeKb, preparedStatementsCache, additionalInitializationFunctions, storageBucket } = this.options;
         if (!enableMultiTabs) {
             this.logger.log({ level: LogLevels.warn, message: 'Multiple tabs are not enabled in this browser' });
         }
@@ -1437,7 +1476,9 @@ class WASQLiteOpenFactory {
                 temporaryStorage,
                 cacheSizeKb,
                 // TODO: Enable prepared statement cache by default?
-                preparedStatementsCache: preparedStatementsCache ?? 0
+                preparedStatementsCache: preparedStatementsCache ?? 0,
+                additionalInitializationFunctions,
+                storageBucket
             };
         }
         if (useWebWorker) {
@@ -1653,10 +1694,8 @@ function getOsInfo(nav) {
 }
 
 class WebRemote extends AbstractRemote {
-    connector;
     constructor(connector, logger) {
         super(connector, logger);
-        this.connector = connector;
     }
     fetch({ resource, request }) {
         return fetch(resource, request);
@@ -1782,10 +1821,10 @@ class SharedSyncClientProvider extends AbstractSharedSyncClientProvider {
          * Don't return anything here, just incase something which is not
          * serializable is returned from the `uploadCrud` function.
          */
-        await this.#relay(() => this.options.uploadCrud());
+        await this.#relay(() => this.options.connector.uploadCrud());
     }
     async postCheckpointRequest(clientId, requestId) {
-        return await this.#relay(async () => (await this.options.postCheckpointRequest(clientId, requestId)) ?? null);
+        return await this.#relay(async () => (await this.options.connector.postCheckpointRequest(clientId, requestId)) ?? null);
     }
     get logger() {
         return this.options.logger;
@@ -1862,9 +1901,13 @@ class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementatio
          * - The client sends the params to the shared worker after locks have been registered.
          */
         const closeSignal = await generateTabCloseSignal(this.abortOnClose.signal);
+        const { identifier, connector } = this.options;
         // Awaiting here ensures the worker is waiting for the lock
-        await this.syncManager.addLockBasedCloseSignal(closeSignal);
-        const { identifier } = this.options;
+        await this.syncManager.initialize(closeSignal, {
+            hasFetchCredentials: !!connector.fetchCredentials,
+            hasPostCheckpointRequest: !!connector.postCheckpointRequest,
+            hasUploadCrud: !!connector.uploadCrud
+        });
         await this.syncManager.setParams({
             dbParams: this.dbAdapter.getConfiguration(),
             streamOptions: {
@@ -1887,8 +1930,26 @@ class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementatio
         return this.syncManager.disconnect();
     }
     async dispose() {
-        await this.waitForReady();
-        await new Promise((resolve) => {
+        let registeredWithWorker = true;
+        try {
+            await this.waitForReady();
+        }
+        catch {
+            // The worker rejected this client (e.g. because it connects in a mode incompatible with other tabs), so it won't
+            // acknowledge a close request either.
+            registeredWithWorker = false;
+        }
+        if (registeredWithWorker) {
+            await this.#closeWorkerClient();
+        }
+        await super.dispose();
+        this.abortOnClose.abort();
+        // Release the proxy
+        this.syncManager[Comlink.releaseProxy]();
+        this.worker.close();
+    }
+    #closeWorkerClient() {
+        return new Promise((resolve) => {
             // This will always be a message port since we use shared workers.
             const messagePort = this.worker.endpoint;
             // Listen for the close acknowledgment from the worker
@@ -1905,11 +1966,6 @@ class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplementatio
             };
             messagePort.postMessage(closeMessagePayload);
         });
-        await super.dispose();
-        this.abortOnClose.abort();
-        // Release the proxy
-        this.syncManager[Comlink.releaseProxy]();
-        this.worker.close();
     }
     async waitForReady() {
         return this.isInitialized;
@@ -2033,6 +2089,9 @@ class WebPowerSyncDatabase extends BasePowerSyncDatabase {
         // Lets development tooling in this page find the live databases.
         registerDatabase(this);
     }
+    get sdkName() {
+        return '@powersync/web';
+    }
     async _initialize() {
         if (this.database instanceof AsyncDbAdapter) {
             /**