react-native-onyx 2.0.32 → 2.0.34

package/dist/DevTools.js

@@ -11,8 +11,8 @@ class DevTools {
         try {
             // We don't want to augment the window type in a library code, so we use type assertion instead
             // eslint-disable-next-line no-underscore-dangle, @typescript-eslint/no-explicit-any
-            const reduxDevtools = window.__REDUX_DEVTOOLS_EXTENSION__;
-            if ((options && options.remote) || typeof window === 'undefined' || !reduxDevtools) {
+            const reduxDevtools = typeof window === 'undefined' ? undefined : window.__REDUX_DEVTOOLS_EXTENSION__;
+            if ((options === null || options === void 0 ? void 0 : options.remote) || !reduxDevtools) {
                 return;
             }
             return reduxDevtools.connect(options);

package/dist/Onyx.js

@@ -221,7 +221,7 @@ function set(key, value) {
  * @param data object keyed by ONYXKEYS and the values to set
  */
 function multiSet(data) {
-    const keyValuePairs = OnyxUtils_1.default.prepareKeyValuePairsForStorage(data);
+    const keyValuePairs = OnyxUtils_1.default.prepareKeyValuePairsForStorage(data, true);
     const updatePromises = keyValuePairs.map(([key, value]) => {
         const prevValue = OnyxCache_1.default.getValue(key, false);
         // Update cache and optimistically inform subscribers on the next tick
@@ -256,7 +256,7 @@ function merge(key, changes) {
     const mergeQueue = OnyxUtils_1.default.getMergeQueue();
     const mergeQueuePromise = OnyxUtils_1.default.getMergeQueuePromise();
     // Top-level undefined values are ignored
-    // Therefore we need to prevent adding them to the merge queue
+    // Therefore, we need to prevent adding them to the merge queue
     if (changes === undefined) {
         return mergeQueue[key] ? mergeQueuePromise[key] : Promise.resolve();
     }
@@ -369,8 +369,13 @@ function mergeCollection(collectionKey, collection) {
             obj[key] = mergedCollection[key];
             return obj;
         }, {});
-        const keyValuePairsForExistingCollection = OnyxUtils_1.default.prepareKeyValuePairsForStorage(existingKeyCollection);
-        const keyValuePairsForNewCollection = OnyxUtils_1.default.prepareKeyValuePairsForStorage(newCollection);
+        // When (multi-)merging the values with the existing values in storage,
+        // we don't want to remove nested null values from the data that we pass to the storage layer,
+        // because the storage layer uses them to remove nested keys from storage natively.
+        const keyValuePairsForExistingCollection = OnyxUtils_1.default.prepareKeyValuePairsForStorage(existingKeyCollection, false);
+        // We can safely remove nested null values when using (multi-)set,
+        // because we will simply overwrite the existing values in storage.
+        const keyValuePairsForNewCollection = OnyxUtils_1.default.prepareKeyValuePairsForStorage(newCollection, true);
         const promises = [];
         // New keys will be added via multiSet while existing keys will be updated using multiMerge
         // This is because setting a key that doesn't exist yet with multiMerge will throw errors

package/dist/OnyxUtils.d.ts

@@ -165,11 +165,12 @@ type RemoveNullValuesOutput = {
 };
 /**
  * Removes a key from storage if the value is null.
- * Otherwise removes all nested null values in objects and returns the object
+ * Otherwise removes all nested null values in objects,
+ * if shouldRemoveNestedNulls is true and returns the object.
  *
  * @returns The value without null values and a boolean "wasRemoved", which indicates if the key got removed completely
  */
-declare function removeNullValues(key: OnyxKey, value: OnyxValue<OnyxKey>): RemoveNullValuesOutput;
+declare function removeNullValues(key: OnyxKey, value: OnyxValue<OnyxKey>, shouldRemoveNestedNulls?: boolean): RemoveNullValuesOutput;
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
  * This method transforms an object like {'@MyApp_user': myUserValue, '@MyApp_key': myKeyValue}
@@ -177,13 +178,13 @@ declare function removeNullValues(key: OnyxKey, value: OnyxValue<OnyxKey>): Remo
 
 * @return an array of key - value pairs <[key, value]>
  */
-declare function prepareKeyValuePairsForStorage(data: Record<OnyxKey, OnyxValue<OnyxKey>>): Array<[OnyxKey, OnyxValue<OnyxKey>]>;
+declare function prepareKeyValuePairsForStorage(data: Record<OnyxKey, OnyxValue<OnyxKey>>, shouldRemoveNestedNulls: boolean): Array<[OnyxKey, OnyxValue<OnyxKey>]>;
 /**
  * Merges an array of changes with an existing value
  *
  * @param changes Array of changes that should be applied to the existing value
  */
-declare function applyMerge(existingValue: OnyxValue<OnyxKey>, changes: Array<OnyxValue<OnyxKey>>, shouldRemoveNullObjectValues: boolean): OnyxValue<OnyxKey>;
+declare function applyMerge(existingValue: OnyxValue<OnyxKey>, changes: Array<OnyxValue<OnyxKey>>, shouldRemoveNestedNulls: boolean): OnyxValue<OnyxKey>;
 /**
  * Merge user provided default key value pairs.
  */

package/dist/OnyxUtils.js

@@ -363,6 +363,7 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
         // We prepare the "cached collection" which is the entire collection + the new partial data that
         // was merged in via mergeCollection().
         const cachedCollection = getCachedCollection(collectionKey);
+        const cachedCollectionWithoutNestedNulls = utils_1.default.removeNestedNullValues(cachedCollection);
         // Regular Onyx.connect() subscriber found.
         if (typeof subscriber.callback === 'function') {
             if (!notifyRegularSubscibers) {
@@ -372,7 +373,7 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
             // send the whole cached collection.
             if (isSubscribedToCollectionKey) {
                 if (subscriber.waitForCollectionCallback) {
-                    subscriber.callback(cachedCollection);
+                    subscriber.callback(cachedCollectionWithoutNestedNulls);
                     continue;
                 }
                 // If they are not using waitForCollectionCallback then we notify the subscriber with
@@ -380,7 +381,7 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
                 const dataKeys = Object.keys(partialCollection !== null && partialCollection !== void 0 ? partialCollection : {});
                 for (let j = 0; j < dataKeys.length; j++) {
                     const dataKey = dataKeys[j];
-                    subscriber.callback(cachedCollection[dataKey], dataKey);
+                    subscriber.callback(cachedCollectionWithoutNestedNulls[dataKey], dataKey);
                 }
                 continue;
             }
@@ -388,7 +389,7 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
             // notify them with the cached data for that key only.
             if (isSubscribedToCollectionMemberKey) {
                 const subscriberCallback = subscriber.callback;
-                subscriberCallback(cachedCollection[subscriber.key], subscriber.key);
+                subscriberCallback(cachedCollectionWithoutNestedNulls[subscriber.key], subscriber.key);
                 continue;
             }
             continue;
@@ -507,12 +508,14 @@ function keyChanged(key, data, prevData, canUpdateSubscriber = () => true, notif
             }
             if (isCollectionKey(subscriber.key) && subscriber.waitForCollectionCallback) {
                 const cachedCollection = getCachedCollection(subscriber.key);
-                cachedCollection[key] = data;
-                subscriber.callback(cachedCollection);
+                const cachedCollectionWithoutNestedNulls = utils_1.default.removeNestedNullValues(cachedCollection);
+                cachedCollectionWithoutNestedNulls[key] = data;
+                subscriber.callback(cachedCollectionWithoutNestedNulls);
                 continue;
             }
+            const dataWithoutNestedNulls = utils_1.default.removeNestedNullValues(data);
             const subscriberCallback = subscriber.callback;
-            subscriberCallback(data, key);
+            subscriberCallback(dataWithoutNestedNulls, key);
             continue;
         }
         // Subscriber connected via withOnyx() HOC
@@ -620,7 +623,8 @@ function sendDataToConnection(mapping, val, matchedKey, isBatched) {
         }
         return;
     }
-    (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, val, matchedKey);
+    const valuesWithoutNestedNulls = utils_1.default.removeNestedNullValues(val);
+    (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, valuesWithoutNestedNulls, matchedKey);
 }
 /**
  * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
@@ -794,11 +798,12 @@ function hasPendingMergeForKey(key) {
 }
 /**
  * Removes a key from storage if the value is null.
- * Otherwise removes all nested null values in objects and returns the object
+ * Otherwise removes all nested null values in objects,
+ * if shouldRemoveNestedNulls is true and returns the object.
  *
  * @returns The value without null values and a boolean "wasRemoved", which indicates if the key got removed completely
  */
-function removeNullValues(key, value) {
+function removeNullValues(key, value, shouldRemoveNestedNulls = true) {
     if (value === null) {
         remove(key);
         return { value, wasRemoved: true };
@@ -806,7 +811,7 @@ function removeNullValues(key, value) {
     // 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 { value: utils_1.default.removeNestedNullValues(value), wasRemoved: false };
+    return { value: shouldRemoveNestedNulls ? utils_1.default.removeNestedNullValues(value) : value, wasRemoved: false };
 }
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
@@ -815,30 +820,28 @@ function removeNullValues(key, value) {
 
 * @return an array of key - value pairs <[key, value]>
  */
-function prepareKeyValuePairsForStorage(data) {
-    const keyValuePairs = [];
-    Object.entries(data).forEach(([key, value]) => {
-        const { value: valueAfterRemoving, wasRemoved } = removeNullValues(key, value);
-        if (wasRemoved) {
-            return;
+function prepareKeyValuePairsForStorage(data, shouldRemoveNestedNulls) {
+    return Object.entries(data).reduce((pairs, [key, value]) => {
+        const { value: valueAfterRemoving, wasRemoved } = removeNullValues(key, value, shouldRemoveNestedNulls);
+        if (!wasRemoved) {
+            pairs.push([key, valueAfterRemoving]);
         }
-        keyValuePairs.push([key, valueAfterRemoving]);
-    });
-    return keyValuePairs;
+        return pairs;
+    }, []);
 }
 /**
  * Merges an array of changes with an existing value
  *
  * @param changes Array of changes that should be applied to the existing value
  */
-function applyMerge(existingValue, changes, shouldRemoveNullObjectValues) {
+function applyMerge(existingValue, changes, shouldRemoveNestedNulls) {
     const lastChange = changes === null || changes === void 0 ? void 0 : changes.at(-1);
     if (Array.isArray(lastChange)) {
         return lastChange;
     }
     if (changes.some((change) => change && typeof change === 'object')) {
         // Object values are then merged one after the other
-        return changes.reduce((modifiedData, change) => utils_1.default.fastMerge(modifiedData, change, shouldRemoveNullObjectValues), existingValue || {});
+        return changes.reduce((modifiedData, change) => utils_1.default.fastMerge(modifiedData, change, shouldRemoveNestedNulls), existingValue || {});
     }
     // If we have anything else we can't merge it so we'll
     // simply return the last value that was queued

package/dist/storage/providers/MemoryOnlyProvider.js

@@ -55,11 +55,7 @@ const provider = {
      */
     multiSet(pairs) {
         const setPromises = underscore_1.default.map(pairs, ([key, value]) => this.setItem(key, value));
-        return new Promise((resolve) => {
-            Promise.all(setPromises).then(() => {
-                resolve(undefined);
-            });
-        });
+        return Promise.all(setPromises).then(() => undefined);
     },
     /**
      * Merging an existing value with a new one

package/dist/utils.d.ts

@@ -4,15 +4,15 @@ type EmptyValue = EmptyObject | null | undefined;
 /** Checks whether the given object is an object and not null/undefined. */
 declare function isEmptyObject<T>(obj: T | EmptyValue): obj is EmptyValue;
 /**
- * Merges two objects and removes null values if "shouldRemoveNullObjectValues" is set to true
+ * Merges two objects and removes null values if "shouldRemoveNestedNulls" 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.
  */
-declare function fastMerge<TObject extends Record<string, unknown>>(target: TObject | null, source: TObject | null, shouldRemoveNullObjectValues?: boolean): TObject | null;
+declare function fastMerge<TObject extends Record<string, unknown>>(target: TObject | null, source: TObject | null, shouldRemoveNestedNulls?: boolean): TObject | null;
 /** Deep removes the nested null values from the given value. */
-declare function removeNestedNullValues(value: unknown[] | Record<string, unknown>): Record<string, unknown> | unknown[] | null;
+declare function removeNestedNullValues<TObject extends Record<string, unknown>>(value: unknown | unknown[] | TObject): Record<string, unknown> | unknown[] | null;
 /** Formats the action name by uppercasing and adding the key if provided. */
 declare function formatActionName(method: string, key?: OnyxKey): string;
 declare const _default: {

package/dist/utils.js

@@ -17,14 +17,14 @@ function isMergeableObject(value) {
  * Merges the source object into the target object.
  * @param target - The target object.
  * @param source - The source object.
- * @param shouldRemoveNullObjectValues - If true, null object values will be removed.
+ * @param shouldRemoveNestedNulls - If true, null object values will be removed.
  * @returns - The merged object.
  */
-function mergeObject(target, source, shouldRemoveNullObjectValues = true) {
+function mergeObject(target, source, shouldRemoveNestedNulls = true) {
     const destination = {};
     // First we want to copy over all keys from the target into the destination object,
     // in case "target" is a mergable object.
-    // If "shouldRemoveNullObjectValues" is true, we want to remove null values from the merged object
+    // If "shouldRemoveNestedNulls" is true, we want to remove null values from the merged object
     // and therefore we need to omit keys where either the source or target value is null.
     if (isMergeableObject(target)) {
         const targetKeys = Object.keys(target);
@@ -32,10 +32,10 @@ function mergeObject(target, source, shouldRemoveNullObjectValues = true) {
             const key = targetKeys[i];
             const sourceValue = source === null || source === void 0 ? void 0 : source[key];
             const targetValue = target === null || target === void 0 ? void 0 : target[key];
-            // If "shouldRemoveNullObjectValues" is true, we want to remove null values from the merged object.
+            // If "shouldRemoveNestedNulls" is true, we want to remove null values from the merged object.
             // Therefore, if either target or source value is null, we want to prevent the key from being set.
             const isSourceOrTargetNull = targetValue === null || sourceValue === null;
-            const shouldOmitTargetKey = shouldRemoveNullObjectValues && isSourceOrTargetNull;
+            const shouldOmitTargetKey = shouldRemoveNestedNulls && isSourceOrTargetNull;
             if (!shouldOmitTargetKey) {
                 destination[key] = targetValue;
             }
@@ -48,13 +48,13 @@ function mergeObject(target, source, shouldRemoveNullObjectValues = true) {
         const sourceValue = source === null || source === void 0 ? void 0 : source[key];
         const targetValue = target === null || target === void 0 ? void 0 : target[key];
         // If undefined is passed as the source value for a key, we want to generally ignore it.
-        // If "shouldRemoveNullObjectValues" is set to true and the source value is null,
+        // If "shouldRemoveNestedNulls" is set to true and the source value is null,
         // we don't want to set/merge the source value into the merged object.
-        const shouldIgnoreNullSourceValue = shouldRemoveNullObjectValues && sourceValue === null;
+        const shouldIgnoreNullSourceValue = shouldRemoveNestedNulls && sourceValue === null;
         const shouldOmitSourceKey = sourceValue === undefined || shouldIgnoreNullSourceValue;
         if (!shouldOmitSourceKey) {
             // If the source value is a mergable object, we want to merge it into the target value.
-            // If "shouldRemoveNullObjectValues" is true, "fastMerge" will recursively
+            // If "shouldRemoveNestedNulls" is true, "fastMerge" will recursively
             // remove nested null values from the merged object.
             // If source value is any other value we need to set the source value it directly.
             if (isMergeableObject(sourceValue)) {
@@ -62,7 +62,7 @@ function mergeObject(target, source, shouldRemoveNullObjectValues = true) {
                 // so that we can still use "fastMerge" to merge the source value,
                 // to ensure that nested null values are removed from the merged object.
                 const targetValueWithFallback = (targetValue !== null && targetValue !== void 0 ? targetValue : {});
-                destination[key] = fastMerge(targetValueWithFallback, sourceValue, shouldRemoveNullObjectValues);
+                destination[key] = fastMerge(targetValueWithFallback, sourceValue, shouldRemoveNestedNulls);
             }
             else {
                 destination[key] = sourceValue;
@@ -72,20 +72,20 @@ function mergeObject(target, source, shouldRemoveNullObjectValues = true) {
     return destination;
 }
 /**
- * Merges two objects and removes null values if "shouldRemoveNullObjectValues" is set to true
+ * Merges two objects and removes null values if "shouldRemoveNestedNulls" 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.
  */
-function fastMerge(target, source, shouldRemoveNullObjectValues = true) {
+function fastMerge(target, source, shouldRemoveNestedNulls = true) {
     // We have to ignore arrays and nullish values here,
     // otherwise "mergeObject" will throw an error,
     // because it expects an object as "source"
     if (Array.isArray(source) || source === null || source === undefined) {
         return source;
     }
-    return mergeObject(target, source, shouldRemoveNullObjectValues);
+    return mergeObject(target, source, shouldRemoveNestedNulls);
 }
 /** Deep removes the nested null values from the given value. */
 function removeNestedNullValues(value) {

package/dist/withOnyx.js

@@ -298,8 +298,9 @@ function default_1(mapOnyxToState, shouldDelayUpdates = false) {
                 // that should not be passed to a wrapped component
                 let stateToPass = underscore_1.default.omit(this.state, 'loading');
                 stateToPass = underscore_1.default.omit(stateToPass, underscore_1.default.isNull);
+                const stateToPassWithoutNestedNulls = utils_1.default.removeNestedNullValues(stateToPass);
                 // Spreading props and state is necessary in an HOC where the data cannot be predicted
-                return (react_1.default.createElement(WrappedComponent, Object.assign({ markReadyForHydration: this.flushPendingSetStates }, propsToPass, stateToPass, { ref: this.props.forwardedRef })));
+                return (react_1.default.createElement(WrappedComponent, Object.assign({ markReadyForHydration: this.flushPendingSetStates }, propsToPass, stateToPassWithoutNestedNulls, { ref: this.props.forwardedRef })));
             }
         }
         withOnyx.propTypes = {

package/package.json

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