react-native-onyx 1.0.97 → 1.0.99

package/dist/web.development.js

@@ -1107,6 +1107,25 @@ function hasPendingMergeForKey(key) {
   return Boolean(mergeQueue[key]);
 }
 
+/**
+ * Removes a key from storage if the value is null.
+ * Otherwise removes all nested null values in objects and returns the object
+ * @param {String} key
+ * @param {Mixed} value
+ * @returns {Mixed} `null` if the key got removed completely, otherwise the value without null values
+ */
+function removeNullValues(key, value) {
+  if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isNull(value)) {
+    remove(key);
+    return null;
+  }
+
+  // We can remove all null values in an object by merging it with itself
+  // utils.fastMerge recursively goes through the object and removes all null values
+  // Passing two identical objects as source and target to fastMerge will not change it, but only remove the null values
+  return _utils__WEBPACK_IMPORTED_MODULE_9__["default"].removeNestedNullValues(value);
+}
+
 /**
  * Write a value to our store with the given key
  *
@@ -1116,28 +1135,28 @@ function hasPendingMergeForKey(key) {
  * @returns {Promise}
  */
 function set(key, value) {
-  if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isNull(value)) {
-    return remove(key);
+  const valueWithoutNull = removeNullValues(key, value);
+
+  if (valueWithoutNull === null) {
+    return Promise.resolve();
   }
 
   if (hasPendingMergeForKey(key)) {
     _Logger__WEBPACK_IMPORTED_MODULE_6__.logAlert(`Onyx.set() called after Onyx.merge() for key: ${key}. It is recommended to use set() or merge() not both.`);
   }
 
-  const valueWithNullRemoved = _utils__WEBPACK_IMPORTED_MODULE_9__["default"].removeNullObjectValues(value);
-
-  const hasChanged = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].hasValueChanged(key, valueWithNullRemoved);
+  const hasChanged = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].hasValueChanged(key, valueWithoutNull);
 
   // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-  const updatePromise = broadcastUpdate(key, valueWithNullRemoved, hasChanged, 'set');
+  const updatePromise = broadcastUpdate(key, valueWithoutNull, hasChanged, 'set');
 
   // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
   if (!hasChanged) {
     return updatePromise;
   }
 
-  return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].setItem(key, valueWithNullRemoved).
-  catch((error) => evictStorageAndRetry(error, set, key, valueWithNullRemoved)).
+  return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].setItem(key, valueWithoutNull).
+  catch((error) => evictStorageAndRetry(error, set, key, valueWithoutNull)).
   then(() => updatePromise);
 }
 
@@ -1170,7 +1189,16 @@ function multiSet(data) {
     return scheduleSubscriberUpdate(key, val);
   });
 
-  return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].multiSet(keyValuePairs).
+  const keyValuePairsWithoutNull = underscore__WEBPACK_IMPORTED_MODULE_1___default().filter(underscore__WEBPACK_IMPORTED_MODULE_1___default().map(keyValuePairs, (_ref2) => {let [key, value] = _ref2;
+    const valueWithoutNull = removeNullValues(key, value);
+
+    if (valueWithoutNull === null) {
+      return;
+    }
+    return [key, valueWithoutNull];
+  }), Boolean);
+
+  return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].multiSet(keyValuePairsWithoutNull).
   catch((error) => evictStorageAndRetry(error, multiSet, data)).
   then(() => Promise.all(updatePromises));
 }
