react-native-onyx 1.0.29 → 1.0.31

package/lib/Onyx.js

@@ -661,7 +661,10 @@ function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
  * @param {Boolean} [mapping.initWithStoredValues] If set to false, then no data will be prefilled into the
  *  component
  * @param {Boolean} [mapping.waitForCollectionCallback] If set to true, it will return the entire collection to the callback as a single object
- * @param {String|Function} [mapping.selector] THIS PARAM IS ONLY USED WITH withOnyx(). If included, this will be used to subscribe to a subset of an Onyx key's data. If the selector is a string, the selector is passed to lodashGet on the sourceData. If the selector is a function, the sourceData is passed to the selector and should return the simplified data. Using this setting on `withOnyx` can have very positive performance benefits because the component will only re-render when the subset of data changes. Otherwise, any change of data on any property would normally cause the component to re-render (and that can be expensive from a performance standpoint).
+ * @param {String|Function} [mapping.selector] THIS PARAM IS ONLY USED WITH withOnyx(). If included, this will be used to subscribe to a subset of an Onyx key's data.
+ *       If the selector is a string, the selector is passed to lodashGet on the sourceData. If the selector is a function, the sourceData is passed to the selector and should return the
+ *       simplified data. Using this setting on `withOnyx` can have very positive performance benefits because the component will only re-render when the subset of data changes.
+ *       Otherwise, any change of data on any property would normally cause the component to re-render (and that can be expensive from a performance standpoint).
  * @returns {Number} an ID to use when calling disconnect
  */
 function connect(mapping) {
@@ -775,6 +778,19 @@ function notifySubscribersOnNextTick(key, value, canUpdateSubscriber) {
     Promise.resolve().then(() => keyChanged(key, value, canUpdateSubscriber));
 }
 
+/**
+ * This method is similar to notifySubscribersOnNextTick 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.
+ *
+ * @param {String} key
+ * @param {*} value
+ */
+// eslint-disable-next-line rulesdir/no-negated-variables
+function notifyCollectionSubscribersOnNextTick(key, value) {
+    Promise.resolve().then(() => keysChanged(key, value));
+}
+
 /**
  * Remove a key from Onyx and update the subscribers
  *
@@ -1025,17 +1041,68 @@ function initializeWithDefaultKeyStates() {
  * Storage.setItem() from Onyx.clear() will have already finished and the merged
  * value will be saved to storage after the default value.
  *
+ * @param {Array} keysToPreserve is a list of ONYXKEYS that should not be cleared with the rest of the data
  * @returns {Promise<void>}
  */
-function clear() {
+function clear(keysToPreserve = []) {
     return getAllKeys()
         .then((keys) => {
-            _.each(keys, (key) => {
-                const resetValue = lodashGet(defaultKeyStates, key, null);
-                cache.set(key, resetValue);
-                notifySubscribersOnNextTick(key, resetValue);
+            const keyValuesToReset = [];
+            const defaultKeys = _.keys(defaultKeyStates);
+
+            // The only keys that should not be cleared are:
+            // 1. Anything specifically passed in keysToPreserve (because some keys like language preferences, offline
+            //      status, or activeClients need to remain in Onyx even when signed out)
+            // 2. Any keys with a default state (because they need to remain in Onyx as their default, and setting them
+            //      to null would cause unknown behavior)
+            const keysToClear = _.difference(keys, keysToPreserve, defaultKeys);
+            keyValuesToReset.push(..._.map(keysToClear, key => [key, null]));
+
+            // Remove any keysToPreserve from the defaultKeyStates because if they are passed in it has been explicitly
+            // called out to preserve those values instead of resetting them back
+            // to the default.
+            const defaultKeyValuePairs = _.pairs(_.omit(defaultKeyStates, ...keysToPreserve));
+
+            // Add the default key value pairs to the keyValuesToReset so that they get set back to their default values
+            // when we clear Onyx
+            keyValuesToReset.push(...defaultKeyValuePairs);
+
+            // We now have all the key/values that need to be reset, but we're not done yet!
+            // There will be two groups of key/values and they each need to be updated a little bit differently.
+            // Collection keys need to be notified differently than non collection keys
+            const keyValuesToResetAsCollection = {};
+            const keyValuesToResetIndividually = {};
+
+            // Make sure that we also reset the cache values before clearing the values from storage.
+            // We do this before clearing Storage so that any call to clear() followed by merge() on a key with a
+            // default state results in the merged value getting saved, since the update from the merge() call would
+            // happen on the tick after the update from this clear()
+            _.each(keyValuesToReset, (keyValue) => {
+                const key = keyValue[0];
+                const value = keyValue[1];
+                cache.set(key, value);
+
+                const collectionKey = key.substring(0, key.indexOf('_') + 1);
+                if (collectionKey) {
+                    if (!keyValuesToResetAsCollection[collectionKey]) {
+                        keyValuesToResetAsCollection[collectionKey] = {};
+                    }
+                    keyValuesToResetAsCollection[collectionKey][key] = value;
+                    return;
+                }
+
+                keyValuesToResetIndividually[key] = value;
             });
-            return Storage.clear();
+
+            // Notify the subscribers for each key/value group so they can receive the new values
+            _.each(keyValuesToResetIndividually, (value, key) => {
+                notifySubscribersOnNextTick(key, value);
+            });
+            _.each(keyValuesToResetAsCollection, (value, key) => {
+                notifyCollectionSubscribersOnNextTick(key, value);
+            });
+
+            return Storage.multiSet(keyValuesToReset);
         });
 }
 

package/package.json

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