react-native-onyx 2.0.33 → 2.0.35

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

@@ -36,6 +36,7 @@ const storage_1 = __importDefault(require("./storage"));
 const utils_1 = __importDefault(require("./utils"));
 const DevTools_1 = __importDefault(require("./DevTools"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
+const logMessages_1 = __importDefault(require("./logMessages"));
 // Keeps track of the last connectionID that was used so we can keep incrementing it
 let lastConnectionID = 0;
 // Connections can be made before `Onyx.init`. They would wait for this task before resolving
@@ -191,6 +192,13 @@ function disconnect(connectionID, keyToRemoveFromEvictionBlocklist) {
  * @param value value to store
  */
 function set(key, value) {
+    // check if the value is compatible with the existing value in the storage
+    const existingValue = OnyxCache_1.default.getValue(key, false);
+    const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(value, existingValue);
+    if (!isCompatible) {
+        Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'set', existingValueType, newValueType));
+        return Promise.resolve();
+    }
     // If the value is null, we remove the key from storage
     const { value: valueAfterRemoving, wasRemoved } = OnyxUtils_1.default.removeNullValues(key, value);
     const valueWithoutNullValues = valueAfterRemoving;
@@ -275,7 +283,17 @@ function merge(key, changes) {
         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 "batchedDeltaChanges", because SQLite uses them to remove keys from storage natively.
-            const batchedDeltaChanges = OnyxUtils_1.default.applyMerge(undefined, mergeQueue[key], false);
+            const validChanges = mergeQueue[key].filter((change) => {
+                const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(change, existingValue);
+                if (!isCompatible) {
+                    Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'merge', existingValueType, newValueType));
+                }
+                return isCompatible;
+            });
+            if (!validChanges.length) {
+                return undefined;
+            }
+            const batchedDeltaChanges = OnyxUtils_1.default.applyMerge(undefined, validChanges, false);
             // Case (1): When there is no existing value in storage, we want to set the value instead of merge it.
             // Case (2): The presence of a top-level `null` in the merge queue instructs us to drop the whole 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
@@ -358,8 +376,14 @@ function mergeCollection(collectionKey, collection) {
             return true;
         });
         const existingKeys = keys.filter((key) => persistedKeys.has(key));
+        const cachedCollectionForExistingKeys = OnyxUtils_1.default.getCachedCollection(collectionKey, existingKeys);
         const newKeys = keys.filter((key) => !persistedKeys.has(key));
         const existingKeyCollection = existingKeys.reduce((obj, key) => {
+            const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(mergedCollection[key], cachedCollectionForExistingKeys[key]);
+            if (!isCompatible) {
+                Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'mergeCollection', existingValueType, newValueType));
+                return obj;
+            }
             // eslint-disable-next-line no-param-reassign
             obj[key] = mergedCollection[key];
             return obj;
@@ -385,11 +409,13 @@ function mergeCollection(collectionKey, collection) {
         if (keyValuePairsForNewCollection.length > 0) {
             promises.push(storage_1.default.multiSet(keyValuePairsForNewCollection));
         }
+        // finalMergedCollection contains all the keys that were merged, without the keys of incompatible updates
+        const finalMergedCollection = Object.assign(Object.assign({}, existingKeyCollection), newCollection);
         // Prefill cache if necessary by calling get() on any existing keys and then merge original data to cache
         // and update all subscribers
         const promiseUpdate = Promise.all(existingKeys.map(OnyxUtils_1.default.get)).then(() => {
-            OnyxCache_1.default.merge(mergedCollection);
-            return OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(collectionKey, mergedCollection);
+            OnyxCache_1.default.merge(finalMergedCollection);
+            return OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection);
         });
         return Promise.all(promises)
             .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, mergeCollection, collectionKey, mergedCollection))

package/dist/OnyxUtils.d.ts

@@ -103,7 +103,7 @@ declare function addToEvictionBlockList(key: OnyxKey, connectionID: number): voi
  * removed.
  */
 declare function addAllSafeEvictionKeysToRecentlyAccessedList(): Promise<void>;
