react-native-onyx 3.0.34 → 3.0.36

package/dist/Onyx.js

@@ -151,7 +151,7 @@ function disconnect(connection) {
  * @param options optional configuration object
  */
 function set(key, value, options) {
-    return OnyxUtils_1.default.setWithRetry({ key, value, options });
+    return OnyxUtils_1.default.afterInit(() => OnyxUtils_1.default.setWithRetry({ key, value, options }));
 }
 /**
  * Sets multiple keys and values
@@ -161,7 +161,7 @@ function set(key, value, options) {
  * @param data object keyed by ONYXKEYS and the values to set
  */
 function multiSet(data) {
-    return OnyxUtils_1.default.multiSetWithRetry(data);
+    return OnyxUtils_1.default.afterInit(() => OnyxUtils_1.default.multiSetWithRetry(data));
 }
 /**
  * Merge a new value into an existing value at a key.
@@ -180,71 +180,73 @@ function multiSet(data) {
  * Onyx.merge(ONYXKEYS.POLICY, {name: 'My Workspace'}); // -> {id: 1, name: 'My Workspace'}
  */
 function merge(key, changes) {
-    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 changes to undefined.
-                // eslint-disable-next-line no-param-reassign
-                changes = undefined;
+    return OnyxUtils_1.default.afterInit(() => {
+        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 changes to undefined.
+                    // eslint-disable-next-line no-param-reassign
+                    changes = undefined;
+                }
+            }
+            catch (e) {
+                // The key is not a collection one or something went wrong during split, so we proceed with the function's logic.
             }
         }
-        catch (e) {
-            // The key is not a collection one or something went wrong during split, so we proceed with the function's logic.
+        const mergeQueue = OnyxUtils_1.default.getMergeQueue();
+        const mergeQueuePromise = OnyxUtils_1.default.getMergeQueuePromise();
+        // Top-level undefined values are ignored
+        // Therefore, we need to prevent adding them to the merge queue
+        if (changes === undefined) {
+            return mergeQueue[key] ? mergeQueuePromise[key] : Promise.resolve();
         }
-    }
-    const mergeQueue = OnyxUtils_1.default.getMergeQueue();
-    const mergeQueuePromise = OnyxUtils_1.default.getMergeQueuePromise();
-    // Top-level undefined values are ignored
-    // Therefore, we need to prevent adding them to the merge queue
-    if (changes === undefined) {
-        return mergeQueue[key] ? mergeQueuePromise[key] : Promise.resolve();
-    }
-    // Merge attempts are batched together. The delta should be applied after a single call to get() to prevent a race condition.
-    // Using the initial value from storage in subsequent merge attempts will lead to an incorrect final merged value.
-    if (mergeQueue[key]) {
-        mergeQueue[key].push(changes);
-        return mergeQueuePromise[key];
-    }
-    mergeQueue[key] = [changes];
-    mergeQueuePromise[key] = OnyxUtils_1.default.get(key).then((existingValue) => {
-        // 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();
+        // Merge attempts are batched together. The delta should be applied after a single call to get() to prevent a race condition.
+        // Using the initial value from storage in subsequent merge attempts will lead to an incorrect final merged value.
+        if (mergeQueue[key]) {
+            mergeQueue[key].push(changes);
+            return mergeQueuePromise[key];
         }
-        try {
-            const validChanges = mergeQueue[key].filter((change) => {
-                const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(change, existingValue);
-                if (!isCompatible) {
-                    Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'merge', existingValueType, newValueType));
-                }
-                return isCompatible;
-            });
-            // Clean up the write queue, so we don't apply these changes again.
-            delete mergeQueue[key];
-            delete mergeQueuePromise[key];
-            if (!validChanges.length) {
+        mergeQueue[key] = [changes];
+        mergeQueuePromise[key] = OnyxUtils_1.default.get(key).then((existingValue) => {
+            // 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();
             }
-            // If the last 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 (validChanges.at(-1) === null) {
-                OnyxUtils_1.default.remove(key);
-                OnyxUtils_1.default.logKeyRemoved(OnyxUtils_1.default.METHOD.MERGE, key);
+            try {
+                const validChanges = mergeQueue[key].filter((change) => {
+                    const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(change, existingValue);
+                    if (!isCompatible) {
+                        Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'merge', existingValueType, newValueType));
+                    }
+                    return isCompatible;
+                });
+                // Clean up the write queue, so we don't apply these changes again.
+                delete mergeQueue[key];
+                delete mergeQueuePromise[key];
+                if (!validChanges.length) {
+                    return Promise.resolve();
+                }
+                // If the last 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 (validChanges.at(-1) === null) {
+                    OnyxUtils_1.default.remove(key);
+                    OnyxUtils_1.default.logKeyRemoved(OnyxUtils_1.default.METHOD.MERGE, key);
+                    return Promise.resolve();
+                }
+                return OnyxMerge_1.default.applyMerge(key, existingValue, validChanges).then(({ mergedValue, updatePromise }) => {
+                    OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE, key, changes, mergedValue);
+                    return updatePromise;
+                });
+            }
+            catch (error) {
+                Logger.logAlert(`An error occurred while applying merge for key: ${key}, Error: ${error}`);
                 return Promise.resolve();
             }
