react-native-onyx 2.0.53 → 2.0.55

package/dist/Onyx.js

@@ -97,6 +97,10 @@ function connect(connectOptions) {
     const callbackToStateMapping = OnyxUtils_1.default.getCallbackToStateMapping();
     callbackToStateMapping[connectionID] = mapping;
     callbackToStateMapping[connectionID].connectionID = connectionID;
+    // When keyChanged is called, a key is passed and the method looks through all the Subscribers in callbackToStateMapping for the matching key to get the connectionID
+    // to avoid having to loop through all the Subscribers all the time (even when just one connection belongs to one key),
+    // We create a mapping from key to lists of connectionIDs to access the specific list of connectionIDs.
+    OnyxUtils_1.default.storeKeyByConnections(mapping.key, callbackToStateMapping[connectionID].connectionID);
     if (mapping.initWithStoredValues === false) {
         return connectionID;
     }
@@ -146,10 +150,11 @@ function connect(connectOptions) {
                     return;
                 }
                 // We did not opt into using waitForCollectionCallback mode so the callback is called for every matching key.
-                // eslint-disable-next-line @typescript-eslint/prefer-for-of
-                for (let i = 0; i < matchingKeys.length; i++) {
-                    OnyxUtils_1.default.get(matchingKeys[i]).then((val) => OnyxUtils_1.default.sendDataToConnection(mapping, val, matchingKeys[i], true));
-                }
+                OnyxUtils_1.default.multiGet(matchingKeys).then((values) => {
+                    values.forEach((val, key) => {
+                        OnyxUtils_1.default.sendDataToConnection(mapping, val, key, true);
+                    });
+                });
                 return;
             }
             // If we are not subscribed to a collection key then there's only a single key to send an update for.
@@ -190,6 +195,7 @@ function disconnect(connectionID, keyToRemoveFromEvictionBlocklist) {
     if (keyToRemoveFromEvictionBlocklist) {
         OnyxUtils_1.default.removeFromEvictionBlockList(keyToRemoveFromEvictionBlocklist, connectionID);
     }
+    OnyxUtils_1.default.deleteKeyByConnections(lastConnectionID);
     delete callbackToStateMapping[connectionID];
 }
 /**
@@ -386,7 +392,8 @@ function mergeCollection(collectionKey, collection) {
     const mergedCollection = collection;
     // Confirm all the collection keys belong to the same parent
     let hasCollectionKeyCheckFailed = false;
-    Object.keys(mergedCollection).forEach((dataKey) => {
+    const mergedCollectionKeys = Object.keys(mergedCollection);
+    mergedCollectionKeys.forEach((dataKey) => {
         if (OnyxUtils_1.default.isKeyMatch(collectionKey, dataKey)) {
             return;
         }
@@ -403,7 +410,7 @@ function mergeCollection(collectionKey, collection) {
     return OnyxUtils_1.default.getAllKeys()
         .then((persistedKeys) => {
         // Split to keys that exist in storage and keys that don't
-        const keys = Object.keys(mergedCollection).filter((key) => {
+        const keys = mergedCollectionKeys.filter((key) => {
             if (mergedCollection[key] === null) {
                 OnyxUtils_1.default.remove(key);
                 return false;
@@ -412,7 +419,6 @@ function mergeCollection(collectionKey, collection) {
         });
         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) {
@@ -423,11 +429,13 @@ function mergeCollection(collectionKey, collection) {
             obj[key] = mergedCollection[key];
             return obj;
         }, {});
-        const newCollection = newKeys.reduce((obj, key) => {
-            // eslint-disable-next-line no-param-reassign
-            obj[key] = mergedCollection[key];
-            return obj;
-        }, {});
+        const newCollection = {};
+        keys.forEach((key) => {
+            if (persistedKeys.has(key)) {
+                return;
+            }
+            newCollection[key] = mergedCollection[key];
+        });
         // 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.

package/dist/OnyxUtils.d.ts

@@ -54,6 +54,20 @@ declare function maybeFlushBatchUpdates(): Promise<void>;
 declare function batchUpdates(updates: () => void): Promise<void>;
 /** Get some data from the store */
 declare function get<TKey extends OnyxKey, TValue extends OnyxValue<TKey>>(key: TKey): Promise<TValue>;
