@powersync/web 0.0.0-dev-20260120150240 → 0.0.0-dev-20260128165909

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powersync/web",
-    "version": "1.31.0",
+    "version": "1.32.0",
     "description": "PowerSync Web SDK",
     "main": "lib/src/index.js",
     "module": "lib/src/index.js",
@@ -67,7 +67,7 @@
     "license": "Apache-2.0",
     "peerDependencies": {
         "@journeyapps/wa-sqlite": "catalog:",
-        "@powersync/common": "workspace:^1.45.0"
+        "@powersync/common": "workspace:^1.46.0"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",
@@ -87,8 +87,6 @@
         "terser-webpack-plugin": "^5.3.9",
         "uuid": "catalog:",
         "vite": "catalog:",
-        "vite-plugin-top-level-await": "catalog:",
-        "vite-plugin-wasm": "catalog:",
         "vm-browserify": "^1.1.2",
         "webpack": "^5.90.1",
         "webpack-cli": "^5.1.4",

package/lib/src/attachments/IndexDBFileSystemAdapter.d.ts

@@ -0,0 +1,25 @@
+import { AttachmentData, EncodingType, LocalStorageAdapter } from '@powersync/common';
+/**
+ * IndexDBFileSystemStorageAdapter implements LocalStorageAdapter using IndexedDB.
+ * Suitable for web browsers and web-based environments.
+ */
+export declare class IndexDBFileSystemStorageAdapter implements LocalStorageAdapter {
+    private databaseName;
+    private dbPromise;
+    constructor(databaseName?: string);
+    initialize(): Promise<void>;
+    clear(): Promise<void>;
+    getLocalUri(filename: string): string;
+    private getStore;
+    saveFile(filePath: string, data: AttachmentData): Promise<number>;
+    readFile(fileUri: string, options?: {
+        encoding?: EncodingType;
+        mediaType?: string;
+    }): Promise<ArrayBuffer>;
+    deleteFile(uri: string, options?: {
+        filename?: string;
+    }): Promise<void>;
+    fileExists(fileUri: string): Promise<boolean>;
+    makeDir(path: string): Promise<void>;
+    rmDir(path: string): Promise<void>;
+}

package/lib/src/attachments/IndexDBFileSystemAdapter.js

@@ -0,0 +1,104 @@
+/**
+ * IndexDBFileSystemStorageAdapter implements LocalStorageAdapter using IndexedDB.
+ * Suitable for web browsers and web-based environments.
+ */
+export class IndexDBFileSystemStorageAdapter {
+    databaseName;
+    dbPromise;
+    constructor(databaseName = 'PowerSyncFiles') {
+        this.databaseName = databaseName;
+    }
+    async initialize() {
+        this.dbPromise = new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.databaseName, 1);
+            request.onupgradeneeded = () => {
+                request.result.createObjectStore('files');
+            };
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async clear() {
+        const db = await this.dbPromise;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction('files', 'readwrite');
+            const store = tx.objectStore('files');
+            const req = store.clear();
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+        });
+    }
+    getLocalUri(filename) {
+        return `indexeddb://${this.databaseName}/files/${filename}`;
+    }
+    async getStore(mode = 'readonly') {
+        const db = await this.dbPromise;
+        const tx = db.transaction('files', mode);
+        return tx.objectStore('files');
+    }
+    async saveFile(filePath, data) {
+        const store = await this.getStore('readwrite');
+        let dataToStore;
+        let size;
+        if (typeof data === 'string') {
+            const binaryString = atob(data);
+            const bytes = new Uint8Array(binaryString.length);
+            for (let i = 0; i < binaryString.length; i++) {
+                bytes[i] = binaryString.charCodeAt(i);
+            }
+            dataToStore = bytes.buffer;
+            size = bytes.byteLength;
+        }
+        else {
+            dataToStore = data;
+            size = dataToStore.byteLength;
+        }
+        return await new Promise((resolve, reject) => {
+            const req = store.put(dataToStore, filePath);
+            req.onsuccess = () => resolve(size);
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async readFile(fileUri, options) {
+        const store = await this.getStore();
+        return new Promise((resolve, reject) => {
+            const req = store.get(fileUri);
+            req.onsuccess = async () => {
+                if (!req.result) {
+                    reject(new Error('File not found'));
+                    return;
+                }
+                resolve(req.result);
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async deleteFile(uri, options) {
+        const store = await this.getStore('readwrite');
+        await new Promise((resolve, reject) => {
+            const req = store.delete(uri);
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async fileExists(fileUri) {
+        const store = await this.getStore();
+        return new Promise((resolve, reject) => {
+            const req = store.get(fileUri);
+            req.onsuccess = () => resolve(!!req.result);
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async makeDir(path) {
+        // No-op for IndexedDB as it does not have a directory structure
+    }
+    async rmDir(path) {
+        const store = await this.getStore('readwrite');
+        const range = IDBKeyRange.bound(path + '/', path + '/\uffff', false, false);
+        await new Promise((resolve, reject) => {
+            const req = store.delete(range);
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+        });
+    }
+}

package/lib/src/db/NavigatorTriggerClaimManager.d.ts

@@ -0,0 +1,6 @@
+import { TriggerClaimManager } from '@powersync/common';
+/**
+ * @internal
+ * @experimental
+ */
+export declare const NAVIGATOR_TRIGGER_CLAIM_MANAGER: TriggerClaimManager;

package/lib/src/db/NavigatorTriggerClaimManager.js

@@ -0,0 +1,20 @@
+import { getNavigatorLocks } from '../shared/navigator.js';
+/**
+ * @internal
+ * @experimental
+ */
+export const NAVIGATOR_TRIGGER_CLAIM_MANAGER = {
+    async obtainClaim(identifier) {
+        return new Promise((resolveReleaser) => {
+            getNavigatorLocks().request(identifier, async () => {
+                await new Promise((releaseLock) => {
+                    resolveReleaser(async () => releaseLock());
+                });
+            });
+        });
+    },
+    async checkClaim(identifier) {
+        const currentState = await getNavigatorLocks().query();
+        return currentState.held?.find((heldLock) => heldLock.name == identifier) != null;
+    }
+};

package/lib/src/db/PowerSyncDatabase.d.ts

@@ -1,4 +1,4 @@
-import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings, StreamingSyncImplementation, type BucketStorageAdapter, type PowerSyncBackendConnector, type PowerSyncCloseOptions, type RequiredAdditionalConnectionOptions } from '@powersync/common';
+import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions, PowerSyncDatabaseOptionsWithDBAdapter, PowerSyncDatabaseOptionsWithOpenFactory, PowerSyncDatabaseOptionsWithSettings, StreamingSyncImplementation, TriggerManagerConfig, type BucketStorageAdapter, type PowerSyncBackendConnector, type PowerSyncCloseOptions, type RequiredAdditionalConnectionOptions } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import { ResolvedWebSQLOpenOptions, WebSQLFlags } from './adapters/web-sql-flags.js';
 export interface WebPowerSyncFlags extends WebSQLFlags {
@@ -62,6 +62,7 @@ export declare class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     constructor(options: WebPowerSyncDatabaseOptionsWithSettings);
     constructor(options: WebPowerSyncDatabaseOptions);
     _initialize(): Promise<void>;
+    protected generateTriggerManagerConfig(): TriggerManagerConfig;
     protected openDBAdapter(options: WebPowerSyncDatabaseOptionsWithSettings): DBAdapter;
     /**
      * Closes the database connection.

package/lib/src/db/PowerSyncDatabase.js

@@ -1,6 +1,8 @@
 import { AbstractPowerSyncDatabase, SqliteBucketStorage, isDBAdapter, isSQLOpenFactory } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import { getNavigatorLocks } from '../shared/navigator.js';
+import { NAVIGATOR_TRIGGER_CLAIM_MANAGER } from './NavigatorTriggerClaimManager.js';
+import { LockedAsyncDatabaseAdapter } from './adapters/LockedAsyncDatabaseAdapter.js';
 import { WASQLiteOpenFactory } from './adapters/wa-sqlite/WASQLiteOpenFactory.js';
 import { DEFAULT_WEB_SQL_FLAGS, isServerSide, resolveWebSQLFlags } from './adapters/web-sql-flags.js';
 import { SSRStreamingSyncImplementation } from './sync/SSRWebStreamingSyncImplementation.js';
@@ -58,7 +60,31 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
             window.addEventListener('unload', this.unloadListener);
         }
     }
-    async _initialize() { }
+    async _initialize() {
+        if (this.database instanceof LockedAsyncDatabaseAdapter) {
+            /**
+             * While init is done automatically,
+             * LockedAsyncDatabaseAdapter only exposes config after init.
+             * We can explicitly wait for init here in order to access config.
+             */
+            await this.database.init();
+        }
+        // In some cases, like the SQLJs adapter, we don't pass a WebDBAdapter, so we need to check.
+        if (typeof this.database.getConfiguration == 'function') {
+            const config = this.database.getConfiguration();
+            if (config.requiresPersistentTriggers) {
+                this.triggersImpl.updateDefaults({
+                    useStorageByDefault: true
+                });
+            }
+        }
+    }
+    generateTriggerManagerConfig() {
+        return {
+            // We need to share hold information between tabs for web
+            claimManager: NAVIGATOR_TRIGGER_CLAIM_MANAGER
+        };
+    }
     openDBAdapter(options) {
         const defaultFactory = new WASQLiteOpenFactory({
             ...options.database,

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

@@ -1,6 +1,6 @@
 import { BaseObserver, DBAdapterListener, DBLockOptions, LockContext, QueryResult, Transaction, type ILogger } from '@powersync/common';
 import { AsyncDatabaseConnection } from './AsyncDatabaseConnection.js';
-import { SharedConnectionWorker, WebDBAdapter } from './WebDBAdapter.js';
+import { SharedConnectionWorker, WebDBAdapter, WebDBAdapterConfiguration } from './WebDBAdapter.js';
 import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
 /**
  * @internal
@@ -55,7 +55,7 @@ export declare class LockedAsyncDatabaseAdapter extends BaseObserver<LockedAsync
      */
     reOpenInternalDB(): Promise<void>;
     protected _init(): Promise<void>;
-    getConfiguration(): ResolvedWebSQLOpenOptions;
+    getConfiguration(): WebDBAdapterConfiguration;
     protected waitForInitialized(): Promise<void>;
     shareConnection(): Promise<SharedConnectionWorker>;
     /**

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

@@ -137,7 +137,11 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
         if (!this._config) {
             throw new Error(`Cannot get config before initialization is completed`);
         }
-        return this._config;
+        return {
+            ...this._config,
+            // This can be overridden by the adapter later
+            requiresPersistentTriggers: false
+        };
     }
     async waitForInitialized() {
         // Awaiting this will expose errors on function calls like .execute etc

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

@@ -4,6 +4,9 @@ export type SharedConnectionWorker = {
     identifier: string;
     port: MessagePort;
 };
+export type WebDBAdapterConfiguration = ResolvedWebSQLOpenOptions & {
+    requiresPersistentTriggers: boolean;
+};
 export interface WebDBAdapter extends DBAdapter {
     /**
      * Get a MessagePort which can be used to share the internals of this connection.
@@ -13,5 +16,5 @@ export interface WebDBAdapter extends DBAdapter {
      * Get the config options used to open this connection.
      * This is useful for sharing connections.
      */
-    getConfiguration(): ResolvedWebSQLOpenOptions;
+    getConfiguration(): WebDBAdapterConfiguration;
 }

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

@@ -0,0 +1,12 @@
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
+import { WebDBAdapterConfiguration } from '../WebDBAdapter.js';
+/**
+ * @internal
+ * An intermediary implementation of WASQLiteDBAdapter, which takes the same
+ * constructor arguments as {@link LockedAsyncDatabaseAdapter}, but provides some
+ * basic WA-SQLite specific functionality.
+ * This base class is used to avoid requiring overloading the constructor of {@link WASQLiteDBAdapter}
+ */
+export declare class InternalWASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+    getConfiguration(): WebDBAdapterConfiguration;
+}

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

@@ -0,0 +1,19 @@
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
+import { WASQLiteVFS } from './WASQLiteConnection.js';
+/**
+ * @internal
+ * An intermediary implementation of WASQLiteDBAdapter, which takes the same
+ * constructor arguments as {@link LockedAsyncDatabaseAdapter}, but provides some
+ * basic WA-SQLite specific functionality.
+ * This base class is used to avoid requiring overloading the constructor of {@link WASQLiteDBAdapter}
+ */
+export class InternalWASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+    getConfiguration() {
+        // This is valid since we only handle WASQLite connections
+        const baseConfig = super.getConfiguration();
+        return {
+            ...super.getConfiguration(),
+            requiresPersistentTriggers: baseConfig.vfs == WASQLiteVFS.OPFSCoopSyncVFS || baseConfig.vfs == WASQLiteVFS.AccessHandlePoolVFS
+        };
+    }
+}

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

@@ -1,6 +1,6 @@
 import { type PowerSyncOpenFactoryOptions } from '@powersync/common';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
 import { ResolvedWebSQLOpenOptions, TemporaryStorageOption, WebSQLFlags } from '../web-sql-flags.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
 import { WASQLiteVFS } from './WASQLiteConnection.js';
 /**
  * These flags are the same as {@link WebSQLFlags}.
@@ -27,6 +27,6 @@ export interface WASQLiteDBAdapterOptions extends Omit<PowerSyncOpenFactoryOptio
 /**
  * Adapter for WA-SQLite SQLite connections.
  */
-export declare class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+export declare class WASQLiteDBAdapter extends InternalWASQLiteDBAdapter {
     constructor(options: WASQLiteDBAdapterOptions);
 }

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

@@ -1,13 +1,13 @@
 import * as Comlink from 'comlink';
 import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase.js';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
 import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags.js';
 import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
 import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
 /**
  * Adapter for WA-SQLite SQLite connections.
  */
-export class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+export class WASQLiteDBAdapter extends InternalWASQLiteDBAdapter {
     constructor(options) {
         super({
             name: options.dbFilename,

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

@@ -1,9 +1,9 @@
 import * as Comlink from 'comlink';
 import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
 import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
 import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
 import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
 import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection.js';
 /**
  * Opens a SQLite connection using WA-SQLite.
@@ -18,7 +18,7 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
         return this.options;
     }
     openAdapter() {
-        return new LockedAsyncDatabaseAdapter({
+        return new InternalWASQLiteDBAdapter({
             name: this.options.dbFilename,
             openConnection: () => this.openConnection(),
             debugMode: this.options.debugMode,

package/lib/src/index.d.ts

@@ -1,4 +1,5 @@
 export * from '@powersync/common';
+export * from './attachments/IndexDBFileSystemAdapter.js';
 export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js';
 export * from './db/adapters/AbstractWebSQLOpenFactory.js';
 export * from './db/adapters/AsyncDatabaseConnection.js';

package/lib/src/index.js

@@ -1,4 +1,5 @@
 export * from '@powersync/common';
+export * from './attachments/IndexDBFileSystemAdapter.js';
 export * from './db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.js';
 export * from './db/adapters/AbstractWebSQLOpenFactory.js';
 export * from './db/adapters/AsyncDatabaseConnection.js';