fix: re-check subscription state per-key in keysChanged to handle self-disconnect

Author: fabioh8010

lib/OnyxUtils.ts

@@ -588,12 +588,20 @@ function keysChanged<TKey extends CollectionKeyBase>(
                 continue;
             }
 
-            // Not using waitForCollectionCallback — notify per changed key
+            // Not using waitForCollectionCallback — notify per changed key.
+            // Re-check the subscription on each iteration because the callback may
+            // synchronously disconnect itself (removing it from callbackToStateMapping),
+            // in which case we must stop firing further callbacks for this subscriber.
             for (const dataKey of changedMemberKeys) {
+                const currentSubscriber = callbackToStateMapping[subID];
+                if (!currentSubscriber || typeof currentSubscriber.callback !== 'function') {
+                    break;
+                }
                 if (cachedCollection[dataKey] === previousCollection[dataKey]) {
                     continue;
                 }
-                subscriber.callback(cachedCollection[dataKey], dataKey);
+                const currentSubscriberCallback = currentSubscriber.callback as DefaultConnectCallback<TKey>;
+                currentSubscriberCallback(cachedCollection[dataKey], dataKey as TKey);
             }
         } catch (error) {
             Logger.logAlert(`[OnyxUtils.keysChanged] Subscriber callback threw an error for key '${collectionKey}': ${error}`);

tests/unit/onyxUtilsTest.ts

@@ -433,6 +433,40 @@ describe('OnyxUtils', () => {
             Onyx.disconnect(conn1);
             Onyx.disconnect(conn2);
         });
+
+        it('should stop firing callbacks for a collection subscriber that disconnects itself mid-batch', async () => {
+            // A collection subscriber (waitForCollectionCallback=false) disconnects itself when
+            // it receives the first member. Subsequent changed members in the same batch must NOT
+            // trigger further callbacks for this subscriber.
+            const callback = jest.fn();
+            let connection: ReturnType<typeof Onyx.connect>;
+
+            callback.mockImplementation(() => {
+                if (!connection) {
+                    return;
+                }
+
+                Onyx.disconnect(connection);
+            });
+
+            connection = Onyx.connect({
+                key: ONYXKEYS.COLLECTION.TEST_KEY,
+                callback,
+                waitForCollectionCallback: false,
+                initWithStoredValues: false,
+            });
+            await waitForPromisesToResolve();
+            callback.mockClear();
+
+            await Onyx.multiSet({
+                [`${ONYXKEYS.COLLECTION.TEST_KEY}1`]: {id: 1},
+                [`${ONYXKEYS.COLLECTION.TEST_KEY}2`]: {id: 2},
+                [`${ONYXKEYS.COLLECTION.TEST_KEY}3`]: {id: 3},
+            });
+
+            // Despite 3 changed members, callback should fire at most once before disconnect stops it
+            expect(callback).toHaveBeenCalledTimes(1);
+        });
     });
 
     describe('keysChanged', () => {