-            return OnyxMerge_1.default.applyMerge(key, existingValue, validChanges).then(({ mergedValue, updatePromise }) => {
-                OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE, key, changes, mergedValue);
-                return updatePromise;
-            });
-        }
-        catch (error) {
-            Logger.logAlert(`An error occurred while applying merge for key: ${key}, Error: ${error}`);
-            return Promise.resolve();
-        }
+        });
+        return mergeQueuePromise[key];
     });
-    return mergeQueuePromise[key];
 }
 /**
  * Merges a collection based on their keys.
@@ -260,7 +262,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, isProcessingCollectionUpdate: true });
+    return OnyxUtils_1.default.afterInit(() => OnyxUtils_1.default.mergeCollectionWithPatches({ collectionKey, collection, isProcessingCollectionUpdate: true }));
 }
 /**
  * Clear out all the data in the store
@@ -284,91 +286,93 @@ function mergeCollection(collectionKey, collection) {
  * @param keysToPreserve is a list of ONYXKEYS that should not be cleared with the rest of the data
  */
 function clear(keysToPreserve = []) {
-    const defaultKeyStates = OnyxUtils_1.default.getDefaultKeyStates();
-    const initialKeys = Object.keys(defaultKeyStates);
-    const promise = OnyxUtils_1.default.getAllKeys()
-        .then((cachedKeys) => {
-        var _a;
-        OnyxCache_1.default.clearNullishStorageKeys();
-        const keysToBeClearedFromStorage = [];
-        const keyValuesToResetIndividually = {};
-        // We need to store old and new values for collection keys to properly notify subscribers when clearing Onyx
-        // because the notification process needs the old values in cache but at that point they will be already removed from it.
-        const keyValuesToResetAsCollection = {};
-        const allKeys = new Set([...cachedKeys, ...initialKeys]);
-        // The only keys that should not be cleared are:
-        // 1. Anything specifically passed in keysToPreserve (because some keys like language preferences, offline
-        //      status, or activeClients need to remain in Onyx even when signed out)
-        // 2. Any keys with a default state (because they need to remain in Onyx as their default, and setting them
-        //      to null would cause unknown behavior)
-        //   2.1 However, if a default key was explicitly set to null, we need to reset it to the default value
-        for (const key of allKeys) {
-            const isKeyToPreserve = keysToPreserve.includes(key);
-            const isDefaultKey = key in defaultKeyStates;
-            // If the key is being removed or reset to default:
-            // 1. Update it in the cache
-            // 2. Figure out whether it is a collection key or not,
-            //      since collection key subscribers need to be updated differently
-            if (!isKeyToPreserve) {
-                const oldValue = OnyxCache_1.default.get(key);
-                const newValue = (_a = defaultKeyStates[key]) !== null && _a !== void 0 ? _a : null;
-                if (newValue !== oldValue) {
-                    OnyxCache_1.default.set(key, newValue);
-                    let collectionKey;
-                    try {
-                        collectionKey = OnyxUtils_1.default.getCollectionKey(key);
-                    }
-                    catch (e) {
-                        // If getCollectionKey() throws an error it means the key is not a collection key.
-                        collectionKey = undefined;
-                    }
-                    if (collectionKey) {
-                        if (!keyValuesToResetAsCollection[collectionKey]) {
-                            keyValuesToResetAsCollection[collectionKey] = { oldValues: {}, newValues: {} };
+    return OnyxUtils_1.default.afterInit(() => {
+        const defaultKeyStates = OnyxUtils_1.default.getDefaultKeyStates();
+        const initialKeys = Object.keys(defaultKeyStates);
+        const promise = OnyxUtils_1.default.getAllKeys()
+            .then((cachedKeys) => {
+            var _a;
+            OnyxCache_1.default.clearNullishStorageKeys();
+            const keysToBeClearedFromStorage = [];
+            const keyValuesToResetIndividually = {};
+            // We need to store old and new values for collection keys to properly notify subscribers when clearing Onyx
+            // because the notification process needs the old values in cache but at that point they will be already removed from it.
+            const keyValuesToResetAsCollection = {};
+            const allKeys = new Set([...cachedKeys, ...initialKeys]);
+            // The only keys that should not be cleared are:
+            // 1. Anything specifically passed in keysToPreserve (because some keys like language preferences, offline
+            //      status, or activeClients need to remain in Onyx even when signed out)
+            // 2. Any keys with a default state (because they need to remain in Onyx as their default, and setting them
+            //      to null would cause unknown behavior)
+            //   2.1 However, if a default key was explicitly set to null, we need to reset it to the default value
+            for (const key of allKeys) {
+                const isKeyToPreserve = keysToPreserve.includes(key);
+                const isDefaultKey = key in defaultKeyStates;
+                // If the key is being removed or reset to default:
+                // 1. Update it in the cache
+                // 2. Figure out whether it is a collection key or not,
+                //      since collection key subscribers need to be updated differently
+                if (!isKeyToPreserve) {
+                    const oldValue = OnyxCache_1.default.get(key);
+                    const newValue = (_a = defaultKeyStates[key]) !== null && _a !== void 0 ? _a : null;
+                    if (newValue !== oldValue) {
+                        OnyxCache_1.default.set(key, newValue);
+                        let collectionKey;
+                        try {
+                            collectionKey = OnyxUtils_1.default.getCollectionKey(key);
+                        }
+                        catch (e) {
+                            // If getCollectionKey() throws an error it means the key is not a collection key.
+                            collectionKey = undefined;
+                        }
+                        if (collectionKey) {
+                            if (!keyValuesToResetAsCollection[collectionKey]) {
+                                keyValuesToResetAsCollection[collectionKey] = { oldValues: {}, newValues: {} };
+                            }
+                            keyValuesToResetAsCollection[collectionKey].oldValues[key] = oldValue;
+                            keyValuesToResetAsCollection[collectionKey].newValues[key] = newValue !== null && newValue !== void 0 ? newValue : undefined;
+                        }
+                        else {
+                            keyValuesToResetIndividually[key] = newValue !== null && newValue !== void 0 ? newValue : undefined;
                         }
-                        keyValuesToResetAsCollection[collectionKey].oldValues[key] = oldValue;
-                        keyValuesToResetAsCollection[collectionKey].newValues[key] = newValue !== null && newValue !== void 0 ? newValue : undefined;
-                    }
-                    else {
-                        keyValuesToResetIndividually[key] = newValue !== null && newValue !== void 0 ? newValue : undefined;
                     }
                 }
+                if (isKeyToPreserve || isDefaultKey) {
+                    continue;
+                }
+                // If it isn't preserved and doesn't have a default, we'll remove it
+                keysToBeClearedFromStorage.push(key);
             }
-            if (isKeyToPreserve || isDefaultKey) {
-                continue;
+            const updatePromises = [];
+            // Notify the subscribers for each key/value group so they can receive the new values
+            for (const [key, value] of Object.entries(keyValuesToResetIndividually)) {
+                updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value));
             }
-            // If it isn't preserved and doesn't have a default, we'll remove it
-            keysToBeClearedFromStorage.push(key);
-        }
-        const updatePromises = [];
-        // Notify the subscribers for each key/value group so they can receive the new values
-        for (const [key, value] of Object.entries(keyValuesToResetIndividually)) {
-            updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value));
-        }
-        for (const [key, value] of Object.entries(keyValuesToResetAsCollection)) {
-            updatePromises.push(OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(key, value.newValues, value.oldValues));
-        }
-        // Exclude RAM-only keys to prevent them from being saved to storage
-        const defaultKeyValuePairs = Object.entries(Object.keys(defaultKeyStates)
-            .filter((key) => !keysToPreserve.includes(key) && !OnyxUtils_1.default.isRamOnlyKey(key))
-            .reduce((obj, key) => {
-            // eslint-disable-next-line no-param-reassign
-            obj[key] = defaultKeyStates[key];
-            return obj;
-        }, {}));
-        // Remove only the items that we want cleared from storage, and reset others to default
-        for (const key of keysToBeClearedFromStorage)
-            OnyxCache_1.default.drop(key);
-        return storage_1.default.removeItems(keysToBeClearedFromStorage)
-            .then(() => OnyxConnectionManager_1.default.refreshSessionID())
-            .then(() => storage_1.default.multiSet(defaultKeyValuePairs))
-            .then(() => {
-            DevTools_1.default.clearState(keysToPreserve);
-            return Promise.all(updatePromises);
-        });
-    })
-        .then(() => undefined);
-    return OnyxCache_1.default.captureTask(OnyxCache_1.TASK.CLEAR, promise);
+            for (const [key, value] of Object.entries(keyValuesToResetAsCollection)) {
+                updatePromises.push(OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(key, value.newValues, value.oldValues));
+            }
+            // Exclude RAM-only keys to prevent them from being saved to storage
+            const defaultKeyValuePairs = Object.entries(Object.keys(defaultKeyStates)
+                .filter((key) => !keysToPreserve.includes(key) && !OnyxUtils_1.default.isRamOnlyKey(key))
+                .reduce((obj, key) => {
+                // eslint-disable-next-line no-param-reassign
+                obj[key] = defaultKeyStates[key];
+                return obj;
+            }, {}));
+            // Remove only the items that we want cleared from storage, and reset others to default
+            for (const key of keysToBeClearedFromStorage)
+                OnyxCache_1.default.drop(key);
+            return storage_1.default.removeItems(keysToBeClearedFromStorage)
+                .then(() => OnyxConnectionManager_1.default.refreshSessionID())
+                .then(() => storage_1.default.multiSet(defaultKeyValuePairs))
+                .then(() => {
+                DevTools_1.default.clearState(keysToPreserve);
+                return Promise.all(updatePromises);
+            });
+        })
+            .then(() => undefined);
+        return OnyxCache_1.default.captureTask(OnyxCache_1.TASK.CLEAR, promise);
+    });
 }
 /**
  * Insert API responses and lifecycle data into Onyx
@@ -377,132 +381,132 @@ function clear(keysToPreserve = []) {
  * @returns resolves when all operations are complete
  */
 function update(data) {
-    // First, validate the Onyx object is in the format we expect
-    for (const { onyxMethod, key, value } of data) {
-        if (!Object.values(OnyxUtils_1.default.METHOD).includes(onyxMethod)) {
-            throw new Error(`Invalid onyxMethod ${onyxMethod} in Onyx update.`);
-        }
-        if (onyxMethod === OnyxUtils_1.default.METHOD.MULTI_SET) {
-            // For multiset, we just expect the value to be an object
-            if (typeof value !== 'object' || Array.isArray(value) || typeof value === 'function') {
-                throw new Error('Invalid value provided in Onyx multiSet. Onyx multiSet value must be of type object.');
+    return OnyxUtils_1.default.afterInit(() => {
+        // The queue of operations within a single `update` call in the format of <item key - list of operations updating the item>.
+        // This allows us to batch the operations per item and merge them into one operation in the order they were requested.
+        const updateQueue = {};
+        const enqueueSetOperation = (key, value) => {
+            // If a `set` operation is enqueued, we should clear the whole queue.
+            // Since the `set` operation replaces the value entirely, there's no need to perform any previous operations.
+            // To do this, we first put `null` in the queue, which removes the existing value, and then merge the new value.
+            updateQueue[key] = [null, value];
+        };
+        const enqueueMergeOperation = (key, value) => {
+            if (value === null) {
+                // If we merge `null`, the value is removed and all the previous operations are discarded.
+                updateQueue[key] = [null];
+            }
+            else if (!updateQueue[key]) {
+                updateQueue[key] = [value];
+            }
+            else {
+                updateQueue[key].push(value);
             }
-        }
-        else if (onyxMethod !== OnyxUtils_1.default.METHOD.CLEAR && typeof key !== 'string') {
-            throw new Error(`Invalid ${typeof key} key provided in Onyx update. Onyx key must be of type string.`);
-        }
-    }
-    // The queue of operations within a single `update` call in the format of <item key - list of operations updating the item>.
-    // This allows us to batch the operations per item and merge them into one operation in the order they were requested.
-    const updateQueue = {};
-    const enqueueSetOperation = (key, value) => {
-        // If a `set` operation is enqueued, we should clear the whole queue.
-        // Since the `set` operation replaces the value entirely, there's no need to perform any previous operations.
-        // To do this, we first put `null` in the queue, which removes the existing value, and then merge the new value.
-        updateQueue[key] = [null, value];
-    };
-    const enqueueMergeOperation = (key, value) => {
-        if (value === null) {
-            // If we merge `null`, the value is removed and all the previous operations are discarded.
-            updateQueue[key] = [null];
-        }
-        else if (!updateQueue[key]) {
-            updateQueue[key] = [value];
-        }
-        else {
-            updateQueue[key].push(value);
-        }
-    };
-    const promises = [];
-    let clearPromise = Promise.resolve();
-    for (const { onyxMethod, key, value } of data) {
-        const handlers = {
-            [OnyxUtils_1.default.METHOD.SET]: enqueueSetOperation,
-            [OnyxUtils_1.default.METHOD.MERGE]: enqueueMergeOperation,
-            [OnyxUtils_1.default.METHOD.MERGE_COLLECTION]: () => {
-                const collection = value;
-                if (!OnyxUtils_1.default.isValidNonEmptyCollectionForMerge(collection)) {
-                    Logger.logInfo('mergeCollection enqueued within update() with invalid or empty value. Skipping this operation.');
-                    return;
-                }
-                // Confirm all the collection keys belong to the same parent
-                const collectionKeys = Object.keys(collection);
-                if (OnyxUtils_1.default.doAllCollectionItemsBelongToSameParent(key, collectionKeys)) {
-                    const mergedCollection = collection;
-                    for (const collectionKey of collectionKeys)
-                        enqueueMergeOperation(collectionKey, mergedCollection[collectionKey]);
-                }
-            },
-            [OnyxUtils_1.default.METHOD.SET_COLLECTION]: (k, v) => promises.push(() => setCollection(k, v)),
-            [OnyxUtils_1.default.METHOD.MULTI_SET]: (k, v) => {
-                for (const [entryKey, entryValue] of Object.entries(v))
-                    enqueueSetOperation(entryKey, entryValue);
-            },
-            [OnyxUtils_1.default.METHOD.CLEAR]: () => {
-                clearPromise = clear();
-            },
         };
-        handlers[onyxMethod](key, value);
-    }
-    // Group all the collection-related keys and update each collection in a single `mergeCollection` call.
-    // This is needed to prevent multiple `mergeCollection` calls for the same collection and `merge` calls for the individual items of the said collection.
-    // This way, we ensure there is no race condition in the queued updates of the same key.
-    for (const collectionKey of OnyxUtils_1.default.getCollectionKeys()) {
-        const collectionItemKeys = Object.keys(updateQueue).filter((key) => OnyxUtils_1.default.isKeyMatch(collectionKey, key));
-        if (collectionItemKeys.length <= 1) {
-            // If there are no items of this collection in the updateQueue, we should skip it.
-            // If there is only one item, we should update it individually, therefore retain it in the updateQueue.
-            continue;
+        const promises = [];
+        let clearPromise = Promise.resolve();
+        const onyxMethods = Object.values(OnyxUtils_1.default.METHOD);
+        for (const { onyxMethod, key, value } of data) {
+            if (!onyxMethods.includes(onyxMethod)) {
+                Logger.logInfo(`Invalid onyxMethod ${onyxMethod} in Onyx update. Skipping this operation.`);
+                continue;
+            }
+            if (onyxMethod !== OnyxUtils_1.default.METHOD.CLEAR && onyxMethod !== OnyxUtils_1.default.METHOD.MULTI_SET && typeof key !== 'string') {
+                Logger.logInfo(`Invalid ${typeof key} key provided in Onyx update. Key must be of type string. Skipping this operation.`);
+                continue;
+            }
+            const handlers = {
+                [OnyxUtils_1.default.METHOD.SET]: enqueueSetOperation,
+                [OnyxUtils_1.default.METHOD.MERGE]: enqueueMergeOperation,
+                [OnyxUtils_1.default.METHOD.MERGE_COLLECTION]: () => {
+                    const collection = value;
+                    if (!OnyxUtils_1.default.isValidNonEmptyCollectionForMerge(collection)) {
+                        Logger.logInfo('Invalid or empty value provided in Onyx mergeCollection. Skipping this operation.');
+                        return;
+                    }
+                    // Confirm all the collection keys belong to the same parent
+                    const collectionKeys = Object.keys(collection);
+                    if (OnyxUtils_1.default.doAllCollectionItemsBelongToSameParent(key, collectionKeys)) {
+                        const mergedCollection = collection;
+                        for (const collectionKey of collectionKeys)
+                            enqueueMergeOperation(collectionKey, mergedCollection[collectionKey]);
+                    }
+                },
+                [OnyxUtils_1.default.METHOD.SET_COLLECTION]: (k, v) => promises.push(() => setCollection(k, v)),
+                [OnyxUtils_1.default.METHOD.MULTI_SET]: (k, v) => {
+                    if (typeof value !== 'object' || Array.isArray(value) || typeof value === 'function') {
+                        Logger.logInfo(`Invalid value provided in Onyx multiSet. Value must be of type object. Skipping this operation.`);
+                        return;
+                    }
+                    for (const [entryKey, entryValue] of Object.entries(v))
+                        enqueueSetOperation(entryKey, entryValue);
+                },
+                [OnyxUtils_1.default.METHOD.CLEAR]: () => {
+                    clearPromise = clear();
+                },
+            };
+            handlers[onyxMethod](key, value);
         }
-        const batchedCollectionUpdates = collectionItemKeys.reduce((queue, key) => {
-            const operations = updateQueue[key];
-            // Remove the collection-related key from the updateQueue so that it won't be processed individually.
-            delete updateQueue[key];
-            const batchedChanges = OnyxUtils_1.default.mergeAndMarkChanges(operations);
-            if (operations[0] === null) {
-                // eslint-disable-next-line no-param-reassign
-                queue.set[key] = batchedChanges.result;
+        // Group all the collection-related keys and update each collection in a single `mergeCollection` call.
+        // This is needed to prevent multiple `mergeCollection` calls for the same collection and `merge` calls for the individual items of the said collection.
+        // This way, we ensure there is no race condition in the queued updates of the same key.
+        for (const collectionKey of OnyxUtils_1.default.getCollectionKeys()) {
+            const collectionItemKeys = Object.keys(updateQueue).filter((key) => OnyxUtils_1.default.isKeyMatch(collectionKey, key));
+            if (collectionItemKeys.length <= 1) {
+                // If there are no items of this collection in the updateQueue, we should skip it.
+                // If there is only one item, we should update it individually, therefore retain it in the updateQueue.
+                continue;
             }
-            else {
-                // eslint-disable-next-line no-param-reassign
-                queue.merge[key] = batchedChanges.result;
-                if (batchedChanges.replaceNullPatches.length > 0) {
+            const batchedCollectionUpdates = collectionItemKeys.reduce((queue, key) => {
+                const operations = updateQueue[key];
+                // Remove the collection-related key from the updateQueue so that it won't be processed individually.
+                delete updateQueue[key];
+                const batchedChanges = OnyxUtils_1.default.mergeAndMarkChanges(operations);
+                if (operations[0] === null) {
+                    // eslint-disable-next-line no-param-reassign
+                    queue.set[key] = batchedChanges.result;
+                }
+                else {
                     // eslint-disable-next-line no-param-reassign
-                    queue.mergeReplaceNullPatches[key] = batchedChanges.replaceNullPatches;
+                    queue.merge[key] = batchedChanges.result;
+                    if (batchedChanges.replaceNullPatches.length > 0) {
+                        // eslint-disable-next-line no-param-reassign
+                        queue.mergeReplaceNullPatches[key] = batchedChanges.replaceNullPatches;
+                    }
                 }
+                return queue;
+            }, {
+                merge: {},
+                mergeReplaceNullPatches: {},
+                set: {},
+            });
+            if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.merge)) {
+                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, collection: batchedCollectionUpdates.set }));
             }
-            return queue;
-        }, {
-            merge: {},
-            mergeReplaceNullPatches: {},
-            set: {},
-        });
-        if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.merge)) {
-            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, collection: batchedCollectionUpdates.set }));
-        }
-    }
-    for (const [key, operations] of Object.entries(updateQueue)) {
-        if (operations[0] === null) {
-            const batchedChanges = OnyxUtils_1.default.mergeChanges(operations).result;
-            promises.push(() => set(key, batchedChanges));
-            continue;
         }
-        for (const operation of operations) {
-            promises.push(() => merge(key, operation));
+        for (const [key, operations] of Object.entries(updateQueue)) {
+            if (operations[0] === null) {
+                const batchedChanges = OnyxUtils_1.default.mergeChanges(operations).result;
+                promises.push(() => set(key, batchedChanges));
+                continue;
+            }
+            for (const operation of operations) {
+                promises.push(() => merge(key, operation));
+            }
         }
-    }
-    const snapshotPromises = OnyxUtils_1.default.updateSnapshots(data, merge);
-    // We need to run the snapshot updates before the other updates so the snapshot data can be updated before the loading state in the snapshot
-    const finalPromises = snapshotPromises.concat(promises);
-    return clearPromise.then(() => Promise.all(finalPromises.map((p) => p()))).then(() => undefined);
+        const snapshotPromises = OnyxUtils_1.default.updateSnapshots(data, merge);
+        // We need to run the snapshot updates before the other updates so the snapshot data can be updated before the loading state in the snapshot
+        const finalPromises = snapshotPromises.concat(promises);
+        return clearPromise.then(() => Promise.all(finalPromises.map((p) => p()))).then(() => undefined);
+    });
 }
 /**
  * Sets a collection by replacing all existing collection members with new values.
@@ -518,7 +522,7 @@ function update(data) {
  * @param collection Object collection keyed by individual collection member keys and values
  */
 function setCollection(collectionKey, collection) {
-    return OnyxUtils_1.default.setCollectionWithRetry({ collectionKey, collection });
+    return OnyxUtils_1.default.afterInit(() => OnyxUtils_1.default.setCollectionWithRetry({ collectionKey, collection }));
 }
 const Onyx = {
     METHOD: OnyxUtils_1.default.METHOD,

package/dist/OnyxUtils.d.ts

@@ -30,6 +30,15 @@ declare function getDefaultKeyStates(): Record<OnyxKey, OnyxValue<OnyxKey>>;
  * Getter - returns the deffered init task.
  */
 declare function getDeferredInitTask(): DeferredTask;
+/**
+ * Executes an action after Onyx has been initialized.
+ * If Onyx is already initialized, the action is executed immediately.
+ * Otherwise, it waits for initialization to complete before executing.
+ *
+ * @param action The action to execute after initialization
+ * @returns The result of the action
+ */
+declare function afterInit<T>(action: () => Promise<T>): Promise<T>;
 /**
  * Getter - returns the skippable collection member IDs.
  */
@@ -343,6 +352,7 @@ declare const OnyxUtils: {
     getMergeQueuePromise: typeof getMergeQueuePromise;
     getDefaultKeyStates: typeof getDefaultKeyStates;
     getDeferredInitTask: typeof getDeferredInitTask;
+    afterInit: typeof afterInit;
     initStoreValues: typeof initStoreValues;
     sendActionToDevTools: typeof sendActionToDevTools;
     get: typeof get;

package/dist/OnyxUtils.js

@@ -122,6 +122,20 @@ function getDefaultKeyStates() {
 function getDeferredInitTask() {
     return deferredInitTask;
 }
+/**
+ * Executes an action after Onyx has been initialized.
+ * If Onyx is already initialized, the action is executed immediately.
+ * Otherwise, it waits for initialization to complete before executing.
+ *
+ * @param action The action to execute after initialization
+ * @returns The result of the action
+ */
+function afterInit(action) {
+    if (deferredInitTask.isResolved) {
+        return action();
+    }
+    return deferredInitTask.promise.then(action);
+}
 /**
  * Getter - returns the skippable collection member IDs.
  */
@@ -1446,6 +1460,7 @@ const OnyxUtils = {
     getMergeQueuePromise,
     getDefaultKeyStates,
     getDeferredInitTask,
+    afterInit,
     initStoreValues,
     sendActionToDevTools,
     get,

package/dist/createDeferredTask.d.ts

@@ -1,6 +1,7 @@
 type DeferredTask = {
     promise: Promise<void>;
-    resolve?: () => void;
+    resolve: () => void;
+    isResolved: boolean;
 };
 /**
  * Create a deferred task that can be resolved when we call `resolve()`

package/dist/createDeferredTask.js

@@ -7,9 +7,14 @@ exports.default = createDeferredTask;
  * Useful when we want to wait for a tasks that is resolved from an external action
  */
 function createDeferredTask() {
-    const deferred = {};
-    deferred.promise = new Promise((res) => {
-        deferred.resolve = res;
-    });
+    const { promise, resolve: originalResolve } = Promise.withResolvers();
+    const deferred = {
+        promise,
+        resolve: () => {
+            deferred.isResolved = true;
+            originalResolve();
+        },
+        isResolved: false,
+    };
     return deferred;
 }

package/dist/types.d.ts

@@ -274,7 +274,7 @@ type ExpandOnyxKeys<TKey extends OnyxKey> = TKey extends CollectionKeyBase ? NoI
  * If a new method is added to OnyxUtils.METHOD constant, it must be added to OnyxMethodValueMap type.
  * Otherwise it will show static type errors.
  */
-type OnyxUpdate<TKey extends OnyxKey = OnyxKey> = {
+type OnyxUpdate<TKey extends OnyxKey> = {
     [K in TKey]: {
         onyxMethod: typeof OnyxUtils.METHOD.SET;
         key: ExpandOnyxKeys<K>;

package/package.json

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