react-native-onyx 1.0.92 → 1.0.94

package/lib/Onyx.js

@@ -1103,14 +1103,12 @@ function multiSet(data) {
 function applyMerge(existingValue, changes) {
     const lastChange = _.last(changes);
 
-    if (_.isArray(existingValue) || _.isArray(lastChange)) {
+    if (_.isArray(lastChange)) {
         return lastChange;
     }
 
-    if (_.isObject(existingValue) || _.every(changes, _.isObject)) {
-        // Object values are merged one after the other
-        // lodash adds a small overhead so we don't use it here
-        // eslint-disable-next-line prefer-object-spread, rulesdir/prefer-underscore-method
+    if (_.some(changes, _.isObject)) {
+        // Object values are then merged one after the other
         return _.reduce(changes, (modifiedData, change) => utils.fastMerge(modifiedData, change),
             existingValue || {});
     }
@@ -1141,6 +1139,12 @@ function applyMerge(existingValue, changes) {
  * @returns {Promise}
  */
 function merge(key, changes) {
+    // Top-level undefined values are ignored
+    // Therefore we need to prevent adding them to the merge queue
+    if (_.isUndefined(changes)) {
+        return mergeQueue[key] ? mergeQueuePromise[key] : Promise.resolve();
+    }
+
     // Merge attempts are batched together. The delta should be applied after a single call to get() to prevent a race condition.
     // Using the initial value from storage in subsequent merge attempts will lead to an incorrect final merged value.
     if (mergeQueue[key]) {
@@ -1155,12 +1159,21 @@ function merge(key, changes) {
                 // 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]);
 
+                if (_.isNull(batchedChanges)) {
+                    return remove(key);
+                }
+
+                // The presence of a `null` in the merge queue instructs us to drop the existing value.
+                // In this case, we can't simply merge the batched changes with the existing value, because then the null in the merge queue would have no effect
+                const shouldOverwriteExistingValue = _.includes(mergeQueue[key], null);
+
                 // Clean up the write queue, so we don't apply these changes again
                 delete mergeQueue[key];
                 delete mergeQueuePromise[key];
 
                 // After that we merge the batched changes with the existing value
-                const modifiedData = utils.removeNullObjectValues(applyMerge(existingValue, [batchedChanges]));
+                const updatedValue = shouldOverwriteExistingValue ? batchedChanges : applyMerge(existingValue, [batchedChanges]);
+                const modifiedData = utils.removeNullObjectValues(updatedValue);
 
                 // 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.

package/lib/OnyxCache.js

@@ -34,9 +34,11 @@ class OnyxCache {
         /**
          * @private
          * Captured pending tasks for already running storage methods
-         * @type {Record<string, Promise>}
+         * Using a map yields better performance on operations such a delete
+         * https://www.zhenghao.io/posts/object-vs-map
+         * @type {Map<string, Promise>}
          */
-        this.pendingPromises = {};
+        this.pendingPromises = new Map();
 
         // bind all public methods to prevent problems with `this`
         _.bindAll(
@@ -133,7 +135,7 @@ class OnyxCache {
      * @returns {*}
      */
     hasPendingTask(taskName) {
-        return isDefined(this.pendingPromises[taskName]);
+        return isDefined(this.pendingPromises.get(taskName));
     }
 
     /**
@@ -145,7 +147,7 @@ class OnyxCache {
      * @returns {Promise<T>}
      */
     getTaskPromise(taskName) {
-        return this.pendingPromises[taskName];
+        return this.pendingPromises.get(taskName);
     }
 
     /**
@@ -157,11 +159,13 @@ class OnyxCache {
      * @returns {Promise<T>}
      */
     captureTask(taskName, promise) {
-        this.pendingPromises[taskName] = promise.finally(() => {
-            delete this.pendingPromises[taskName];
+        const returnPromise = promise.finally(() => {
+            this.pendingPromises.delete(taskName);
         });
 
-        return this.pendingPromises[taskName];
+        this.pendingPromises.set(taskName, returnPromise);
+
+        return returnPromise;
     }
 
     /**

package/lib/utils.js

@@ -65,8 +65,9 @@ function mergeObject(target, source) {
 * @returns {Object|Array}
 */
 function fastMerge(target, source) {
-    // lodash adds a small overhead so we don't use it here
-    // eslint-disable-next-line rulesdir/prefer-underscore-method
+    // We have to ignore arrays and nullish values here,
+    // otherwise "mergeObject" will throw an error,
+    // because it expects an object as "source"
     if (_.isArray(source) || _.isNull(source) || _.isUndefined(source)) {
         return source;
     }

package/package.json

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

package/lib/fastMerge.js

@@ -1,65 +0,0 @@
-import _ from 'underscore';
-
-// Mostly copied from https://medium.com/@lubaka.a/how-to-remove-lodash-performance-improvement-b306669ad0e1
-
-/**
- * @param {mixed} val
- * @returns {boolean}
-*/
-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]');
-}
-
-/**
- * @param {Object} target
- * @param {Object} source
- * @returns {Object}
-*/
-function mergeObject(target, source) {
-    const destination = {};
-    if (isMergeableObject(target)) {
-        // lodash adds a small overhead so we don't use it here
-        // eslint-disable-next-line rulesdir/prefer-underscore-method
-        const targetKeys = Object.keys(target);
-        for (let i = 0; i < targetKeys.length; ++i) {
-            const key = targetKeys[i];
-            destination[key] = target[key];
-        }
-    }
-
-    // lodash adds a small overhead so we don't use it here
-    // eslint-disable-next-line rulesdir/prefer-underscore-method
-    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]);
-        }
-    }
-
-    return destination;
-}
-
-/**
- * @param {Object|Array} target
- * @param {Object|Array} source
- * @returns {Object|Array}
-*/
-function fastMerge(target, source) {
-    if (_.isArray(source) || _.isNull(source) || _.isUndefined(source)) {
-        return source;
-    }
-    return mergeObject(target, source);
-}
-
-export default fastMerge;