+declare function multiGet<TKey extends OnyxKey>(keys: CollectionKeyBase[]): Promise<Map<OnyxKey, OnyxValue<TKey>>>;
+/**
+ * Stores a connection ID associated with a given key.
+ *
+ * @param connectionID - a connection ID of the subscriber
+ * @param key - a key that the subscriber is connected to
+ */
+declare function storeKeyByConnections(key: OnyxKey, connectionID: number): void;
+/**
+ * Deletes a connection ID associated with its corresponding key.
+ *
+ * @param {number} connectionID - The connection ID to be deleted.
+ */
+declare function deleteKeyByConnections(connectionID: number): void;
 /** Returns current key names stored in persisted storage */
 declare function getAllKeys(): Promise<Set<OnyxKey>>;
 /**
@@ -75,6 +89,18 @@ declare function splitCollectionMemberKey<TKey extends CollectionKey>(key: TKey)
 declare function isKeyMatch(configKey: OnyxKey, key: OnyxKey): boolean;
 /** Checks to see if this key has been flagged as safe for removal. */
 declare function isSafeEvictionKey(testKey: OnyxKey): boolean;
+/**
+ * It extracts the non-numeric collection identifier of a given key.
+ *
+ * For example:
+ * - `getCollectionKey("report_123")` would return "report_"
+ * - `getCollectionKey("report")` would return "report"
+ * - `getCollectionKey("report_")` would return "report_"
+ *
+ * @param {OnyxKey} key - The key to process.
+ * @return {string} The pure key without any numeric
+ */
+declare function getCollectionKey(key: OnyxKey): string;
 /**
  * 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.
@@ -224,6 +250,7 @@ declare const OnyxUtils: {
     keyChanged: typeof keyChanged;
     sendDataToConnection: typeof sendDataToConnection;
     addKeyToRecentlyAccessedIfNeeded: typeof addKeyToRecentlyAccessedIfNeeded;
+    getCollectionKey: typeof getCollectionKey;
     getCollectionDataAndSendAsObject: typeof getCollectionDataAndSendAsObject;
     scheduleSubscriberUpdate: typeof scheduleSubscriberUpdate;
     scheduleNotifyCollectionSubscribers: typeof scheduleNotifyCollectionSubscribers;
@@ -236,6 +263,9 @@ declare const OnyxUtils: {
     prepareKeyValuePairsForStorage: typeof prepareKeyValuePairsForStorage;
     applyMerge: typeof applyMerge;
     initializeWithDefaultKeyStates: typeof initializeWithDefaultKeyStates;
+    storeKeyByConnections: typeof storeKeyByConnections;
+    deleteKeyByConnections: typeof deleteKeyByConnections;
     getSnapshotKey: typeof getSnapshotKey;
+    multiGet: typeof multiGet;
 };
 export default OnyxUtils;

package/dist/OnyxUtils.js

@@ -53,6 +53,8 @@ const mergeQueuePromise = {};
 const callbackToStateMapping = {};
 // Keeps a copy of the values of the onyx collection keys as a map for faster lookups
 let onyxCollectionKeyMap = new Map();
+// Holds a mapping of the connected key to the connectionID for faster lookups
+const onyxKeyToConnectionIDs = new Map();
 // Holds a list of keys that have been directly subscribed to or recently modified from least to most recent
 let recentlyAccessedKeys = [];
 // Holds a list of keys that are safe to remove when we reach max storage. If a key does not match with
@@ -190,6 +192,93 @@ function get(key) {
         .catch((err) => Logger.logInfo(`Unable to get item from persistent storage. Key: ${key} Error: ${err}`));
     return OnyxCache_1.default.captureTask(taskName, promise);
 }
+// multiGet the data first from the cache and then from the storage for the missing keys.
+function multiGet(keys) {
+    // Keys that are not in the cache
+    const missingKeys = [];
+    // Tasks that are pending
+    const pendingTasks = [];
+    // Keys for the tasks that are pending
+    const pendingKeys = [];
+    // Data to be sent back to the invoker
+    const dataMap = new Map();
+    /**
+     * We are going to iterate over all the matching keys and check if we have the data in the cache.
+     * If we do then we add it to the data object. If we do not have them, then we check if there is a pending task
+     * for the key. If there is such task, then we add the promise to the pendingTasks array and the key to the pendingKeys
+     * array. If there is no pending task then we add the key to the missingKeys array.
+     *
+     * These missingKeys will be later used to multiGet the data from the storage.
+     */
+    keys.forEach((key) => {
+        const cacheValue = OnyxCache_1.default.get(key);
+        if (cacheValue) {
+            dataMap.set(key, cacheValue);
+            return;
+        }
+        const pendingKey = `get:${key}`;
+        if (OnyxCache_1.default.hasPendingTask(pendingKey)) {
+            pendingTasks.push(OnyxCache_1.default.getTaskPromise(pendingKey));
+            pendingKeys.push(key);
+        }
+        else {
+            missingKeys.push(key);
+        }
+    });
+    return (Promise.all(pendingTasks)
+        // Wait for all the pending tasks to resolve and then add the data to the data map.
+        .then((values) => {
+        values.forEach((value, index) => {
+            dataMap.set(pendingKeys[index], value);
+        });
+        return Promise.resolve();
+    })
+        // Get the missing keys using multiGet from the storage.
+        .then(() => {
+        if (missingKeys.length === 0) {
+            return Promise.resolve(undefined);
+        }
+        return storage_1.default.multiGet(missingKeys);
+    })
+        // Add the data from the missing keys to the data map and also merge it to the cache.
+        .then((values) => {
+        if (!values || values.length === 0) {
+            return dataMap;
+        }
+        // temp object is used to merge the missing data into the cache
+        const temp = {};
+        values.forEach(([key, value]) => {
+            dataMap.set(key, value);
+            temp[key] = value;
+        });
+        OnyxCache_1.default.merge(temp);
+        return dataMap;
+    }));
+}
+/**
+ * Stores a connection ID associated with a given key.
+ *
+ * @param connectionID - a connection ID of the subscriber
+ * @param key - a key that the subscriber is connected to
+ */
+function storeKeyByConnections(key, connectionID) {
+    if (!onyxKeyToConnectionIDs.has(key)) {
+        onyxKeyToConnectionIDs.set(key, []);
+    }
+    onyxKeyToConnectionIDs.get(key).push(connectionID);
+}
+/**
+ * Deletes a connection ID associated with its corresponding key.
+ *
+ * @param {number} connectionID - The connection ID to be deleted.
+ */
+function deleteKeyByConnections(connectionID) {
+    const subscriber = callbackToStateMapping[connectionID];
+    if (subscriber && onyxKeyToConnectionIDs.has(subscriber.key)) {
+        const updatedConnectionIDs = onyxKeyToConnectionIDs.get(subscriber.key).filter((id) => id !== connectionID);
+        onyxKeyToConnectionIDs.set(subscriber.key, updatedConnectionIDs);
+    }
+}
 /** Returns current key names stored in persisted storage */
 function getAllKeys() {
     // When we've already read stored keys, resolve right away
@@ -226,7 +315,7 @@ function isCollectionMemberKey(collectionKey, key) {
  * @returns A tuple where the first element is the collection part and the second element is the ID part.
  */
 function splitCollectionMemberKey(key) {
-    const underscoreIndex = key.indexOf('_');
+    const underscoreIndex = key.lastIndexOf('_');
     if (underscoreIndex === -1) {
         throw new Error(`Invalid ${key} key provided, only collection keys are allowed.`);
     }
@@ -243,6 +332,24 @@ function isKeyMatch(configKey, key) {
 function isSafeEvictionKey(testKey) {
     return evictionAllowList.some((key) => isKeyMatch(key, testKey));
 }
+/**
+ * It extracts the non-numeric collection identifier of a given key.
+ *
+ * For example:
+ * - `getCollectionKey("report_123")` would return "report_"
+ * - `getCollectionKey("report")` would return "report"
+ * - `getCollectionKey("report_")` would return "report_"
+ *
+ * @param {OnyxKey} key - The key to process.
+ * @return {string} The pure key without any numeric
+ */
+function getCollectionKey(key) {
+    const underscoreIndex = key.lastIndexOf('_');
+    if (underscoreIndex === -1) {
+        return key;
+    }
+    return key.substring(0, underscoreIndex + 1);
+}
 /**
  * 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.
@@ -513,6 +620,7 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
  * keyChanged(key, value, subscriber => subscriber.initWithStoredValues === false)
  */
 function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true, notifyRegularSubscibers = true, notifyWithOnyxSubscibers = true) {
+    var _a, _b;
     // Add or remove this key from the recentlyAccessedKeys lists
     if (value !== null) {
         addLastAccessedKey(key);
@@ -520,10 +628,22 @@ function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true,
     else {
         removeLastAccessedKey(key);
     }
-    // We are iterating over all subscribers to see if they are interested in the key that has just changed. If the subscriber's  key is a collection key then we will
+    // We get the subscribers interested in the key that has just changed. If the subscriber's  key is a collection key then we will
     // notify them if the key that changed is a collection member. Or if it is a regular key notify them when there is an exact match. Depending on whether the subscriber
     // was connected via withOnyx we will call setState() directly on the withOnyx instance. If it is a regular connection we will pass the data to the provided callback.
-    const stateMappingKeys = Object.keys(callbackToStateMapping);
+    // Given the amount of times this function is called we need to make sure we are not iterating over all subscribers every time. On the other hand, we don't need to
+    // 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 = onyxKeyToConnectionIDs.get(key)) !== null && _a !== void 0 ? _a : [];
+    const collectionKey = getCollectionKey(key);
+    const plainCollectionKey = collectionKey.lastIndexOf('_') !== -1 ? collectionKey : undefined;
+    if (plainCollectionKey) {
+        // Getting the collection key from the specific key because only collection keys were stored in the mapping.
+        stateMappingKeys = [...stateMappingKeys, ...((_b = onyxKeyToConnectionIDs.get(plainCollectionKey)) !== null && _b !== void 0 ? _b : [])];
+        if (stateMappingKeys.length === 0) {
+            return;
+        }
+    }
     for (let i = 0; i < stateMappingKeys.length; i++) {
         const subscriber = callbackToStateMapping[stateMappingKeys[i]];
         if (!subscriber || !isKeyMatch(subscriber.key, key) || !canUpdateSubscriber(subscriber)) {
@@ -682,68 +802,8 @@ function addKeyToRecentlyAccessedIfNeeded(mapping) {
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
  */
 function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
-    // Keys that are not in the cache
-    const missingKeys = [];
-    // Tasks that are pending
-    const pendingTasks = [];
-    // Keys for the tasks that are pending
-    const pendingKeys = [];
-    // We are going to combine all the data from the matching keys into a single object
-    const data = {};
-    /**
-     * We are going to iterate over all the matching keys and check if we have the data in the cache.
-     * If we do then we add it to the data object. If we do not then we check if there is a pending task
-     * for the key. If there is then we add the promise to the pendingTasks array and the key to the pendingKeys
-     * array. If there is no pending task then we add the key to the missingKeys array.
-     *
-     * These missingKeys will be later to use to multiGet the data from the storage.
-     */
-    matchingKeys.forEach((key) => {
-        const cacheValue = OnyxCache_1.default.get(key);
-        if (cacheValue) {
-            data[key] = cacheValue;
-            return;
-        }
-        const pendingKey = `get:${key}`;
-        if (OnyxCache_1.default.hasPendingTask(pendingKey)) {
-            pendingTasks.push(OnyxCache_1.default.getTaskPromise(pendingKey));
-            pendingKeys.push(key);
-        }
-        else {
-            missingKeys.push(key);
-        }
-    });
-    Promise.all(pendingTasks)
-        // We are going to wait for all the pending tasks to resolve and then add the data to the data object.
-        .then((values) => {
-        values.forEach((value, index) => {
-            data[pendingKeys[index]] = value;
-        });
-        return Promise.resolve();
-    })
-        // We are going to get the missing keys using multiGet from the storage.
-        .then(() => {
-        if (missingKeys.length === 0) {
-            return Promise.resolve(undefined);
-        }
-        return storage_1.default.multiGet(missingKeys);
-    })
-        // We are going to add the data from the missing keys to the data object and also merge it to the cache.
-        .then((values) => {
-        if (!values || values.length === 0) {
-            return Promise.resolve();
-        }
-        // temp object is used to merge the missing data into the cache
-        const temp = {};
-        values.forEach(([key, value]) => {
-            data[key] = value;
-            temp[key] = value;
-        });
-        OnyxCache_1.default.merge(temp);
-        return Promise.resolve();
-    })
-        // We are going to send the data to the subscriber.
-        .finally(() => {
+    multiGet(matchingKeys).then((dataMap) => {
+        const data = Object.fromEntries(dataMap.entries());
         sendDataToConnection(mapping, data, undefined, true);
     });
 }
@@ -923,6 +983,7 @@ const OnyxUtils = {
     keyChanged,
     sendDataToConnection,
     addKeyToRecentlyAccessedIfNeeded,
+    getCollectionKey,
     getCollectionDataAndSendAsObject,
     scheduleSubscriberUpdate,
     scheduleNotifyCollectionSubscribers,
@@ -935,6 +996,9 @@ const OnyxUtils = {
     prepareKeyValuePairsForStorage,
     applyMerge,
     initializeWithDefaultKeyStates,
+    storeKeyByConnections,
+    deleteKeyByConnections,
     getSnapshotKey,
+    multiGet,
 };
 exports.default = OnyxUtils;

package/dist/utils.js

@@ -11,7 +11,7 @@ function isEmptyObject(obj) {
  */
 function isMergeableObject(value) {
     const isNonNullObject = value != null ? typeof value === 'object' : false;
-    return isNonNullObject && Object.prototype.toString.call(value) !== '[object RegExp]' && Object.prototype.toString.call(value) !== '[object Date]' && !Array.isArray(value);
+    return isNonNullObject && !(value instanceof RegExp) && !(value instanceof Date) && !Array.isArray(value);
 }
 /**
  * Merges the source object into the target object.
@@ -28,9 +28,8 @@ function mergeObject(target, source, shouldRemoveNestedNulls = true) {
     // 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 (targetObject) {
-        const targetKeys = Object.keys(targetObject);
-        for (let i = 0; i < targetKeys.length; ++i) {
-            const key = targetKeys[i];
+        // eslint-disable-next-line no-restricted-syntax, guard-for-in
+        for (const key in targetObject) {
             const sourceValue = source === null || source === void 0 ? void 0 : source[key];
             const targetValue = targetObject === null || targetObject === void 0 ? void 0 : targetObject[key];
             // If "shouldRemoveNestedNulls" is true, we want to remove null values from the merged object.
@@ -46,9 +45,8 @@ function mergeObject(target, source, shouldRemoveNestedNulls = true) {
         }
     }
     // After copying over all keys from the target object, we want to merge the source object into the destination object.
-    const sourceKeys = Object.keys(source);
-    for (let i = 0; i < sourceKeys.length; ++i) {
-        const key = sourceKeys[i];
+    // eslint-disable-next-line no-restricted-syntax, guard-for-in
+    for (const key in source) {
         const sourceValue = source === null || source === void 0 ? void 0 : source[key];
         const targetValue = targetObject === null || targetObject === void 0 ? void 0 : targetObject[key];
         // If undefined is passed as the source value for a key, we want to generally ignore it.

package/package.json

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