react-native-onyx 3.0.83 → 3.0.85

package/dist/storage/providers/IDBKeyValProvider/createStore.js

@@ -35,12 +35,47 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const IDB = __importStar(require("idb-keyval"));
 const Logger = __importStar(require("../../../Logger"));
+const HEAL_ATTEMPTS_MAX = 3;
+/**
+ * Detects the Chromium-specific IDB backing store corruption error.
+ * Fires when LevelDB files backing IndexedDB are corrupted and Chrome's
+ * internal recovery (RepairDB -> delete -> recreate) also fails.
+ */
+function isBackingStoreError(error) {
+    return (error instanceof Error || error instanceof DOMException) && error.message.includes('Internal error opening backing store');
+}
+/**
+ * Detects Safari/WebKit IDB connection termination errors.
+ * Fires when Safari kills the IDB server process for backgrounded tabs.
+ * WebKit bugs: https://bugs.webkit.org/show_bug.cgi?id=197050, https://bugs.webkit.org/show_bug.cgi?id=201483
+ */
+function isConnectionLostError(error) {
+    if (!(error instanceof Error || error instanceof DOMException))
+        return false;
+    const msg = error.message.toLowerCase();
+    return msg.includes('connection to indexed database server lost') || msg.includes('connection is closing');
+}
+function isInvalidStateError(error) {
+    return (error instanceof Error || error instanceof DOMException) && error.name === 'InvalidStateError';
+}
+/** Errors that trigger a budgeted heal-and-retry in store(). */
+function isBudgetedHealError(error) {
+    return isBackingStoreError(error) || isConnectionLostError(error);
+}
+function getBudgetedHealErrorLabel(error) {
+    if (isBackingStoreError(error))
+        return 'backing store';
+    if (isConnectionLostError(error))
+        return 'connection lost';
+    return 'unknown';
+}
 // This is a copy of the createStore function from idb-keyval, we need a custom implementation
 // because we need to create the database manually in order to ensure that the store exists before we use it.
 // If the store does not exist, idb-keyval will throw an error
 // source: https://github.com/jakearchibald/idb-keyval/blob/9d19315b4a83897df1e0193dccdc29f78466a0f3/src/index.ts#L12
 function createStore(dbName, storeName) {
     let dbp;
+    let healAttemptsRemaining = HEAL_ATTEMPTS_MAX;
     const attachHandlers = (db) => {
         // Browsers may close idle IDB connections at any time, especially Safari.
         // We clear the cached promise so the next operation opens a fresh connection.
@@ -60,16 +95,27 @@ function createStore(dbName, storeName) {
             dbp = undefined;
         };
     };
+    // Cache the open promise and attach handlers + rejection cleanup.
+    // On rejection, clears dbp so the next operation retries with a fresh indexedDB.open()
+    // instead of returning the same rejected promise.
+    // Guard: only clear if dbp hasn't been replaced by a concurrent heal/retry.
+    function cacheOpenPromise(openPromise) {
+        dbp = openPromise;
+        const currentPromise = openPromise;
+        openPromise.then(attachHandlers, () => {
+            if (dbp !== currentPromise) {
+                return;
+            }
+            dbp = undefined;
+        });
+        return openPromise;
+    }
     const getDB = () => {
         if (dbp)
             return dbp;
         const request = indexedDB.open(dbName);
         request.onupgradeneeded = () => request.result.createObjectStore(storeName);
-        dbp = IDB.promisifyRequest(request);
-        dbp.then(attachHandlers, 
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        () => { });
-        return dbp;
+        return cacheOpenPromise(IDB.promisifyRequest(request));
     };
     // Ensures the store exists in the DB. If missing, bumps the version to trigger
     // onupgradeneeded, recreates the store, and returns a promise to the new DB.
@@ -89,29 +135,65 @@ function createStore(dbName, storeName) {
             Logger.logInfo(`Creating store ${storeName} in database ${dbName}.`);
             updatedDatabase.createObjectStore(storeName);
         };
-        dbp = IDB.promisifyRequest(request);
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        dbp.then(attachHandlers, () => { });
-        return dbp;
+        return cacheOpenPromise(IDB.promisifyRequest(request));
     };
     function executeTransaction(txMode, callback) {
         return getDB()
             .then(verifyStoreExists)
             .then((db) => callback(db.transaction(storeName, txMode).objectStore(storeName)));
     }
