react-native-onyx 3.0.60 → 3.0.62

package/dist/Onyx.js

@@ -246,9 +246,8 @@ 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, updatePromise }) => {
+                return OnyxMerge_1.default.applyMerge(key, existingValue, validChanges).then(({ mergedValue }) => {
                     OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE, key, changes, mergedValue);
-                    return updatePromise;
                 });
             }
             catch (error) {
@@ -347,14 +346,6 @@ 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.some((preserveKey) => OnyxKeys_1.default.isKeyMatch(preserveKey, key)) && !OnyxKeys_1.default.isRamOnlyKey(key))
@@ -371,7 +362,13 @@ function clear(keysToPreserve = []) {
                 .then(() => storage_1.default.multiSet(defaultKeyValuePairs))
                 .then(() => {
                 DevTools_1.default.clearState(keysToPreserve);
-                return Promise.all(updatePromises);
+                // 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);
+                }
             });
         })
             .then(() => undefined);

package/dist/OnyxMerge/index.js

@@ -14,17 +14,16 @@ 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.
-    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
+    OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
     const shouldSkipStorageOperations = !hasChanged || OnyxKeys_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, updatePromise });
+        return Promise.resolve({ mergedValue });
     }
     // 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

@@ -20,18 +20,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.
-    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
+    OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
     const shouldSkipStorageOperations = !hasChanged || OnyxKeys_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, updatePromise });
+        return Promise.resolve({ mergedValue });
     }
     // 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,7 +1,6 @@
 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

