return undefined instead of null

Author: JKobrynski

lib/Onyx.ts

@@ -346,7 +346,7 @@ function clear(keysToPreserve: OnyxKey[] = []): Promise<void> {
                         if (newValue !== oldValue) {
                             cache.set(key, newValue);
 
-                            const collectionKey = OnyxUtils.getCollectionKey(key) ?? undefined;
+                            const collectionKey = OnyxUtils.getCollectionKey(key);
 
                             if (collectionKey) {
                                 if (!keyValuesToResetAsCollection[collectionKey]) {

lib/OnyxCache.ts

@@ -458,13 +458,13 @@ class OnyxCache {
     /**
      * Get the collection key for a given member key
      */
-    getCollectionKey(key: OnyxKey): OnyxKey | null {
+    getCollectionKey(key: OnyxKey): OnyxKey | undefined {
         for (const collectionKey of this.collectionKeys) {
             if (key.startsWith(collectionKey) && key.length > collectionKey.length) {
                 return collectionKey;
             }
         }
-        return null;
+        return undefined;
     }
 
     /**

lib/OnyxSnapshotCache.ts

@@ -135,7 +135,7 @@ class OnyxSnapshotCache {
 
         // Check if the key is a collection member and invalidate the collection base key
         const collectionBaseKey = OnyxUtils.getCollectionKey(keyToInvalidate);
-        if (collectionBaseKey !== null) {
+        if (collectionBaseKey) {
             this.snapshotCache.delete(collectionBaseKey);
         }
     }

lib/OnyxUtils.ts

@@ -477,7 +477,7 @@ function isCollectionMemberKey<TCollectionKey extends CollectionKeyBase>(collect
 function isCollectionMember(key: OnyxKey): boolean {
     const collectionKey = getCollectionKey(key);
     // If the key is longer than the collection key, it's a collection member
-    return collectionKey !== null && key.length > collectionKey.length;
+    return !!collectionKey && key.length > collectionKey.length;
 }
 
 /**
@@ -499,7 +499,7 @@ function isCollectionMember(key: OnyxKey): boolean {
  */
 function isRamOnlyKey(key: OnyxKey): boolean {
     const collectionKey = getCollectionKey(key);
-    if (collectionKey !== null) {
+    if (collectionKey) {
         return cache.isRamOnlyKey(collectionKey);
     }
 
@@ -523,7 +523,7 @@ function splitCollectionMemberKey<TKey extends CollectionKey, CollectionKeyType
 
     if (!collectionKey) {
         const resolvedKey = getCollectionKey(key);
-        if (resolvedKey === null) {
+        if (!resolvedKey) {
             throw new Error(`Invalid '${key}' key provided, only collection keys are allowed.`);
         }
         // eslint-disable-next-line no-param-reassign
@@ -551,9 +551,9 @@ 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 null 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: CollectionKey): string | null {
+function getCollectionKey(key: CollectionKey): string | undefined {
     // Start by finding the position of the last underscore in the string
     let lastUnderscoreIndex = key.lastIndexOf('_');
 
@@ -571,7 +571,7 @@ function getCollectionKey(key: CollectionKey): string | null {
         lastUnderscoreIndex = key.lastIndexOf('_', lastUnderscoreIndex - 1);
     }
 
-    return null;
+    return undefined;
 }
 
 /**
@@ -750,7 +750,7 @@ function keyChanged<TKey extends OnyxKey>(
     // 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 = onyxKeyToSubscriptionIDs.get(key) ?? [];
-    const collectionKey = getCollectionKey(key) ?? undefined;
+    const collectionKey = getCollectionKey(key);
 
     if (collectionKey) {
         // Getting the collection key from the specific key because only collection keys were stored in the mapping.

tests/unit/OnyxSnapshotCacheTest.ts

@@ -158,7 +158,7 @@ describe('OnyxSnapshotCache', () => {
 
         it('should invalidate non-collection keys without affecting others', () => {
             mockedOnyxUtils.isCollectionKey.mockReturnValue(false);
-            mockedOnyxUtils.getCollectionKey.mockReturnValue(null);
+            mockedOnyxUtils.getCollectionKey.mockReturnValue(undefined);
 
             cache.invalidateForKey('nonCollectionKey');
 

tests/unit/onyxUtilsTest.ts

@@ -342,9 +342,9 @@ describe('OnyxUtils', () => {
             });
         });
 
-        it('should return null if key does not contain underscore', () => {
-            expect(OnyxUtils.getCollectionKey(ONYXKEYS.TEST_KEY)).toBeNull();
-            expect(OnyxUtils.getCollectionKey('')).toBeNull();
+        it('should return undefined if key does not contain underscore', () => {
+            expect(OnyxUtils.getCollectionKey(ONYXKEYS.TEST_KEY)).toBeUndefined();
+            expect(OnyxUtils.getCollectionKey('')).toBeUndefined();
         });
     });