react-native-onyx 3.0.11 → 3.0.13

package/dist/Onyx.js

@@ -145,62 +145,7 @@ function disconnect(connection) {
  * @param options optional configuration object
  */
 function set(key, value, options) {
-    // When we use Onyx.set to set a key we want to clear the current delta changes from Onyx.merge that were queued
-    // before the value was set. If Onyx.merge is currently reading the old value from storage, it will then not apply the changes.
-    if (OnyxUtils_1.default.hasPendingMergeForKey(key)) {
-        delete OnyxUtils_1.default.getMergeQueue()[key];
-    }
-    const skippableCollectionMemberIDs = OnyxUtils_1.default.getSkippableCollectionMemberIDs();
-    if (skippableCollectionMemberIDs.size) {
-        try {
-            const [, collectionMemberID] = OnyxUtils_1.default.splitCollectionMemberKey(key);
-            if (skippableCollectionMemberIDs.has(collectionMemberID)) {
-                // The key is a skippable one, so we set the new value to null.
-                // eslint-disable-next-line no-param-reassign
-                value = null;
-            }
-        }
-        catch (e) {
-            // The key is not a collection one or something went wrong during split, so we proceed with the function's logic.
-        }
-    }
-    // Onyx.set will ignore `undefined` values as inputs, therefore we can return early.
-    if (value === undefined) {
-        return Promise.resolve();
-    }
-    const existingValue = OnyxCache_1.default.get(key, false);
-    // If the existing value as well as the new value are null, we can return early.
-    if (existingValue === undefined && value === null) {
-        return Promise.resolve();
-    }
-    // Check if the value is compatible with the existing value in the storage
-    const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(value, existingValue);
-    if (!isCompatible) {
-        Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'set', existingValueType, newValueType));
-        return Promise.resolve();
-    }
-    // If the change is null, we can just delete the key.
-    // Therefore, we don't need to further broadcast and update the value so we can return early.
-    if (value === null) {
-        OnyxUtils_1.default.remove(key);
-        OnyxUtils_1.default.logKeyRemoved(OnyxUtils_1.default.METHOD.SET, key);
-        return Promise.resolve();
-    }
-    const valueWithoutNestedNullValues = utils_1.default.removeNestedNullValues(value);
-    const hasChanged = (options === null || options === void 0 ? void 0 : options.skipCacheCheck) ? true : OnyxCache_1.default.hasValueChanged(key, valueWithoutNestedNullValues);
-    OnyxUtils_1.default.logKeyChanged(OnyxUtils_1.default.METHOD.SET, key, value, hasChanged);
-    // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, valueWithoutNestedNullValues, hasChanged);
-    // If the value has not changed or the key got removed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
-    if (!hasChanged) {
-        return updatePromise;
-    }
-    return storage_1.default.setItem(key, valueWithoutNestedNullValues)
-        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, set, key, valueWithoutNestedNullValues))
-        .then(() => {
-        OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.SET, key, valueWithoutNestedNullValues);
-        return updatePromise;
-    });
+    return OnyxUtils_1.default.setWithRetry({ key, value, options });
 }
 /**
  * Sets multiple keys and values
@@ -210,42 +155,7 @@ function set(key, value, options) {
  * @param data object keyed by ONYXKEYS and the values to set
  */
 function multiSet(data) {
-    let newData = data;
-    const skippableCollectionMemberIDs = OnyxUtils_1.default.getSkippableCollectionMemberIDs();
-    if (skippableCollectionMemberIDs.size) {
-        newData = Object.keys(newData).reduce((result, key) => {
-            try {
-                const [, collectionMemberID] = OnyxUtils_1.default.splitCollectionMemberKey(key);
-                // If the collection member key is a skippable one we set its value to null.
-                // eslint-disable-next-line no-param-reassign
-                result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? newData[key] : null;
-            }
-            catch (_a) {
-                // The key is not a collection one or something went wrong during split, so we assign the data to result anyway.
-                // eslint-disable-next-line no-param-reassign
-                result[key] = newData[key];
-            }
-            return result;
-        }, {});
-    }
-    const keyValuePairsToSet = OnyxUtils_1.default.prepareKeyValuePairsForStorage(newData, true);
-    const updatePromises = keyValuePairsToSet.map(([key, value]) => {
-        // When we use multiSet to set a key we want to clear the current delta changes from Onyx.merge that were queued
-        // before the value was set. If Onyx.merge is currently reading the old value from storage, it will then not apply the changes.
-        if (OnyxUtils_1.default.hasPendingMergeForKey(key)) {
-            delete OnyxUtils_1.default.getMergeQueue()[key];
-        }
-        // Update cache and optimistically inform subscribers on the next tick
-        OnyxCache_1.default.set(key, value);
-        return OnyxUtils_1.default.scheduleSubscriberUpdate(key, value);
-    });
-    return storage_1.default.multiSet(keyValuePairsToSet)
-        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, multiSet, newData))
-        .then(() => {
-        OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MULTI_SET, undefined, newData);
-        return Promise.all(updatePromises);
-    })
-        .then(() => undefined);
+    return OnyxUtils_1.default.multiSetWithRetry(data);
 }
 /**
  * Merge a new value into an existing value at a key.
@@ -344,7 +254,7 @@ function merge(key, changes) {
  * @param collection Object collection keyed by individual collection member keys and values
  */
 function mergeCollection(collectionKey, collection) {
-    return OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, collection, undefined, true);
+    return OnyxUtils_1.default.mergeCollectionWithPatches({ collectionKey, collection, isProcessingCollectionUpdate: true });
 }
 /**
  * Clear out all the data in the store
@@ -553,10 +463,15 @@ function update(data) {
             set: {},
         });
         if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.merge)) {
-            promises.push(() => OnyxUtils_1.default.mergeCollectionWithPatches(collectionKey, batchedCollectionUpdates.merge, batchedCollectionUpdates.mergeReplaceNullPatches, true));
+            promises.push(() => OnyxUtils_1.default.mergeCollectionWithPatches({
+                collectionKey,
+                collection: batchedCollectionUpdates.merge,
+                mergeReplaceNullPatches: batchedCollectionUpdates.mergeReplaceNullPatches,
+                isProcessingCollectionUpdate: true,
+            }));
         }
         if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.set)) {
-            promises.push(() => OnyxUtils_1.default.partialSetCollection(collectionKey, batchedCollectionUpdates.set));
+            promises.push(() => OnyxUtils_1.default.partialSetCollection({ collectionKey, collection: batchedCollectionUpdates.set }));
         }
     });
     Object.entries(updateQueue).forEach(([key, operations]) => {
@@ -588,54 +503,7 @@ function update(data) {
  * @param collection Object collection keyed by individual collection member keys and values
  */
 function setCollection(collectionKey, collection) {
-    let resultCollection = collection;
-    let resultCollectionKeys = Object.keys(resultCollection);
-    // Confirm all the collection keys belong to the same parent
-    if (!OnyxUtils_1.default.doAllCollectionItemsBelongToSameParent(collectionKey, resultCollectionKeys)) {
-        Logger.logAlert(`setCollection called with keys that do not belong to the same parent ${collectionKey}. Skipping this update.`);
-        return Promise.resolve();
-    }
-    const skippableCollectionMemberIDs = OnyxUtils_1.default.getSkippableCollectionMemberIDs();
-    if (skippableCollectionMemberIDs.size) {
-        resultCollection = resultCollectionKeys.reduce((result, key) => {
-            try {
-                const [, collectionMemberID] = OnyxUtils_1.default.splitCollectionMemberKey(key, collectionKey);
-                // If the collection member key is a skippable one we set its value to null.
-                // eslint-disable-next-line no-param-reassign
-                result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? resultCollection[key] : null;
-            }
-            catch (_a) {
-                // Something went wrong during split, so we assign the data to result anyway.
-                // eslint-disable-next-line no-param-reassign
-                result[key] = resultCollection[key];
-            }
-            return result;
-        }, {});
-    }
-    resultCollectionKeys = Object.keys(resultCollection);
-    return OnyxUtils_1.default.getAllKeys().then((persistedKeys) => {
-        const mutableCollection = Object.assign({}, resultCollection);
-        persistedKeys.forEach((key) => {
-            if (!key.startsWith(collectionKey)) {
-                return;
-            }
-            if (resultCollectionKeys.includes(key)) {
-                return;
-            }
-            mutableCollection[key] = null;
-        });
-        const keyValuePairs = OnyxUtils_1.default.prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
-        const previousCollection = OnyxUtils_1.default.getCachedCollection(collectionKey);
-        // Preserve references for unchanged items in setCollection
-        const preservedCollection = OnyxUtils_1.default.preserveCollectionReferences(keyValuePairs);
-        const updatePromise = OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(collectionKey, preservedCollection, previousCollection);
-        return storage_1.default.multiSet(keyValuePairs)
-            .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, setCollection, collectionKey, collection))
-            .then(() => {
-            OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.SET_COLLECTION, undefined, mutableCollection);
-            return updatePromise;
-        });
-    });
+    return OnyxUtils_1.default.setCollectionWithRetry({ collectionKey, collection });
 }
 const Onyx = {
     METHOD: OnyxUtils_1.default.METHOD,

package/dist/OnyxUtils.d.ts

@@ -1,6 +1,6 @@
 import type { ValueOf } from 'type-fest';
 import type Onyx from './Onyx';
-import type { CollectionKey, CollectionKeyBase, ConnectOptions, DeepRecord, KeyValueMapping, CallbackToStateMapping, MultiMergeReplaceNullPatches, OnyxCollection, OnyxEntry, OnyxInput, OnyxInputKeyValueMapping, OnyxKey, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, Selector, OnyxSetCollectionInput } from './types';
+import type { CollectionKey, CollectionKeyBase, ConnectOptions, DeepRecord, KeyValueMapping, CallbackToStateMapping, MultiMergeReplaceNullPatches, OnyxCollection, OnyxEntry, OnyxInput, OnyxKey, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, Selector, MergeCollectionWithPatchesParams, SetCollectionParams, SetParams, OnyxMultiSetInput, RetriableOnyxOperation } from './types';
 import type { FastMergeResult } from './utils';
 import type { DeferredTask } from './createDeferredTask';
 import type { StorageKeyValuePair } from './storage/providers/types';
@@ -138,18 +138,6 @@ declare function getCollectionKey(key: CollectionKey): string;
  * If the requested key is a collection, it will return an object with all the collection members.
  */
 declare function tryGetCachedValue<TKey extends OnyxKey>(key: TKey): OnyxValue<OnyxKey>;
-/**
- * Utility function to preserve object references for unchanged items in collection operations.
- * Compares new values with cached values using deep equality and preserves references when data is identical.
- * @returns The preserved collection with unchanged references maintained
- */
-declare function preserveCollectionReferences(keyValuePairs: StorageKeyValuePair[]): OnyxInputKeyValueMapping;
-/**
- * Utility function for merge operations that preserves references after cache merge has been performed.
- * Compares merged values with original cached values and preserves references when data is unchanged.
- * @returns The preserved collection with unchanged references maintained
- */
-declare function preserveCollectionReferencesAfterMerge(collection: Record<string, OnyxValue<OnyxKey>>, originalCachedValues: Record<string, OnyxValue<OnyxKey>>): Record<string, OnyxValue<OnyxKey>>;
 declare function getCachedCollection<TKey extends CollectionKeyBase>(collectionKey: TKey, collectionMemberKeys?: string[]): NonNullable<OnyxCollection<KeyValueMapping[TKey]>>;
 /**
  * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
@@ -194,11 +182,12 @@ declare function scheduleNotifyCollectionSubscribers<TKey extends OnyxKey>(key:
 declare function remove<TKey extends OnyxKey>(key: TKey, isProcessingCollectionUpdate?: boolean): Promise<void>;
 declare function reportStorageQuota(): Promise<void>;
 /**
- * If we fail to set or merge we must handle this by
- * evicting some data from Onyx and then retrying to do
- * whatever it is we attempted to do.
+ * Handles storage operation failures based on the error type:
+ * - Storage capacity errors: evicts data and retries the operation
+ * - Invalid data errors: logs an alert and throws an error
+ * - Other errors: retries the operation
  */
-declare function evictStorageAndRetry<TMethod extends typeof Onyx.set | typeof Onyx.multiSet | typeof Onyx.mergeCollection | typeof Onyx.setCollection>(error: Error, onyxMethod: TMethod, ...args: Parameters<TMethod>): Promise<void>;
+declare function retryOperation<TMethod extends RetriableOnyxOperation>(error: Error, onyxMethod: TMethod, defaultParams: Parameters<TMethod>[0], retryAttempt: number | undefined): Promise<void>;
 /**
  * Notifies subscribers and writes current value to cache
  */
@@ -253,25 +242,64 @@ declare function subscribeToKey<TKey extends OnyxKey>(connectOptions: ConnectOpt
  */
 declare function unsubscribeFromKey(subscriptionID: number): void;
 declare function updateSnapshots(data: OnyxUpdate[], mergeFn: typeof Onyx.merge): Array<() => Promise<void>>;
+/**
+ * Writes a value to our store with the given key.
+ * Serves as core implementation for `Onyx.set()` public function, the difference being
+ * that this internal function allows passing an additional `retryAttempt` parameter to retry on failure.
+ *
+ * @param params - set parameters
+ * @param params.key ONYXKEY to set
+ * @param params.value value to store
+ * @param params.options optional configuration object
+ * @param retryAttempt retry attempt
+ */
+declare function setWithRetry<TKey extends OnyxKey>({ key, value, options }: SetParams<TKey>, retryAttempt?: number): Promise<void>;
+/**
+ * Sets multiple keys and values.
+ * Serves as core implementation for `Onyx.multiSet()` public function, the difference being
+ * that this internal function allows passing an additional `retryAttempt` parameter to retry on failure.
+ *
+ * @param data object keyed by ONYXKEYS and the values to set
+ * @param retryAttempt retry attempt
+ */
+declare function multiSetWithRetry(data: OnyxMultiSetInput, retryAttempt?: number): Promise<void>;
+/**
+ * Sets a collection by replacing all existing collection members with new values.
+ * Any existing collection members not included in the new data will be removed.
+ * Serves as core implementation for `Onyx.setCollection()` public function, the difference being
+ * that this internal function allows passing an additional `retryAttempt` parameter to retry on failure.
+ *
+ * @param params - collection parameters
+ * @param params.collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
+ * @param params.collection Object collection keyed by individual collection member keys and values
+ * @param retryAttempt retry attempt
+ */
+declare function setCollectionWithRetry<TKey extends CollectionKeyBase>({ collectionKey, collection }: SetCollectionParams<TKey>, retryAttempt?: number): Promise<void>;
 /**
  * Merges a collection based on their keys.
  * Serves as core implementation for `Onyx.mergeCollection()` public function, the difference being
- * that this internal function allows passing an additional `mergeReplaceNullPatches` parameter.
+ * that this internal function allows passing an additional `mergeReplaceNullPatches` parameter and retries on failure.
  *
- * @param collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
- * @param collection Object collection keyed by individual collection member keys and values
- * @param mergeReplaceNullPatches Record where the key is a collection member key and the value is a list of
+ * @param params - mergeCollection parameters
+ * @param params.collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
+ * @param params.collection Object collection keyed by individual collection member keys and values
+ * @param params.mergeReplaceNullPatches Record where the key is a collection member key and the value is a list of
  * tuples that we'll use to replace the nested objects of that collection member record with something else.
+ * @param params.isProcessingCollectionUpdate whether this is part of a collection update operation.
+ * @param retryAttempt retry attempt
  */
-declare function mergeCollectionWithPatches<TKey extends CollectionKeyBase>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey>, mergeReplaceNullPatches?: MultiMergeReplaceNullPatches, isProcessingCollectionUpdate?: boolean): Promise<void>;
+declare function mergeCollectionWithPatches<TKey extends CollectionKeyBase>({ collectionKey, collection, mergeReplaceNullPatches, isProcessingCollectionUpdate }: MergeCollectionWithPatchesParams<TKey>, retryAttempt?: number): Promise<void>;
 /**
  * Sets keys in a collection by replacing all targeted collection members with new values.
  * Any existing collection members not included in the new data will not be removed.
+ * Retries on failure.
  *
- * @param collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
- * @param collection Object collection keyed by individual collection member keys and values
+ * @param params - collection parameters
+ * @param params.collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
+ * @param params.collection Object collection keyed by individual collection member keys and values
+ * @param retryAttempt retry attempt
  */
-declare function partialSetCollection<TKey extends CollectionKeyBase>(collectionKey: TKey, collection: OnyxSetCollectionInput<TKey>): Promise<void>;
+declare function partialSetCollection<TKey extends CollectionKeyBase>({ collectionKey, collection }: SetCollectionParams<TKey>, retryAttempt?: number): Promise<void>;
 declare function logKeyChanged(onyxMethod: Extract<OnyxMethod, 'set' | 'merge'>, key: OnyxKey, value: unknown, hasChanged: boolean): void;
 declare function logKeyRemoved(onyxMethod: Extract<OnyxMethod, 'set' | 'merge'>, key: OnyxKey): void;
 /**
@@ -313,7 +341,7 @@ declare const OnyxUtils: {
     scheduleNotifyCollectionSubscribers: typeof scheduleNotifyCollectionSubscribers;
     remove: typeof remove;
     reportStorageQuota: typeof reportStorageQuota;
-    evictStorageAndRetry: typeof evictStorageAndRetry;
+    retryOperation: typeof retryOperation;
     broadcastUpdate: typeof broadcastUpdate;
     hasPendingMergeForKey: typeof hasPendingMergeForKey;
     prepareKeyValuePairsForStorage: typeof prepareKeyValuePairsForStorage;
@@ -336,10 +364,11 @@ declare const OnyxUtils: {
     updateSnapshots: typeof updateSnapshots;
     mergeCollectionWithPatches: typeof mergeCollectionWithPatches;
     partialSetCollection: typeof partialSetCollection;
-    preserveCollectionReferences: typeof preserveCollectionReferences;
-    preserveCollectionReferencesAfterMerge: typeof preserveCollectionReferencesAfterMerge;
     logKeyChanged: typeof logKeyChanged;
     logKeyRemoved: typeof logKeyRemoved;
+    setWithRetry: typeof setWithRetry;
+    multiSetWithRetry: typeof multiSetWithRetry;
+    setCollectionWithRetry: typeof setCollectionWithRetry;
 };
 export type { OnyxMethod };
 export default OnyxUtils;

package/dist/OnyxUtils.js

@@ -61,6 +61,19 @@ const METHOD = {
     MULTI_SET: 'multiset',
     CLEAR: 'clear',
 };
+// IndexedDB errors that indicate storage capacity issues where eviction can help
+const IDB_STORAGE_ERRORS = [
+    'quotaexceedederror', // Browser storage quota exceeded
+];
+// SQLite errors that indicate storage capacity issues where eviction can help
+const SQLITE_STORAGE_ERRORS = [
+    'database or disk is full', // Device storage is full
+    'disk I/O error', // File system I/O failure, often due to insufficient space or corrupted storage
+    'out of memory', // Insufficient RAM or storage space to complete the operation
+];
+const STORAGE_ERRORS = [...IDB_STORAGE_ERRORS, ...SQLITE_STORAGE_ERRORS];
+// Max number of retries for failed storage operations
+const MAX_STORAGE_OPERATION_RETRY_ATTEMPTS = 5;
 // Key/value store of Onyx key and arrays of values to merge
 let mergeQueue = {};
 let mergeQueuePromise = {};
@@ -452,51 +465,6 @@ function tryGetCachedValue(key) {
     }
     return val;
 }
-/**
- * Utility function to preserve object references for unchanged items in collection operations.
- * Compares new values with cached values using deep equality and preserves references when data is identical.
- * @returns The preserved collection with unchanged references maintained
- */
-function preserveCollectionReferences(keyValuePairs) {
-    const preservedCollection = {};
-    keyValuePairs.forEach(([key, value]) => {
-        const cachedValue = OnyxCache_1.default.get(key, false);
-        // If no cached value exists, we need to add the new value (skip expensive deep equality check)
-        // Use deep equality check to preserve references for unchanged items
-        if (cachedValue !== undefined && (0, fast_equals_1.deepEqual)(value, cachedValue)) {
-            // Keep the existing reference
-            preservedCollection[key] = cachedValue;
-        }
-        else {
-            // Update cache only for changed items
-            OnyxCache_1.default.set(key, value);
-            preservedCollection[key] = value;
-        }
-    });
-    return preservedCollection;
-}
-/**
- * Utility function for merge operations that preserves references after cache merge has been performed.
- * Compares merged values with original cached values and preserves references when data is unchanged.
- * @returns The preserved collection with unchanged references maintained
- */
-function preserveCollectionReferencesAfterMerge(collection, originalCachedValues) {
-    const preservedCollection = {};
-    Object.keys(collection).forEach((key) => {
-        const newMergedValue = OnyxCache_1.default.get(key, false);
-        const originalValue = originalCachedValues[key];
-        // Use deep equality check to preserve references for unchanged items
-        if (originalValue !== undefined && (0, fast_equals_1.deepEqual)(newMergedValue, originalValue)) {
-            // Keep the existing reference and update cache
-            preservedCollection[key] = originalValue;
-            OnyxCache_1.default.set(key, originalValue);
-        }
-        else {
-            preservedCollection[key] = newMergedValue;
-        }
-    });
-    return preservedCollection;
-}
 function getCachedCollection(collectionKey, collectionMemberKeys) {
     // Use optimized collection data retrieval when cache is populated
     const collectionData = OnyxCache_1.default.getCollectionData(collectionKey);
@@ -757,16 +725,31 @@ function reportStorageQuota() {
     });
 }
 /**
- * If we fail to set or merge we must handle this by
- * evicting some data from Onyx and then retrying to do
- * whatever it is we attempted to do.
+ * Handles storage operation failures based on the error type:
+ * - Storage capacity errors: evicts data and retries the operation
+ * - Invalid data errors: logs an alert and throws an error
+ * - Other errors: retries the operation
  */