@@ -1181,9 +1209,10 @@ function multiSet(data) {
  * @private
  * @param {*} existingValue
  * @param {Array<*>} changes Array of changes that should be applied to the existing value
+ * @param {Boolean} shouldRemoveNullObjectValues
  * @returns {*}
  */
-function applyMerge(existingValue, changes) {
+function applyMerge(existingValue, changes, shouldRemoveNullObjectValues) {
   const lastChange = underscore__WEBPACK_IMPORTED_MODULE_1___default().last(changes);
 
   if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isArray(lastChange)) {
@@ -1192,7 +1221,7 @@ function applyMerge(existingValue, changes) {
 
   if (underscore__WEBPACK_IMPORTED_MODULE_1___default().some(changes, (underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject))) {
     // Object values are then merged one after the other
-    return underscore__WEBPACK_IMPORTED_MODULE_1___default().reduce(changes, (modifiedData, change) => _utils__WEBPACK_IMPORTED_MODULE_9__["default"].fastMerge(modifiedData, change),
+    return underscore__WEBPACK_IMPORTED_MODULE_1___default().reduce(changes, (modifiedData, change) => _utils__WEBPACK_IMPORTED_MODULE_9__["default"].fastMerge(modifiedData, change, shouldRemoveNullObjectValues),
     existingValue || {});
   }
 
@@ -1240,10 +1269,12 @@ function merge(key, changes) {
   then((existingValue) => {
     try {
       // We first only merge the changes, so we can provide these to the native implementation (SQLite uses only delta changes in "JSON_PATCH" to merge)
-      let batchedChanges = applyMerge(undefined, mergeQueue[key]);
+      // We don't want to remove null values from the "batchedChanges", because SQLite uses them to remove keys from storage natively.
+      let batchedChanges = applyMerge(undefined, mergeQueue[key], false);
 
       if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isNull(batchedChanges)) {
-        return remove(key);
+        remove(key);
+        return;
       }
 
       // The presence of a `null` in the merge queue instructs us to drop the existing value.
@@ -1255,15 +1286,16 @@ function merge(key, changes) {
       delete mergeQueuePromise[key];
 
       // After that we merge the batched changes with the existing value
-      const updatedValue = shouldOverwriteExistingValue ? batchedChanges : applyMerge(existingValue, [batchedChanges]);
-      const modifiedData = _utils__WEBPACK_IMPORTED_MODULE_9__["default"].removeNullObjectValues(updatedValue);
+      // We can remove null values from the "modifiedData", because "null" implicates that the user wants to remove a value from storage.
+      // The "modifiedData" will be directly "set" in storage instead of being merged
+      const modifiedData = shouldOverwriteExistingValue ? batchedChanges : applyMerge(existingValue, [batchedChanges], true);
 
       // On native platforms we use SQLite which utilises JSON_PATCH to merge changes.
-      // JSON_PATCH generally removes top-level nullish values from the stored object.
-      // When there is no existing value though, SQLite will just insert the changes as a new value and thus the top-level nullish values won't be removed.
-      // Therefore we need to remove nullish values from the `batchedChanges` which are sent to the SQLite, if no existing value is present.
+      // JSON_PATCH generally removes null values from the stored object.
+      // When there is no existing value though, SQLite will just insert the changes as a new value and thus the null values won't be removed.
+      // Therefore we need to remove null values from the `batchedChanges` which are sent to the SQLite, if no existing value is present.
       if (!existingValue) {
-        batchedChanges = _utils__WEBPACK_IMPORTED_MODULE_9__["default"].removeNullObjectValues(batchedChanges);
+        batchedChanges = applyMerge(undefined, [batchedChanges], true);
       }
 
       const hasChanged = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].hasValueChanged(key, modifiedData);
@@ -1432,6 +1464,13 @@ function mergeCollection(collectionKey, collection) {
   then((persistedKeys) => {
     // Split to keys that exist in storage and keys that don't
     const [existingKeys, newKeys] = underscore__WEBPACK_IMPORTED_MODULE_1___default().chain(collection).
+    pick((value, key) => {
+      if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isNull(value)) {
+        remove(key);
+        return false;
+      }
+      return true;
+    }).
     keys().
     partition((key) => persistedKeys.includes(key)).
     value();
@@ -1474,7 +1513,7 @@ function mergeCollection(collectionKey, collection) {
  */
 function update(data) {
   // First, validate the Onyx object is in the format we expect
-  underscore__WEBPACK_IMPORTED_MODULE_1___default().each(data, (_ref2) => {let { onyxMethod, key, value } = _ref2;
+  underscore__WEBPACK_IMPORTED_MODULE_1___default().each(data, (_ref3) => {let { onyxMethod, key, value } = _ref3;
     if (!underscore__WEBPACK_IMPORTED_MODULE_1___default().contains([METHOD.CLEAR, METHOD.SET, METHOD.MERGE, METHOD.MERGE_COLLECTION, METHOD.MULTI_SET], onyxMethod)) {
       throw new Error(`Invalid onyxMethod ${onyxMethod} in Onyx update.`);
     }
@@ -1491,7 +1530,7 @@ function update(data) {
   const promises = [];
   let clearPromise = Promise.resolve();
 
-  underscore__WEBPACK_IMPORTED_MODULE_1___default().each(data, (_ref3) => {let { onyxMethod, key, value } = _ref3;
+  underscore__WEBPACK_IMPORTED_MODULE_1___default().each(data, (_ref4) => {let { onyxMethod, key, value } = _ref4;
     switch (onyxMethod) {
       case METHOD.SET:
         promises.push(() => set(key, value));
@@ -2279,6 +2318,7 @@ const provider = {
   /**
    * Multiple merging of existing and new values in a batch
    * @param {Array<[key, value]>} pairs
+   * This function also removes all nested null values from an object.
    * @return {Promise<void>}
    */
   multiMerge: (pairs) => getCustomStore()('readwrite', (store) => {
@@ -2290,8 +2330,8 @@ const provider = {
     return getValues.then((values) => {
       const upsertMany = underscore__WEBPACK_IMPORTED_MODULE_1___default().map(pairs, (_ref2, index) => {let [key, value] = _ref2;
         const prev = values[index];
-        const newValue = underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject(prev) ? _utils__WEBPACK_IMPORTED_MODULE_2__["default"].fastMerge(prev, value) : value;
-        return (0,idb_keyval__WEBPACK_IMPORTED_MODULE_0__.promisifyRequest)(store.put(_utils__WEBPACK_IMPORTED_MODULE_2__["default"].removeNullObjectValues(newValue), key));
+        const newValue = _utils__WEBPACK_IMPORTED_MODULE_2__["default"].fastMarge(prev, value);
+        return (0,idb_keyval__WEBPACK_IMPORTED_MODULE_0__.promisifyRequest)(store.put(newValue, key));
       });
       return Promise.all(upsertMany);
     });
@@ -2396,8 +2436,8 @@ function areObjectsEmpty(a, b) {
   return (
     typeof a === 'object' &&
     typeof b === 'object' &&
-    underscore__WEBPACK_IMPORTED_MODULE_0__.isEmpty(a) &&
-    underscore__WEBPACK_IMPORTED_MODULE_0__.isEmpty(b));
+    underscore__WEBPACK_IMPORTED_MODULE_0___default().isEmpty(a) &&
+    underscore__WEBPACK_IMPORTED_MODULE_0___default().isEmpty(b));
 
 }
 
@@ -2411,15 +2451,18 @@ function isMergeableObject(val) {
   const nonNullObject = val != null ? typeof val === 'object' : false;
   return nonNullObject &&
   Object.prototype.toString.call(val) !== '[object RegExp]' &&
-  Object.prototype.toString.call(val) !== '[object Date]';
+  Object.prototype.toString.call(val) !== '[object Date]'
+  // eslint-disable-next-line rulesdir/prefer-underscore-method
+  && !Array.isArray(val);
 }
 
 /**
 * @param {Object} target
 * @param {Object} source
+* @param {Boolean} shouldRemoveNullObjectValues
 * @returns {Object}
 */
-function mergeObject(target, source) {
+function mergeObject(target, source) {let shouldRemoveNullObjectValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
   const destination = {};
   if (isMergeableObject(target)) {
     // lodash adds a small overhead so we don't use it here
@@ -2427,7 +2470,14 @@ function mergeObject(target, source) {
     const targetKeys = Object.keys(target);
     for (let i = 0; i < targetKeys.length; ++i) {
       const key = targetKeys[i];
-      destination[key] = target[key];
+
+      // If shouldRemoveNullObjectValues is true, we want to remove null values from the merged object
+      const isSourceOrTargetNull = target[key] === null || source[key] === null;
+      const shouldOmitSourceKey = shouldRemoveNullObjectValues && isSourceOrTargetNull;
+
+      if (!shouldOmitSourceKey) {
+        destination[key] = target[key];
+      }
     }
   }
 
@@ -2436,15 +2486,24 @@ function mergeObject(target, source) {
   const sourceKeys = Object.keys(source);
   for (let i = 0; i < sourceKeys.length; ++i) {
     const key = sourceKeys[i];
-    if (source[key] === undefined) {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    if (!isMergeableObject(source[key]) || !target[key]) {
-      destination[key] = source[key];
-    } else {
-      // eslint-disable-next-line no-use-before-define
-      destination[key] = fastMerge(target[key], source[key]);
+
+    // If shouldRemoveNullObjectValues is true, we want to remove null values from the merged object
+    const shouldOmitSourceKey = shouldRemoveNullObjectValues && source[key] === null;
+
+    // If we pass undefined as the updated value for a key, we want to generally ignore it
+    const isSourceKeyUndefined = source[key] === undefined;
+
+    if (!isSourceKeyUndefined && !shouldOmitSourceKey) {
+      const isSourceKeyMergable = isMergeableObject(source[key]);
+
+      if (isSourceKeyMergable && target[key]) {
+        if (!shouldRemoveNullObjectValues || isSourceKeyMergable) {
+          // eslint-disable-next-line no-use-before-define
+          destination[key] = fastMerge(target[key], source[key], shouldRemoveNullObjectValues);
+        }
+      } else if (!shouldRemoveNullObjectValues || source[key] !== null) {
+        destination[key] = source[key];
+      }
     }
   }
 
@@ -2452,41 +2511,36 @@ function mergeObject(target, source) {
 }
 
 /**
+ * Merges two objects and removes null values if "shouldRemoveNullObjectValues" is set to true
+ *
+ * We generally want to remove null values from objects written to disk and cache, because it decreases the amount of data stored in memory and on disk.
+ * On native, when merging an existing value with new changes, SQLite will use JSON_PATCH, which removes top-level nullish values.
+ * To be consistent with the behaviour for merge, we'll also want to remove null values for "set" operations.
+ *
 * @param {Object|Array} target
 * @param {Object|Array} source
+* @param {Boolean} shouldRemoveNullObjectValues
 * @returns {Object|Array}
 */
-function fastMerge(target, source) {
+function fastMerge(target, source) {let shouldRemoveNullObjectValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
   // We have to ignore arrays and nullish values here,
   // otherwise "mergeObject" will throw an error,
   // because it expects an object as "source"
-  if (underscore__WEBPACK_IMPORTED_MODULE_0__.isArray(source) || underscore__WEBPACK_IMPORTED_MODULE_0__.isNull(source) || underscore__WEBPACK_IMPORTED_MODULE_0__.isUndefined(source)) {
+  if (underscore__WEBPACK_IMPORTED_MODULE_0___default().isArray(source) || source === null || source === undefined) {
     return source;
   }
-  return mergeObject(target, source);
+  return mergeObject(target, source, shouldRemoveNullObjectValues);
 }
 
-/**
- * We generally want to remove top-level nullish values from objects written to disk and cache, because it decreases the amount of data stored in memory and on disk.
- * On native, when merging an existing value with new changes, SQLite will use  JSON_PATCH, which removes top-level nullish values.
- * To be consistent with the behaviour for merge, we'll also want to remove nullish values for "set" operations.
- * On web, IndexedDB will keep the top-level keys along with a null value and this uses up storage and memory.
- * This method will ensure that keys for null values are removed before an object is written to disk and cache so that all platforms are storing the data in the same efficient way.
- * @private
- * @param {*} value
- * @returns {*}
- */
-function removeNullObjectValues(value) {
-  if (underscore__WEBPACK_IMPORTED_MODULE_0__.isArray(value) || !underscore__WEBPACK_IMPORTED_MODULE_0__.isObject(value)) {
-    return value;
+function removeNestedNullValues(value) {
+  if (typeof value === 'object' && !underscore__WEBPACK_IMPORTED_MODULE_0___default().isArray(value)) {
+    return fastMerge(value, value);
   }
 
-  const objectWithoutNullObjectValues = underscore__WEBPACK_IMPORTED_MODULE_0__.omit(value, (objectValue) => underscore__WEBPACK_IMPORTED_MODULE_0__.isNull(objectValue));
-
-  return objectWithoutNullObjectValues;
+  return value;
 }
 
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({ removeNullObjectValues, areObjectsEmpty, fastMerge });
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({ areObjectsEmpty, fastMerge, removeNestedNullValues });
 
 /***/ }),