react-native-onyx 3.0.47 → 3.0.49

package/dist/Onyx.js

@@ -221,7 +221,13 @@ function merge(key, changes) {
             }
             try {
                 const validChanges = mergeQueue[key].filter((change) => {
-                    const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(change, existingValue);
+                    const { isCompatible, existingValueType, newValueType, isEmptyArrayCoercion } = utils_1.default.checkCompatibilityWithExistingValue(change, existingValue);
+                    if (isEmptyArrayCoercion) {
+                        // Merging an object into an empty array isn't semantically correct, but we allow it
+                        // in case we accidentally encoded an empty object as an empty array in PHP. If you're
+                        // looking at a bugbot from this message, we're probably missing that key in OnyxKeys::KEYS_REQUIRING_EMPTY_OBJECT
+                        Logger.logAlert(`[ENSURE_BUGBOT] Onyx merge called on key "${key}" whose existing value is an empty array. Will coerce to object.`);
+                    }
                     if (!isCompatible) {
                         Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'merge', existingValueType, newValueType));
                     }

package/dist/OnyxSnapshotCache.d.ts

@@ -40,7 +40,7 @@ declare class OnyxSnapshotCache {
      * - `selector`: Different selectors produce different results, so each selector needs its own cache entry
      * - `initWithStoredValues`: This flag changes the initial loading behavior and affects the returned fetch status
      *
-     * Other options like `canEvict`, `reuseConnection`, and `allowDynamicKey` don't affect the data transformation
+     * Other options like `canEvict` and `reuseConnection` don't affect the data transformation
      * or timing behavior of getSnapshot, so they're excluded from the cache key for better cache hit rates.
      */
     registerConsumer<TKey extends OnyxKey, TReturnValue>(options: Pick<UseOnyxOptions<TKey, TReturnValue>, 'selector' | 'initWithStoredValues'>): string;

package/dist/OnyxSnapshotCache.js

@@ -37,7 +37,7 @@ class OnyxSnapshotCache {
      * - `selector`: Different selectors produce different results, so each selector needs its own cache entry
      * - `initWithStoredValues`: This flag changes the initial loading behavior and affects the returned fetch status
      *
-     * Other options like `canEvict`, `reuseConnection`, and `allowDynamicKey` don't affect the data transformation
+     * Other options like `canEvict` and `reuseConnection` don't affect the data transformation
      * or timing behavior of getSnapshot, so they're excluded from the cache key for better cache hit rates.
      */
     registerConsumer(options) {

package/dist/OnyxUtils.js

@@ -1111,7 +1111,13 @@ function setWithRetry({ key, value, options }, retryAttempt) {
         return Promise.resolve();
     }
     // Check if the value is compatible with the existing value in the storage
-    const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(value, existingValue);
+    const { isCompatible, existingValueType, newValueType, isEmptyArrayCoercion } = utils_1.default.checkCompatibilityWithExistingValue(value, existingValue);
+    if (isEmptyArrayCoercion) {
+        // Setting an object over empty array isn't semantically correct, but we allow it
+        // in case we accidentally encoded an empty object as an empty array in PHP. If you're
+        // looking at a bugbot from this message, we're probably missing that key in OnyxKeys::KEYS_REQUIRING_EMPTY_OBJECT
+        Logger.logAlert(`[ENSURE_BUGBOT] Onyx setWithRetry called on key "${key}" whose existing value is an empty array. Will coerce to object.`);
+    }
     if (!isCompatible) {
         Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'set', existingValueType, newValueType));
         return Promise.resolve();
@@ -1309,7 +1315,13 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
         const existingKeys = keys.filter((key) => persistedKeys.has(key));
         const cachedCollectionForExistingKeys = getCachedCollection(collectionKey, existingKeys);
         const existingKeyCollection = existingKeys.reduce((obj, key) => {
-            const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(resultCollection[key], cachedCollectionForExistingKeys[key]);
+            const { isCompatible, existingValueType, newValueType, isEmptyArrayCoercion } = utils_1.default.checkCompatibilityWithExistingValue(resultCollection[key], cachedCollectionForExistingKeys[key]);
+            if (isEmptyArrayCoercion) {
+                // Merging an object into an empty array isn't semantically correct, but we allow it
+                // in case we accidentally encoded an empty object as an empty array in PHP. If you're
+                // looking at a bugbot from this message, we're probably missing that key in OnyxKeys::KEYS_REQUIRING_EMPTY_OBJECT
+                Logger.logAlert(`[ENSURE_BUGBOT] Onyx mergeCollection called on key "${key}" whose existing value is an empty array. Will coerce to object.`);
+            }
             if (!isCompatible) {
                 Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'mergeCollection', existingValueType, newValueType));
                 return obj;

package/dist/useOnyx.d.ts

@@ -16,10 +16,6 @@ type UseOnyxOptions<TKey extends OnyxKey, TReturnValue> = {
      * with the same connect configurations.
      */
     reuseConnection?: boolean;
-    /**
-     * If set to `true`, the key can be changed dynamically during the component lifecycle.
-     */
-    allowDynamicKey?: boolean;
     /**
      * This will be used to subscribe to a subset of an Onyx key's data.
      * Using this setting on `useOnyx` can have very positive performance benefits because the component will only re-render

package/dist/useOnyx.js

@@ -111,23 +111,6 @@ function useOnyx(key, options, dependencies = []) {
         initWithStoredValues: options === null || options === void 0 ? void 0 : options.initWithStoredValues,
     }), [options === null || options === void 0 ? void 0 : options.selector, options === null || options === void 0 ? void 0 : options.initWithStoredValues]);
     (0, react_1.useEffect)(() => () => OnyxSnapshotCache_1.default.deregisterConsumer(key, cacheKey), [key, cacheKey]);
-    (0, react_1.useEffect)(() => {
-        // These conditions will ensure we can only handle dynamic collection member keys from the same collection.
-        if ((options === null || options === void 0 ? void 0 : options.allowDynamicKey) || previousKey === key) {
-            return;
-        }
-        try {
-            const previousCollectionKey = OnyxUtils_1.default.splitCollectionMemberKey(previousKey)[0];
-            const collectionKey = OnyxUtils_1.default.splitCollectionMemberKey(key)[0];
-            if (OnyxUtils_1.default.isCollectionMemberKey(previousCollectionKey, previousKey) && OnyxUtils_1.default.isCollectionMemberKey(collectionKey, key) && previousCollectionKey === collectionKey) {
-                return;
-            }
-        }
-        catch (e) {
-            throw new Error(`'${previousKey}' key can't be changed to '${key}'. useOnyx() only supports dynamic keys if they are both collection member keys from the same collection e.g. from 'collection_id1' to 'collection_id2'.`);
-        }
-        throw new Error(`'${previousKey}' key can't be changed to '${key}'. useOnyx() only supports dynamic keys if they are both collection member keys from the same collection e.g. from 'collection_id1' to 'collection_id2'.`);
-    }, [previousKey, key, options === null || options === void 0 ? void 0 : options.allowDynamicKey]);
     // Track previous dependencies to prevent infinite loops
     const previousDependenciesRef = (0, react_1.useRef)([]);
     (0, react_1.useEffect)(() => {

package/dist/utils.d.ts

@@ -46,6 +46,7 @@ declare function checkCompatibilityWithExistingValue(value: unknown, existingVal
     isCompatible: boolean;
     existingValueType?: string;
     newValueType?: string;
+    isEmptyArrayCoercion?: boolean;
 };
 /**
  * Picks entries from an object based on a condition.

package/dist/utils.js

@@ -142,6 +142,16 @@ function checkCompatibilityWithExistingValue(value, existingValue) {
             isCompatible: true,
         };
     }
+    // PHP's associative arrays cannot distinguish between an empty list and an
+    // empty object, so it encodes both as []. A key that should hold an
+    // object may arrive from the server as [] and be stored that way. If
+    // we then try to MERGE an object into that key, the array-vs-object type check
+    // would normally block it. Since an empty array carries no data worth
+    // preserving, we treat it as compatible with an object update and coerce it.
+    const isObjectValue = typeof value === 'object' && !Array.isArray(value);
+    if (Array.isArray(existingValue) && existingValue.length === 0 && isObjectValue) {
+        return { isCompatible: true, isEmptyArrayCoercion: true };
+    }
     const existingValueType = Array.isArray(existingValue) ? 'array' : 'non-array';
     const newValueType = Array.isArray(value) ? 'array' : 'non-array';
     if (existingValueType !== newValueType) {

package/package.json

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