react-native-onyx 1.0.32 → 1.0.34

package/dist/web.development.js

@@ -856,8 +856,7 @@ function notifyCollectionSubscribersOnNextTick(key, value) {
  * @return {Promise}
  */
 function remove(key) {
-  // Cache the fact that the value was removed
-  _OnyxCache.default.set(key, null);
+  _OnyxCache.default.drop(key);
   notifySubscribersOnNextTick(key, null);
   return _storage.default.removeItem(key);
 }
@@ -904,8 +903,9 @@ function evictStorageAndRetry(error, onyxMethod) {for (var _len = arguments.leng
  * @returns {Promise}
  */
 function set(key, value) {
-  // Logging properties only since values could be sensitive things we don't want to log
-  Logger.logInfo("set() called for key: " + key + (_underscore.default.isObject(value) ? " properties: " + _underscore.default.keys(value).join(',') : ''));
+  if (_underscore.default.isNull(value)) {
+    return remove(key);
+  }
 
   // eslint-disable-next-line no-use-before-define
   if (hasPendingMergeForKey(key)) {
@@ -1107,6 +1107,10 @@ function clear() {var keysToPreserve = arguments.length > 0 && arguments[0] !==
     var keyValuesToReset = [];
     var defaultKeys = _underscore.default.keys(defaultKeyStates);
 
+    // Get all the values for the keys that need to be preserved. These key/value pairs will be set
+    // in Onyx after the database is cleared().
+    var keyValuesToPreserve = _underscore.default.map(keysToPreserve, function (key) {return [key, _OnyxCache.default.getValue(key)];});
+
     // 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)
@@ -1159,7 +1163,11 @@ function clear() {var keysToPreserve = arguments.length > 0 && arguments[0] !==
       notifyCollectionSubscribersOnNextTick(key, value);
     });
 
-    return _storage.default.multiSet(keyValuesToReset);
+    // Call clear() and make sure that the default key/values and the key/values from the parameter
+    // are preserved in storage. This makes sure to always leave storage in a state that contains
+    // all the default values and any additional values that we want to remain after the database is cleared.
+    return _storage.default.clear().
+    then(function () {return _storage.default.multiSet([].concat((0, _toConsumableArray2.default)(defaultKeyValuePairs), (0, _toConsumableArray2.default)(keyValuesToPreserve)));});
   });
 }
 
@@ -1351,6 +1359,7 @@ var Onyx = {
   mergeCollection: mergeCollection,
   update: update,
   clear: clear,
+  getAllKeys: getAllKeys,
   init: init,
   registerLogger: Logger.registerLogger,
   addToEvictionBlockList: addToEvictionBlockList,
@@ -1513,6 +1522,8 @@ OnyxCache = /*#__PURE__*/function () {
      */ }, { key: "drop", value:
     function drop(key) {
       delete this.storageMap[key];
+      this.storageKeys.delete(key);
+      this.recentKeys.delete(key);
     }
 
     /**
@@ -1649,7 +1660,15 @@ SyncQueue = /*#__PURE__*/function () {
     this.queue = [];
     this.isProcessing = false;
     this.run = run;
-  }(0, _createClass2.default)(SyncQueue, [{ key: "process", value:
+  }
+
+  /**
+   * Stop the queue from being processed and clear out any existing tasks
+   */(0, _createClass2.default)(SyncQueue, [{ key: "abort", value:
+    function abort() {
+      this.queue = [];
+      this.isProcessing = false;
+    } }, { key: "process", value:
 
     function process() {var _this = this;
       if (this.isProcessing || this.queue.length === 0) {
@@ -1874,12 +1893,17 @@ function resetMetrics() {}
   \***********************************/
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
-var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default"] = void 0;var _underscore = _interopRequireDefault(__webpack_require__(/*! underscore */ "underscore"));
-var _LocalForage = _interopRequireDefault(__webpack_require__(/*! ./providers/LocalForage */ "./lib/storage/providers/LocalForage.js"));
+var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default"] = void 0;
 
-var SYNC_ONYX = 'SYNC_ONYX';
 
-/**
+
+
+var _underscore = _interopRequireDefault(__webpack_require__(/*! underscore */ "underscore"));
+var _LocalForage = _interopRequireDefault(__webpack_require__(/*! ./providers/LocalForage */ "./lib/storage/providers/LocalForage.js")); /**
+ * This file is here to wrap LocalForage with a layer that provides data-changed events like the ones that exist
+ * when using LocalStorage APIs in the browser. These events are great because multiple tabs can listen for when
+ * data changes and then stay up-to-date with everything happening in Onyx.
+ */var SYNC_ONYX = 'SYNC_ONYX'; /**
  * Raise an event thorough `localStorage` to let other tabs know a value changed
  * @param {String} onyxKey
  */
@@ -1894,7 +1918,7 @@ _LocalForage.default, {
   /**
    * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
    */
-  keepInstancesSync: function keepInstancesSync(onStorageKeyChanged) {var _this = this;
+  keepInstancesSync: function keepInstancesSync(onStorageKeyChanged) {
     // Override set, remove and clear to raise storage events that we intercept in other tabs
     this.setItem = function (key, value) {return _LocalForage.default.setItem(key, value).
       then(function () {return raiseStorageSyncEvent(key);});};
@@ -1903,10 +1927,23 @@ _LocalForage.default, {
       then(function () {return raiseStorageSyncEvent(key);});};
 
     // If we just call Storage.clear other tabs will have no idea which keys were available previously
-    // so that they can call keysChanged for them. That's why we iterate and remove keys one by one
-    this.clear = function () {return _LocalForage.default.getAllKeys().
-      then(function (keys) {return _underscore.default.map(keys, function (key) {return _this.removeItem(key);});}).
-      then(function (tasks) {return Promise.all(tasks);});};
+    // so that they can call keysChanged for them. That's why we iterate over every key and raise a storage sync
+    // event for each one
+    this.clear = function () {
+      var allKeys;
+
+      // They keys must be retreived before storage is cleared or else the list of keys would be empty
+      return _LocalForage.default.getAllKeys().
+      then(function (keys) {
+        allKeys = keys;
+      }).
+      then(function () {return _LocalForage.default.clear();}).
+      then(function () {
+        // Now that storage is cleared, the storage sync event can happen which is a more atomic action
+        // for other browser tabs
+        _underscore.default.each(allKeys, raiseStorageSyncEvent);
+      });
+    };
 
     // This listener will only be triggered by events coming from other tabs
     __webpack_require__.g.addEventListener('storage', function (event) {
@@ -2021,10 +2058,13 @@ var provider = {
   },
 
   /**
-   * Clear absolutely everything from storage
+   * Clear everything from storage and also stops the SyncQueue from adding anything more to storage
    * @returns {Promise<void>}
    */
-  clear: _localforage.default.clear,
+  clear: function clear() {
+    this.setItemQueue.abort();
+    return _localforage.default.clear();
+  },
 
   /**
    * Returns all keys available in storage