Try to synchronize operations within one update

lib/Onyx.js

@@ -1080,7 +1080,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
@@ -1437,24 +1437,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
@@ -1471,9 +1457,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();
     }
 
@@ -1546,22 +1548,36 @@ function update(data) {
         }
     });
 
-    const promises = [];
-    let clearPromise = Promise.resolve();
+    const updateQueue = {};
+    const enqueueSetOperation = (key, value) => {
+        updateQueue[key] = [{onyxMethod: METHOD.SET, value}];
+    }
+    const enqueueMergeOperation = (key, value) => {
+        const operation = {onyxMethod: METHOD.MERGE, value};
+        if (!updateQueue[key]) {
+            updateQueue[key] = [operation];
+        } else {
+            updateQueue[key].push(operation);
+        }
+    }
 
+    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();
@@ -1571,7 +1587,25 @@ function update(data) {
         }
     });
 
-    return clearPromise.then(() => Promise.all(_.map(promises, (p) => p())));
+    return clearPromise.then(() => Storage.multiGet(_.keys(updateQueue)).then((pairs) => {
+        const existingSnapshot = _.reduce(pairs, (acc, [key, value]) => {
+            acc[key] = value;
+            return acc;
+        }, {});
+
+        const updatedSnapshot = {};
+        _.each(updateQueue, (operations, key) => {
+            let existingValue = existingSnapshot[key];
+            if (operations[0].onyxMethod === METHOD.SET) {
+                existingValue = operations[0].value;
+            }
+
+            const mergeOperations = _.filter(operations, ({onyxMethod}) => onyxMethod === METHOD.MERGE);
+            updatedSnapshot[key] = applyMerge(existingValue, _.map(mergeOperations, ({value}) => value), true);
+        });
+
+        return Storage.multiSet(_.pairs(updatedSnapshot));
+    }));
 }
 
 /**