-    // If the connection was closed between getDB() resolving and db.transaction() executing,
-    // the transaction throws InvalidStateError. We catch it and retry once with a fresh connection.
-    return (txMode, callback) => executeTransaction(txMode, callback).catch((error) => {
-        if (error instanceof DOMException && error.name === 'InvalidStateError') {
-            Logger.logAlert('IDB InvalidStateError, retrying with fresh connection', {
+    function resetHealBudget(result) {
+        healAttemptsRemaining = HEAL_ATTEMPTS_MAX;
+        return result;
+    }
+    // Handles three recoverable error classes:
+    // 1. InvalidStateError — connection closed between getDB() resolving and db.transaction().
+    //    Retry once with a fresh connection. No budget limit (transient, always worth one reopen).
+    // 2. Backing store corruption (Chromium UnknownError) — drop cached connection and reopen.
+    // 3. Connection lost (Safari UnknownError) — IDB server terminated for backgrounded tabs.
+    //    Both 2 and 3 share a heal budget (3 attempts, reset on success).
+    //    Mirrors Dexie's PR1398_maxLoop pattern: https://github.com/dexie/Dexie.js/blob/master/src/functions/temp-transaction.ts
+    // Note: concurrent store() calls share the budget. Under overlapping failures each caller
+    // decrements independently, so the budget may drain faster than one-per-incident. This is
+    // acceptable — same as Dexie's approach — and the budget resets on any success.
+    return (txMode, callback) => executeTransaction(txMode, callback)
+        .then(resetHealBudget)
+        .catch((error) => {
+        if (isInvalidStateError(error)) {
+            Logger.logInfo('IDB InvalidStateError — dropping cached connection and retrying', {
                 dbName,
                 storeName,
                 txMode,
-                errorMessage: error.message,
+                errorMessage: error instanceof Error ? error.message : String(error),
             });
             dbp = undefined;
-            // Retry only once — this call is not wrapped, so if it also fails the error propagates normally.
-            return executeTransaction(txMode, callback);
+            return executeTransaction(txMode, callback).then(resetHealBudget);
+        }
+        if (isBudgetedHealError(error) && healAttemptsRemaining > 0) {
+            healAttemptsRemaining--;
+            const label = getBudgetedHealErrorLabel(error);
+            Logger.logInfo(`IDB heal: ${label} error detected — dropping cached connection and reopening (${healAttemptsRemaining} attempts left)`, {
+                dbName,
+                storeName,
+            });
+            dbp = undefined;
+            return executeTransaction(txMode, callback).then((result) => {
+                Logger.logInfo(`IDB heal: successfully recovered after ${label} error`, { dbName, storeName });
+                return resetHealBudget(result);
+            });
+        }
+        if (isBudgetedHealError(error)) {
+            Logger.logAlert(`IDB heal: ${getBudgetedHealErrorLabel(error)} error — heal budget exhausted, giving up`, {
+                dbName,
+                storeName,
+            });
+        }
+        else {
+            Logger.logAlert('IDB error is not recoverable, giving up', {
+                dbName,
+                storeName,
+                errorMessage: error instanceof Error ? error.message : String(error),
+            });
         }
         throw error;
     });

package/dist/storage/providers/IDBKeyValProvider/index.js

@@ -41,6 +41,17 @@ const utils_1 = __importDefault(require("../../../utils"));
 const createStore_1 = __importDefault(require("./createStore"));
 const DB_NAME = 'OnyxDB';
 const STORE_NAME = 'keyvaluepairs';
+/**
+ * Awaits an IndexedDB write transaction. idb-keyval's promisifyRequest rejects with
+ * `transaction.error`, which is `null` for an abort not caused by its own request
+ * (connection close / versionchange / a sibling transaction aborting). Normalize that
+ * `null` into a tagged AbortError.
+ */
+function promisifyWriteTransaction(transaction) {
+    return IDB.promisifyRequest(transaction).catch((error) => {
+        throw error !== null && error !== void 0 ? error : new DOMException('IDB write transaction aborted without an error', 'AbortError');
+    });
+}
 const provider = {
     // We don't want to initialize the store while the JS bundle loads as idb-keyval will try to use global.indexedDB
     // which might not be available in certain environments that load the bundle (e.g. electron main process).
@@ -66,7 +77,13 @@ const provider = {
         if (value === null) {
             return provider.removeItem(key);
         }
-        return IDB.set(key, value, provider.store);
+        // Drive the write through the manual store transaction so promisifyWriteTransaction can
+        // normalize a null abort error — idb-keyval's IDB.set() awaits the raw transaction and
+        // would propagate the unclassifiable "Error: null".
+        return provider.store('readwrite', (store) => {
+            store.put(value, key);
+            return promisifyWriteTransaction(store.transaction);
+        });
     },
     multiGet(keysParam) {
         if (!provider.store) {
@@ -95,7 +112,7 @@ const provider = {
                         store.put(newValue, key);
                     }
                 }
-                return IDB.promisifyRequest(store.transaction);
+                return promisifyWriteTransaction(store.transaction);
             });
         });
     },
@@ -116,7 +133,7 @@ const provider = {
                     store.put(value, key);
                 }
             }
-            return IDB.promisifyRequest(store.transaction);
+            return promisifyWriteTransaction(store.transaction);
         });
     },
     clear() {
@@ -149,13 +166,21 @@ const provider = {
         if (!provider.store) {
             throw new Error('Store not initialized!');
         }
-        return IDB.del(key, provider.store);
+        return provider.store('readwrite', (store) => {
+            store.delete(key);
+            return promisifyWriteTransaction(store.transaction);
+        });
     },
     removeItems(keysParam) {
         if (!provider.store) {
             throw new Error('Store not initialized!');
         }
-        return IDB.delMany(keysParam, provider.store);
+        return provider.store('readwrite', (store) => {
+            for (const key of keysParam) {
+                store.delete(key);
+            }
+            return promisifyWriteTransaction(store.transaction);
+        });
     },
     getDatabaseSize() {
         if (!provider.store) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "3.0.83",
+  "version": "3.0.85",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",