react-native-onyx 1.0.121 → 1.0.123

package/README.md

@@ -410,5 +410,6 @@ To continuously work on Onyx we have to set up a task that copies content to par
 
 There are Playwright e2e tests implemented for the web. To run them:
 
+- in the tests/e2e/app directory, run `npm install`
 - `npm run e2e` to run the e2e tests
 - or `npm run e2e-ui` to run the e2e tests in UI mode 

package/dist/web.development.js

@@ -1219,17 +1219,18 @@ function evictStorageAndRetry(error, onyxMethod) {for (var _len = arguments.leng
  *
  * @param {String} key
  * @param {*} value
- * @param {Boolean} hasChanged
  * @param {String} method
+ * @param {Boolean} hasChanged
+ * @param {Boolean} wasRemoved
  * @returns {Promise}
  */
-function broadcastUpdate(key, value, hasChanged, method) {
+function broadcastUpdate(key, value, method, hasChanged) {let wasRemoved = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
   // Logging properties only since values could be sensitive things we don't want to log
   _Logger__WEBPACK_IMPORTED_MODULE_6__.logInfo(`${method}() called for key: ${key}${underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject(value) ? ` properties: ${underscore__WEBPACK_IMPORTED_MODULE_1___default().keys(value).join(',')}` : ''}`);
 
   // Update subscribers if the cached value has changed, or when the subscriber specifically requires
   // all updates regardless of value changes (indicated by initWithStoredValues set to false).
-  if (hasChanged) {
+  if (hasChanged && !wasRemoved) {
     _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].set(key, value);
   } else {
     _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].addToAccessedKeys(key);
@@ -1251,18 +1252,18 @@ function hasPendingMergeForKey(key) {
  * 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
+ * @returns {Mixed} The value without null values and a boolean "wasRemoved", which indicates if the key got removed completely
  */
 function removeNullValues(key, value) {
   if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isNull(value)) {
     remove(key);
-    return null;
+    return { value, wasRemoved: true };
   }
 
   // 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);
+  return { value: _utils__WEBPACK_IMPORTED_MODULE_9__["default"].removeNestedNullValues(value), wasRemoved: false };
 }
 
 /**
@@ -1283,41 +1284,48 @@ function set(key, value) {
     return Promise.resolve();
   }
 
-  const valueWithoutNull = removeNullValues(key, value);
-
-  if (valueWithoutNull === null) {
-    return Promise.resolve();
-  }
+  // If the value is null, we remove the key from storage
+  const { value: valueAfterRemoving, wasRemoved } = removeNullValues(key, value);
 
   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.`);
+    delete mergeQueue[key];
   }
 
-  const hasChanged = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].hasValueChanged(key, valueWithoutNull);
+  const hasChanged = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].hasValueChanged(key, valueAfterRemoving);
 
   // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-  const updatePromise = broadcastUpdate(key, valueWithoutNull, hasChanged, 'set');
+  const updatePromise = broadcastUpdate(key, valueAfterRemoving, 'set', hasChanged, wasRemoved);
 
-  // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
-  if (!hasChanged) {
+  // If the value has not changed or the key got removed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
+  if (!hasChanged || wasRemoved) {
     return updatePromise;
   }
 
-  return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].setItem(key, valueWithoutNull).
-  catch((error) => evictStorageAndRetry(error, set, key, valueWithoutNull)).
+  return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].setItem(key, valueAfterRemoving).
+  catch((error) => evictStorageAndRetry(error, set, key, valueAfterRemoving)).
   then(() => updatePromise);
 }
 
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
  * This method transforms an object like {'@MyApp_user': myUserValue, '@MyApp_key': myKeyValue}
- * to an array of key-value pairs in the above format
+ * to an array of key-value pairs in the above format and removes key-value pairs that are being set to null
  * @private
  * @param {Record} data
  * @return {Array} an array of key - value pairs <[key, value]>
  */
 function prepareKeyValuePairsForStorage(data) {
-  return underscore__WEBPACK_IMPORTED_MODULE_1___default().map(data, (value, key) => [key, value]);
+  const keyValuePairs = [];
+
+  underscore__WEBPACK_IMPORTED_MODULE_1___default().forEach(data, (value, key) => {
+    const { value: valueAfterRemoving, wasRemoved } = removeNullValues(key, value);
+
+    if (wasRemoved) return;
+
+    keyValuePairs.push([key, valueAfterRemoving]);
+  });
+
+  return keyValuePairs;
 }
 
 /**
@@ -1340,25 +1348,13 @@ function multiSet(data) {
 
   const keyValuePairs = prepareKeyValuePairsForStorage(data);
 
-  const updatePromises = underscore__WEBPACK_IMPORTED_MODULE_1___default().map(data, (val, key) => {
+  const updatePromises = underscore__WEBPACK_IMPORTED_MODULE_1___default().map(keyValuePairs, (_ref2) => {let [key, value] = _ref2;
     // Update cache and optimistically inform subscribers on the next tick
-    _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].set(key, val);
-    return scheduleSubscriberUpdate(key, val);
+    _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].set(key, value);
+    return scheduleSubscriberUpdate(key, value);
   });
 
-  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).
+  return _storage__WEBPACK_IMPORTED_MODULE_5__["default"].multiSet(keyValuePairs).
   catch((error) => evictStorageAndRetry(error, multiSet, data)).
   then(() => Promise.all(updatePromises));
 }
@@ -1434,6 +1430,9 @@ function merge(key, changes) {
   mergeQueue[key] = [changes];
 
   mergeQueuePromise[key] = get(key).then((existingValue) => {
+    // Calls to Onyx.set after a merge will terminate the current merge process and clear the merge queue
+    if (mergeQueue[key] == null) return;
+
     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)
       // We don't want to remove null values from the "batchedChanges", because SQLite uses them to remove keys from storage natively.
@@ -1448,10 +1447,7 @@ function merge(key, changes) {
       delete mergeQueuePromise[key];
 
       // If the batched changes equal null, we want to remove the key from storage, to reduce storage size
-      if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isNull(batchedChanges)) {
-        remove(key);
-        return;
-      }
+      const { wasRemoved } = removeNullValues(key, batchedChanges);
 
       // After that we merge the batched changes with the existing value
       // We can remove null values from the "modifiedData", because "null" implicates that the user wants to remove a value from storage.
@@ -1469,10 +1465,10 @@ function merge(key, changes) {
       const hasChanged = _OnyxCache__WEBPACK_IMPORTED_MODULE_4__["default"].hasValueChanged(key, modifiedData);
 
       // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-      const updatePromise = broadcastUpdate(key, modifiedData, hasChanged, 'merge');
+      const updatePromise = broadcastUpdate(key, modifiedData, 'merge', hasChanged, wasRemoved);
 
       // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
-      if (!hasChanged || isClearing) {
+      if (!hasChanged || isClearing || wasRemoved) {
         return updatePromise;
       }