Try to synchronize operations within one update

lib/Onyx.js

@@ -31,7 +31,7 @@ let lastConnectionID = 0;
 const callbackToStateMapping = {};
 
 // Keeps a copy of the values of the onyx collection keys as a map for faster lookups
-let onyxCollectionKeyMap = new Map();
+let onyxCollectionKeySet = new Set();
 
 // Holds a list of keys that have been directly subscribed to or recently modified from least to most recent
 let recentlyAccessedKeys = [];
@@ -194,14 +194,14 @@ function getAllKeys() {
 }
 
 /**
- * Checks to see if the a subscriber's supplied key
+ * Checks to see if the subscriber's supplied key
  * is associated with a collection of keys.
  *
  * @param {String} key
  * @returns {Boolean}
  */
 function isCollectionKey(key) {
-    return onyxCollectionKeyMap.has(key);
+    return onyxCollectionKeySet.has(key);
 }
 
 /**
@@ -1115,7 +1115,7 @@ function evictStorageAndRetry(error, onyxMethod, ...args) {
 }
 
 /**
- * Notifys subscribers and writes current value to cache
+ * Notifies subscribers and writes current value to cache
  *
  * @param {String} key
  * @param {*} value
@@ -1472,24 +1472,10 @@ function clear(keysToPreserve = []) {
     });
 }
 
-/**
- * Merges a collection based on their keys
- *
- * @example
- *
- * Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT, {
- *     [`${ONYXKEYS.COLLECTION.REPORT}1`]: report1,
- *     [`${ONYXKEYS.COLLECTION.REPORT}2`]: report2,
- * });
- *
- * @param {String} collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
- * @param {Object} collection Object collection keyed by individual collection member keys and values
- * @returns {Promise}
- */
-function mergeCollection(collectionKey, collection) {
+function isValidMergeCollection(collectionKey, collection) {
     if (!_.isObject(collection) || _.isArray(collection) || _.isEmpty(collection)) {
         Logger.logInfo('mergeCollection() called with invalid or empty value. Skipping this update.');
-        return Promise.resolve();
+        return false;
     }
 
     // Confirm all the collection keys belong to the same parent
@@ -1506,9 +1492,25 @@ function mergeCollection(collectionKey, collection) {
         hasCollectionKeyCheckFailed = true;
         Logger.logAlert(`Provided collection doesn't have all its data belonging to the same parent. CollectionKey: ${collectionKey}, DataKey: ${dataKey}`);
     });
+    return !hasCollectionKeyCheckFailed;
+}
 
-    // Gracefully handle bad mergeCollection updates so it doesn't block the merge queue
-    if (hasCollectionKeyCheckFailed) {
+/**
+ * Merges a collection based on their keys
+ *
+ * @example
+ *
+ * Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT, {
+ *     [`${ONYXKEYS.COLLECTION.REPORT}1`]: report1,
+ *     [`${ONYXKEYS.COLLECTION.REPORT}2`]: report2,
+ * });
+ *
+ * @param {String} collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
+ * @param {Object} collection Object collection keyed by individual collection member keys and values
+ * @returns {Promise}
+ */
+function mergeCollection(collectionKey, collection) {
+    if (!isValidMergeCollection(collectionKey, collection)) {
         return Promise.resolve();
     }
 
@@ -1581,22 +1583,42 @@ function update(data) {
         }
     });
 
-    const promises = [];
+    const updateQueue = {};
+    const enqueueSetOperation = (key, value) => {
+        // If a `set` operation is enqueued, we should clear the whole queue.
+        // Since the `set` operation replaces the value entirely, there's no need to perform any previous operations.
+        // To do this, we first put `null` in the queue, which removes the existing value, and then merge the new value.
+        updateQueue[key] = [null, value];
+    };
+    const enqueueMergeOperation = (key, value) => {
+        if (value === null) {
+            // If we merge `null`, the value is removed and all the previous operations are discarded.
+            updateQueue[key] = [null];
+        } else if (!updateQueue[key]) {
+            updateQueue[key] = [value];
+        } else {
+            updateQueue[key].push(value);
+        }
+    };
+
     let clearPromise = Promise.resolve();
 
     _.each(data, ({onyxMethod, key, value}) => {
         switch (onyxMethod) {
             case METHOD.SET:
-                promises.push(() => set(key, value));
+                enqueueSetOperation(key, value);
                 break;
-            case METHOD.MERGE:
-                promises.push(() => merge(key, value));
+            case METHOD.MERGE: {
+                enqueueMergeOperation(key, value);
                 break;
+            }
             case METHOD.MERGE_COLLECTION:
-                promises.push(() => mergeCollection(key, value));
+                if (isValidMergeCollection(key, value)) {
+                    _.each(value, (_value, _key) => enqueueMergeOperation(_key, _value));
+                }
                 break;
             case METHOD.MULTI_SET:
-                promises.push(() => multiSet(value));
+                _.each(value, (_value, _key) => enqueueSetOperation(_key, _value));
                 break;
             case METHOD.CLEAR:
                 clearPromise = clear();
@@ -1606,6 +1628,57 @@ function update(data) {
         }
     });
 
+    const promises = [];
+
+    // Group all the collection-related keys and update each collection in a single `mergeCollection` call
+    onyxCollectionKeySet.forEach((collectionKey) => {
+        const collectionItemKeys = _.filter(_.keys(updateQueue), (key) => isKeyMatch(collectionKey, key));
+        if (_.size(collectionItemKeys) <= 1) {
+            // If there are no items of this collection in the updateQueue, we should skip it.
+            // If there is only one item, we should update it individually, therefore retain it in the updateQueue.
+            return;
+        }
+
+        const batchedCollectionUpdates = _.reduce(
+            collectionItemKeys,
+            (acc, key) => {
+                const operations = updateQueue[key];
+
+                // Remove the collection-related key from the updateQueue so that it won't be processed individually later.
+                delete updateQueue[key];
+
+                const updatedValue = applyMerge(undefined, operations, false);
+                if (operations[0] === null) {
+                    acc.set[key] = updatedValue;
+                } else {
+                    acc.merge[key] = updatedValue;
+                }
+                return acc;
+            },
+            {
+                merge: {},
+                set: {},
+            },
+        );
+
+        if (!_.isEmpty(batchedCollectionUpdates.merge)) {
+            promises.push(() => mergeCollection(collectionKey, batchedCollectionUpdates.merge));
+        }
+        if (!_.isEmpty(batchedCollectionUpdates.set)) {
+            promises.push(() => multiSet(batchedCollectionUpdates.set));
+        }
+    });
+
+    _.each(updateQueue, (operations, key) => {
+        const batchedChanges = applyMerge(undefined, operations, false);
+
+        if (operations[0] === null) {
+            promises.push(() => set(key, batchedChanges));
+        } else {
+            promises.push(() => merge(key, batchedChanges));
+        }
+    });
+
     return clearPromise.then(() => Promise.all(_.map(promises, (p) => p())));
 }
 
@@ -1655,15 +1728,15 @@ function init({keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCache
     }
 
     // We need the value of the collection keys later for checking if a
-    // key is a collection. We store it in a map for faster lookup.
+    // key is a collection. We store it in a Set for faster lookup.
     const collectionValues = _.values(keys.COLLECTION);
-    onyxCollectionKeyMap = _.reduce(
+    onyxCollectionKeySet = _.reduce(
         collectionValues,
         (acc, val) => {
-            acc.set(val, true);
+            acc.add(val);
             return acc;
         },
-        new Map(),
+        new Set(),
     );
 
     // Set our default key states to use when initializing and clearing Onyx data