react-native-onyx 3.0.37 → 3.0.39

package/README.md

@@ -206,21 +206,6 @@ export default App;
 
 It's also beneficial to use a [selector](https://github.com/Expensify/react-native-onyx/blob/main/API.md#connectmapping--number) with the mapping in case you need to grab a single item in a collection (like a single report action).
 
-### useOnyx()'s `canBeMissing` option
-
-You must pass the `canBeMissing` configuration flag to `useOnyx` if you want the hook to log an alert when data is missing from Onyx store. Regarding usage in `Expensify/App` repo, if the component calling this is the one loading the data by calling an action, then you should set this to `true`. If the component calling this does not load the data then you should set it to `false`, which means that if the data is not there, it will log an alert, as it means we are using data that no one loaded and that's most probably a bug.
-
-```javascript
-const Component = ({reportID}) => {
-    // This hook will log an alert (via `Logger.logAlert()`) if `report` is `undefined`.
-    const [report] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`, {canBeMissing: false});
-    
-    // rest of the component's code.
-};
-
-export default Component;
-```
-
 ## Collections
 
 Collections allow keys with similar value types to be subscribed together by subscribing to the collection key. To define one, it must be included in the `ONYXKEYS.COLLECTION` object and it must be suffixed with an underscore. Member keys should use a unique identifier or index after the collection key prefix (e.g. `report_42`).

package/dist/Onyx.js

@@ -317,14 +317,7 @@ function clear(keysToPreserve = []) {
                     const newValue = (_a = defaultKeyStates[key]) !== null && _a !== void 0 ? _a : null;
                     if (newValue !== oldValue) {
                         OnyxCache_1.default.set(key, newValue);
-                        let collectionKey;
-                        try {
-                            collectionKey = OnyxUtils_1.default.getCollectionKey(key);
-                        }
-                        catch (e) {
-                            // If getCollectionKey() throws an error it means the key is not a collection key.
-                            collectionKey = undefined;
-                        }
+                        const collectionKey = OnyxUtils_1.default.getCollectionKey(key);
                         if (collectionKey) {
                             if (!keyValuesToResetAsCollection[collectionKey]) {
                                 keyValuesToResetAsCollection[collectionKey] = { oldValues: {}, newValues: {} };

package/dist/OnyxCache.d.ts

@@ -162,7 +162,7 @@ declare class OnyxCache {
     /**
      * Get the collection key for a given member key
      */
-    getCollectionKey(key: OnyxKey): OnyxKey | null;
+    getCollectionKey(key: OnyxKey): OnyxKey | undefined;
     /**
      * Get all data for a collection key
      */

package/dist/OnyxCache.js

@@ -383,7 +383,7 @@ class OnyxCache {
                 return collectionKey;
             }
         }
-        return null;
+        return undefined;
     }
     /**
      * Get all data for a collection key

package/dist/OnyxSnapshotCache.d.ts

@@ -40,12 +40,11 @@ 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
      * - `allowStaleData`: Controls whether stale data can be returned during pending merges, affecting result timing
-     * - `canBeMissing`: Determines logging behavior for missing data, but doesn't affect the actual data returned
      *
      * Other options like `canEvict`, `reuseConnection`, and `allowDynamicKey` 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' | 'allowStaleData' | 'canBeMissing'>): string;
+    registerConsumer<TKey extends OnyxKey, TReturnValue>(options: Pick<UseOnyxOptions<TKey, TReturnValue>, 'selector' | 'initWithStoredValues' | 'allowStaleData'>): string;
     /**
      * Deregister a consumer for a cache key.
      * Decrements reference counter and removes cache entry if no consumers remain.

package/dist/OnyxSnapshotCache.js

@@ -37,19 +37,17 @@ 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
      * - `allowStaleData`: Controls whether stale data can be returned during pending merges, affecting result timing
-     * - `canBeMissing`: Determines logging behavior for missing data, but doesn't affect the actual data returned
      *
      * Other options like `canEvict`, `reuseConnection`, and `allowDynamicKey` 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) {
-        var _a, _b, _c;
+        var _a, _b;
         const selectorID = (options === null || options === void 0 ? void 0 : options.selector) ? this.getSelectorID(options.selector) : 'no_selector';
         // Create options hash without expensive JSON.stringify
         const initWithStoredValues = (_a = options === null || options === void 0 ? void 0 : options.initWithStoredValues) !== null && _a !== void 0 ? _a : true;
         const allowStaleData = (_b = options === null || options === void 0 ? void 0 : options.allowStaleData) !== null && _b !== void 0 ? _b : false;
-        const canBeMissing = (_c = options === null || options === void 0 ? void 0 : options.canBeMissing) !== null && _c !== void 0 ? _c : true;
-        const cacheKey = `${selectorID}_${initWithStoredValues}_${allowStaleData}_${canBeMissing}`;
+        const cacheKey = `${selectorID}_${initWithStoredValues}_${allowStaleData}`;
         // Increment reference count for this cache key
         const currentCount = this.cacheKeyRefCounts.get(cacheKey) || 0;
         this.cacheKeyRefCounts.set(cacheKey, currentCount + 1);
@@ -102,14 +100,11 @@ class OnyxSnapshotCache {
     invalidateForKey(keyToInvalidate) {
         // Always invalidate the exact key
         this.snapshotCache.delete(keyToInvalidate);
-        try {
-            // Check if the key is a collection member and invalidate the collection base key
-            const collectionBaseKey = OnyxUtils_1.default.getCollectionKey(keyToInvalidate);
+        // Check if the key is a collection member and invalidate the collection base key
+        const collectionBaseKey = OnyxUtils_1.default.getCollectionKey(keyToInvalidate);
+        if (collectionBaseKey) {
             this.snapshotCache.delete(collectionBaseKey);
         }
-        catch (e) {
-            // do nothing - this just means the key is not a collection member
-        }
     }
     /**
      * Clear all snapshot cache

package/dist/OnyxUtils.d.ts

@@ -163,9 +163,9 @@ declare function isKeyMatch(configKey: OnyxKey, key: OnyxKey): boolean;
  * - `getCollectionKey("sharedNVP_user_-1_something")` would return "sharedNVP_user_"
  *
  * @param key - The collection key to process.
- * @returns The plain collection key or throws an Error if the key is not a collection one.
+ * @returns The plain collection key or undefined if the key is not a collection one.
  */
-declare function getCollectionKey(key: CollectionKey): string;
+declare function getCollectionKey(key: CollectionKey): string | undefined;
 /**
  * Tries to get a value from the cache. If the value is not present in cache it will return the default value or undefined.
  * If the requested key is a collection, it will return an object with all the collection members.

package/dist/OnyxUtils.js

@@ -389,15 +389,9 @@ function isCollectionMemberKey(collectionKey, key) {
  * @returns true if the key is a collection member, false otherwise
  */
 function isCollectionMember(key) {
-    try {
-        const collectionKey = getCollectionKey(key);
-        // If the key is longer than the collection key, it's a collection member
-        return key.length > collectionKey.length;
-    }
-    catch (e) {
-        // If getCollectionKey throws, the key is not a collection member
-        return false;
-    }
+    const collectionKey = getCollectionKey(key);
+    // If the key is longer than the collection key, it's a collection member
+    return !!collectionKey && key.length > collectionKey.length;
 }
 /**
  * Checks if a given key is a RAM-only key, RAM-only collection key, or a RAM-only collection member
@@ -417,14 +411,10 @@ function isCollectionMember(key) {
  * @returns true if key is a RAM-only key, RAM-only collection key, or a RAM-only collection member
  */
 function isRamOnlyKey(key) {
-    try {
-        const collectionKey = getCollectionKey(key);
-        // If collectionKey exists for a given key, check if it's a RAM-only key
+    const collectionKey = getCollectionKey(key);
+    if (collectionKey) {
         return OnyxCache_1.default.isRamOnlyKey(collectionKey);
     }
-    catch (_a) {
-        // If getCollectionKey throws, the key is not a collection member
-    }
     return OnyxCache_1.default.isRamOnlyKey(key);
 }
 /**
@@ -439,8 +429,12 @@ function splitCollectionMemberKey(key, collectionKey) {
         throw new Error(`Invalid '${collectionKey}' collection key provided, it isn't compatible with '${key}' key.`);
     }
     if (!collectionKey) {
+        const resolvedKey = getCollectionKey(key);
+        if (!resolvedKey) {
+            throw new Error(`Invalid '${key}' key provided, only collection keys are allowed.`);
+        }
         // eslint-disable-next-line no-param-reassign
-        collectionKey = getCollectionKey(key);
+        collectionKey = resolvedKey;
     }
     return [collectionKey, key.slice(collectionKey.length)];
 }
