react-native-onyx 2.0.11 → 2.0.12

package/dist/Onyx.js

@@ -694,13 +694,70 @@ function addKeyToRecentlyAccessedIfNeeded(mapping) {
  * @param {Object} mapping
  */
 function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
-    Promise.all(underscore_1.default.map(matchingKeys, (key) => get(key)))
-        .then((values) => underscore_1.default.reduce(values, (finalObject, value, i) => {
-        // eslint-disable-next-line no-param-reassign
-        finalObject[matchingKeys[i]] = value;
-        return finalObject;
-    }, {}))
-        .then((val) => sendDataToConnection(mapping, val, undefined, true));
+    // Keys that are not in the cache
+    const missingKeys = [];
+    // Tasks that are pending
+    const pendingTasks = [];
+    // Keys for the tasks that are pending
+    const pendingKeys = [];
+    // We are going to combine all the data from the matching keys into a single object
+    const data = {};
+    /**
+     * We are going to iterate over all the matching keys and check if we have the data in the cache.
+     * If we do then we add it to the data object. If we do not then we check if there is a pending task
+     * for the key. If there is then we add the promise to the pendingTasks array and the key to the pendingKeys
+     * array. If there is no pending task then we add the key to the missingKeys array.
+     *
+     * These missingKeys will be later to use to multiGet the data from the storage.
+     */
+    matchingKeys.forEach((key) => {
+        const cacheValue = OnyxCache_1.default.getValue(key);
+        if (cacheValue) {
+            data[key] = cacheValue;
+            return;
+        }
+        const pendingKey = `get:${key}`;
+        if (OnyxCache_1.default.hasPendingTask(pendingKey)) {
+            pendingTasks.push(OnyxCache_1.default.getTaskPromise(pendingKey));
+            pendingKeys.push(key);
+        }
+        else {
+            missingKeys.push(key);
+        }
+    });
+    Promise.all(pendingTasks)
+        // We are going to wait for all the pending tasks to resolve and then add the data to the data object.
+        .then((values) => {
+        values.forEach((value, index) => {
+            data[pendingKeys[index]] = value;
+        });
+        return Promise.resolve();
+    })
+        // We are going to get the missing keys using multiGet from the storage.
+        .then(() => {
+        if (missingKeys.length === 0) {
+            return Promise.resolve();
+        }
+        return storage_1.default.multiGet(missingKeys);
+    })
+        // We are going to add the data from the missing keys to the data object and also merge it to the cache.
+        .then((values) => {
+        if (!values || values.length === 0) {
+            return Promise.resolve();
+        }
+        // temp object is used to merge the missing data into the cache
+        const temp = {};
+        values.forEach((value) => {
+            data[value[0]] = value[1];
+            temp[value[0]] = value[1];
+        });
+        OnyxCache_1.default.merge(temp);
+        return Promise.resolve();
+    })
+        // We are going to send the data to the subscriber.
+        .finally(() => {
+        sendDataToConnection(mapping, data, undefined, true);
+    });
 }
 /**
  * Subscribes a react component's state directly to a store key

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "2.0.11",
+  "version": "2.0.12",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",