react-native-onyx 2.0.90 → 2.0.92

package/dist/Onyx.d.ts

@@ -2,7 +2,7 @@ import * as Logger from './Logger';
 import type { CollectionKeyBase, ConnectOptions, InitOptions, Mapping, OnyxKey, OnyxMergeCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetInput, OnyxUpdate } from './types';
 import type { Connection } from './OnyxConnectionManager';
 /** Initialize the store with actions and listening for storage events */
-declare function init({ keys, initialKeyStates, safeEvictionKeys, maxCachedKeysCount, shouldSyncMultipleInstances, debugSetState, enablePerformanceMetrics, }: InitOptions): void;
+declare function init({ keys, initialKeyStates, safeEvictionKeys, maxCachedKeysCount, shouldSyncMultipleInstances, debugSetState, enablePerformanceMetrics, skippableCollectionMemberIDs, }: InitOptions): void;
 /**
  * Connects to an Onyx key given the options passed and listens to its changes.
  *
@@ -132,7 +132,7 @@ declare function update(data: OnyxUpdate[]): Promise<void>;
  * @param collectionKey e.g. `ONYXKEYS.COLLECTION.REPORT`
  * @param collection Object collection keyed by individual collection member keys and values
  */
-declare function setCollection<TKey extends CollectionKeyBase, TMap extends string>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TMap>): Promise<void>;
+declare function setCollection<TKey extends CollectionKeyBase, TMap>(collectionKey: TKey, collection: OnyxMergeCollectionInput<TKey, TMap>): Promise<void>;
 declare const Onyx: {
     METHOD: {
         readonly SET: "set";

package/dist/Onyx.js

@@ -41,13 +41,14 @@ const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager
 const GlobalSettings = __importStar(require("./GlobalSettings"));
 const metrics_1 = __importDefault(require("./metrics"));
 /** Initialize the store with actions and listening for storage events */
-function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = Boolean(global.localStorage), debugSetState = false, enablePerformanceMetrics = false, }) {
+function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = Boolean(global.localStorage), debugSetState = false, enablePerformanceMetrics = false, skippableCollectionMemberIDs = [], }) {
     var _a;
     if (enablePerformanceMetrics) {
         GlobalSettings.setPerformanceMetricsEnabled(true);
         applyDecorators();
     }
     storage_1.default.init();
+    OnyxUtils_1.default.setSkippableCollectionMemberIDs(new Set(skippableCollectionMemberIDs));
     if (shouldSyncMultipleInstances) {
         (_a = storage_1.default.keepInstancesSync) === null || _a === void 0 ? void 0 : _a.call(storage_1.default, (key, value) => {
             const prevValue = OnyxCache_1.default.get(key, false);
@@ -122,6 +123,20 @@ function set(key, value) {
     if (OnyxUtils_1.default.hasPendingMergeForKey(key)) {
         delete OnyxUtils_1.default.getMergeQueue()[key];
     }
+    const skippableCollectionMemberIDs = OnyxUtils_1.default.getSkippableCollectionMemberIDs();
+    if (skippableCollectionMemberIDs.size) {
+        try {
+            const [, collectionMemberID] = OnyxUtils_1.default.splitCollectionMemberKey(key);
+            if (skippableCollectionMemberIDs.has(collectionMemberID)) {
+                // The key is a skippable one, so we set the new value to null.
+                // eslint-disable-next-line no-param-reassign
+                value = null;
+            }
+        }
+        catch (e) {
+            // The key is not a collection one or something went wrong during split, so we proceed with the function's logic.
+        }
+    }
     // Onyx.set will ignore `undefined` values as inputs, therefore we can return early.
     if (value === undefined) {
         return Promise.resolve();
@@ -173,7 +188,25 @@ function set(key, value) {
  * @param data object keyed by ONYXKEYS and the values to set
  */
 function multiSet(data) {
-    const keyValuePairsToSet = OnyxUtils_1.default.prepareKeyValuePairsForStorage(data, true);
+    let newData = data;
+    const skippableCollectionMemberIDs = OnyxUtils_1.default.getSkippableCollectionMemberIDs();
+    if (skippableCollectionMemberIDs.size) {
+        newData = Object.keys(newData).reduce((result, key) => {
+            try {
+                const [, collectionMemberID] = OnyxUtils_1.default.splitCollectionMemberKey(key);
+                // If the collection member key is a skippable one we set its value to null.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? newData[key] : null;
+            }
+            catch (_a) {
+                // The key is not a collection one or something went wrong during split, so we assign the data to result anyway.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = newData[key];
+            }
+            return result;
+        }, {});
+    }
+    const keyValuePairsToSet = OnyxUtils_1.default.prepareKeyValuePairsForStorage(newData, true);
     const updatePromises = keyValuePairsToSet.map(([key, value]) => {
         const prevValue = OnyxCache_1.default.get(key, false);
         // Update cache and optimistically inform subscribers on the next tick
@@ -181,9 +214,9 @@ function multiSet(data) {
         return OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, prevValue);
     });
     return storage_1.default.multiSet(keyValuePairsToSet)
-        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, multiSet, data))
+        .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, multiSet, newData))
         .then(() => {
-        OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MULTI_SET, undefined, data);
+        OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MULTI_SET, undefined, newData);
         return Promise.all(updatePromises);
     })
         .then(() => undefined);
@@ -205,6 +238,20 @@ function multiSet(data) {
  * Onyx.merge(ONYXKEYS.POLICY, {name: 'My Workspace'}); // -> {id: 1, name: 'My Workspace'}
  */
 function merge(key, changes) {
+    const skippableCollectionMemberIDs = OnyxUtils_1.default.getSkippableCollectionMemberIDs();
+    if (skippableCollectionMemberIDs.size) {
+        try {
+            const [, collectionMemberID] = OnyxUtils_1.default.splitCollectionMemberKey(key);
+            if (skippableCollectionMemberIDs.has(collectionMemberID)) {
+                // The key is a skippable one, so we set the new changes to undefined.
+                // eslint-disable-next-line no-param-reassign
+                changes = undefined;
+            }
+        }
+        catch (e) {
+            // The key is not a collection one or something went wrong during split, so we proceed with the function's logic.
+        }
+    }
     const mergeQueue = OnyxUtils_1.default.getMergeQueue();
     const mergeQueuePromise = OnyxUtils_1.default.getMergeQueuePromise();
     // Top-level undefined values are ignored
@@ -301,17 +348,35 @@ function mergeCollection(collectionKey, collection) {
         Logger.logInfo('mergeCollection() called with invalid or empty value. Skipping this update.');
         return Promise.resolve();
     }
-    const mergedCollection = collection;
+    let resultCollection = collection;
+    let resultCollectionKeys = Object.keys(resultCollection);
     // Confirm all the collection keys belong to the same parent
-    const mergedCollectionKeys = Object.keys(mergedCollection);
-    if (!OnyxUtils_1.default.doAllCollectionItemsBelongToSameParent(collectionKey, mergedCollectionKeys)) {
+    if (!OnyxUtils_1.default.doAllCollectionItemsBelongToSameParent(collectionKey, resultCollectionKeys)) {
         return Promise.resolve();
     }
+    const skippableCollectionMemberIDs = OnyxUtils_1.default.getSkippableCollectionMemberIDs();
+    if (skippableCollectionMemberIDs.size) {
+        resultCollection = resultCollectionKeys.reduce((result, key) => {
+            try {
+                const [, collectionMemberID] = OnyxUtils_1.default.splitCollectionMemberKey(key, collectionKey);
+                // If the collection member key is a skippable one we set its value to null.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? resultCollection[key] : null;
+            }
+            catch (_a) {
+                // Something went wrong during split, so we assign the data to result anyway.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = resultCollection[key];
+            }
+            return result;
+        }, {});
+    }
+    resultCollectionKeys = Object.keys(resultCollection);
     return OnyxUtils_1.default.getAllKeys()
         .then((persistedKeys) => {
         // Split to keys that exist in storage and keys that don't
-        const keys = mergedCollectionKeys.filter((key) => {
-            if (mergedCollection[key] === null) {
+        const keys = resultCollectionKeys.filter((key) => {
+            if (resultCollection[key] === null) {
                 OnyxUtils_1.default.remove(key);
                 return false;
             }
@@ -320,13 +385,13 @@ function mergeCollection(collectionKey, collection) {
         const existingKeys = keys.filter((key) => persistedKeys.has(key));
         const cachedCollectionForExistingKeys = OnyxUtils_1.default.getCachedCollection(collectionKey, existingKeys);
         const existingKeyCollection = existingKeys.reduce((obj, key) => {
-            const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(mergedCollection[key], cachedCollectionForExistingKeys[key]);
+            const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(resultCollection[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];
+            obj[key] = resultCollection[key];
             return obj;
         }, {});
         const newCollection = {};
@@ -334,7 +399,7 @@ function mergeCollection(collectionKey, collection) {
             if (persistedKeys.has(key)) {
                 return;
             }
-            newCollection[key] = mergedCollection[key];
+            newCollection[key] = resultCollection[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,
@@ -364,9 +429,9 @@ function mergeCollection(collectionKey, collection) {
             return OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(collectionKey, finalMergedCollection, previousCollection);
         });
         return Promise.all(promises)
-            .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, mergeCollection, collectionKey, mergedCollection))
+            .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, mergeCollection, collectionKey, resultCollection))
             .then(() => {
-            OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE_COLLECTION, undefined, mergedCollection);
+            OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE_COLLECTION, undefined, resultCollection);
             return promiseUpdate;
         });
     })
@@ -649,18 +714,38 @@ function update(data) {
  * @param collection Object collection keyed by individual collection member keys and values
  */
 function setCollection(collectionKey, collection) {
-    const newCollectionKeys = Object.keys(collection);
-    if (!OnyxUtils_1.default.doAllCollectionItemsBelongToSameParent(collectionKey, newCollectionKeys)) {
+    let resultCollection = collection;
+    let resultCollectionKeys = Object.keys(resultCollection);
+    // Confirm all the collection keys belong to the same parent
+    if (!OnyxUtils_1.default.doAllCollectionItemsBelongToSameParent(collectionKey, resultCollectionKeys)) {
         Logger.logAlert(`setCollection called with keys that do not belong to the same parent ${collectionKey}. Skipping this update.`);
         return Promise.resolve();
     }
+    const skippableCollectionMemberIDs = OnyxUtils_1.default.getSkippableCollectionMemberIDs();
+    if (skippableCollectionMemberIDs.size) {
+        resultCollection = resultCollectionKeys.reduce((result, key) => {
+            try {
+                const [, collectionMemberID] = OnyxUtils_1.default.splitCollectionMemberKey(key, collectionKey);
+                // If the collection member key is a skippable one we set its value to null.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? resultCollection[key] : null;
+            }
+            catch (_a) {
+                // Something went wrong during split, so we assign the data to result anyway.
+                // eslint-disable-next-line no-param-reassign
+                result[key] = resultCollection[key];
+            }
+            return result;
+        }, {});
+    }
+    resultCollectionKeys = Object.keys(resultCollection);
     return OnyxUtils_1.default.getAllKeys().then((persistedKeys) => {
-        const mutableCollection = Object.assign({}, collection);
+        const mutableCollection = Object.assign({}, resultCollection);
         persistedKeys.forEach((key) => {
             if (!key.startsWith(collectionKey)) {
                 return;
             }
-            if (newCollectionKeys.includes(key)) {
+            if (resultCollectionKeys.includes(key)) {
                 return;
             }
             mutableCollection[key] = null;

package/dist/OnyxUtils.d.ts

@@ -32,6 +32,14 @@ declare function getDeferredInitTask(): DeferredTask;
  * Getter - returns the eviction block list.
  */
 declare function getEvictionBlocklist(): Record<OnyxKey, string[] | undefined>;
+/**
+ * Getter - returns the skippable collection member IDs.
+ */
+declare function getSkippableCollectionMemberIDs(): Set<string>;
+/**
+ * Setter - sets the skippable collection member IDs.
+ */
+declare function setSkippableCollectionMemberIDs(ids: Set<string>): void;
 /**
  * Sets the initial values for the Onyx store
  *
@@ -76,10 +84,11 @@ declare function isCollectionMemberKey<TCollectionKey extends CollectionKeyBase>
 /**
  * Splits a collection member key into the collection key part and the ID part.
  * @param key - The collection member key to split.
+ * @param collectionKey - The collection key of the `key` param that can be passed in advance to optimize the function.
  * @returns A tuple where the first element is the collection part and the second element is the ID part,
  * or throws an Error if the key is not a collection one.
  */
-declare function splitCollectionMemberKey<TKey extends CollectionKey, CollectionKeyType = TKey extends `${infer Prefix}_${string}` ? `${Prefix}_` : never>(key: TKey): [CollectionKeyType, string];
+declare function splitCollectionMemberKey<TKey extends CollectionKey, CollectionKeyType = TKey extends `${infer Prefix}_${string}` ? `${Prefix}_` : never>(key: TKey, collectionKey?: string): [CollectionKeyType, string];
 /**
  * Checks to see if a provided key is the exact configured key of our connected subscriber
  * or if the provided key is a collection member key (in case our configured key is a "collection key")
@@ -277,6 +286,8 @@ declare const OnyxUtils: {
     subscribeToKey: typeof subscribeToKey;
     unsubscribeFromKey: typeof unsubscribeFromKey;
     getEvictionBlocklist: typeof getEvictionBlocklist;
+    getSkippableCollectionMemberIDs: typeof getSkippableCollectionMemberIDs;
+    setSkippableCollectionMemberIDs: typeof setSkippableCollectionMemberIDs;
 };
 export type { OnyxMethod };
 export default OnyxUtils;

package/dist/OnyxUtils.js

@@ -78,6 +78,8 @@ let snapshotKey = null;
 let lastSubscriptionID = 0;
 // Connections can be made before `Onyx.init`. They would wait for this task before resolving
 const deferredInitTask = (0, createDeferredTask_1.default)();
+// Holds a set of collection member IDs which updates will be ignored when using Onyx methods.
+let skippableCollectionMemberIDs = new Set();
 function getSnapshotKey() {
     return snapshotKey;
 }
@@ -111,6 +113,18 @@ function getDeferredInitTask() {
 function getEvictionBlocklist() {
     return evictionBlocklist;
 }
+/**
+ * Getter - returns the skippable collection member IDs.
+ */
+function getSkippableCollectionMemberIDs() {
+    return skippableCollectionMemberIDs;
+}
+/**
+ * Setter - sets the skippable collection member IDs.
+ */
+function setSkippableCollectionMemberIDs(ids) {
+    skippableCollectionMemberIDs = ids;
+}
 /**
  * Sets the initial values for the Onyx store
  *
@@ -198,6 +212,19 @@ function get(key) {
     // Otherwise retrieve the value from storage and capture a promise to aid concurrent usages
     const promise = storage_1.default.getItem(key)
         .then((val) => {
+        if (skippableCollectionMemberIDs.size) {
+            try {
+                const [, collectionMemberID] = splitCollectionMemberKey(key);
+                if (skippableCollectionMemberIDs.has(collectionMemberID)) {
+                    // The key is a skippable one, so we set the value to undefined.
+                    // eslint-disable-next-line no-param-reassign
+                    val = undefined;
+                }
+            }
+            catch (e) {
+                // The key is not a collection one or something went wrong during split, so we proceed with the function's logic.
+            }
+        }
         if (val === undefined) {
             OnyxCache_1.default.addNullishStorageKey(key);
             return undefined;
@@ -264,6 +291,18 @@ function multiGet(keys) {
         // temp object is used to merge the missing data into the cache
         const temp = {};
         values.forEach(([key, value]) => {
+            if (skippableCollectionMemberIDs.size) {
+                try {
+                    const [, collectionMemberID] = OnyxUtils.splitCollectionMemberKey(key);
+                    if (skippableCollectionMemberIDs.has(collectionMemberID)) {
+                        // The key is a skippable one, so we skip this iteration.
+                        return;
+                    }
+                }
+                catch (e) {
+                    // The key is not a collection one or something went wrong during split, so we proceed with the function's logic.
+                }
+            }
             dataMap.set(key, value);
             temp[key] = value;
         });
@@ -334,11 +373,18 @@ function isCollectionMemberKey(collectionKey, key, collectionKeyLength) {
 /**
  * Splits a collection member key into the collection key part and the ID part.
  * @param key - The collection member key to split.
+ * @param collectionKey - The collection key of the `key` param that can be passed in advance to optimize the function.
  * @returns A tuple where the first element is the collection part and the second element is the ID part,
  * or throws an Error if the key is not a collection one.
  */
-function splitCollectionMemberKey(key) {
-    const collectionKey = getCollectionKey(key);
+function splitCollectionMemberKey(key, collectionKey) {
+    if (collectionKey && !isCollectionMemberKey(collectionKey, key, collectionKey.length)) {
+        throw new Error(`Invalid '${collectionKey}' collection key provided, it isn't compatible with '${key}' key.`);
+    }
+    if (!collectionKey) {
+        // eslint-disable-next-line no-param-reassign
+        collectionKey = getCollectionKey(key);
+    }
     return [collectionKey, key.slice(collectionKey.length)];
 }
 /**
@@ -1162,6 +1208,8 @@ const OnyxUtils = {
     subscribeToKey,
     unsubscribeFromKey,
     getEvictionBlocklist,
+    getSkippableCollectionMemberIDs,
+    setSkippableCollectionMemberIDs,
 };
 GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) => {
     if (!enablePerformanceMetrics) {

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 import type { ConnectOptions, OnyxUpdate } from './Onyx';
 import Onyx from './Onyx';
 import type { CustomTypeOptions, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, Selector, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput } from './types';
-import type { FetchStatus, ResultMetadata, UseOnyxResult } from './useOnyx';
+import type { FetchStatus, ResultMetadata, UseOnyxResult, UseOnyxOptions } from './useOnyx';
 import type { Connection } from './OnyxConnectionManager';
 import useOnyx from './useOnyx';
 import withOnyx from './withOnyx';
 import type { WithOnyxState } from './withOnyx/types';
 export default Onyx;
 export { useOnyx, withOnyx };
-export type { ConnectOptions, CustomTypeOptions, FetchStatus, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, ResultMetadata, Selector, UseOnyxResult, WithOnyxState, Connection, };
+export type { ConnectOptions, CustomTypeOptions, FetchStatus, KeyValueMapping, NullishDeep, OnyxCollection, OnyxEntry, OnyxKey, OnyxInputValue, OnyxCollectionInputValue, OnyxInput, OnyxSetInput, OnyxMultiSetInput, OnyxMergeInput, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, ResultMetadata, Selector, UseOnyxResult, WithOnyxState, Connection, UseOnyxOptions, };

package/dist/types.d.ts

@@ -398,6 +398,11 @@ type InitOptions = {
      * @default false
      */
     enablePerformanceMetrics?: boolean;
+    /**
+     * Array of collection member IDs which updates will be ignored when using Onyx methods.
+     * Additionally, any subscribers from these keys to won't receive any data from Onyx.
+     */
+    skippableCollectionMemberIDs?: string[];
 };
 type GenericFunction = (...args: any[]) => any;
 /**

package/dist/useOnyx.d.ts

@@ -49,4 +49,4 @@ type UseOnyxResult<TValue> = [NonNullable<TValue> | undefined, ResultMetadata];
 declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: BaseUseOnyxOptions & UseOnyxInitialValueOption<TReturnValue> & Required<UseOnyxSelectorOption<TKey, TReturnValue>>, dependencies?: DependencyList): UseOnyxResult<TReturnValue>;
 declare function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey, options?: BaseUseOnyxOptions & UseOnyxInitialValueOption<NoInfer<TReturnValue>>, dependencies?: DependencyList): UseOnyxResult<TReturnValue>;
 export default useOnyx;
-export type { FetchStatus, ResultMetadata, UseOnyxResult, BaseUseOnyxOptions, UseOnyxSelector, UseOnyxSelectorOption, UseOnyxInitialValueOption, UseOnyxOptions };
+export type { FetchStatus, ResultMetadata, UseOnyxResult, UseOnyxOptions };

package/package.json

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