@@ -461,7 +455,7 @@ function isKeyMatch(configKey, key) {
  * - `getCollectionKey("sharedNVP_user_-1_something")` would return "sharedNVP_user_"
  *
  * @param key - The collection key to process.
- * @returns The plain collection key or throws an Error if the key is not a collection one.
+ * @returns The plain collection key or undefined if the key is not a collection one.
  */
 function getCollectionKey(key) {
     // Start by finding the position of the last underscore in the string
@@ -477,7 +471,7 @@ function getCollectionKey(key) {
         // Move to the next underscore to check smaller possible keys
         lastUnderscoreIndex = key.lastIndexOf('_', lastUnderscoreIndex - 1);
     }
-    throw new Error(`Invalid '${key}' key provided, only collection keys are allowed.`);
+    return undefined;
 }
 /**
  * Tries to get a value from the cache. If the value is not present in cache it will return the default value or undefined.
@@ -625,14 +619,7 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
     // do the same in keysChanged, because we only call that function when a collection key changes, and it doesn't happen that often.
     // For performance reason, we look for the given key and later if don't find it we look for the collection key, instead of checking if it is a collection key first.
     let stateMappingKeys = (_a = onyxKeyToSubscriptionIDs.get(key)) !== null && _a !== void 0 ? _a : [];
-    let collectionKey;
-    try {
-        collectionKey = getCollectionKey(key);
-    }
-    catch (e) {
-        // If getCollectionKey() throws an error it means the key is not a collection key.
-        collectionKey = undefined;
-    }
+    const collectionKey = getCollectionKey(key);
     if (collectionKey) {
         // Getting the collection key from the specific key because only collection keys were stored in the mapping.
         stateMappingKeys = [...stateMappingKeys, ...((_b = onyxKeyToSubscriptionIDs.get(collectionKey)) !== null && _b !== void 0 ? _b : [])];

package/dist/useOnyx.d.ts

@@ -24,13 +24,6 @@ type UseOnyxOptions<TKey extends OnyxKey, TReturnValue> = {
      * If set to `true`, the key can be changed dynamically during the component lifecycle.
      */
     allowDynamicKey?: boolean;
-    /**
-     * If the component calling this is the one loading the data by calling an action, then you should set this to `true`.
-     *
-     * If the component calling this does not load the data then you should set it to `false`, which means that if the data
-     * is not there, it will log an alert, as it means we are using data that no one loaded and that's most probably a bug.
-     */
-    canBeMissing?: 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

@@ -44,7 +44,6 @@ const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const GlobalSettings = __importStar(require("./GlobalSettings"));
 const usePrevious_1 = __importDefault(require("./usePrevious"));
 const metrics_1 = __importDefault(require("./metrics"));
-const Logger = __importStar(require("./Logger"));
 const OnyxSnapshotCache_1 = __importDefault(require("./OnyxSnapshotCache"));
 const useLiveRef_1 = __importDefault(require("./useLiveRef"));
 function useOnyx(key, options, dependencies = []) {
@@ -111,8 +110,7 @@ function useOnyx(key, options, dependencies = []) {
         selector: options === null || options === void 0 ? void 0 : options.selector,
         initWithStoredValues: options === null || options === void 0 ? void 0 : options.initWithStoredValues,
         allowStaleData: options === null || options === void 0 ? void 0 : options.allowStaleData,
-        canBeMissing: options === null || options === void 0 ? void 0 : options.canBeMissing,
-    }), [options === null || options === void 0 ? void 0 : options.selector, options === null || options === void 0 ? void 0 : options.initWithStoredValues, options === null || options === void 0 ? void 0 : options.allowStaleData, options === null || options === void 0 ? void 0 : options.canBeMissing]);
+    }), [options === null || options === void 0 ? void 0 : options.selector, options === null || options === void 0 ? void 0 : options.initWithStoredValues, options === null || options === void 0 ? void 0 : options.allowStaleData]);
     (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.
@@ -178,7 +176,6 @@ function useOnyx(key, options, dependencies = []) {
                 return cachedResult;
             }
         }
