@powersync/web 1.32.0 → 1.33.0

package/lib/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",
@@ -67,7 +67,7 @@
     "license": "Apache-2.0",
     "peerDependencies": {
         "@journeyapps/wa-sqlite": "catalog:",
-        "@powersync/common": "workspace:^1.46.0"
+        "@powersync/common": "workspace:^1.47.0"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",

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

@@ -104,13 +104,17 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
      * Returns a pending operation if one is already in progress.
      */
     async reOpenInternalDB() {
-        if (!this.options.reOpenOnConnectionClosed) {
-            throw new Error(`Cannot re-open underlying database, reOpenOnConnectionClosed is not enabled`);
+        if (this.closing || !this.options.reOpenOnConnectionClosed) {
+            // No-op
+            return;
         }
-        if (this.databaseOpenPromise) {
+        else if (this.databaseOpenPromise) {
+            // Already busy opening
             return this.databaseOpenPromise;
         }
-        return this._reOpen();
+        else {
+            return this._reOpen();
+        }
     }
     async _init() {
         /**
@@ -241,10 +245,19 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     }
     async acquireLock(callback, options) {
         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 () => {
             let holdId = null;
             try {
@@ -262,11 +275,9 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
             }
             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;
             }

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