multiGet: prefer cache over stale storage on concurrent writes

Mirrors the existing prefer-cache check in get() (lib/OnyxUtils.ts
around line 299). Before this change, if a concurrent set/merge
populated cache while multiGet's Storage.multiGet was in flight, the
trailing cache.merge(temp) would fastMerge the stale storage snapshot
on top of the fresher cache value — resurrecting fields the
concurrent write meant to drop.

Per-key check at the storage-result loop: if cache.hasCacheForKey is
true at the time we'd write, take the cached value into dataMap and
skip writing to temp. cache.merge(temp) at the end then only touches
keys that stayed genuinely cold throughout the read.

Adds a regression test under `multiGet cache hit consistency` that
sets the cache from inside the Storage.multiGet mock (synchronously,
before the promise resolves), then asserts both the returned dataMap
and the in-memory cache reflect the concurrent write — not the stale
storage snapshot. Fails without the lib change, passes with it.

Author: elirangoshen

lib/OnyxUtils.ts

@@ -402,6 +402,13 @@ function multiGet<TKey extends OnyxKey>(keys: CollectionKeyBase[]): Promise<Map<
                         }
                     }
 
+                    // Prefer cache over stale storage if a concurrent write populated it during
+                    // the read — otherwise cache.merge(temp) below would resurrect dropped fields.
+                    if (cache.hasCacheForKey(key)) {
+                        dataMap.set(key, cache.get(key) as OnyxValue<TKey>);
+                        continue;
+                    }
+
                     dataMap.set(key, value as OnyxValue<TKey>);
                     temp[key] = value as OnyxValue<TKey>;
                 }

tests/unit/onyxUtilsTest.ts

@@ -1174,6 +1174,27 @@ describe('OnyxUtils', () => {
             expect(getItemSpy).not.toHaveBeenCalled();
             expect(result.get(falsyKey)).toBe(0);
         });
+
+        it('prefers cache when a concurrent write lands during the storage read', async () => {
+            // Concurrent write during multiGet's storage read must not be overwritten by the
+            // stale snapshot via cache.merge.
+            const key = `${ONYXKEYS.COLLECTION.TEST_KEY}race`;
+
+            OnyxCache.drop(key);
+            OnyxCache.addKey(key);
+
+            // Set cache inside the mock so it lands before Storage.multiGet's promise resolves —
+            // multiGet's .then() then sees a populated cache and skips writing the stale value.
+            StorageMock.multiGet = jest.fn().mockImplementation(() => {
+                OnyxCache.set(key, {fresh: 'data'});
+                return Promise.resolve([[key, {stale: 'a', alsoStale: 'b'}]]);
+            });
+
+            const result = await OnyxUtils.multiGet([key]);
+
+            expect(OnyxCache.get(key)).toEqual({fresh: 'data'});
+            expect(result.get(key)).toEqual({fresh: 'data'});
+        });
     });
 
     describe('storage eviction', () => {