react-native-onyx 3.0.48 → 3.0.50

package/dist/Onyx.js

@@ -221,7 +221,13 @@ function merge(key, changes) {
             }
             try {
                 const validChanges = mergeQueue[key].filter((change) => {
-                    const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(change, existingValue);
+                    const { isCompatible, existingValueType, newValueType, isEmptyArrayCoercion } = utils_1.default.checkCompatibilityWithExistingValue(change, existingValue);
+                    if (isEmptyArrayCoercion) {
+                        // Merging an object into an empty array isn't semantically correct, but we allow it
+                        // in case we accidentally encoded an empty object as an empty array in PHP. If you're
+                        // looking at a bugbot from this message, we're probably missing that key in OnyxKeys::KEYS_REQUIRING_EMPTY_OBJECT
+                        Logger.logAlert(`[ENSURE_BUGBOT] Onyx merge called on key "${key}" whose existing value is an empty array. Will coerce to object.`);
+                    }
                     if (!isCompatible) {
                         Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'merge', existingValueType, newValueType));
                     }
@@ -240,8 +246,9 @@ function merge(key, changes) {
                     OnyxUtils_1.default.logKeyRemoved(OnyxUtils_1.default.METHOD.MERGE, key);
                     return Promise.resolve();
                 }
-                return OnyxMerge_1.default.applyMerge(key, existingValue, validChanges).then(({ mergedValue }) => {
+                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) {
@@ -340,6 +347,14 @@ function clear(keysToPreserve = []) {
                 // 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))
@@ -356,13 +371,7 @@ function clear(keysToPreserve = []) {
                 .then(() => storage_1.default.multiSet(defaultKeyValuePairs))
                 .then(() => {
                 DevTools_1.default.clearState(keysToPreserve);
-                // Notify the subscribers for each key/value group so they can receive the new values
-                for (const [key, value] of Object.entries(keyValuesToResetIndividually)) {
-                    OnyxUtils_1.default.keyChanged(key, value);
-                }
-                for (const [key, value] of Object.entries(keyValuesToResetAsCollection)) {
-                    OnyxUtils_1.default.keysChanged(key, value.newValues, value.oldValues);
-                }
+                return Promise.all(updatePromises);
             });
         })
             .then(() => undefined);

package/dist/OnyxMerge/index.js

@@ -13,16 +13,17 @@ const applyMerge = (key, existingValue, validChanges) => {
     // Logging properties only since values could be sensitive things we don't want to log.
     OnyxUtils_1.default.logKeyChanged(OnyxUtils_1.default.METHOD.MERGE, key, mergedValue, hasChanged);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-    OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
+    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
     const shouldSkipStorageOperations = !hasChanged || OnyxUtils_1.default.isRamOnlyKey(key);
     // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
     // If the key is marked as RAM-only, it should not be saved nor updated in the storage.
     if (shouldSkipStorageOperations) {
-        return Promise.resolve({ mergedValue });
+        return Promise.resolve({ mergedValue, updatePromise });
     }
     // For web platforms we use `setItem` since the object was already merged with its changes before.
     return storage_1.default.setItem(key, mergedValue).then(() => ({
         mergedValue,
+        updatePromise,
     }));
 };
 const OnyxMerge = {

package/dist/OnyxMerge/index.native.js

@@ -19,17 +19,18 @@ const applyMerge = (key, existingValue, validChanges) => {
     // Logging properties only since values could be sensitive things we don't want to log.
     OnyxUtils_1.default.logKeyChanged(OnyxUtils_1.default.METHOD.MERGE, key, mergedValue, hasChanged);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-    OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
+    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
     const shouldSkipStorageOperations = !hasChanged || OnyxUtils_1.default.isRamOnlyKey(key);
     // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
     // If the key is marked as RAM-only, it should not be saved nor updated in the storage.
     if (shouldSkipStorageOperations) {
-        return Promise.resolve({ mergedValue });
+        return Promise.resolve({ mergedValue, updatePromise });
     }
     // For native platforms we use `mergeItem` that will take advantage of JSON_PATCH and JSON_REPLACE SQL operations to
     // merge the object in a performant way.
     return storage_1.default.mergeItem(key, batchedChanges, replaceNullPatches).then(() => ({
         mergedValue,
+        updatePromise,
     }));
 };
 const OnyxMerge = {

package/dist/OnyxMerge/types.d.ts

@@ -1,6 +1,7 @@
 import type { OnyxInput, OnyxKey } from '../types';
 type ApplyMergeResult<TValue> = {
     mergedValue: TValue;
+    updatePromise: Promise<void>;
 };
 type ApplyMerge = <TKey extends OnyxKey, TValue extends OnyxInput<OnyxKey> | undefined, TChange extends OnyxInput<OnyxKey> | null>(key: TKey, existingValue: TValue, validChanges: TChange[]) => Promise<ApplyMergeResult<TChange>>;
 export type { ApplyMerge, ApplyMergeResult };

package/dist/OnyxUtils.d.ts

@@ -186,7 +186,7 @@ declare function keyChanged<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TK
 /**
  * Sends the data obtained from the keys to the connection.
  */
-declare function sendDataToConnection<TKey extends OnyxKey>(mapping: CallbackToStateMapping<TKey>, matchedKey: TKey | undefined): void;
+declare function sendDataToConnection<TKey extends OnyxKey>(mapping: CallbackToStateMapping<TKey>, value: OnyxValue<TKey> | null, matchedKey: TKey | undefined): void;
 /**
  * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
  * run out of storage the least recently accessed key can be removed.
@@ -196,6 +196,19 @@ declare function addKeyToRecentlyAccessedIfNeeded<TKey extends OnyxKey>(key: TKe
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
  */
 declare function getCollectionDataAndSendAsObject<TKey extends OnyxKey>(matchingKeys: CollectionKeyBase[], mapping: CallbackToStateMapping<TKey>): void;
+/**
+ * Schedules an update that will be appended to the macro task queue (so it doesn't update the subscribers immediately).
+ *
+ * @example
+ * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
+ */
+declare function scheduleSubscriberUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, canUpdateSubscriber?: (subscriber?: CallbackToStateMapping<OnyxKey>) => boolean, isProcessingCollectionUpdate?: boolean): Promise<void>;
+/**
+ * This method is similar to scheduleSubscriberUpdate but it is built for working specifically with collections
+ * so that keysChanged() is triggered for the collection and not keyChanged(). If this was not done, then the
+ * subscriber callbacks receive the data in a different format than they normally expect and it breaks code.
+ */
+declare function scheduleNotifyCollectionSubscribers<TKey extends OnyxKey>(key: TKey, value: OnyxCollection<KeyValueMapping[TKey]>, previousValue?: OnyxCollection<KeyValueMapping[TKey]>): Promise<void>;
 /**
  * Remove a key from Onyx and update the subscribers
  */
@@ -211,7 +224,7 @@ declare function retryOperation<TMethod extends RetriableOnyxOperation>(error: E
 /**
  * Notifies subscribers and writes current value to cache
  */
-declare function broadcastUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, hasChanged?: boolean): void;
+declare function broadcastUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, hasChanged?: boolean): Promise<void>;
 declare function hasPendingMergeForKey(key: OnyxKey): boolean;
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
@@ -357,6 +370,8 @@ declare const OnyxUtils: {
     sendDataToConnection: typeof sendDataToConnection;
     getCollectionKey: typeof getCollectionKey;
     getCollectionDataAndSendAsObject: typeof getCollectionDataAndSendAsObject;
+    scheduleSubscriberUpdate: typeof scheduleSubscriberUpdate;
+    scheduleNotifyCollectionSubscribers: typeof scheduleNotifyCollectionSubscribers;
     remove: typeof remove;
     reportStorageQuota: typeof reportStorageQuota;
     retryOperation: typeof retryOperation;

package/dist/OnyxUtils.js

@@ -74,6 +74,8 @@ const MAX_STORAGE_OPERATION_RETRY_ATTEMPTS = 5;
 // Key/value store of Onyx key and arrays of values to merge
 let mergeQueue = {};
 let mergeQueuePromise = {};
+// Used to schedule subscriber update to the macro task queue
+let nextMacrotaskPromise = null;
 // Holds a mapping of all the React components that want their state subscribed to a store key
 let callbackToStateMapping = {};
 // Keeps a copy of the values of the onyx collection keys as a map for faster lookups
@@ -584,7 +586,6 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
             // If they are subscribed to the collection key and using waitForCollectionCallback then we'll
             // send the whole cached collection.
             if (isSubscribedToCollectionKey) {
-                lastConnectionCallbackData.set(subscriber.subscriptionID, cachedCollection);
                 if (subscriber.waitForCollectionCallback) {
                     subscriber.callback(cachedCollection, subscriber.key, partialCollection);
                     continue;
@@ -667,7 +668,6 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
                     cachedCollections[subscriber.key] = cachedCollection;
                 }
                 cachedCollection[key] = value;
-                lastConnectionCallbackData.set(subscriber.subscriptionID, cachedCollection);
                 subscriber.callback(cachedCollection, subscriber.key, { [key]: value });
                 continue;
             }
@@ -682,32 +682,22 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
 /**
  * Sends the data obtained from the keys to the connection.
  */
-function sendDataToConnection(mapping, matchedKey) {
+function sendDataToConnection(mapping, value, matchedKey) {
     var _a, _b;
     // If the mapping no longer exists then we should not send any data.
     // This means our subscriber was disconnected.
     if (!callbackToStateMapping[mapping.subscriptionID]) {
         return;
     }
-    // Always read the latest value from cache to avoid stale or duplicate data.
-    // For collection subscribers with waitForCollectionCallback, read the full collection.
-    // For individual key subscribers, read just that key's value.
-    let value;
-    if (isCollectionKey(mapping.key) && mapping.waitForCollectionCallback) {
-        const collection = getCachedCollection(mapping.key);
-        value = Object.keys(collection).length > 0 ? collection : undefined;
-    }
-    else {
-        value = OnyxCache_1.default.get(matchedKey !== null && matchedKey !== void 0 ? matchedKey : mapping.key);
-    }
     // For regular callbacks, we never want to pass null values, but always just undefined if a value is not set in cache or storage.
-    value = value === null ? undefined : value;
+    const valueToPass = value === null ? undefined : value;
     const lastValue = lastConnectionCallbackData.get(mapping.subscriptionID);
+    lastConnectionCallbackData.get(mapping.subscriptionID);
     // If the value has not changed we do not need to trigger the callback
-    if (lastConnectionCallbackData.has(mapping.subscriptionID) && (0, fast_equals_1.shallowEqual)(lastValue, value)) {
+    if (lastConnectionCallbackData.has(mapping.subscriptionID) && valueToPass === lastValue) {
         return;
     }
-    (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, value, matchedKey);
+    (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, valueToPass, matchedKey);
 }
 /**
  * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
@@ -726,16 +716,50 @@ function addKeyToRecentlyAccessedIfNeeded(key) {
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
  */
 function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
-    multiGet(matchingKeys).then(() => {
-        sendDataToConnection(mapping, mapping.key);
+    multiGet(matchingKeys).then((dataMap) => {
+        const data = Object.fromEntries(dataMap.entries());
+        sendDataToConnection(mapping, data, mapping.key);
     });
 }
+/**
+ * Delays promise resolution until the next macrotask to prevent race condition if the key subscription is in progress.
+ *
+ * @param callback The keyChanged/keysChanged callback
+ * */
+function prepareSubscriberUpdate(callback) {
+    if (!nextMacrotaskPromise) {
+        nextMacrotaskPromise = new Promise((resolve) => {
+            setTimeout(() => {
+                nextMacrotaskPromise = null;
+                resolve();
+            }, 0);
+        });
+    }
+    return Promise.all([nextMacrotaskPromise, Promise.resolve().then(callback)]).then();
+}
+/**
+ * Schedules an update that will be appended to the macro task queue (so it doesn't update the subscribers immediately).
+ *
+ * @example
+ * scheduleSubscriberUpdate(key, value, subscriber => subscriber.initWithStoredValues === false)
+ */
+function scheduleSubscriberUpdate(key, value, canUpdateSubscriber = () => true, isProcessingCollectionUpdate = false) {
+    return prepareSubscriberUpdate(() => keyChanged(key, value, canUpdateSubscriber, isProcessingCollectionUpdate));
+}
+/**
+ * This method is similar to scheduleSubscriberUpdate but it is built for working specifically with collections
+ * so that keysChanged() is triggered for the collection and not keyChanged(). If this was not done, then the
+ * subscriber callbacks receive the data in a different format than they normally expect and it breaks code.
+ */
+function scheduleNotifyCollectionSubscribers(key, value, previousValue) {
+    return prepareSubscriberUpdate(() => keysChanged(key, value, previousValue));
+}
 /**
  * Remove a key from Onyx and update the subscribers
  */
 function remove(key, isProcessingCollectionUpdate) {
     OnyxCache_1.default.drop(key);
-    keyChanged(key, undefined, undefined, isProcessingCollectionUpdate);
+    scheduleSubscriberUpdate(key, undefined, undefined, isProcessingCollectionUpdate);
     if (isRamOnlyKey(key)) {
         return Promise.resolve();
     }
@@ -803,7 +827,7 @@ function broadcastUpdate(key, value, hasChanged) {
     else {
         OnyxCache_1.default.addToAccessedKeys(key);
     }
-    keyChanged(key, value, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false);
+    return scheduleSubscriberUpdate(key, value, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false).then(() => undefined);
 }
 function hasPendingMergeForKey(key) {
     return !!mergeQueue[key];
@@ -978,7 +1002,7 @@ function subscribeToKey(connectOptions) {
             const matchedKey = isCollectionKey(mapping.key) && mapping.waitForCollectionCallback ? mapping.key : undefined;
             // Here we cannot use batching because the nullish value is expected to be set immediately for default props
             // or they will be undefined.
-            sendDataToConnection(mapping, matchedKey);
+            sendDataToConnection(mapping, null, matchedKey);
             return;
         }
         // When using a callback subscriber we will either trigger the provided callback for each key we find or combine all values
@@ -991,15 +1015,15 @@ function subscribeToKey(connectOptions) {
                     return;
                 }
                 // We did not opt into using waitForCollectionCallback mode so the callback is called for every matching key.
-                multiGet(matchingKeys).then(() => {
-                    for (const key of matchingKeys) {
-                        sendDataToConnection(mapping, key);
+                multiGet(matchingKeys).then((values) => {
+                    for (const [key, val] of values.entries()) {
+                        sendDataToConnection(mapping, val, key);
                     }
                 });
                 return;
             }
             // If we are not subscribed to a collection key then there's only a single key to send an update for.
-            get(mapping.key).then(() => sendDataToConnection(mapping, mapping.key));
+            get(mapping.key).then((val) => sendDataToConnection(mapping, val, mapping.key));
             return;
         }
         console.error('Warning: Onyx.connect() was found without a callback');
@@ -1111,7 +1135,13 @@ function setWithRetry({ key, value, options }, retryAttempt) {
         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);
+    const { isCompatible, existingValueType, newValueType, isEmptyArrayCoercion } = utils_1.default.checkCompatibilityWithExistingValue(value, existingValue);
+    if (isEmptyArrayCoercion) {
+        // Setting an object over empty array isn't semantically correct, but we allow it
+        // in case we accidentally encoded an empty object as an empty array in PHP. If you're
+        // looking at a bugbot from this message, we're probably missing that key in OnyxKeys::KEYS_REQUIRING_EMPTY_OBJECT
+        Logger.logAlert(`[ENSURE_BUGBOT] Onyx setWithRetry called on key "${key}" whose existing value is an empty array. Will coerce to object.`);
+    }
     if (!isCompatible) {
         Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'set', existingValueType, newValueType));
         return Promise.resolve();
@@ -1127,20 +1157,21 @@ function setWithRetry({ key, value, options }, retryAttempt) {
     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.
-    OnyxUtils.broadcastUpdate(key, valueWithoutNestedNullValues, hasChanged);
+    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 Promise.resolve();
+        return updatePromise;
     }
     // If a key is a RAM-only key or a member of RAM-only collection, we skip the step that modifies the storage
     if (isRamOnlyKey(key)) {
         OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET, key, valueWithoutNestedNullValues);
-        return Promise.resolve();
+        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;
     });
 }
 /**
@@ -1170,16 +1201,16 @@ function multiSetWithRetry(data, retryAttempt) {
         }, {});
     }
     const keyValuePairsToSet = OnyxUtils.prepareKeyValuePairsForStorage(newData, true);
-    for (const [key, value] of keyValuePairsToSet) {
+    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
+        // Update cache and optimistically inform subscribers on the next tick
         OnyxCache_1.default.set(key, value);
-        keyChanged(key, value);
-    }
+        return OnyxUtils.scheduleSubscriberUpdate(key, value);
+    });
     const keyValuePairsToStore = keyValuePairsToSet.filter((keyValuePair) => {
         const [key] = keyValuePair;
         // Filter out the RAM-only key value pairs, as they should not be saved to storage
@@ -1189,7 +1220,9 @@ function multiSetWithRetry(data, retryAttempt) {
         .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.
@@ -1242,16 +1275,17 @@ function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
         const previousCollection = OnyxUtils.getCachedCollection(collectionKey);
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
-        keysChanged(collectionKey, mutableCollection, previousCollection);
+        const updatePromise = OnyxUtils.scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
         // RAM-only keys are not supposed to be saved to storage
         if (isRamOnlyKey(collectionKey)) {
             OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET_COLLECTION, undefined, mutableCollection);
-            return;
+            return updatePromise;
         }
         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;
         });
     });
 }
@@ -1309,7 +1343,13 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
         const existingKeys = keys.filter((key) => persistedKeys.has(key));
         const cachedCollectionForExistingKeys = getCachedCollection(collectionKey, existingKeys);
         const existingKeyCollection = existingKeys.reduce((obj, key) => {
-            const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(resultCollection[key], cachedCollectionForExistingKeys[key]);
+            const { isCompatible, existingValueType, newValueType, isEmptyArrayCoercion } = utils_1.default.checkCompatibilityWithExistingValue(resultCollection[key], cachedCollectionForExistingKeys[key]);
+            if (isEmptyArrayCoercion) {
+                // Merging an object into an empty array isn't semantically correct, but we allow it
+                // in case we accidentally encoded an empty object as an empty array in PHP. If you're
+                // looking at a bugbot from this message, we're probably missing that key in OnyxKeys::KEYS_REQUIRING_EMPTY_OBJECT
+                Logger.logAlert(`[ENSURE_BUGBOT] Onyx mergeCollection called on key "${key}" whose existing value is an empty array. Will coerce to object.`);
+            }
             if (!isCompatible) {
                 Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'mergeCollection', existingValueType, newValueType));
                 return obj;
@@ -1352,7 +1392,7 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
         // and update all subscribers
         const promiseUpdate = previousCollectionPromise.then((previousCollection) => {
             OnyxCache_1.default.merge(finalMergedCollection);
-            keysChanged(collectionKey, finalMergedCollection, previousCollection);
+            return scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection, previousCollection);
         });
         return Promise.all(promises)
             .catch((error) => retryOperation(error, mergeCollectionWithPatches, { collectionKey, collection: resultCollection, mergeReplaceNullPatches, isProcessingCollectionUpdate }, retryAttempt))
@@ -1405,15 +1445,16 @@ function partialSetCollection({ collectionKey, collection }, retryAttempt) {
         const keyValuePairs = prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
-        keysChanged(collectionKey, mutableCollection, previousCollection);
+        const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
         if (isRamOnlyKey(collectionKey)) {
             sendActionToDevTools(METHOD.SET_COLLECTION, undefined, mutableCollection);
-            return;
+            return updatePromise;
         }
         return storage_1.default.multiSet(keyValuePairs)
             .catch((error) => retryOperation(error, partialSetCollection, { collectionKey, collection }, retryAttempt))
             .then(() => {
             sendActionToDevTools(METHOD.SET_COLLECTION, undefined, mutableCollection);
+            return updatePromise;
         });
     });
 }
@@ -1457,6 +1498,8 @@ const OnyxUtils = {
     sendDataToConnection,
     getCollectionKey,
     getCollectionDataAndSendAsObject,
+    scheduleSubscriberUpdate,
+    scheduleNotifyCollectionSubscribers,
     remove,
     reportStorageQuota,
     retryOperation,
@@ -1511,6 +1554,10 @@ GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) =>
     // @ts-expect-error Reassign
     sendDataToConnection = (0, metrics_1.default)(sendDataToConnection, 'OnyxUtils.sendDataToConnection');
     // @ts-expect-error Reassign
+    scheduleSubscriberUpdate = (0, metrics_1.default)(scheduleSubscriberUpdate, 'OnyxUtils.scheduleSubscriberUpdate');
+    // @ts-expect-error Reassign
+    scheduleNotifyCollectionSubscribers = (0, metrics_1.default)(scheduleNotifyCollectionSubscribers, 'OnyxUtils.scheduleNotifyCollectionSubscribers');
+    // @ts-expect-error Reassign
     remove = (0, metrics_1.default)(remove, 'OnyxUtils.remove');
     // @ts-expect-error Reassign
     reportStorageQuota = (0, metrics_1.default)(reportStorageQuota, 'OnyxUtils.reportStorageQuota');

package/dist/utils.d.ts

@@ -46,6 +46,7 @@ declare function checkCompatibilityWithExistingValue(value: unknown, existingVal
     isCompatible: boolean;
     existingValueType?: string;
     newValueType?: string;
+    isEmptyArrayCoercion?: boolean;
 };
 /**
  * Picks entries from an object based on a condition.

package/dist/utils.js

@@ -142,6 +142,16 @@ function checkCompatibilityWithExistingValue(value, existingValue) {
             isCompatible: true,
         };
     }
+    // PHP's associative arrays cannot distinguish between an empty list and an
+    // empty object, so it encodes both as []. A key that should hold an
+    // object may arrive from the server as [] and be stored that way. If
+    // we then try to MERGE an object into that key, the array-vs-object type check
+    // would normally block it. Since an empty array carries no data worth
+    // preserving, we treat it as compatible with an object update and coerce it.
+    const isObjectValue = typeof value === 'object' && !Array.isArray(value);
+    if (Array.isArray(existingValue) && existingValue.length === 0 && isObjectValue) {
+        return { isCompatible: true, isEmptyArrayCoercion: true };
+    }
     const existingValueType = Array.isArray(existingValue) ? 'array' : 'non-array';
     const newValueType = Array.isArray(value) ? 'array' : 'non-array';
     if (existingValueType !== newValueType) {

package/package.json

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