fix: process non-collection keys inline in multiSetWithRetry to preserve callback semantics

Author: fabioh8010

lib/OnyxUtils.ts

@@ -1379,7 +1379,6 @@ function multiSetWithRetry(data: OnyxMultiSetInput, retryAttempt?: number): Prom
     // collection, `partial` holds the new values being set and `previous` holds the cached values
     // from before the set, which keysChanged() uses to skip subscribers whose value didn't change.
     const collectionBatches = new Map<string, {partial: Record<string, OnyxValue<OnyxKey>>; previous: Record<string, OnyxValue<OnyxKey>>}>();
-    const nonCollectionPairs: Array<[string, OnyxValue<OnyxKey>]> = [];
 
     for (const [key, value] of keyValuePairsToSet) {
         // When we use multiSet to set a key we want to clear the current delta changes from Onyx.merge that were queued
@@ -1403,9 +1402,11 @@ function multiSetWithRetry(data: OnyxMultiSetInput, retryAttempt?: number): Prom
             batch.partial[key] = value;
             batch.previous[key] = previousValue;
         } else {
-            // Non-collection keys are notified individually — no batching.
+            // Non-collection keys are notified inline (cache.set + keyChanged in iteration order)
+            // so re-entrant callbacks (e.g. Onyx.set inside a callback) see consistent cache
+            // and subscriber state, matching the original per-key notification semantics.
             cache.set(key, value);
-            nonCollectionPairs.push([key, value]);
+            keyChanged(key, value);
         }
     }
 
@@ -1415,11 +1416,6 @@ function multiSetWithRetry(data: OnyxMultiSetInput, retryAttempt?: number): Prom
         keysChanged(collectionKey as CollectionKeyBase, batch.partial, batch.previous);
     }
 
-    // Non-collection keys go through the regular per-key notification path.
-    for (const [key, value] of nonCollectionPairs) {
-        keyChanged(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

tests/unit/onyxUtilsTest.ts

@@ -74,6 +74,7 @@ const testMergeChanges: GenericDeepRecord[] = [
 
 const ONYXKEYS = {
     TEST_KEY: 'test',
+    TEST_KEY_2: 'test2',
     COLLECTION: {
         TEST_KEY: 'test_',
         TEST_LEVEL_KEY: 'test_level_',
@@ -467,6 +468,54 @@ describe('OnyxUtils', () => {
             // Despite 3 changed members, callback should fire at most once before disconnect stops it
             expect(callback).toHaveBeenCalledTimes(1);
         });
+
+        it('should keep cache and subscriber state consistent when a non-collection callback writes to another payload key', async () => {
+            // A subscriber for keyA synchronously calls Onyx.set() on keyB during its callback.
+            // After multiSet completes, the cache must reflect the multiSet's value for keyB
+            // (multiSet wins), and the keyB subscriber's last seen value must equal the cache.
+            await Onyx.multiSet({[ONYXKEYS.TEST_KEY]: 'initialA', [ONYXKEYS.TEST_KEY_2]: 'initialB'});
+
+            const callbackA = jest.fn((value: unknown) => {
+                if (value !== 'newA') {
+                    return;
+                }
+
+                // While processing the new value of keyA, write to keyB.
+                // keyB is later in the same multiSet payload — multiSet should win.
+                Onyx.set(ONYXKEYS.TEST_KEY_2, 'callbackB');
+            });
+            const callbackB = jest.fn();
+
+            const connA = Onyx.connect({
+                key: ONYXKEYS.TEST_KEY,
+                callback: callbackA,
+                initWithStoredValues: false,
+            });
+            const connB = Onyx.connect({
+                key: ONYXKEYS.TEST_KEY_2,
+                callback: callbackB,
+                initWithStoredValues: false,
+            });
+            await waitForPromisesToResolve();
+            callbackA.mockClear();
+            callbackB.mockClear();
+
+            await Onyx.multiSet({
+                [ONYXKEYS.TEST_KEY]: 'newA',
+                [ONYXKEYS.TEST_KEY_2]: 'multiSetB',
+            });
+
+            // Cache reflects multiSet's payload value for keyB (the multiSet's later cache.set wins)
+            expect(OnyxCache.get(ONYXKEYS.TEST_KEY_2)).toBe('multiSetB');
+
+            expect(callbackB.mock.calls.length).toBe(2);
+            expect(callbackB.mock.calls.at(0)?.[0]).toBe('callbackB');
+            // keyB subscriber's last received value matches the cache (no stale callback)
+            expect(callbackB.mock.calls.at(1)?.[0]).toBe('multiSetB');
+
+            Onyx.disconnect(connA);
+            Onyx.disconnect(connB);
+        });
     });
 
     describe('keysChanged', () => {