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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/web",
-  "version": "0.0.0-dev-20260120150240",
+  "version": "0.0.0-dev-20260128165909",
   "description": "PowerSync Web SDK",
   "main": "lib/src/index.js",
   "module": "lib/src/index.js",
@@ -56,14 +56,14 @@
   "license": "Apache-2.0",
   "peerDependencies": {
     "@journeyapps/wa-sqlite": "^1.4.1",
-    "@powersync/common": "0.0.0-dev-20260120150240"
+    "@powersync/common": "0.0.0-dev-20260128165909"
   },
   "dependencies": {
     "async-mutex": "^0.5.0",
     "bson": "^6.10.4",
     "comlink": "^4.4.2",
     "commander": "^12.1.0",
-    "@powersync/common": "0.0.0-dev-20260120150240"
+    "@powersync/common": "0.0.0-dev-20260128165909"
   },
   "devDependencies": {
     "@journeyapps/wa-sqlite": "^1.4.1",
@@ -76,8 +76,6 @@
     "terser-webpack-plugin": "^5.3.9",
     "uuid": "^11.1.0",
     "vite": "^7.3.1",
-    "vite-plugin-top-level-await": "^1.4.4",
-    "vite-plugin-wasm": "^3.3.0",
     "vm-browserify": "^1.1.2",
     "webpack": "^5.90.1",
     "webpack-cli": "^5.1.4",

package/src/attachments/IndexDBFileSystemAdapter.ts

@@ -0,0 +1,117 @@
+import { AttachmentData, EncodingType, LocalStorageAdapter } from '@powersync/common';
+
+/**
+ * IndexDBFileSystemStorageAdapter implements LocalStorageAdapter using IndexedDB.
+ * Suitable for web browsers and web-based environments.
+ */
+export class IndexDBFileSystemStorageAdapter implements LocalStorageAdapter {
+  private dbPromise!: Promise<IDBDatabase>;
+
+  constructor(private databaseName: string = 'PowerSyncFiles') {}
+
+  async initialize(): Promise<void> {
+    this.dbPromise = new Promise<IDBDatabase>((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(): Promise<void> {
+    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: string): string {
+    return `indexeddb://${this.databaseName}/files/${filename}`;
+  }
+
+  private async getStore(mode: IDBTransactionMode = 'readonly'): Promise<IDBObjectStore> {
+    const db = await this.dbPromise;
+    const tx = db.transaction('files', mode);
+    return tx.objectStore('files');
+  }
+
+  async saveFile(filePath: string, data: AttachmentData): Promise<number> {
+    const store = await this.getStore('readwrite');
+
+    let dataToStore: ArrayBuffer;
+    let size: number;
+
+    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<number>((resolve, reject) => {
+      const req = store.put(dataToStore, filePath);
+      req.onsuccess = () => resolve(size);
+      req.onerror = () => reject(req.error);
+    });
+  }
+
+  async readFile(fileUri: string, options?: { encoding?: EncodingType; mediaType?: string }): Promise<ArrayBuffer> {
+    const store = await this.getStore();
+    return new Promise<ArrayBuffer>((resolve, reject) => {
+      const req = store.get(fileUri);
+      req.onsuccess = async () => {
+        if (!req.result) {
+          reject(new Error('File not found'));
+          return;
+        }
+
+        resolve(req.result as ArrayBuffer);
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+
+  async deleteFile(uri: string, options?: { filename?: string }): Promise<void> {
+    const store = await this.getStore('readwrite');
+    await new Promise<void>((resolve, reject) => {
+      const req = store.delete(uri);
+      req.onsuccess = () => resolve();
+      req.onerror = () => reject(req.error);
+    });
+  }
+
+  async fileExists(fileUri: string): Promise<boolean> {
+    const store = await this.getStore();
+    return new Promise<boolean>((resolve, reject) => {
+      const req = store.get(fileUri);
+      req.onsuccess = () => resolve(!!req.result);
+      req.onerror = () => reject(req.error);
+    });
+  }
+
+  async makeDir(path: string): Promise<void> {
+    // No-op for IndexedDB as it does not have a directory structure
+  }
+
+  async rmDir(path: string): Promise<void> {
+    const store = await this.getStore('readwrite');
+    const range = IDBKeyRange.bound(path + '/', path + '/\uffff', false, false);
+    await new Promise<void>((resolve, reject) => {
+      const req = store.delete(range);
+      req.onsuccess = () => resolve();
+      req.onerror = () => reject(req.error);
+    });
+  }
+}

package/src/db/NavigatorTriggerClaimManager.ts

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

package/src/db/PowerSyncDatabase.ts

@@ -7,6 +7,7 @@ import {
   PowerSyncDatabaseOptionsWithSettings,
   SqliteBucketStorage,
   StreamingSyncImplementation,
+  TriggerManagerConfig,
   isDBAdapter,
   isSQLOpenFactory,
   type BucketStorageAdapter,
@@ -16,6 +17,8 @@ import {
 } 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 { WebDBAdapter } from './adapters/WebDBAdapter.js';
 import { WASQLiteOpenFactory } from './adapters/wa-sqlite/WASQLiteOpenFactory.js';
 import {
@@ -144,7 +147,33 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     }
   }
 
-  async _initialize(): Promise<void> {}
+  async _initialize(): Promise<void> {
+    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 as WebDBAdapter).getConfiguration == 'function') {
+      const config = (this.database as WebDBAdapter).getConfiguration();
+      if (config.requiresPersistentTriggers) {
+        this.triggersImpl.updateDefaults({
+          useStorageByDefault: true
+        });
+      }
+    }
+  }
+
+  protected generateTriggerManagerConfig(): TriggerManagerConfig {
+    return {
+      // We need to share hold information between tabs for web
+      claimManager: NAVIGATOR_TRIGGER_CLAIM_MANAGER
+    };
+  }
 
   protected openDBAdapter(options: WebPowerSyncDatabaseOptionsWithSettings): DBAdapter {
     const defaultFactory = new WASQLiteOpenFactory({

package/src/db/adapters/LockedAsyncDatabaseAdapter.ts

@@ -13,7 +13,7 @@ import {
 } from '@powersync/common';
 import { getNavigatorLocks } from '../../shared/navigator.js';
 import { AsyncDatabaseConnection } from './AsyncDatabaseConnection.js';
-import { SharedConnectionWorker, WebDBAdapter } from './WebDBAdapter.js';
+import { SharedConnectionWorker, WebDBAdapter, WebDBAdapterConfiguration } from './WebDBAdapter.js';
 import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection.js';
 import { WASQLiteVFS } from './wa-sqlite/WASQLiteConnection.js';
 import { ResolvedWASQLiteOpenFactoryOptions } from './wa-sqlite/WASQLiteOpenFactory.js';
@@ -181,11 +181,15 @@ export class LockedAsyncDatabaseAdapter
     this.iterateListeners((cb) => cb.initialized?.());
   }
 
-  getConfiguration(): ResolvedWebSQLOpenOptions {
+  getConfiguration(): WebDBAdapterConfiguration {
     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
+    };
   }
 
   protected async waitForInitialized() {

package/src/db/adapters/WebDBAdapter.ts

@@ -6,6 +6,10 @@ export type SharedConnectionWorker = {
   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.
@@ -16,5 +20,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/src/db/adapters/wa-sqlite/InternalWASQLiteDBAdapter.ts

@@ -0,0 +1,23 @@
+import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
+import { WebDBAdapterConfiguration } from '../WebDBAdapter.js';
+import { WASQLiteVFS } from './WASQLiteConnection.js';
+import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.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(): WebDBAdapterConfiguration {
+    // This is valid since we only handle WASQLite connections
+    const baseConfig = super.getConfiguration() as unknown as ResolvedWASQLiteOpenFactoryOptions;
+    return {
+      ...super.getConfiguration(),
+      requiresPersistentTriggers:
+        baseConfig.vfs == WASQLiteVFS.OPFSCoopSyncVFS || baseConfig.vfs == WASQLiteVFS.AccessHandlePoolVFS
+    };
+  }
+}

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

@@ -2,7 +2,6 @@ import { type PowerSyncOpenFactoryOptions } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase.js';
 import { OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection.js';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
 import {
   DEFAULT_CACHE_SIZE_KB,
   ResolvedWebSQLOpenOptions,
@@ -10,6 +9,7 @@ import {
   WebSQLFlags
 } from '../web-sql-flags.js';
 import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
 import { WASQLiteVFS } from './WASQLiteConnection.js';
 import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
 
@@ -44,7 +44,7 @@ export interface WASQLiteDBAdapterOptions extends Omit<PowerSyncOpenFactoryOptio
 /**
  * Adapter for WA-SQLite SQLite connections.
  */
-export class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
+export class WASQLiteDBAdapter extends InternalWASQLiteDBAdapter {
   constructor(options: WASQLiteDBAdapterOptions) {
     super({
       name: options.dbFilename,

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

@@ -3,7 +3,6 @@ import * as Comlink from 'comlink';
 import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
 import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory.js';
 import { AsyncDatabaseConnection, OpenAsyncDatabaseConnection } from '../AsyncDatabaseConnection.js';
-import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter.js';
 import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection.js';
 import {
   DEFAULT_CACHE_SIZE_KB,
@@ -11,6 +10,7 @@ import {
   TemporaryStorageOption,
   WebSQLOpenFactoryOptions
 } from '../web-sql-flags.js';
+import { InternalWASQLiteDBAdapter } from './InternalWASQLiteDBAdapter.js';
 import { WASQLiteVFS, WASqliteConnection } from './WASQLiteConnection.js';
 
 export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
@@ -41,7 +41,7 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
   }
 
   protected openAdapter(): DBAdapter {
-    return new LockedAsyncDatabaseAdapter({
+    return new InternalWASQLiteDBAdapter({
       name: this.options.dbFilename,
       openConnection: () => this.openConnection(),
       debugMode: this.options.debugMode,

package/src/index.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';