-declare function getCachedCollection<TKey extends CollectionKeyBase>(collectionKey: TKey): NonNullable<OnyxCollection<KeyValueMapping[TKey]>>;
+declare function getCachedCollection<TKey extends CollectionKeyBase>(collectionKey: TKey, collectionMemberKeys?: string[]): NonNullable<OnyxCollection<KeyValueMapping[TKey]>>;
 /**
  * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
  */

package/dist/OnyxUtils.js

@@ -323,9 +323,9 @@ function addAllSafeEvictionKeysToRecentlyAccessedList() {
         });
     });
 }
-function getCachedCollection(collectionKey) {
-    const collectionMemberKeys = Array.from(OnyxCache_1.default.getAllKeys()).filter((storedKey) => isCollectionMemberKey(collectionKey, storedKey));
-    return collectionMemberKeys.reduce((prev, key) => {
+function getCachedCollection(collectionKey, collectionMemberKeys) {
+    const resolvedCollectionMemberKeys = collectionMemberKeys || Array.from(OnyxCache_1.default.getAllKeys()).filter((storedKey) => isCollectionMemberKey(collectionKey, storedKey));
+    return resolvedCollectionMemberKeys.reduce((prev, key) => {
         const cachedValue = OnyxCache_1.default.getValue(key);
         if (!cachedValue) {
             return prev;

package/dist/logMessages.d.ts

@@ -0,0 +1,4 @@
+declare const logMessages: {
+    incompatibleUpdateAlert: (key: string, operation: string, existingValueType?: string, newValueType?: string) => string;
+};
+export default logMessages;

package/dist/logMessages.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logMessages = {
+    incompatibleUpdateAlert: (key, operation, existingValueType, newValueType) => {
+        return `Warning: Trying to apply "${operation}" with ${newValueType !== null && newValueType !== void 0 ? newValueType : 'unknown'} type to ${existingValueType !== null && existingValueType !== void 0 ? existingValueType : 'unknown'} type in the key "${key}"`;
+    },
+};
+exports.default = logMessages;

package/dist/utils.d.ts

@@ -15,10 +15,17 @@ declare function fastMerge<TObject extends Record<string, unknown>>(target: TObj
 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;
+/** validate that the update and the existing value are compatible */
+declare function checkCompatibilityWithExistingValue(value: unknown, existingValue: unknown): {
+    isCompatible: boolean;
+    existingValueType?: string;
+    newValueType?: string;
+};
 declare const _default: {
     isEmptyObject: typeof isEmptyObject;
     fastMerge: typeof fastMerge;
     formatActionName: typeof formatActionName;
     removeNestedNullValues: typeof removeNestedNullValues;
+    checkCompatibilityWithExistingValue: typeof checkCompatibilityWithExistingValue;
 };
 export default _default;

package/dist/utils.js

@@ -98,4 +98,24 @@ function removeNestedNullValues(value) {
 function formatActionName(method, key) {
     return key ? `${method.toUpperCase()}/${key}` : method.toUpperCase();
 }
-exports.default = { isEmptyObject, fastMerge, formatActionName, removeNestedNullValues };
+/** validate that the update and the existing value are compatible */
+function checkCompatibilityWithExistingValue(value, existingValue) {
+    if (!existingValue || !value) {
+        return {
+            isCompatible: true,
+        };
+    }
+    const existingValueType = Array.isArray(existingValue) ? 'array' : 'non-array';
+    const newValueType = Array.isArray(value) ? 'array' : 'non-array';
+    if (existingValueType !== newValueType) {
+        return {
+            isCompatible: false,
+            existingValueType,
+            newValueType,
+        };
+    }
+    return {
+        isCompatible: true,
+    };
+}
+exports.default = { isEmptyObject, fastMerge, formatActionName, removeNestedNullValues, checkCompatibilityWithExistingValue };

package/package.json

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