-        let isOnyxValueDefined = true;
         // We return the initial result right away during the first connection if `initWithStoredValues` is set to `false`.
         if (isFirstConnectionRef.current && (options === null || options === void 0 ? void 0 : options.initWithStoredValues) === false) {
             const result = resultRef.current;
@@ -194,9 +191,6 @@ function useOnyx(key, options, dependencies = []) {
             const value = OnyxUtils_1.default.tryGetCachedValue(key);
             const selectedValue = memoizedSelector ? memoizedSelector(value) : value;
             newValueRef.current = (selectedValue !== null && selectedValue !== void 0 ? selectedValue : undefined);
-            // This flag is `false` when the original Onyx value (without selector) is not defined yet.
-            // It will be used later to check if we need to log an alert that the value is missing.
-            isOnyxValueDefined = value !== null && value !== undefined;
             // We set this flag to `false` again since we don't want to get the newest cached value every time `getSnapshot()` is executed,
             // and only when `Onyx.connect()` callback is fired.
             shouldGetCachedValueRef.current = false;
@@ -243,18 +237,12 @@ function useOnyx(key, options, dependencies = []) {
                     sourceValue: sourceValueRef.current,
                 },
             ];
-            // If `canBeMissing` is set to `false` and the Onyx value of that key is not defined,
-            // we log an alert so it can be acknowledged by the consumer. Additionally, we won't log alerts
-            // if there's a `Onyx.clear()` task in progress.
-            if ((options === null || options === void 0 ? void 0 : options.canBeMissing) === false && newFetchStatus === 'loaded' && !isOnyxValueDefined && !OnyxCache_1.default.hasPendingTask(OnyxCache_1.TASK.CLEAR)) {
-                Logger.logAlert(`useOnyx returned no data for key with canBeMissing set to false for key ${key}`, { showAlert: true });
-            }
         }
         if (newFetchStatus !== 'loading') {
             OnyxSnapshotCache_1.default.setCachedResult(key, cacheKey, resultRef.current);
         }
         return resultRef.current;
-    }, [options === null || options === void 0 ? void 0 : options.initWithStoredValues, options === null || options === void 0 ? void 0 : options.allowStaleData, options === null || options === void 0 ? void 0 : options.canBeMissing, key, memoizedSelector, cacheKey, previousKey]);
+    }, [options === null || options === void 0 ? void 0 : options.initWithStoredValues, options === null || options === void 0 ? void 0 : options.allowStaleData, key, memoizedSelector, cacheKey, previousKey]);
     const subscribe = (0, react_1.useCallback)((onStoreChange) => {
         isConnectingRef.current = true;
         onStoreChangeFnRef.current = onStoreChange;

package/package.json

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