@powersync/web 1.32.0 → 1.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/web",
-  "version": "1.32.0",
+  "version": "1.33.0",
   "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": "^1.46.0"
+    "@powersync/common": "^1.47.0"
   },
   "dependencies": {
     "async-mutex": "^0.5.0",
     "bson": "^6.10.4",
     "comlink": "^4.4.2",
     "commander": "^12.1.0",
-    "@powersync/common": "1.46.0"
+    "@powersync/common": "1.47.0"
   },
   "devDependencies": {
     "@journeyapps/wa-sqlite": "^1.4.1",

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/adapters/LockedAsyncDatabaseAdapter.ts

@@ -151,13 +151,15 @@ export class LockedAsyncDatabaseAdapter
    * Returns a pending operation if one is already in progress.
    */
   async reOpenInternalDB(): Promise<void> {
-    if (!this.options.reOpenOnConnectionClosed) {
-      throw new Error(`Cannot re-open underlying database, reOpenOnConnectionClosed is not enabled`);
-    }
-    if (this.databaseOpenPromise) {
+    if (this.closing || !this.options.reOpenOnConnectionClosed) {
+      // No-op
+      return;
+    } else if (this.databaseOpenPromise) {
+      // Already busy opening
       return this.databaseOpenPromise;
+    } else {
+      return this._reOpen();
     }
-    return this._reOpen();
   }
 
   protected async _init() {
@@ -317,9 +319,17 @@ export class LockedAsyncDatabaseAdapter
   protected async acquireLock(callback: () => Promise<any>, options?: { timeoutMs?: number }): Promise<any> {
     await this.waitForInitialized();
 
-    // The database is being opened in the background. Wait for it here.
+    // The database is being (re)opened in the background. Wait for it here.
     if (this.databaseOpenPromise) {
       await this.databaseOpenPromise;
+    } else if (!this._db) {
+      /**
+       * The database is not open anymore, we might need to re-open it.
+       * Typically, _db, can be `null` if we tried to reOpen the database, but failed to succeed in re-opening.
+       * This can happen when disconnecting the client.
+       * Note: It is safe to re-enter this method multiple times.
+       */
+      await this.reOpenInternalDB();
     }
 
     return this._acquireLock(async () => {
@@ -339,11 +349,9 @@ export class LockedAsyncDatabaseAdapter
         return await callback();
       } catch (ex) {
         if (ConnectionClosedError.MATCHES(ex)) {
-          if (this.options.reOpenOnConnectionClosed && !this.databaseOpenPromise && !this.closing) {
-            // Immediately re-open the database. We need to miss as little table updates as possible.
-            // Note, don't await this since it uses the same lock as we're in now.
-            this.reOpenInternalDB();
-          }
+          // Immediately re-open the database. We need to miss as little table updates as possible.
+          // Note, don't await this since it uses the same lock as we're in now.
+          this.reOpenInternalDB();
         }
         throw ex;
       } finally {

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';