react-native-onyx 3.0.96 → 3.0.98

package/dist/Onyx.js

@@ -240,11 +240,15 @@ function merge(key, changes) {
             return mergeQueuePromise[key];
         }
         mergeQueue[key] = [changes];
-        mergeQueuePromise[key] = OnyxUtils_1.default.get(key).then((existingValue) => {
+        mergeQueuePromise[key] = OnyxUtils_1.default.get(key).then((valueFromGet) => {
             // Calls to Onyx.set after a merge will terminate the current merge process and clear the merge queue
             if (mergeQueue[key] == null) {
                 return Promise.resolve();
             }
+            // Other writers (notably Onyx.update's mergeCollection path, which doesn't participate in mergeQueue)
+            // can land between get() resolving and this callback running. Applying the delta on top of the value
+            // captured back then and broadcasting it would overwrite those writes wholesale, so re-read the cache.
+            const existingValue = OnyxCache_1.default.hasCacheForKey(key) ? OnyxCache_1.default.get(key) : valueFromGet;
             try {
                 const validChanges = mergeQueue[key].filter((change) => {
                     const { isCompatible, existingValueType, newValueType, isEmptyArrayCoercion } = utils_1.default.checkCompatibilityWithExistingValue(change, existingValue);

package/dist/OnyxUtils.d.ts

@@ -12,6 +12,8 @@ declare const METHOD: {
     readonly MULTI_SET: "multiset";
     readonly CLEAR: "clear";
 };
+/** Test-only: clears the disk-pressure log throttle so each test observes its own alert. */
+declare function resetDiskPressureLogThrottle(): void;
 type OnyxMethod = ValueOf<typeof METHOD>;
 declare function getSnapshotKey(): OnyxKey | null;
 /**
@@ -143,6 +145,9 @@ declare function reportStorageQuota(error?: Error): Promise<void>;
  * - CAPACITY: evicts the least recently accessed evictable key and retries, under a session-level
  *   circuit breaker (see lib/StorageCircuitBreaker.ts) that halts the loop once eviction stops making
  *   progress or failures storm — the per-operation budget alone cannot stop a session-wide storm.
+ * - DISK_PRESSURE: the device disk itself is full (or the database files are unreadable), so neither
+ *   retries nor in-DB eviction can free space — the write is dropped (cache stays authoritative) with
+ *   a single throttled alert + quota snapshot per burst.
  * - UNKNOWN: the provider couldn't classify it — log the full error shape (name + message +
  *   provider) once so it's visible, then bounded retry without eviction.
  */
@@ -291,6 +296,7 @@ declare const OnyxUtils: {
     getCollectionDataAndSendAsObject: typeof getCollectionDataAndSendAsObject;
     remove: typeof remove;
     reportStorageQuota: typeof reportStorageQuota;
+    resetDiskPressureLogThrottle: typeof resetDiskPressureLogThrottle;
     retryOperation: typeof retryOperation;
     broadcastUpdate: typeof broadcastUpdate;
     hasPendingMergeForKey: typeof hasPendingMergeForKey;

package/dist/OnyxUtils.js

@@ -60,6 +60,14 @@ const METHOD = {
 };
 // Max number of retries for failed storage operations
 const MAX_STORAGE_OPERATION_RETRY_ATTEMPTS = 5;
+/** Minimum interval between disk-pressure alerts. One disk-pressure burst fails every queued operation
+ * with the identical error, so per-operation logging would amplify the very storm it reports. */
+const DISK_PRESSURE_LOG_INTERVAL_MS = 60000;
+let lastDiskPressureLogTime = 0;
+/** Test-only: clears the disk-pressure log throttle so each test observes its own alert. */
+function resetDiskPressureLogThrottle() {
+    lastDiskPressureLogTime = 0;
+}
 // Key/value store of Onyx key and arrays of values to merge
 let mergeQueue = {};
 let mergeQueuePromise = {};
@@ -659,6 +667,9 @@ function reportStorageQuota(error) {
  * - CAPACITY: evicts the least recently accessed evictable key and retries, under a session-level
  *   circuit breaker (see lib/StorageCircuitBreaker.ts) that halts the loop once eviction stops making
  *   progress or failures storm — the per-operation budget alone cannot stop a session-wide storm.
+ * - DISK_PRESSURE: the device disk itself is full (or the database files are unreadable), so neither
+ *   retries nor in-DB eviction can free space — the write is dropped (cache stays authoritative) with
+ *   a single throttled alert + quota snapshot per burst.
  * - UNKNOWN: the provider couldn't classify it — log the full error shape (name + message +
  *   provider) once so it's visible, then bounded retry without eviction.
  */
@@ -674,6 +685,18 @@ function retryOperation(error, onyxMethod, defaultParams, retryAttempt, inFlight
         StorageCircuitBreaker_1.default.recordProbeFailure();
         return Promise.resolve();
     }
+    // DISK_PRESSURE: the device disk is full, so neither retries nor eviction can succeed until the OS
+    // frees space. Drop the write (cache stays authoritative) and log one alert + quota snapshot per
+    // interval — the snapshot's free-disk bytes let telemetry confirm (or rule out) disk pressure.
+    if (errorClass === errors_1.StorageErrorClass.DISK_PRESSURE) {
+        const now = Date.now();
+        if (now - lastDiskPressureLogTime < DISK_PRESSURE_LOG_INTERVAL_MS) {
+            return Promise.resolve();
+        }
+        lastDiskPressureLogTime = now;
+        Logger.logAlert(`Disk-pressure storage error; skipping retries. provider: ${storage_1.default.getStorageProvider().name}. message: ${error === null || error === void 0 ? void 0 : error.message}. onyxMethod: ${onyxMethod.name}.`);
+        return reportStorageQuota(error);
+    }
     Logger.logInfo(`Failed to save to storage. Error: ${error}. class: ${errorClass}. onyxMethod: ${onyxMethod.name}. retryAttempt: ${currentRetryAttempt}/${MAX_STORAGE_OPERATION_RETRY_ATTEMPTS}`);
     if (errorClass === errors_1.StorageErrorClass.INVALID_DATA) {
         Logger.logAlert(`Attempted to set invalid data set in Onyx. Please ensure all data is serializable. Error: ${error}`);
@@ -1510,6 +1533,7 @@ const OnyxUtils = {
     getCollectionDataAndSendAsObject,
     remove,
     reportStorageQuota,
+    resetDiskPressureLogThrottle,
     retryOperation,
     broadcastUpdate,
     hasPendingMergeForKey,

package/dist/storage/__mocks__/index.d.ts

@@ -3,6 +3,7 @@ declare const StorageMock: {
     classifyError: jest.Mock<import("type-fest").ValueOf<{
         readonly TRANSIENT: "transient";
         readonly CAPACITY: "capacity";
+        readonly DISK_PRESSURE: "diskPressure";
         readonly INVALID_DATA: "invalidData";
         readonly FATAL: "fatal";
         readonly UNKNOWN: "unknown";

package/dist/storage/errors.d.ts

@@ -15,6 +15,10 @@ declare const StorageErrorClass: {
     readonly TRANSIENT: "transient";
     /** Quota exceeded / disk full. Owner: operation layer — evict and retry. */
     readonly CAPACITY: "capacity";
+    /** Filesystem-level failure around the database files (device disk full, or the files cannot be
+     *  created/read). Owner: operation layer — skip retries and eviction (neither can free OS-level
+     *  space) and log one throttled alert + quota snapshot per burst. */
+    readonly DISK_PRESSURE: "diskPressure";
     /** Non-serializable payload. Never retriable — the same data will always fail. */
     readonly INVALID_DATA: "invalidData";
     /** Backing-store corruption. Owner: connection layer — budgeted heal, then give up. */

package/dist/storage/errors.js

@@ -19,6 +19,10 @@ const StorageErrorClass = {
     TRANSIENT: 'transient',
     /** Quota exceeded / disk full. Owner: operation layer — evict and retry. */
     CAPACITY: 'capacity',
+    /** Filesystem-level failure around the database files (device disk full, or the files cannot be
+     *  created/read). Owner: operation layer — skip retries and eviction (neither can free OS-level
+     *  space) and log one throttled alert + quota snapshot per burst. */
+    DISK_PRESSURE: 'diskPressure',
     /** Non-serializable payload. Never retriable — the same data will always fail. */
     INVALID_DATA: 'invalidData',
     /** Backing-store corruption. Owner: connection layer — budgeted heal, then give up. */

package/dist/storage/providers/SQLiteProvider.js

@@ -244,15 +244,20 @@ const provider = {
         if (!provider.store) {
             throw new Error('Store is not initialized!');
         }
-        return Promise.all([provider.store.executeAsync('PRAGMA page_size;'), provider.store.executeAsync('PRAGMA page_count;'), (0, react_native_device_info_1.getFreeDiskStorage)()]).then(([pageSizeResult, pageCountResult, bytesRemaining]) => {
+        // The PRAGMAs need the SQLite connection; getFreeDiskStorage() is filesystem-level. Degrade
+        // bytesUsed to -1 instead of failing, so the free-disk bytes always get logged.
+        const bytesUsedPromise = Promise.all([provider.store.executeAsync('PRAGMA page_size;'), provider.store.executeAsync('PRAGMA page_count;')])
+            .then(([pageSizeResult, pageCountResult]) => {
             var _a, _b, _c, _d, _e, _f;
             const pageSize = (_c = (_b = (_a = pageSizeResult.rows) === null || _a === void 0 ? void 0 : _a.item(0)) === null || _b === void 0 ? void 0 : _b.page_size) !== null && _c !== void 0 ? _c : 0;
             const pageCount = (_f = (_e = (_d = pageCountResult.rows) === null || _d === void 0 ? void 0 : _d.item(0)) === null || _e === void 0 ? void 0 : _e.page_count) !== null && _f !== void 0 ? _f : 0;
-            return {
-                bytesUsed: pageSize * pageCount,
-                bytesRemaining,
-            };
-        });
+            return pageSize * pageCount;
+        })
+            .catch(() => -1);
+        return Promise.all([bytesUsedPromise, (0, react_native_device_info_1.getFreeDiskStorage)()]).then(([bytesUsed, bytesRemaining]) => ({
+            bytesUsed,
+            bytesRemaining,
+        }));
     },
 };
 exports.default = provider;

package/dist/storage/providers/classifySQLiteError.js

@@ -16,6 +16,9 @@ function classifySQLiteError(error) {
     if (message.includes('database or disk is full')) {
         return errors_1.StorageErrorClass.CAPACITY;
     }
+    if (message.includes('disk i/o error') || message.includes('unable to open database file')) {
+        return errors_1.StorageErrorClass.DISK_PRESSURE;
+    }
     return errors_1.StorageErrorClass.UNKNOWN;
 }
 exports.default = classifySQLiteError;

package/package.json

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