react-native-onyx 3.0.33 → 3.0.35

package/README.md

@@ -460,6 +460,25 @@ Onyx.init({
 });
 ```
 
+### Using RAM-only keys
+
+You can choose not to save certain keys on disk and keep them RAM-only, that way their values will reset with each session. You just have to pass an array of `ramOnlyKeys` to the `Onyx.init` method. You can mark entire collections as RAM-only by including the collection key (e.g., `ONYXKEYS.COLLECTION.TEMP_DATA`). This will make all members of that collection RAM-only. Individual collection member keys cannot be selectively marked as RAM-only.
+
+```javascript
+import Onyx from 'react-native-onyx';
+
+Onyx.init({
+    keys: ONYXKEYS,
+    ramOnlyKeys: [
+        ONYXKEYS.RAM_ONLY_KEY_1,
+        ONYXKEYS.RAM_ONLY_KEY_2,
+        ONYXKEYS.COLLECTION.TEMP_DATA,
+    ],
+});
+```
+
+> Note: RAM-only keys still consume memory and will remain in cache until explicitly cleared or until Onyx.clear() is called. Use them judiciously for truly ephemeral data.
+
 ### Usage
 
 The extension interface is pretty simple, on the left sidebar you can see all the updates made to the local storage, in ascending order, and on the right pane you can see the whole the current state, payload of an action and the diff between the previous state and the current state after the action was triggered.

package/dist/Onyx.d.ts

@@ -2,7 +2,7 @@ import * as Logger from './Logger';
 import type { CollectionKeyBase, ConnectOptions, InitOptions, OnyxKey, OnyxMergeCollectionInput, OnyxSetCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetInput, OnyxUpdate, SetOptions } from './types';
 import type { Connection } from './OnyxConnectionManager';
 /** Initialize the store with actions and listening for storage events */
-declare function init({ keys, initialKeyStates, evictableKeys, maxCachedKeysCount, shouldSyncMultipleInstances, enablePerformanceMetrics, enableDevTools, skippableCollectionMemberIDs, snapshotMergeKeys, }: InitOptions): void;
+declare function init({ keys, initialKeyStates, evictableKeys, maxCachedKeysCount, shouldSyncMultipleInstances, enablePerformanceMetrics, enableDevTools, skippableCollectionMemberIDs, ramOnlyKeys, snapshotMergeKeys, }: InitOptions): void;
 /**
  * Connects to an Onyx key given the options passed and listens to its changes.
  * This method will be deprecated soon. Please use `Onyx.connectWithoutView()` instead.

package/dist/Onyx.js

@@ -48,7 +48,7 @@ const GlobalSettings = __importStar(require("./GlobalSettings"));
 const metrics_1 = __importDefault(require("./metrics"));
 const OnyxMerge_1 = __importDefault(require("./OnyxMerge"));
 /** Initialize the store with actions and listening for storage events */
-function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = !!global.localStorage, enablePerformanceMetrics = false, enableDevTools = true, skippableCollectionMemberIDs = [], snapshotMergeKeys = [], }) {
+function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = !!global.localStorage, enablePerformanceMetrics = false, enableDevTools = true, skippableCollectionMemberIDs = [], ramOnlyKeys = [], snapshotMergeKeys = [], }) {
     var _a;
     if (enablePerformanceMetrics) {
         GlobalSettings.setPerformanceMetricsEnabled(true);
@@ -58,6 +58,7 @@ function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedK
     storage_1.default.init();
     OnyxUtils_1.default.setSkippableCollectionMemberIDs(new Set(skippableCollectionMemberIDs));
     OnyxUtils_1.default.setSnapshotMergeKeys(new Set(snapshotMergeKeys));
+    OnyxCache_1.default.setRamOnlyKeys(new Set(ramOnlyKeys));
     if (shouldSyncMultipleInstances) {
         (_a = storage_1.default.keepInstancesSync) === null || _a === void 0 ? void 0 : _a.call(storage_1.default, (key, value) => {
             OnyxCache_1.default.set(key, value);
@@ -150,7 +151,7 @@ function disconnect(connection) {
  * @param options optional configuration object
  */
 function set(key, value, options) {
-    return OnyxUtils_1.default.setWithRetry({ key, value, options });
+    return OnyxUtils_1.default.afterInit(() => OnyxUtils_1.default.setWithRetry({ key, value, options }));
 }
 /**
  * Sets multiple keys and values
@@ -160,7 +161,7 @@ function set(key, value, options) {
  * @param data object keyed by ONYXKEYS and the values to set
  */
 function multiSet(data) {
-    return OnyxUtils_1.default.multiSetWithRetry(data);
+    return OnyxUtils_1.default.afterInit(() => OnyxUtils_1.default.multiSetWithRetry(data));
 }
 /**
  * Merge a new value into an existing value at a key.
@@ -179,71 +180,73 @@ 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;
+    return OnyxUtils_1.default.afterInit(() => {
+        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.
             }
         }
-        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
+        // Therefore, we need to prevent adding them to the merge queue
+        if (changes === undefined) {
+            return mergeQueue[key] ? mergeQueuePromise[key] : Promise.resolve();
         }
-    }
-    const mergeQueue = OnyxUtils_1.default.getMergeQueue();
-    const mergeQueuePromise = OnyxUtils_1.default.getMergeQueuePromise();
-    // Top-level undefined values are ignored
-    // Therefore, we need to prevent adding them to the merge queue
-    if (changes === undefined) {
-        return mergeQueue[key] ? mergeQueuePromise[key] : Promise.resolve();
-    }
-    // Merge attempts are batched together. The delta should be applied after a single call to get() to prevent a race condition.
-    // Using the initial value from storage in subsequent merge attempts will lead to an incorrect final merged value.
-    if (mergeQueue[key]) {
-        mergeQueue[key].push(changes);
-        return mergeQueuePromise[key];
-    }
-    mergeQueue[key] = [changes];
-    mergeQueuePromise[key] = OnyxUtils_1.default.get(key).then((existingValue) => {
-        // Calls to Onyx.set after a merge will terminate the current merge process and clear the merge queue
-        if (mergeQueue[key] == null) {
-            return Promise.resolve();
+        // Merge attempts are batched together. The delta should be applied after a single call to get() to prevent a race condition.
+        // Using the initial value from storage in subsequent merge attempts will lead to an incorrect final merged value.
+        if (mergeQueue[key]) {
+            mergeQueue[key].push(changes);
+            return mergeQueuePromise[key];
         }
-        try {
-            const validChanges = mergeQueue[key].filter((change) => {
-                const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(change, existingValue);
-                if (!isCompatible) {
-                    Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'merge', existingValueType, newValueType));
-                }
-                return isCompatible;
-            });
-            // Clean up the write queue, so we don't apply these changes again.
-            delete mergeQueue[key];
-            delete mergeQueuePromise[key];
-            if (!validChanges.length) {
+        mergeQueue[key] = [changes];
+        mergeQueuePromise[key] = OnyxUtils_1.default.get(key).then((existingValue) => {
+            // Calls to Onyx.set after a merge will terminate the current merge process and clear the merge queue
+            if (mergeQueue[key] == null) {
                 return Promise.resolve();
             }
-            // If the last change is null, we can just delete the key.
-            // Therefore, we don't need to further broadcast and update the value so we can return early.
-            if (validChanges.at(-1) === null) {
-                OnyxUtils_1.default.remove(key);
-                OnyxUtils_1.default.logKeyRemoved(OnyxUtils_1.default.METHOD.MERGE, key);
+            try {
+                const validChanges = mergeQueue[key].filter((change) => {
+                    const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(change, existingValue);
+                    if (!isCompatible) {
+                        Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'merge', existingValueType, newValueType));
+                    }
+                    return isCompatible;
+                });
+                // Clean up the write queue, so we don't apply these changes again.
+                delete mergeQueue[key];
+                delete mergeQueuePromise[key];
+                if (!validChanges.length) {
+                    return Promise.resolve();
+                }
+                // If the last change is null, we can just delete the key.
+                // Therefore, we don't need to further broadcast and update the value so we can return early.
+                if (validChanges.at(-1) === null) {
+                    OnyxUtils_1.default.remove(key);
+                    OnyxUtils_1.default.logKeyRemoved(OnyxUtils_1.default.METHOD.MERGE, key);
+                    return Promise.resolve();
+                }
+                return OnyxMerge_1.default.applyMerge(key, existingValue, validChanges).then(({ mergedValue, updatePromise }) => {
+                    OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE, key, changes, mergedValue);
+                    return updatePromise;
+                });
+            }
+            catch (error) {
+                Logger.logAlert(`An error occurred while applying merge for key: ${key}, Error: ${error}`);
                 return Promise.resolve();
             }
-            return OnyxMerge_1.default.applyMerge(key, existingValue, validChanges).then(({ mergedValue, updatePromise }) => {
-                OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE, key, changes, mergedValue);
-                return updatePromise;
-            });
-        }
-        catch (error) {
-            Logger.logAlert(`An error occurred while applying merge for key: ${key}, Error: ${error}`);
-            return Promise.resolve();
-        }
+        });
+        return mergeQueuePromise[key];
     });
-    return mergeQueuePromise[key];
 }
 /**
  * Merges a collection based on their keys.
@@ -259,7 +262,7 @@ function merge(key, changes) {
  * @param collection Object collection keyed by individual collection member keys and values
  */
 function mergeCollection(collectionKey, collection) {
-    return OnyxUtils_1.default.mergeCollectionWithPatches({ collectionKey, collection, isProcessingCollectionUpdate: true });
+    return OnyxUtils_1.default.afterInit(() => OnyxUtils_1.default.mergeCollectionWithPatches({ collectionKey, collection, isProcessingCollectionUpdate: true }));
 }
 /**
  * Clear out all the data in the store
@@ -283,90 +286,93 @@ function mergeCollection(collectionKey, collection) {
  * @param keysToPreserve is a list of ONYXKEYS that should not be cleared with the rest of the data
  */
 function clear(keysToPreserve = []) {
-    const defaultKeyStates = OnyxUtils_1.default.getDefaultKeyStates();
-    const initialKeys = Object.keys(defaultKeyStates);
-    const promise = OnyxUtils_1.default.getAllKeys()
-        .then((cachedKeys) => {
-        var _a;
-        OnyxCache_1.default.clearNullishStorageKeys();
-        const keysToBeClearedFromStorage = [];
-        const keyValuesToResetIndividually = {};
-        // We need to store old and new values for collection keys to properly notify subscribers when clearing Onyx
-        // because the notification process needs the old values in cache but at that point they will be already removed from it.
-        const keyValuesToResetAsCollection = {};
-        const allKeys = new Set([...cachedKeys, ...initialKeys]);
-        // The only keys that should not be cleared are:
-        // 1. Anything specifically passed in keysToPreserve (because some keys like language preferences, offline
-        //      status, or activeClients need to remain in Onyx even when signed out)
-        // 2. Any keys with a default state (because they need to remain in Onyx as their default, and setting them
-        //      to null would cause unknown behavior)
-        //   2.1 However, if a default key was explicitly set to null, we need to reset it to the default value
-        for (const key of allKeys) {
-            const isKeyToPreserve = keysToPreserve.includes(key);
-            const isDefaultKey = key in defaultKeyStates;
-            // If the key is being removed or reset to default:
-            // 1. Update it in the cache
-            // 2. Figure out whether it is a collection key or not,
-            //      since collection key subscribers need to be updated differently
-            if (!isKeyToPreserve) {
-                const oldValue = OnyxCache_1.default.get(key);
-                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;
-                    }
-                    if (collectionKey) {
-                        if (!keyValuesToResetAsCollection[collectionKey]) {
-                            keyValuesToResetAsCollection[collectionKey] = { oldValues: {}, newValues: {} };
+    return OnyxUtils_1.default.afterInit(() => {
+        const defaultKeyStates = OnyxUtils_1.default.getDefaultKeyStates();
+        const initialKeys = Object.keys(defaultKeyStates);
+        const promise = OnyxUtils_1.default.getAllKeys()
+            .then((cachedKeys) => {
+            var _a;
+            OnyxCache_1.default.clearNullishStorageKeys();
+            const keysToBeClearedFromStorage = [];
+            const keyValuesToResetIndividually = {};
+            // We need to store old and new values for collection keys to properly notify subscribers when clearing Onyx
+            // because the notification process needs the old values in cache but at that point they will be already removed from it.
+            const keyValuesToResetAsCollection = {};
+            const allKeys = new Set([...cachedKeys, ...initialKeys]);
+            // The only keys that should not be cleared are:
+            // 1. Anything specifically passed in keysToPreserve (because some keys like language preferences, offline
+            //      status, or activeClients need to remain in Onyx even when signed out)
+            // 2. Any keys with a default state (because they need to remain in Onyx as their default, and setting them
+            //      to null would cause unknown behavior)
+            //   2.1 However, if a default key was explicitly set to null, we need to reset it to the default value
+            for (const key of allKeys) {
+                const isKeyToPreserve = keysToPreserve.includes(key);
+                const isDefaultKey = key in defaultKeyStates;
+                // If the key is being removed or reset to default:
+                // 1. Update it in the cache
+                // 2. Figure out whether it is a collection key or not,
+                //      since collection key subscribers need to be updated differently
+                if (!isKeyToPreserve) {
+                    const oldValue = OnyxCache_1.default.get(key);
+                    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;
+                        }
+                        if (collectionKey) {
+                            if (!keyValuesToResetAsCollection[collectionKey]) {
+                                keyValuesToResetAsCollection[collectionKey] = { oldValues: {}, newValues: {} };
+                            }
+                            keyValuesToResetAsCollection[collectionKey].oldValues[key] = oldValue;
+                            keyValuesToResetAsCollection[collectionKey].newValues[key] = newValue !== null && newValue !== void 0 ? newValue : undefined;
+                        }
+                        else {
+                            keyValuesToResetIndividually[key] = newValue !== null && newValue !== void 0 ? newValue : undefined;
                         }
-                        keyValuesToResetAsCollection[collectionKey].oldValues[key] = oldValue;
-                        keyValuesToResetAsCollection[collectionKey].newValues[key] = newValue !== null && newValue !== void 0 ? newValue : undefined;
-                    }
-                    else {
-                        keyValuesToResetIndividually[key] = newValue !== null && newValue !== void 0 ? newValue : undefined;
                     }
                 }
+                if (isKeyToPreserve || isDefaultKey) {
+                    continue;
+                }
+                // If it isn't preserved and doesn't have a default, we'll remove it
+                keysToBeClearedFromStorage.push(key);
             }
-            if (isKeyToPreserve || isDefaultKey) {
-                continue;
+            const updatePromises = [];
+            // Notify the subscribers for each key/value group so they can receive the new values
+            for (const [key, value] of Object.entries(keyValuesToResetIndividually)) {
+                updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value));
             }
-            // If it isn't preserved and doesn't have a default, we'll remove it
-            keysToBeClearedFromStorage.push(key);
-        }
-        const updatePromises = [];
-        // Notify the subscribers for each key/value group so they can receive the new values
-        for (const [key, value] of Object.entries(keyValuesToResetIndividually)) {
-            updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value));
-        }
-        for (const [key, value] of Object.entries(keyValuesToResetAsCollection)) {
-            updatePromises.push(OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(key, value.newValues, value.oldValues));
-        }
-        const defaultKeyValuePairs = Object.entries(Object.keys(defaultKeyStates)
-            .filter((key) => !keysToPreserve.includes(key))
-            .reduce((obj, key) => {
-            // eslint-disable-next-line no-param-reassign
-            obj[key] = defaultKeyStates[key];
-            return obj;
-        }, {}));
-        // Remove only the items that we want cleared from storage, and reset others to default
-        for (const key of keysToBeClearedFromStorage)
-            OnyxCache_1.default.drop(key);
-        return storage_1.default.removeItems(keysToBeClearedFromStorage)
-            .then(() => OnyxConnectionManager_1.default.refreshSessionID())
-            .then(() => storage_1.default.multiSet(defaultKeyValuePairs))
-            .then(() => {
-            DevTools_1.default.clearState(keysToPreserve);
-            return Promise.all(updatePromises);
-        });
-    })
-        .then(() => undefined);
-    return OnyxCache_1.default.captureTask(OnyxCache_1.TASK.CLEAR, promise);
+            for (const [key, value] of Object.entries(keyValuesToResetAsCollection)) {
+                updatePromises.push(OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(key, value.newValues, value.oldValues));
+            }
+            // Exclude RAM-only keys to prevent them from being saved to storage
+            const defaultKeyValuePairs = Object.entries(Object.keys(defaultKeyStates)
+                .filter((key) => !keysToPreserve.includes(key) && !OnyxUtils_1.default.isRamOnlyKey(key))
+                .reduce((obj, key) => {
+                // eslint-disable-next-line no-param-reassign
+                obj[key] = defaultKeyStates[key];
+                return obj;
+            }, {}));
+            // Remove only the items that we want cleared from storage, and reset others to default
+            for (const key of keysToBeClearedFromStorage)
+                OnyxCache_1.default.drop(key);
+            return storage_1.default.removeItems(keysToBeClearedFromStorage)
+                .then(() => OnyxConnectionManager_1.default.refreshSessionID())
+                .then(() => storage_1.default.multiSet(defaultKeyValuePairs))
+                .then(() => {
+                DevTools_1.default.clearState(keysToPreserve);
+                return Promise.all(updatePromises);
+            });
+        })
+            .then(() => undefined);
+        return OnyxCache_1.default.captureTask(OnyxCache_1.TASK.CLEAR, promise);
+    });
 }
 /**
  * Insert API responses and lifecycle data into Onyx
@@ -375,132 +381,132 @@ function clear(keysToPreserve = []) {
  * @returns resolves when all operations are complete
  */
 function update(data) {
-    // First, validate the Onyx object is in the format we expect
-    for (const { onyxMethod, key, value } of data) {
-        if (!Object.values(OnyxUtils_1.default.METHOD).includes(onyxMethod)) {
-            throw new Error(`Invalid onyxMethod ${onyxMethod} in Onyx update.`);
-        }
-        if (onyxMethod === OnyxUtils_1.default.METHOD.MULTI_SET) {
-            // For multiset, we just expect the value to be an object
-            if (typeof value !== 'object' || Array.isArray(value) || typeof value === 'function') {
-                throw new Error('Invalid value provided in Onyx multiSet. Onyx multiSet value must be of type object.');
+    return OnyxUtils_1.default.afterInit(() => {
+        // The queue of operations within a single `update` call in the format of <item key - list of operations updating the item>.
+        // This allows us to batch the operations per item and merge them into one operation in the order they were requested.
+        const updateQueue = {};
+        const enqueueSetOperation = (key, value) => {
+            // If a `set` operation is enqueued, we should clear the whole queue.
+            // Since the `set` operation replaces the value entirely, there's no need to perform any previous operations.
+            // To do this, we first put `null` in the queue, which removes the existing value, and then merge the new value.
+            updateQueue[key] = [null, value];
+        };
+        const enqueueMergeOperation = (key, value) => {
+            if (value === null) {
+                // If we merge `null`, the value is removed and all the previous operations are discarded.
+                updateQueue[key] = [null];
+            }
+            else if (!updateQueue[key]) {
+                updateQueue[key] = [value];
+            }
+            else {
+                updateQueue[key].push(value);
             }
-        }
-        else if (onyxMethod !== OnyxUtils_1.default.METHOD.CLEAR && typeof key !== 'string') {
-            throw new Error(`Invalid ${typeof key} key provided in Onyx update. Onyx key must be of type string.`);
-        }
-    }
-    // The queue of operations within a single `update` call in the format of <item key - list of operations updating the item>.
-    // This allows us to batch the operations per item and merge them into one operation in the order they were requested.
-    const updateQueue = {};
-    const enqueueSetOperation = (key, value) => {
-        // If a `set` operation is enqueued, we should clear the whole queue.
-        // Since the `set` operation replaces the value entirely, there's no need to perform any previous operations.
-        // To do this, we first put `null` in the queue, which removes the existing value, and then merge the new value.
-        updateQueue[key] = [null, value];
-    };
-    const enqueueMergeOperation = (key, value) => {
-        if (value === null) {
-            // If we merge `null`, the value is removed and all the previous operations are discarded.
-            updateQueue[key] = [null];
-        }
-        else if (!updateQueue[key]) {
-            updateQueue[key] = [value];
-        }
-        else {
-            updateQueue[key].push(value);
-        }
-    };
-    const promises = [];
-    let clearPromise = Promise.resolve();
-    for (const { onyxMethod, key, value } of data) {
-        const handlers = {
-            [OnyxUtils_1.default.METHOD.SET]: enqueueSetOperation,
-            [OnyxUtils_1.default.METHOD.MERGE]: enqueueMergeOperation,
-            [OnyxUtils_1.default.METHOD.MERGE_COLLECTION]: () => {
-                const collection = value;
-                if (!OnyxUtils_1.default.isValidNonEmptyCollectionForMerge(collection)) {
-                    Logger.logInfo('mergeCollection enqueued within update() with invalid or empty value. Skipping this operation.');
-                    return;
-                }
-                // Confirm all the collection keys belong to the same parent
-                const collectionKeys = Object.keys(collection);
-                if (OnyxUtils_1.default.doAllCollectionItemsBelongToSameParent(key, collectionKeys)) {
-                    const mergedCollection = collection;
-                    for (const collectionKey of collectionKeys)
-                        enqueueMergeOperation(collectionKey, mergedCollection[collectionKey]);
-                }
-            },
-            [OnyxUtils_1.default.METHOD.SET_COLLECTION]: (k, v) => promises.push(() => setCollection(k, v)),
-            [OnyxUtils_1.default.METHOD.MULTI_SET]: (k, v) => {
-                for (const [entryKey, entryValue] of Object.entries(v))
-                    enqueueSetOperation(entryKey, entryValue);
-            },
-            [OnyxUtils_1.default.METHOD.CLEAR]: () => {
-                clearPromise = clear();
-            },
         };
-        handlers[onyxMethod](key, value);
-    }
-    // Group all the collection-related keys and update each collection in a single `mergeCollection` call.
-    // This is needed to prevent multiple `mergeCollection` calls for the same collection and `merge` calls for the individual items of the said collection.
-    // This way, we ensure there is no race condition in the queued updates of the same key.
-    for (const collectionKey of OnyxUtils_1.default.getCollectionKeys()) {
-        const collectionItemKeys = Object.keys(updateQueue).filter((key) => OnyxUtils_1.default.isKeyMatch(collectionKey, key));
-        if (collectionItemKeys.length <= 1) {
-            // If there are no items of this collection in the updateQueue, we should skip it.
-            // If there is only one item, we should update it individually, therefore retain it in the updateQueue.
-            continue;
+        const promises = [];
+        let clearPromise = Promise.resolve();
+        const onyxMethods = Object.values(OnyxUtils_1.default.METHOD);
+        for (const { onyxMethod, key, value } of data) {
+            if (!onyxMethods.includes(onyxMethod)) {
+                Logger.logInfo(`Invalid onyxMethod ${onyxMethod} in Onyx update. Skipping this operation.`);
+                continue;
+            }
+            if (onyxMethod !== OnyxUtils_1.default.METHOD.CLEAR && onyxMethod !== OnyxUtils_1.default.METHOD.MULTI_SET && typeof key !== 'string') {
+                Logger.logInfo(`Invalid ${typeof key} key provided in Onyx update. Key must be of type string. Skipping this operation.`);
+                continue;
+            }
+            const handlers = {
+                [OnyxUtils_1.default.METHOD.SET]: enqueueSetOperation,
+                [OnyxUtils_1.default.METHOD.MERGE]: enqueueMergeOperation,
+                [OnyxUtils_1.default.METHOD.MERGE_COLLECTION]: () => {
+                    const collection = value;
+                    if (!OnyxUtils_1.default.isValidNonEmptyCollectionForMerge(collection)) {
+                        Logger.logInfo('Invalid or empty value provided in Onyx mergeCollection. Skipping this operation.');
+                        return;
+                    }
+                    // Confirm all the collection keys belong to the same parent
+                    const collectionKeys = Object.keys(collection);
+                    if (OnyxUtils_1.default.doAllCollectionItemsBelongToSameParent(key, collectionKeys)) {
+                        const mergedCollection = collection;
+                        for (const collectionKey of collectionKeys)
+                            enqueueMergeOperation(collectionKey, mergedCollection[collectionKey]);
+                    }
+                },
+                [OnyxUtils_1.default.METHOD.SET_COLLECTION]: (k, v) => promises.push(() => setCollection(k, v)),
+                [OnyxUtils_1.default.METHOD.MULTI_SET]: (k, v) => {
+                    if (typeof value !== 'object' || Array.isArray(value) || typeof value === 'function') {
+                        Logger.logInfo(`Invalid value provided in Onyx multiSet. Value must be of type object. Skipping this operation.`);
+                        return;
+                    }
+                    for (const [entryKey, entryValue] of Object.entries(v))
+                        enqueueSetOperation(entryKey, entryValue);
+                },
+                [OnyxUtils_1.default.METHOD.CLEAR]: () => {
+                    clearPromise = clear();
+                },
+            };
+            handlers[onyxMethod](key, value);
         }
-        const batchedCollectionUpdates = collectionItemKeys.reduce((queue, key) => {
-            const operations = updateQueue[key];
-            // Remove the collection-related key from the updateQueue so that it won't be processed individually.
-            delete updateQueue[key];
-            const batchedChanges = OnyxUtils_1.default.mergeAndMarkChanges(operations);
-            if (operations[0] === null) {
-                // eslint-disable-next-line no-param-reassign
-                queue.set[key] = batchedChanges.result;
+        // Group all the collection-related keys and update each collection in a single `mergeCollection` call.
+        // This is needed to prevent multiple `mergeCollection` calls for the same collection and `merge` calls for the individual items of the said collection.
+        // This way, we ensure there is no race condition in the queued updates of the same key.
+        for (const collectionKey of OnyxUtils_1.default.getCollectionKeys()) {
+            const collectionItemKeys = Object.keys(updateQueue).filter((key) => OnyxUtils_1.default.isKeyMatch(collectionKey, key));
+            if (collectionItemKeys.length <= 1) {
+                // If there are no items of this collection in the updateQueue, we should skip it.
+                // If there is only one item, we should update it individually, therefore retain it in the updateQueue.
+                continue;
             }
-            else {
-                // eslint-disable-next-line no-param-reassign
-                queue.merge[key] = batchedChanges.result;
-                if (batchedChanges.replaceNullPatches.length > 0) {
+            const batchedCollectionUpdates = collectionItemKeys.reduce((queue, key) => {
+                const operations = updateQueue[key];
+                // Remove the collection-related key from the updateQueue so that it won't be processed individually.
+                delete updateQueue[key];
+                const batchedChanges = OnyxUtils_1.default.mergeAndMarkChanges(operations);
+                if (operations[0] === null) {
+                    // eslint-disable-next-line no-param-reassign
+                    queue.set[key] = batchedChanges.result;
+                }
+                else {
                     // eslint-disable-next-line no-param-reassign
-                    queue.mergeReplaceNullPatches[key] = batchedChanges.replaceNullPatches;
+                    queue.merge[key] = batchedChanges.result;
+                    if (batchedChanges.replaceNullPatches.length > 0) {
+                        // eslint-disable-next-line no-param-reassign
+                        queue.mergeReplaceNullPatches[key] = batchedChanges.replaceNullPatches;
+                    }
                 }
+                return queue;
+            }, {
+                merge: {},
+                mergeReplaceNullPatches: {},
+                set: {},
+            });
+            if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.merge)) {
+                promises.push(() => OnyxUtils_1.default.mergeCollectionWithPatches({
+                    collectionKey,
+                    collection: batchedCollectionUpdates.merge,
+                    mergeReplaceNullPatches: batchedCollectionUpdates.mergeReplaceNullPatches,
+                    isProcessingCollectionUpdate: true,
+                }));
+            }
+            if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.set)) {
+                promises.push(() => OnyxUtils_1.default.partialSetCollection({ collectionKey, collection: batchedCollectionUpdates.set }));
             }
-            return queue;
-        }, {
-            merge: {},
-            mergeReplaceNullPatches: {},
-            set: {},
-        });
-        if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.merge)) {
-            promises.push(() => OnyxUtils_1.default.mergeCollectionWithPatches({
-                collectionKey,
-                collection: batchedCollectionUpdates.merge,
-                mergeReplaceNullPatches: batchedCollectionUpdates.mergeReplaceNullPatches,
-                isProcessingCollectionUpdate: true,
-            }));
-        }
-        if (!utils_1.default.isEmptyObject(batchedCollectionUpdates.set)) {
-            promises.push(() => OnyxUtils_1.default.partialSetCollection({ collectionKey, collection: batchedCollectionUpdates.set }));
-        }
-    }
-    for (const [key, operations] of Object.entries(updateQueue)) {
-        if (operations[0] === null) {
-            const batchedChanges = OnyxUtils_1.default.mergeChanges(operations).result;
-            promises.push(() => set(key, batchedChanges));
-            continue;
         }
-        for (const operation of operations) {
-            promises.push(() => merge(key, operation));
+        for (const [key, operations] of Object.entries(updateQueue)) {
+            if (operations[0] === null) {
+                const batchedChanges = OnyxUtils_1.default.mergeChanges(operations).result;
+                promises.push(() => set(key, batchedChanges));
+                continue;
+            }
+            for (const operation of operations) {
+                promises.push(() => merge(key, operation));
+            }
         }
-    }
-    const snapshotPromises = OnyxUtils_1.default.updateSnapshots(data, merge);
-    // We need to run the snapshot updates before the other updates so the snapshot data can be updated before the loading state in the snapshot
-    const finalPromises = snapshotPromises.concat(promises);
-    return clearPromise.then(() => Promise.all(finalPromises.map((p) => p()))).then(() => undefined);
+        const snapshotPromises = OnyxUtils_1.default.updateSnapshots(data, merge);
+        // We need to run the snapshot updates before the other updates so the snapshot data can be updated before the loading state in the snapshot
+        const finalPromises = snapshotPromises.concat(promises);
+        return clearPromise.then(() => Promise.all(finalPromises.map((p) => p()))).then(() => undefined);
+    });
 }
 /**
  * Sets a collection by replacing all existing collection members with new values.
@@ -516,7 +522,7 @@ function update(data) {
  * @param collection Object collection keyed by individual collection member keys and values
  */
 function setCollection(collectionKey, collection) {
-    return OnyxUtils_1.default.setCollectionWithRetry({ collectionKey, collection });
+    return OnyxUtils_1.default.afterInit(() => OnyxUtils_1.default.setCollectionWithRetry({ collectionKey, collection }));
 }
 const Onyx = {
     METHOD: OnyxUtils_1.default.METHOD,

package/dist/OnyxCache.d.ts

@@ -36,6 +36,8 @@ declare class OnyxCache {
     private recentlyAccessedKeys;
     /** Set of collection keys for fast lookup */
     private collectionKeys;
+    /** Set of RAM-only keys for fast lookup */
+    private ramOnlyKeys;
     constructor();
     /** Get all the storage keys */
     getAllKeys(): Set<OnyxKey>;
@@ -165,6 +167,14 @@ declare class OnyxCache {
      * Get all data for a collection key
      */
     getCollectionData(collectionKey: OnyxKey): Record<OnyxKey, OnyxValue<OnyxKey>> | undefined;
+    /**
+     * Set the RAM-only keys for optimized storage
+     */
+    setRamOnlyKeys(ramOnlyKeys: Set<OnyxKey>): void;
+    /**
+     * Check if a key is a RAM-only key
+     */
+    isRamOnlyKey(key: OnyxKey): boolean;
 }
 declare const instance: OnyxCache;
 export default instance;

package/dist/OnyxCache.js

@@ -64,6 +64,8 @@ class OnyxCache {
         this.recentlyAccessedKeys = new Set();
         /** Set of collection keys for fast lookup */
         this.collectionKeys = new Set();
+        /** Set of RAM-only keys for fast lookup */
+        this.ramOnlyKeys = new Set();
         this.storageKeys = new Set();
         this.nullishStorageKeys = new Set();
         this.recentKeys = new Set();
@@ -71,7 +73,7 @@ class OnyxCache {
         this.collectionData = {};
         this.pendingPromises = new Map();
         // bind all public methods to prevent problems with `this`
-        (0, bindAll_1.default)(this, 'getAllKeys', 'get', 'hasCacheForKey', 'addKey', 'addNullishStorageKey', 'hasNullishStorageKey', 'clearNullishStorageKeys', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'addToAccessedKeys', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit', 'setAllKeys', 'setEvictionAllowList', 'getEvictionBlocklist', 'isEvictableKey', 'removeLastAccessedKey', 'addLastAccessedKey', 'addEvictableKeysToRecentlyAccessedList', 'getKeyForEviction', 'setCollectionKeys', 'isCollectionKey', 'getCollectionKey', 'getCollectionData');
+        (0, bindAll_1.default)(this, 'getAllKeys', 'get', 'hasCacheForKey', 'addKey', 'addNullishStorageKey', 'hasNullishStorageKey', 'clearNullishStorageKeys', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'addToAccessedKeys', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit', 'setAllKeys', 'setEvictionAllowList', 'getEvictionBlocklist', 'isEvictableKey', 'removeLastAccessedKey', 'addLastAccessedKey', 'addEvictableKeysToRecentlyAccessedList', 'getKeyForEviction', 'setCollectionKeys', 'isCollectionKey', 'getCollectionKey', 'getCollectionData', 'setRamOnlyKeys', 'isRamOnlyKey');
     }
     /** Get all the storage keys */
     getAllKeys() {
@@ -394,6 +396,18 @@ class OnyxCache {
         // Return a shallow copy to ensure React detects changes when items are added/removed
         return Object.assign({}, cachedCollection);
     }
+    /**
+     * Set the RAM-only keys for optimized storage
+     */
+    setRamOnlyKeys(ramOnlyKeys) {
+        this.ramOnlyKeys = ramOnlyKeys;
+    }
+    /**
+     * Check if a key is a RAM-only key
+     */
+    isRamOnlyKey(key) {
+        return this.ramOnlyKeys.has(key);
+    }
 }
 const instance = new OnyxCache();
 exports.default = instance;

package/dist/OnyxMerge/index.js

@@ -14,8 +14,10 @@ const applyMerge = (key, existingValue, validChanges) => {
     OnyxUtils_1.default.logKeyChanged(OnyxUtils_1.default.METHOD.MERGE, key, mergedValue, hasChanged);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
     const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
+    const shouldSkipStorageOperations = !hasChanged || OnyxUtils_1.default.isRamOnlyKey(key);
     // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
-    if (!hasChanged) {
+    // If the key is marked as RAM-only, it should not be saved nor updated in the storage.
+    if (shouldSkipStorageOperations) {
         return Promise.resolve({ mergedValue, updatePromise });
     }
     // For web platforms we use `setItem` since the object was already merged with its changes before.

package/dist/OnyxMerge/index.native.js

@@ -20,8 +20,10 @@ const applyMerge = (key, existingValue, validChanges) => {
     OnyxUtils_1.default.logKeyChanged(OnyxUtils_1.default.METHOD.MERGE, key, mergedValue, hasChanged);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
     const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
+    const shouldSkipStorageOperations = !hasChanged || OnyxUtils_1.default.isRamOnlyKey(key);
     // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
-    if (!hasChanged) {
+    // If the key is marked as RAM-only, it should not be saved nor updated in the storage.
+    if (shouldSkipStorageOperations) {
         return Promise.resolve({ mergedValue, updatePromise });
     }
     // For native platforms we use `mergeItem` that will take advantage of JSON_PATCH and JSON_REPLACE SQL operations to

package/dist/OnyxUtils.d.ts

@@ -30,6 +30,15 @@ declare function getDefaultKeyStates(): Record<OnyxKey, OnyxValue<OnyxKey>>;
  * Getter - returns the deffered init task.
  */
 declare function getDeferredInitTask(): DeferredTask;
+/**
+ * Executes an action after Onyx has been initialized.
+ * If Onyx is already initialized, the action is executed immediately.
+ * Otherwise, it waits for initialization to complete before executing.
+ *
+ * @param action The action to execute after initialization
+ * @returns The result of the action
+ */
+declare function afterInit<T>(action: () => Promise<T>): Promise<T>;
 /**
  * Getter - returns the skippable collection member IDs.
  */
@@ -113,6 +122,24 @@ declare function isCollectionMemberKey<TCollectionKey extends CollectionKeyBase>
  * @returns true if the key is a collection member, false otherwise
  */
 declare function isCollectionMember(key: OnyxKey): boolean;
+/**
+ * Checks if a given key is a RAM-only key, RAM-only collection key, or a RAM-only collection member
+ *
+ * For example:
+ *
+ * For the following Onyx setup
+ *
+ * ramOnlyKeys: ["ramOnlyKey", "ramOnlyCollection_"]
+ *
+ * - `isRamOnlyKey("ramOnlyKey")` would return true
+ * - `isRamOnlyKey("ramOnlyCollection_")` would return true
+ * - `isRamOnlyKey("ramOnlyCollection_1")` would return true
+ * - `isRamOnlyKey("someOtherKey")` would return false
+ *
+ * @param key - The key to check
+ * @returns true if key is a RAM-only key, RAM-only collection key, or a RAM-only collection member
+ */
+declare function isRamOnlyKey(key: OnyxKey): boolean;
 /**
  * Splits a collection member key into the collection key part and the ID part.
  * @param key - The collection member key to split.
@@ -325,6 +352,7 @@ declare const OnyxUtils: {
     getMergeQueuePromise: typeof getMergeQueuePromise;
     getDefaultKeyStates: typeof getDefaultKeyStates;
     getDeferredInitTask: typeof getDeferredInitTask;
+    afterInit: typeof afterInit;
     initStoreValues: typeof initStoreValues;
     sendActionToDevTools: typeof sendActionToDevTools;
     get: typeof get;
@@ -376,6 +404,7 @@ declare const OnyxUtils: {
     setWithRetry: typeof setWithRetry;
     multiSetWithRetry: typeof multiSetWithRetry;
     setCollectionWithRetry: typeof setCollectionWithRetry;
+    isRamOnlyKey: typeof isRamOnlyKey;
 };
 export type { OnyxMethod };
 export default OnyxUtils;

package/dist/OnyxUtils.js

@@ -122,6 +122,20 @@ function getDefaultKeyStates() {
 function getDeferredInitTask() {
     return deferredInitTask;
 }
+/**
+ * Executes an action after Onyx has been initialized.
+ * If Onyx is already initialized, the action is executed immediately.
+ * Otherwise, it waits for initialization to complete before executing.
+ *
+ * @param action The action to execute after initialization
+ * @returns The result of the action
+ */
+function afterInit(action) {
+    if (deferredInitTask.isResolved) {
+        return action();
+    }
+    return deferredInitTask.promise.then(action);
+}
 /**
  * Getter - returns the skippable collection member IDs.
  */
@@ -385,6 +399,34 @@ function isCollectionMember(key) {
         return false;
     }
 }
+/**
+ * Checks if a given key is a RAM-only key, RAM-only collection key, or a RAM-only collection member
+ *
+ * For example:
+ *
+ * For the following Onyx setup
+ *
+ * ramOnlyKeys: ["ramOnlyKey", "ramOnlyCollection_"]
+ *
+ * - `isRamOnlyKey("ramOnlyKey")` would return true
+ * - `isRamOnlyKey("ramOnlyCollection_")` would return true
+ * - `isRamOnlyKey("ramOnlyCollection_1")` would return true
+ * - `isRamOnlyKey("someOtherKey")` would return false
+ *
+ * @param key - The key to check
+ * @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
+        return OnyxCache_1.default.isRamOnlyKey(collectionKey);
+    }
+    catch (_a) {
+        // If getCollectionKey throws, the key is not a collection member
+    }
+    return OnyxCache_1.default.isRamOnlyKey(key);
+}
 /**
  * Splits a collection member key into the collection key part and the ID part.
  * @param key - The collection member key to split.
@@ -713,6 +755,9 @@ function scheduleNotifyCollectionSubscribers(key, value, previousValue) {
 function remove(key, isProcessingCollectionUpdate) {
     OnyxCache_1.default.drop(key);
     scheduleSubscriberUpdate(key, undefined, undefined, isProcessingCollectionUpdate);
+    if (isRamOnlyKey(key)) {
+        return Promise.resolve();
+    }
     return storage_1.default.removeItem(key).then(() => undefined);
 }
 function reportStorageQuota() {
@@ -1103,6 +1148,11 @@ function setWithRetry({ key, value, options }, retryAttempt) {
     if (!hasChanged && !retryAttempt) {
         return updatePromise;
     }
+    // If a key is a RAM-only key or a member of RAM-only collection, we skip the step that modifies the storage
+    if (isRamOnlyKey(key)) {
+        OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET, key, valueWithoutNestedNullValues);
+        return updatePromise;
+    }
     return storage_1.default.setItem(key, valueWithoutNestedNullValues)
         .catch((error) => OnyxUtils.retryOperation(error, setWithRetry, { key, value: valueWithoutNestedNullValues, options }, retryAttempt))
         .then(() => {
@@ -1147,7 +1197,12 @@ function multiSetWithRetry(data, retryAttempt) {
         OnyxCache_1.default.set(key, value);
         return OnyxUtils.scheduleSubscriberUpdate(key, value);
     });
-    return storage_1.default.multiSet(keyValuePairsToSet)
+    const keyValuePairsToStore = keyValuePairsToSet.filter((keyValuePair) => {
+        const [key] = keyValuePair;
+        // Filter out the RAM-only key value pairs, as they should not be saved to storage
+        return !isRamOnlyKey(key);
+    });
+    return storage_1.default.multiSet(keyValuePairsToStore)
         .catch((error) => OnyxUtils.retryOperation(error, multiSetWithRetry, newData, retryAttempt))
         .then(() => {
         OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.MULTI_SET, undefined, newData);
@@ -1207,6 +1262,11 @@ function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
         const updatePromise = OnyxUtils.scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
+        // RAM-only keys are not supposed to be saved to storage
+        if (isRamOnlyKey(collectionKey)) {
+            OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET_COLLECTION, undefined, mutableCollection);
+            return updatePromise;
+        }
         return storage_1.default.multiSet(keyValuePairs)
             .catch((error) => OnyxUtils.retryOperation(error, setCollectionWithRetry, { collectionKey, collection }, retryAttempt))
             .then(() => {
@@ -1298,10 +1358,12 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
         const previousCollectionPromise = Promise.all(existingKeys.map((key) => get(key).then((value) => [key, value]))).then(Object.fromEntries);
         // New keys will be added via multiSet while existing keys will be updated using multiMerge
         // This is because setting a key that doesn't exist yet with multiMerge will throw errors
-        if (keyValuePairsForExistingCollection.length > 0) {
+        // We can skip this step for RAM-only keys as they should never be saved to storage
+        if (!isRamOnlyKey(collectionKey) && keyValuePairsForExistingCollection.length > 0) {
             promises.push(storage_1.default.multiMerge(keyValuePairsForExistingCollection));
         }
-        if (keyValuePairsForNewCollection.length > 0) {
+        // We can skip this step for RAM-only keys as they should never be saved to storage
+        if (!isRamOnlyKey(collectionKey) && keyValuePairsForNewCollection.length > 0) {
             promises.push(storage_1.default.multiSet(keyValuePairsForNewCollection));
         }
         // finalMergedCollection contains all the keys that were merged, without the keys of incompatible updates
@@ -1364,6 +1426,10 @@ function partialSetCollection({ collectionKey, collection }, retryAttempt) {
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
         const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
+        if (isRamOnlyKey(collectionKey)) {
+            sendActionToDevTools(METHOD.SET_COLLECTION, undefined, mutableCollection);
+            return updatePromise;
+        }
         return storage_1.default.multiSet(keyValuePairs)
             .catch((error) => retryOperation(error, partialSetCollection, { collectionKey, collection }, retryAttempt))
             .then(() => {
@@ -1394,6 +1460,7 @@ const OnyxUtils = {
     getMergeQueuePromise,
     getDefaultKeyStates,
     getDeferredInitTask,
+    afterInit,
     initStoreValues,
     sendActionToDevTools,
     get,
@@ -1445,6 +1512,7 @@ const OnyxUtils = {
     setWithRetry,
     multiSetWithRetry,
     setCollectionWithRetry,
+    isRamOnlyKey,
 };
 GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) => {
     if (!enablePerformanceMetrics) {

package/dist/createDeferredTask.d.ts

@@ -1,6 +1,7 @@
 type DeferredTask = {
     promise: Promise<void>;
-    resolve?: () => void;
+    resolve: () => void;
+    isResolved: boolean;
 };
 /**
  * Create a deferred task that can be resolved when we call `resolve()`

package/dist/createDeferredTask.js

@@ -7,9 +7,14 @@ exports.default = createDeferredTask;
  * Useful when we want to wait for a tasks that is resolved from an external action
  */
 function createDeferredTask() {
-    const deferred = {};
-    deferred.promise = new Promise((res) => {
-        deferred.resolve = res;
-    });
+    const { promise, resolve: originalResolve } = Promise.withResolvers();
+    const deferred = {
+        promise,
+        resolve: () => {
+            deferred.isResolved = true;
+            originalResolve();
+        },
+        isResolved: false,
+    };
     return deferred;
 }

package/dist/types.d.ts

@@ -364,6 +364,10 @@ type InitOptions = {
      * Additionally, any subscribers from these keys to won't receive any data from Onyx.
      */
     skippableCollectionMemberIDs?: string[];
+    /**
+     * Array of keys that when provided to Onyx are flagged as RAM-only keys, and thus are not saved to disk.
+     */
+    ramOnlyKeys?: OnyxKey[];
     /**
      * A list of field names that should always be merged into snapshot entries even if those fields are
      * missing in the snapshot. Snapshots are saved "views" of a key's data used to populate read-only

package/dist/useOnyx.d.ts

@@ -8,6 +8,7 @@ type UseOnyxOptions<TKey extends OnyxKey, TReturnValue> = {
     canEvict?: boolean;
     /**
      * If set to `false`, then no data will be prefilled into the component.
+     * @deprecated This param is going to be removed soon. Use RAM-only keys instead.
      */
     initWithStoredValues?: boolean;
     /**

package/package.json

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