-function evictStorageAndRetry(error, onyxMethod, ...args) {
-    Logger.logInfo(`Failed to save to storage. Error: ${error}. onyxMethod: ${onyxMethod.name}`);
+function retryOperation(error, onyxMethod, defaultParams, retryAttempt) {
+    var _a, _b, _c, _d;
+    const currentRetryAttempt = retryAttempt !== null && retryAttempt !== void 0 ? retryAttempt : 0;
+    const nextRetryAttempt = currentRetryAttempt + 1;
+    Logger.logInfo(`Failed to save to storage. Error: ${error}. onyxMethod: ${onyxMethod.name}. retryAttempt: ${currentRetryAttempt}/${MAX_STORAGE_OPERATION_RETRY_ATTEMPTS}`);
     if (error && Str.startsWith(error.message, "Failed to execute 'put' on 'IDBObjectStore'")) {
         Logger.logAlert('Attempted to set invalid data set in Onyx. Please ensure all data is serializable.');
         throw error;
     }
+    const errorMessage = (_b = (_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.toLowerCase) === null || _b === void 0 ? void 0 : _b.call(_a);
+    const errorName = (_d = (_c = error === null || error === void 0 ? void 0 : error.name) === null || _c === void 0 ? void 0 : _c.toLowerCase) === null || _d === void 0 ? void 0 : _d.call(_c);
+    const isStorageCapacityError = STORAGE_ERRORS.some((storageError) => (errorName === null || errorName === void 0 ? void 0 : errorName.includes(storageError)) || (errorMessage === null || errorMessage === void 0 ? void 0 : errorMessage.includes(storageError)));
+    if (nextRetryAttempt > MAX_STORAGE_OPERATION_RETRY_ATTEMPTS) {
+        Logger.logAlert(`Storage operation failed after 5 retries. Error: ${error}. onyxMethod: ${onyxMethod.name}.`);
+        return Promise.resolve();
+    }
+    if (!isStorageCapacityError) {
+        // @ts-expect-error No overload matches this call.
+        return onyxMethod(defaultParams, nextRetryAttempt);
+    }
     // Find the first key that we can remove that has no subscribers in our blocklist
     const keyForRemoval = OnyxCache_1.default.getKeyForEviction();
     if (!keyForRemoval) {
@@ -780,7 +763,7 @@ function evictStorageAndRetry(error, onyxMethod, ...args) {
     Logger.logInfo(`Out of storage. Evicting least recently accessed key (${keyForRemoval}) and retrying.`);
     reportStorageQuota();
     // @ts-expect-error No overload matches this call.
-    return remove(keyForRemoval).then(() => onyxMethod(...args));
+    return remove(keyForRemoval).then(() => onyxMethod(defaultParams, nextRetryAttempt));
 }
 /**
  * Notifies subscribers and writes current value to cache
@@ -1050,17 +1033,192 @@ function updateSnapshots(data, mergeFn) {
     });
     return promises;
 }
+/**
+ * Writes a value to our store with the given key.
+ * Serves as core implementation for `Onyx.set()` public function, the difference being
+ * that this internal function allows passing an additional `retryAttempt` parameter to retry on failure.
+ *
+ * @param params - set parameters
+ * @param params.key ONYXKEY to set
+ * @param params.value value to store
+ * @param params.options optional configuration object
+ * @param retryAttempt retry attempt
+ */
+function setWithRetry({ key, value, options }, retryAttempt) {
+    // When we use Onyx.set to set a key we want to clear the current delta changes from Onyx.merge that were queued
+    // before the value was set. If Onyx.merge is currently reading the old value from storage, it will then not apply the changes.
+    if (OnyxUtils.hasPendingMergeForKey(key)) {
+        delete OnyxUtils.getMergeQueue()[key];
+    }
+    if (skippableCollectionMemberIDs.size) {
+        try {
+            const [, collectionMemberID] = OnyxUtils.splitCollectionMemberKey(key);
+            if (skippableCollectionMemberIDs.has(collectionMemberID)) {
+                // The key is a skippable one, so we set the new value to null.
+                // eslint-disable-next-line no-param-reassign
+                value = null;
+            }
+        }
+        catch (e) {
+            // The key is not a collection one or something went wrong during split, so we proceed with the function's logic.
+        }
+    }
+    // Onyx.set will ignore `undefined` values as inputs, therefore we can return early.
+    if (value === undefined) {
+        return Promise.resolve();
+    }
+    const existingValue = OnyxCache_1.default.get(key, false);
+    // If the existing value as well as the new value are null, we can return early.
+    if (existingValue === undefined && value === null) {
+        return Promise.resolve();
+    }
+    // Check if the value is compatible with the existing value in the storage
+    const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(value, existingValue);
+    if (!isCompatible) {
+        Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'set', existingValueType, newValueType));
+        return Promise.resolve();
+    }
+    // If the change is null, we can just delete the key.
+    // Therefore, we don't need to further broadcast and update the value so we can return early.
+    if (value === null) {
+        OnyxUtils.remove(key);
+        OnyxUtils.logKeyRemoved(OnyxUtils.METHOD.SET, key);
+        return Promise.resolve();
+    }
+    const valueWithoutNestedNullValues = utils_1.default.removeNestedNullValues(value);
+    const hasChanged = (options === null || options === void 0 ? void 0 : options.skipCacheCheck) ? true : OnyxCache_1.default.hasValueChanged(key, valueWithoutNestedNullValues);
+    OnyxUtils.logKeyChanged(OnyxUtils.METHOD.SET, key, value, hasChanged);
+    // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
+    const updatePromise = OnyxUtils.broadcastUpdate(key, valueWithoutNestedNullValues, hasChanged);
+    // If the value has not changed and this isn't a retry attempt, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
+    if (!hasChanged && !retryAttempt) {
+        return updatePromise;
+    }
+    return storage_1.default.setItem(key, valueWithoutNestedNullValues)
+        .catch((error) => OnyxUtils.retryOperation(error, setWithRetry, { key, value: valueWithoutNestedNullValues, options }, retryAttempt))
+        .then(() => {
+        OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET, key, valueWithoutNestedNullValues);
+        return updatePromise;
+    });
+}
+/**
+ * Sets multiple keys and values.
+ * Serves as core implementation for `Onyx.multiSet()` public function, the difference being
+ * that this internal function allows passing an additional `retryAttempt` parameter to retry on failure.
+ *
+ * @param data object keyed by ONYXKEYS and the values to set
+ * @param retryAttempt retry attempt
+ */
+function multiSetWithRetry(data, retryAttempt) {
+    let newData = data;
+    if (skippableCollectionMemberIDs.size) {
+        newData = Object.keys(newData).reduce((result, key) => {
+            try {
+                const [, collectionMemberID] = OnyxUtils.splitCollectionMemberKey(key);
+                // If the collection member key is a skippable one we set its value to null.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? newData[key] : null;
+            }
+            catch (_a) {
+                // The key is not a collection one or something went wrong during split, so we assign the data to result anyway.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = newData[key];
+            }
+            return result;
+        }, {});
+    }
+    const keyValuePairsToSet = OnyxUtils.prepareKeyValuePairsForStorage(newData, true);
+    const updatePromises = keyValuePairsToSet.map(([key, value]) => {
+        // When we use multiSet to set a key we want to clear the current delta changes from Onyx.merge that were queued
+        // before the value was set. If Onyx.merge is currently reading the old value from storage, it will then not apply the changes.
+        if (OnyxUtils.hasPendingMergeForKey(key)) {
+            delete OnyxUtils.getMergeQueue()[key];
+        }
+        // Update cache and optimistically inform subscribers on the next tick
+        OnyxCache_1.default.set(key, value);
+        return OnyxUtils.scheduleSubscriberUpdate(key, value);
+    });
+    return storage_1.default.multiSet(keyValuePairsToSet)
+        .catch((error) => OnyxUtils.retryOperation(error, multiSetWithRetry, newData, retryAttempt))
+        .then(() => {
+        OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.MULTI_SET, undefined, newData);
+        return Promise.all(updatePromises);
+    })
+        .then(() => undefined);
+}
+/**
+ * Sets a collection by replacing all existing collection members with new values.
+ * Any existing collection members not included in the new data will be removed.
+ * Serves as core implementation for `Onyx.setCollection()` public function, the difference being
+ * that this internal function allows passing an additional `retryAttempt` parameter to retry on failure.
+ *
+ * @param params - collection parameters
+ * @param params.collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
+ * @param params.collection Object collection keyed by individual collection member keys and values
+ * @param retryAttempt retry attempt
+ */
+function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
+    let resultCollection = collection;
+    let resultCollectionKeys = Object.keys(resultCollection);
+    // Confirm all the collection keys belong to the same parent
+    if (!OnyxUtils.doAllCollectionItemsBelongToSameParent(collectionKey, resultCollectionKeys)) {
+        Logger.logAlert(`setCollection called with keys that do not belong to the same parent ${collectionKey}. Skipping this update.`);
+        return Promise.resolve();
+    }
+    if (skippableCollectionMemberIDs.size) {
+        resultCollection = resultCollectionKeys.reduce((result, key) => {
+            try {
+                const [, collectionMemberID] = OnyxUtils.splitCollectionMemberKey(key, collectionKey);
+                // If the collection member key is a skippable one we set its value to null.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? resultCollection[key] : null;
+            }
+            catch (_a) {
+                // Something went wrong during split, so we assign the data to result anyway.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = resultCollection[key];
+            }
+            return result;
+        }, {});
+    }
+    resultCollectionKeys = Object.keys(resultCollection);
+    return OnyxUtils.getAllKeys().then((persistedKeys) => {
+        const mutableCollection = Object.assign({}, resultCollection);
+        persistedKeys.forEach((key) => {
+            if (!key.startsWith(collectionKey)) {
+                return;
+            }
+            if (resultCollectionKeys.includes(key)) {
+                return;
+            }
+            mutableCollection[key] = null;
+        });
+        const keyValuePairs = OnyxUtils.prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
+        const previousCollection = OnyxUtils.getCachedCollection(collectionKey);
+        keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
+        const updatePromise = OnyxUtils.scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
+        return storage_1.default.multiSet(keyValuePairs)
+            .catch((error) => OnyxUtils.retryOperation(error, setCollectionWithRetry, { collectionKey, collection }, retryAttempt))
+            .then(() => {
+            OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET_COLLECTION, undefined, mutableCollection);
+            return updatePromise;
+        });
+    });
+}
 /**
  * Merges a collection based on their keys.
  * Serves as core implementation for `Onyx.mergeCollection()` public function, the difference being
- * that this internal function allows passing an additional `mergeReplaceNullPatches` parameter.
+ * that this internal function allows passing an additional `mergeReplaceNullPatches` parameter and retries on failure.
  *
- * @param collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
- * @param collection Object collection keyed by individual collection member keys and values
- * @param mergeReplaceNullPatches Record where the key is a collection member key and the value is a list of
+ * @param params - mergeCollection parameters
+ * @param params.collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
+ * @param params.collection Object collection keyed by individual collection member keys and values
+ * @param params.mergeReplaceNullPatches Record where the key is a collection member key and the value is a list of
  * tuples that we'll use to replace the nested objects of that collection member record with something else.
+ * @param params.isProcessingCollectionUpdate whether this is part of a collection update operation.
+ * @param retryAttempt retry attempt
  */