@@ -126,7 +126,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>, value: OnyxValue<TKey> | null, matchedKey: TKey | undefined): void;
+declare function sendDataToConnection<TKey extends OnyxKey>(mapping: CallbackToStateMapping<TKey>, 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.
@@ -136,19 +136,6 @@ 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
  */
@@ -164,7 +151,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): Promise<void>;
+declare function broadcastUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, hasChanged?: boolean): void;
 declare function hasPendingMergeForKey(key: OnyxKey): boolean;
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
@@ -303,8 +290,6 @@ declare const OnyxUtils: {
     keyChanged: typeof keyChanged;
     sendDataToConnection: typeof sendDataToConnection;
     getCollectionDataAndSendAsObject: typeof getCollectionDataAndSendAsObject;
-    scheduleSubscriberUpdate: typeof scheduleSubscriberUpdate;
-    scheduleNotifyCollectionSubscribers: typeof scheduleNotifyCollectionSubscribers;
     remove: typeof remove;
     reportStorageQuota: typeof reportStorageQuota;
     retryOperation: typeof retryOperation;

package/dist/OnyxUtils.js

@@ -73,8 +73,6 @@ 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 = {};
 // Holds a mapping of the connected key to the subscriptionID for faster lookups
@@ -476,36 +474,42 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
         const isSubscribedToCollectionMemberKey = OnyxKeys_1.default.isCollectionMemberKey(collectionKey, subscriber.key);
         // Regular Onyx.connect() subscriber found.
         if (typeof subscriber.callback === 'function') {
-            // If they are subscribed to the collection key and using waitForCollectionCallback then we'll
-            // send the whole cached collection.
-            if (isSubscribedToCollectionKey) {
-                if (subscriber.waitForCollectionCallback) {
-                    subscriber.callback(cachedCollection, subscriber.key, partialCollection);
+            try {
+                // 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, { value: cachedCollection, matchedKey: subscriber.key });
+                    if (subscriber.waitForCollectionCallback) {
+                        subscriber.callback(cachedCollection, subscriber.key, partialCollection);
+                        continue;
+                    }
+                    // If they are not using waitForCollectionCallback then we notify the subscriber with
+                    // the new merged data but only for any keys in the partial collection.
+                    const dataKeys = Object.keys(partialCollection !== null && partialCollection !== void 0 ? partialCollection : {});
+                    for (const dataKey of dataKeys) {
+                        if ((0, fast_equals_1.deepEqual)(cachedCollection[dataKey], previousCollection[dataKey])) {
+                            continue;
+                        }
+                        subscriber.callback(cachedCollection[dataKey], dataKey);
+                    }
                     continue;
                 }
-                // If they are not using waitForCollectionCallback then we notify the subscriber with
-                // the new merged data but only for any keys in the partial collection.
-                const dataKeys = Object.keys(partialCollection !== null && partialCollection !== void 0 ? partialCollection : {});
-                for (const dataKey of dataKeys) {
-                    if ((0, fast_equals_1.deepEqual)(cachedCollection[dataKey], previousCollection[dataKey])) {
+                // And if the subscriber is specifically only tracking a particular collection member key then we will
+                // notify them with the cached data for that key only.
+                if (isSubscribedToCollectionMemberKey) {
+                    if ((0, fast_equals_1.deepEqual)(cachedCollection[subscriber.key], previousCollection[subscriber.key])) {
                         continue;
                     }
-                    subscriber.callback(cachedCollection[dataKey], dataKey);
-                }
-                continue;
-            }
-            // And if the subscriber is specifically only tracking a particular collection member key then we will
-            // notify them with the cached data for that key only.
-            if (isSubscribedToCollectionMemberKey) {
-                if ((0, fast_equals_1.deepEqual)(cachedCollection[subscriber.key], previousCollection[subscriber.key])) {
+                    const subscriberCallback = subscriber.callback;
+                    subscriberCallback(cachedCollection[subscriber.key], subscriber.key);
+                    lastConnectionCallbackData.set(subscriber.subscriptionID, { value: cachedCollection[subscriber.key], matchedKey: subscriber.key });
                     continue;
                 }
-                const subscriberCallback = subscriber.callback;
-                subscriberCallback(cachedCollection[subscriber.key], subscriber.key);
-                lastConnectionCallbackData.set(subscriber.subscriptionID, cachedCollection[subscriber.key]);
                 continue;
             }
-            continue;
+            catch (error) {
+                Logger.logAlert(`[OnyxUtils.keysChanged] Subscriber callback threw an error for key '${collectionKey}': ${error}`);
+            }
         }
     }
 }
@@ -546,27 +550,35 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
         }
         // Subscriber is a regular call to connect() and provided a callback
         if (typeof subscriber.callback === 'function') {
-            if (lastConnectionCallbackData.has(subscriber.subscriptionID) && lastConnectionCallbackData.get(subscriber.subscriptionID) === value) {
-                continue;
-            }
-            if (OnyxKeys_1.default.isCollectionKey(subscriber.key) && subscriber.waitForCollectionCallback) {
-                // Skip individual key changes for collection callbacks during collection updates
-                // to prevent duplicate callbacks - the collection update will handle this properly
-                if (isProcessingCollectionUpdate) {
+            try {
+                const lastData = lastConnectionCallbackData.get(subscriber.subscriptionID);
+                if (lastData && lastData.matchedKey === key && lastData.value === value) {
                     continue;
                 }
-                let cachedCollection = cachedCollections[subscriber.key];
-                if (!cachedCollection) {
-                    cachedCollection = getCachedCollection(subscriber.key);
-                    cachedCollections[subscriber.key] = cachedCollection;
+                if (OnyxKeys_1.default.isCollectionKey(subscriber.key) && subscriber.waitForCollectionCallback) {
+                    // Skip individual key changes for collection callbacks during collection updates
+                    // to prevent duplicate callbacks - the collection update will handle this properly
+                    if (isProcessingCollectionUpdate) {
+                        continue;
+                    }
+                    let cachedCollection = cachedCollections[subscriber.key];
+                    if (!cachedCollection) {
+                        cachedCollection = getCachedCollection(subscriber.key);
+                        cachedCollections[subscriber.key] = cachedCollection;
+                    }
+                    cachedCollection[key] = value;
+                    lastConnectionCallbackData.set(subscriber.subscriptionID, { value: cachedCollection, matchedKey: subscriber.key });
+                    subscriber.callback(cachedCollection, subscriber.key, { [key]: value });
+                    continue;
                 }
-                cachedCollection[key] = value;
-                subscriber.callback(cachedCollection, subscriber.key, { [key]: value });
+                const subscriberCallback = subscriber.callback;
+                subscriberCallback(value, key);
+                lastConnectionCallbackData.set(subscriber.subscriptionID, { value, matchedKey: key });
                 continue;
             }
-            const subscriberCallback = subscriber.callback;
-            subscriberCallback(value, key);
-            lastConnectionCallbackData.set(subscriber.subscriptionID, value);
+            catch (error) {
+                Logger.logAlert(`[OnyxUtils.keyChanged] Subscriber callback threw an error for key '${key}': ${error}`);
+            }
             continue;
         }
         console.error('Warning: Found a matching subscriber to a key that changed, but no callback could be found.');
@@ -575,22 +587,34 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
 /**
  * Sends the data obtained from the keys to the connection.
  */
-function sendDataToConnection(mapping, value, matchedKey) {
+function sendDataToConnection(mapping, 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 (OnyxKeys_1.default.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.
-    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) && valueToPass === lastValue) {
+    value = value === null ? undefined : value;
+    const lastData = lastConnectionCallbackData.get(mapping.subscriptionID);
+    // If the value has not changed for the same key we do not need to trigger the callback.
+    // We compare matchedKey to avoid suppressing callbacks for different collection members
+    // that happen to have shallow-equal values (e.g. during hydration racing with set()).
+    if (lastData && lastData.matchedKey === matchedKey && (0, fast_equals_1.shallowEqual)(lastData.value, value)) {
         return;
     }
-    (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, valueToPass, matchedKey);
+    (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, value, 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
@@ -609,50 +633,16 @@ 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((dataMap) => {
-        const data = Object.fromEntries(dataMap.entries());
-        sendDataToConnection(mapping, data, mapping.key);
+    multiGet(matchingKeys).then(() => {
+        sendDataToConnection(mapping, 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);
-    scheduleSubscriberUpdate(key, undefined, undefined, isProcessingCollectionUpdate);
+    keyChanged(key, undefined, undefined, isProcessingCollectionUpdate);
     if (OnyxKeys_1.default.isRamOnlyKey(key)) {
         return Promise.resolve();
     }
@@ -720,7 +710,7 @@ function broadcastUpdate(key, value, hasChanged) {
     else {
         OnyxCache_1.default.addToAccessedKeys(key);
     }
-    return scheduleSubscriberUpdate(key, value, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false).then(() => undefined);
+    keyChanged(key, value, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false);
 }
 function hasPendingMergeForKey(key) {
     return !!mergeQueue[key];
@@ -943,7 +933,7 @@ function subscribeToKey(connectOptions) {
             const matchedKey = OnyxKeys_1.default.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, null, matchedKey);
+            sendDataToConnection(mapping, matchedKey);
             return;
         }
         // When using a callback subscriber we will either trigger the provided callback for each key we find or combine all values
@@ -956,15 +946,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((values) => {
-                    for (const [key, val] of values.entries()) {
-                        sendDataToConnection(mapping, val, key);
+                multiGet(matchingKeys).then(() => {
+                    for (const key of matchingKeys) {
+                        sendDataToConnection(mapping, 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((val) => sendDataToConnection(mapping, val, mapping.key));
+            get(mapping.key).then(() => sendDataToConnection(mapping, mapping.key));
             return;
         }
         console.error('Warning: Onyx.connect() was found without a callback');
@@ -1098,21 +1088,20 @@ 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.
-    const updatePromise = OnyxUtils.broadcastUpdate(key, valueWithoutNestedNullValues, hasChanged);
+    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 updatePromise;
+        return Promise.resolve();
     }
     // If a key is a RAM-only key or a member of RAM-only collection, we skip the step that modifies the storage
     if (OnyxKeys_1.default.isRamOnlyKey(key)) {
         OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET, key, valueWithoutNestedNullValues);
-        return updatePromise;
+        return Promise.resolve();
     }
     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;
     });
 }
 /**
@@ -1142,16 +1131,16 @@ function multiSetWithRetry(data, retryAttempt) {
         }, {});
     }
     const keyValuePairsToSet = OnyxUtils.prepareKeyValuePairsForStorage(newData, true);
-    const updatePromises = keyValuePairsToSet.map(([key, value]) => {
+    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
         // 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 on the next tick
+        // Update cache and optimistically inform subscribers
         OnyxCache_1.default.set(key, value);
-        return OnyxUtils.scheduleSubscriberUpdate(key, value);
-    });
+        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
@@ -1161,9 +1150,7 @@ 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.
@@ -1216,17 +1203,16 @@ function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
         const previousCollection = OnyxUtils.getCachedCollection(collectionKey);
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
-        const updatePromise = OnyxUtils.scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
+        keysChanged(collectionKey, mutableCollection, previousCollection);
         // RAM-only keys are not supposed to be saved to storage
         if (OnyxKeys_1.default.isRamOnlyKey(collectionKey)) {
             OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET_COLLECTION, undefined, mutableCollection);
-            return updatePromise;
+            return;
         }
         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;
         });
     });
 }
@@ -1333,7 +1319,7 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
         // and update all subscribers
         const promiseUpdate = previousCollectionPromise.then((previousCollection) => {
             OnyxCache_1.default.merge(finalMergedCollection);
-            return scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection, previousCollection);
+            keysChanged(collectionKey, finalMergedCollection, previousCollection);
         });
         return Promise.all(promises)
             .catch((error) => retryOperation(error, mergeCollectionWithPatches, { collectionKey, collection: resultCollection, mergeReplaceNullPatches, isProcessingCollectionUpdate }, retryAttempt))
@@ -1386,16 +1372,15 @@ function partialSetCollection({ collectionKey, collection }, retryAttempt) {
         const keyValuePairs = prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
-        const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
+        keysChanged(collectionKey, mutableCollection, previousCollection);
         if (OnyxKeys_1.default.isRamOnlyKey(collectionKey)) {
             sendActionToDevTools(METHOD.SET_COLLECTION, undefined, mutableCollection);
-            return updatePromise;
+            return;
         }
         return storage_1.default.multiSet(keyValuePairs)
             .catch((error) => retryOperation(error, partialSetCollection, { collectionKey, collection }, retryAttempt))
             .then(() => {
             sendActionToDevTools(METHOD.SET_COLLECTION, undefined, mutableCollection);
-            return updatePromise;
         });
     });
 }
@@ -1432,8 +1417,6 @@ const OnyxUtils = {
     keyChanged,
     sendDataToConnection,
     getCollectionDataAndSendAsObject,
-    scheduleSubscriberUpdate,
-    scheduleNotifyCollectionSubscribers,
     remove,
     reportStorageQuota,
     retryOperation,

package/dist/storage/providers/SQLiteProvider.js

@@ -6,12 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const react_native_nitro_sqlite_1 = require("react-native-nitro-sqlite");
 const react_native_device_info_1 = require("react-native-device-info");
 const utils_1 = __importDefault(require("../../utils"));
-// By default, NitroSQLite does not accept nullish values due to current limitations in Nitro Modules.
-// This flag enables a feature in NitroSQLite that allows for nullish values to be passed to operations, such as "execute" or "executeBatch".
-// Simple null handling can potentially add a minor performance overhead,
-// since parameters and results from SQLite queries need to be parsed from and to JavaScript nullish values.
-// https://github.com/margelo/react-native-nitro-sqlite#sending-and-receiving-nullish-values
-(0, react_native_nitro_sqlite_1.enableSimpleNullHandling)();
 const DB_NAME = 'OnyxDB';
 /**
  * Prevents the stringifying of the object markers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "3.0.60",
+  "version": "3.0.62",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",
@@ -91,8 +91,8 @@
     "react": "18.2.0",
     "react-native": "0.76.3",
     "react-native-device-info": "^10.3.0",
-    "react-native-nitro-modules": "^0.27.2",
-    "react-native-nitro-sqlite": "^9.2.0",
+    "react-native-nitro-modules": "^0.35.0",
+    "react-native-nitro-sqlite": "^9.6.0",
     "react-test-renderer": "18.2.0",
     "reassure": "1.4.0",
     "ts-node": "^10.9.2",
@@ -104,8 +104,8 @@
     "react": ">=18.1.0",
     "react-native": ">=0.75.0",
     "react-native-device-info": "^10.3.0",
-    "react-native-nitro-modules": ">=0.27.2",
-    "react-native-nitro-sqlite": "^9.2.0"
+    "react-native-nitro-modules": ">=0.35.0",
+    "react-native-nitro-sqlite": "^9.6.0"
   },
   "peerDependenciesMeta": {
     "idb-keyval": {