-function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullPatches, isProcessingCollectionUpdate = false) {
+function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNullPatches, isProcessingCollectionUpdate = false }, retryAttempt) {
     if (!isValidNonEmptyCollectionForMerge(collection)) {
         Logger.logInfo('mergeCollection() called with invalid or empty value. Skipping this update.');
         return Promise.resolve();
@@ -1139,21 +1297,13 @@ function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullP
         // finalMergedCollection contains all the keys that were merged, without the keys of incompatible updates
         const finalMergedCollection = Object.assign(Object.assign({}, existingKeyCollection), newCollection);
         // Prefill cache if necessary by calling get() on any existing keys and then merge original data to cache
-        // and update all subscribers with reference preservation for unchanged items
+        // and update all subscribers
         const promiseUpdate = previousCollectionPromise.then((previousCollection) => {
-            // Capture the original cached values before merging
-            const originalCachedValues = {};
-            Object.keys(finalMergedCollection).forEach((key) => {
-                originalCachedValues[key] = OnyxCache_1.default.get(key, false);
-            });
-            // Then merge all the data into cache as normal
             OnyxCache_1.default.merge(finalMergedCollection);
-            // Finally, preserve references for items that didn't actually change
-            const preservedCollection = preserveCollectionReferencesAfterMerge(finalMergedCollection, originalCachedValues);
-            return scheduleNotifyCollectionSubscribers(collectionKey, preservedCollection, previousCollection);
+            return scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection, previousCollection);
         });
         return Promise.all(promises)
-            .catch((error) => evictStorageAndRetry(error, mergeCollectionWithPatches, collectionKey, resultCollection))
+            .catch((error) => retryOperation(error, mergeCollectionWithPatches, { collectionKey, collection: resultCollection, mergeReplaceNullPatches, isProcessingCollectionUpdate }, retryAttempt))
             .then(() => {
             sendActionToDevTools(METHOD.MERGE_COLLECTION, undefined, resultCollection);
             return promiseUpdate;
@@ -1164,11 +1314,14 @@ function mergeCollectionWithPatches(collectionKey, collection, mergeReplaceNullP
 /**
  * Sets keys in a collection by replacing all targeted collection members with new values.
  * Any existing collection members not included in the new data will not be removed.
+ * Retries on failure.
  *
- * @param collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
- * @param collection Object collection keyed by individual collection member keys and values
+ * @param params - collection parameters
+ * @param params.collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
+ * @param params.collection Object collection keyed by individual collection member keys and values
+ * @param retryAttempt retry attempt
  */
-function partialSetCollection(collectionKey, collection) {
+function partialSetCollection({ collectionKey, collection }, retryAttempt) {
     let resultCollection = collection;
     let resultCollectionKeys = Object.keys(resultCollection);
     // Confirm all the collection keys belong to the same parent
@@ -1198,11 +1351,10 @@ function partialSetCollection(collectionKey, collection) {
         const existingKeys = resultCollectionKeys.filter((key) => persistedKeys.has(key));
         const previousCollection = getCachedCollection(collectionKey, existingKeys);
         const keyValuePairs = prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
-        // Preserve references for unchanged items in partialSetCollection
-        const preservedCollection = preserveCollectionReferences(keyValuePairs);
-        const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, preservedCollection, previousCollection);
+        keyValuePairs.forEach(([key, value]) => OnyxCache_1.default.set(key, value));
+        const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
         return storage_1.default.multiSet(keyValuePairs)
-            .catch((error) => evictStorageAndRetry(error, partialSetCollection, collectionKey, collection))
+            .catch((error) => retryOperation(error, partialSetCollection, { collectionKey, collection }, retryAttempt))
             .then(() => {
             sendActionToDevTools(METHOD.SET_COLLECTION, undefined, mutableCollection);
             return updatePromise;
@@ -1254,7 +1406,7 @@ const OnyxUtils = {
     scheduleNotifyCollectionSubscribers,
     remove,
     reportStorageQuota,
-    evictStorageAndRetry,
+    retryOperation,
     broadcastUpdate,
     hasPendingMergeForKey,
     prepareKeyValuePairsForStorage,
@@ -1277,10 +1429,11 @@ const OnyxUtils = {
     updateSnapshots,
     mergeCollectionWithPatches,
     partialSetCollection,
-    preserveCollectionReferences,
-    preserveCollectionReferencesAfterMerge,
     logKeyChanged,
     logKeyRemoved,
+    setWithRetry,
+    multiSetWithRetry,
+    setCollectionWithRetry,
 };
 GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) => {
     if (!enablePerformanceMetrics) {
@@ -1314,7 +1467,7 @@ GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) =>
     // @ts-expect-error Reassign
     reportStorageQuota = (0, metrics_1.default)(reportStorageQuota, 'OnyxUtils.reportStorageQuota');
     // @ts-expect-error Complex type signature
-    evictStorageAndRetry = (0, metrics_1.default)(evictStorageAndRetry, 'OnyxUtils.evictStorageAndRetry');
+    retryOperation = (0, metrics_1.default)(retryOperation, 'OnyxUtils.retryOperation');
     // @ts-expect-error Reassign
     broadcastUpdate = (0, metrics_1.default)(broadcastUpdate, 'OnyxUtils.broadcastUpdate');
     // @ts-expect-error Reassign
@@ -1325,5 +1478,11 @@ GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) =>
     tupleGet = (0, metrics_1.default)(tupleGet, 'OnyxUtils.tupleGet');
     // @ts-expect-error Reassign
     subscribeToKey = (0, metrics_1.default)(subscribeToKey, 'OnyxUtils.subscribeToKey');
+    // @ts-expect-error Reassign
+    setWithRetry = (0, metrics_1.default)(setWithRetry, 'OnyxUtils.setWithRetry');
+    // @ts-expect-error Reassign
+    multiSetWithRetry = (0, metrics_1.default)(multiSetWithRetry, 'OnyxUtils.multiSetWithRetry');
+    // @ts-expect-error Reassign
+    setCollectionWithRetry = (0, metrics_1.default)(setCollectionWithRetry, 'OnyxUtils.setCollectionWithRetry');
 });
 exports.default = OnyxUtils;

package/dist/types.d.ts

@@ -311,6 +311,22 @@ type SetOptions = {
     /** Skip the deep equality check against the cached value. Improves performance for large objects. */
     skipCacheCheck?: boolean;
 };
+type SetParams<TKey extends OnyxKey> = {
+    key: TKey;
+    value: OnyxSetInput<TKey>;
+    options?: SetOptions;
+};
+type SetCollectionParams<TKey extends CollectionKeyBase> = {
+    collectionKey: TKey;
+    collection: OnyxSetCollectionInput<TKey>;
+};
+type MergeCollectionWithPatchesParams<TKey extends CollectionKeyBase> = {
+    collectionKey: TKey;
+    collection: OnyxMergeCollectionInput<TKey>;
+    mergeReplaceNullPatches?: MultiMergeReplaceNullPatches;
+    isProcessingCollectionUpdate?: boolean;
+};
+type RetriableOnyxOperation = typeof OnyxUtils.setWithRetry | typeof OnyxUtils.multiSetWithRetry | typeof OnyxUtils.setCollectionWithRetry | typeof OnyxUtils.mergeCollectionWithPatches | typeof OnyxUtils.partialSetCollection;
 /**
  * Represents the options used in `Onyx.init()` method.
  */
@@ -368,4 +384,4 @@ type MixedOperationsQueue = {
     mergeReplaceNullPatches: MultiMergeReplaceNullPatches;
     set: OnyxInputKeyValueMapping;
 };
-export type { BaseConnectOptions, Collection, CollectionConnectCallback, CollectionConnectOptions, CollectionKey, CollectionKeyBase, ConnectOptions, CustomTypeOptions, DeepRecord, DefaultConnectCallback, DefaultConnectOptions, ExtractOnyxCollectionValue, GenericFunction, InitOptions, Key, KeyValueMapping, CallbackToStateMapping, NonNull, NonUndefined, OnyxInputKeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxSetCollectionInput, OnyxMethod, OnyxMethodMap, OnyxUpdate, OnyxValue, Selector, SetOptions, MultiMergeReplaceNullPatches, MixedOperationsQueue, };
+export type { BaseConnectOptions, Collection, CollectionConnectCallback, CollectionConnectOptions, CollectionKey, CollectionKeyBase, ConnectOptions, CustomTypeOptions, DeepRecord, DefaultConnectCallback, DefaultConnectOptions, ExtractOnyxCollectionValue, GenericFunction, InitOptions, Key, KeyValueMapping, CallbackToStateMapping, NonNull, NonUndefined, OnyxInputKeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxSetCollectionInput, OnyxMethod, OnyxMethodMap, OnyxUpdate, OnyxValue, Selector, SetOptions, SetParams, SetCollectionParams, MergeCollectionWithPatchesParams, MultiMergeReplaceNullPatches, MixedOperationsQueue, RetriableOnyxOperation, };

package/package.json

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