react-native-onyx 2.0.41 → 2.0.43

package/dist/Onyx.js

@@ -47,7 +47,7 @@ function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCach
     storage_1.default.init();
     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.getValue(key, false);
+            const prevValue = OnyxCache_1.default.get(key, false);
             OnyxCache_1.default.set(key, value);
             OnyxUtils_1.default.keyChanged(key, value, prevValue);
         });
@@ -106,7 +106,7 @@ function connect(connectOptions) {
         // Performance improvement
         // If the mapping is connected to an onyx key that is not a collection
         // we can skip the call to getAllKeys() and return an array with a single item
-        if (Boolean(mapping.key) && typeof mapping.key === 'string' && !mapping.key.endsWith('_') && OnyxCache_1.default.storageKeys.has(mapping.key)) {
+        if (Boolean(mapping.key) && typeof mapping.key === 'string' && !mapping.key.endsWith('_') && OnyxCache_1.default.getAllKeys().has(mapping.key)) {
             return new Set([mapping.key]);
         }
         return OnyxUtils_1.default.getAllKeys();
@@ -122,9 +122,9 @@ function connect(connectOptions) {
         // component. This null value will be filtered out so that the connected component can utilize defaultProps.
         if (matchingKeys.length === 0) {
             if (mapping.key && !OnyxUtils_1.default.isCollectionKey(mapping.key)) {
-                OnyxCache_1.default.set(mapping.key, null);
+                OnyxCache_1.default.addNullishStorageKey(mapping.key);
             }
-            // Here we cannot use batching because the null value is expected to be set immediately for default props
+            // Here we cannot use batching because the nullish value is expected to be set immediately for default props
             // or they will be undefined.
             OnyxUtils_1.default.sendDataToConnection(mapping, null, undefined, false);
             return;
@@ -192,8 +192,17 @@ function disconnect(connectionID, keyToRemoveFromEvictionBlocklist) {
  * @param value value to store
  */
 function set(key, value) {
-    // check if the value is compatible with the existing value in the storage
-    const existingValue = OnyxCache_1.default.getValue(key, false);
+    // When we use Onyx.set to set a key we want to clear the current delta changes from Onyx.merge that were queued
+    // before the value was set. If Onyx.merge is currently reading the old value from storage, it will then not apply the changes.
+    if (OnyxUtils_1.default.hasPendingMergeForKey(key)) {
+        delete OnyxUtils_1.default.getMergeQueue()[key];
+    }
+    const existingValue = OnyxCache_1.default.get(key, false);
+    // If the existing value as well as the new value are null, we can return early.
+    if (value === null && existingValue === null) {
+        return Promise.resolve();
+    }
+    // Check if the value is compatible with the existing value in the storage
     const { isCompatible, existingValueType, newValueType } = utils_1.default.checkCompatibilityWithExistingValue(value, existingValue);
     if (!isCompatible) {
         Logger.logAlert(logMessages_1.default.incompatibleUpdateAlert(key, 'set', existingValueType, newValueType));
@@ -201,17 +210,23 @@ function set(key, value) {
     }
     // If the value is null, we remove the key from storage
     const { value: valueAfterRemoving, wasRemoved } = OnyxUtils_1.default.removeNullValues(key, value);
-    const valueWithoutNullValues = valueAfterRemoving;
-    if (OnyxUtils_1.default.hasPendingMergeForKey(key)) {
-        delete OnyxUtils_1.default.getMergeQueue()[key];
+    const logSetCall = (hasChanged = true) => {
+        // Logging properties only since values could be sensitive things we don't want to log
+        Logger.logInfo(`set called for key: ${key}${underscore_1.default.isObject(value) ? ` properties: ${underscore_1.default.keys(value).join(',')}` : ''} hasChanged: ${hasChanged}`);
+    };
+    // Calling "OnyxUtils.removeNullValues" removes the key from storage and cache and updates the subscriber.
+    // Therefore, we don't need to further broadcast and update the value so we can return early.
+    if (wasRemoved) {
+        logSetCall();
+        return Promise.resolve();
     }
+    const valueWithoutNullValues = valueAfterRemoving;
     const hasChanged = OnyxCache_1.default.hasValueChanged(key, valueWithoutNullValues);
-    // Logging properties only since values could be sensitive things we don't want to log
-    Logger.logInfo(`set called for key: ${key}${underscore_1.default.isObject(value) ? ` properties: ${underscore_1.default.keys(value).join(',')}` : ''} hasChanged: ${hasChanged}`);
+    logSetCall(hasChanged);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, valueWithoutNullValues, hasChanged, wasRemoved);
+    const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, valueWithoutNullValues, hasChanged);
     // If the value has not changed or the key got removed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
-    if (!hasChanged || wasRemoved) {
+    if (!hasChanged) {
         return updatePromise;
     }
     return storage_1.default.setItem(key, valueWithoutNullValues)
@@ -229,18 +244,28 @@ function set(key, value) {
  * @param data object keyed by ONYXKEYS and the values to set
  */
 function multiSet(data) {
-    const keyValuePairs = OnyxUtils_1.default.prepareKeyValuePairsForStorage(data, true);
-    const updatePromises = keyValuePairs.map(([key, value]) => {
-        const prevValue = OnyxCache_1.default.getValue(key, false);
+    const allKeyValuePairs = OnyxUtils_1.default.prepareKeyValuePairsForStorage(data, true);
+    // When a key is set to null, we need to remove the remove the key from storage using "OnyxUtils.remove".
+    // Therefore, we filter the key value pairs to exclude null values and remove those keys explicitly.
+    const removePromises = [];
+    const keyValuePairsToUpdate = allKeyValuePairs.filter(([key, value]) => {
+        if (value === null) {
+            removePromises.push(OnyxUtils_1.default.remove(key));
+            return false;
+        }
+        return true;
+    });
+    const updatePromises = keyValuePairsToUpdate.map(([key, value]) => {
+        const prevValue = OnyxCache_1.default.get(key, false);
         // Update cache and optimistically inform subscribers on the next tick
         OnyxCache_1.default.set(key, value);
         return OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, prevValue);
     });
-    return storage_1.default.multiSet(keyValuePairs)
+    return storage_1.default.multiSet(allKeyValuePairs)
         .catch((error) => OnyxUtils_1.default.evictStorageAndRetry(error, multiSet, data))
         .then(() => {
         OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MULTI_SET, undefined, data);
-        return Promise.all(updatePromises);
+        return Promise.all([removePromises, updatePromises]);
     })
         .then(() => undefined);
 }
@@ -278,7 +303,7 @@ function merge(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 undefined;
+            return Promise.resolve();
         }
         try {
             // We first only merge the changes, so we can provide these to the native implementation (SQLite uses only delta changes in "JSON_PATCH" to merge)
@@ -291,7 +316,7 @@ function merge(key, changes) {
                 return isCompatible;
             });
             if (!validChanges.length) {
-                return undefined;
+                return Promise.resolve();
             }
             const batchedDeltaChanges = OnyxUtils_1.default.applyMerge(undefined, validChanges, false);
             // Case (1): When there is no existing value in storage, we want to set the value instead of merge it.
@@ -301,8 +326,18 @@ function merge(key, changes) {
             // Clean up the write queue, so we don't apply these changes again
             delete mergeQueue[key];
             delete mergeQueuePromise[key];
+            const logMergeCall = (hasChanged = true) => {
+                // Logging properties only since values could be sensitive things we don't want to log
+                Logger.logInfo(`merge called for key: ${key}${underscore_1.default.isObject(batchedDeltaChanges) ? ` properties: ${underscore_1.default.keys(batchedDeltaChanges).join(',')}` : ''} hasChanged: ${hasChanged}`);
+            };
             // If the batched changes equal null, we want to remove the key from storage, to reduce storage size
             const { wasRemoved } = OnyxUtils_1.default.removeNullValues(key, batchedDeltaChanges);
+            // Calling "OnyxUtils.removeNullValues" removes the key from storage and cache and updates the subscriber.
+            // Therefore, we don't need to further broadcast and update the value so we can return early.
+            if (wasRemoved) {
+                logMergeCall();
+                return Promise.resolve();
+            }
             // For providers that can't handle delta changes, we need to merge the batched changes with the existing value beforehand.
             // The "preMergedValue" will be directly "set" in storage instead of being merged
             // Therefore we merge the batched changes with the existing value to get the final merged value that will be stored.
@@ -310,12 +345,11 @@ function merge(key, changes) {
             const preMergedValue = OnyxUtils_1.default.applyMerge(shouldSetValue ? undefined : existingValue, [batchedDeltaChanges], true);
             // In cache, we don't want to remove the key if it's null to improve performance and speed up the next merge.
             const hasChanged = OnyxCache_1.default.hasValueChanged(key, preMergedValue);
-            // Logging properties only since values could be sensitive things we don't want to log
-            Logger.logInfo(`merge called for key: ${key}${underscore_1.default.isObject(batchedDeltaChanges) ? ` properties: ${underscore_1.default.keys(batchedDeltaChanges).join(',')}` : ''} hasChanged: ${hasChanged}`);
+            logMergeCall(hasChanged);
             // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-            const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, preMergedValue, hasChanged, wasRemoved);
+            const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, preMergedValue, hasChanged);
             // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
-            if (!hasChanged || wasRemoved) {
+            if (!hasChanged) {
                 return updatePromise;
             }
             return storage_1.default.mergeItem(key, batchedDeltaChanges, preMergedValue, shouldSetValue).then(() => {
@@ -453,6 +487,7 @@ function mergeCollection(collectionKey, collection) {
 function clear(keysToPreserve = []) {
     return OnyxUtils_1.default.getAllKeys()
         .then((keys) => {
+        OnyxCache_1.default.clearNullishStorageKeys();
         const keysToBeClearedFromStorage = [];
         const keyValuesToResetAsCollection = {};
         const keyValuesToResetIndividually = {};
@@ -471,7 +506,7 @@ function clear(keysToPreserve = []) {
             // 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.getValue(key);
+                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);
@@ -496,7 +531,7 @@ function clear(keysToPreserve = []) {
         const updatePromises = [];
         // Notify the subscribers for each key/value group so they can receive the new values
         Object.entries(keyValuesToResetIndividually).forEach(([key, value]) => {
-            updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, OnyxCache_1.default.getValue(key, false)));
+            updatePromises.push(OnyxUtils_1.default.scheduleSubscriberUpdate(key, value, OnyxCache_1.default.get(key, false)));
         });
         Object.entries(keyValuesToResetAsCollection).forEach(([key, value]) => {
             updatePromises.push(OnyxUtils_1.default.scheduleNotifyCollectionSubscribers(key, value));

package/dist/OnyxCache.d.ts

@@ -5,7 +5,9 @@ import type { OnyxKey, OnyxValue } from './types';
  */
 declare class OnyxCache {
     /** Cache of all the storage keys available in persistent storage */
-    storageKeys: Set<OnyxKey>;
+    private storageKeys;
+    /** A list of keys where a nullish value has been fetched from storage before, but the key still exists in cache */
+    private nullishStorageKeys;
     /** Unique list of keys maintained in access order (most recent at the end) */
     private recentKeys;
     /** A map of cached values */
@@ -21,16 +23,32 @@ declare class OnyxCache {
     /** Get all the storage keys */
     getAllKeys(): Set<OnyxKey>;
     /**
-     * Get a cached value from storage
-     * @param [shouldReindexCache] – This is an LRU cache, and by default accessing a value will make it become last in line to be evicted. This flag can be used to skip that and just access the value directly without side-effects.
+     * Allows to set all the keys at once.
+     * This is useful when we are getting
+     * all the keys from the storage provider
+     * and we want to keep the cache in sync.
+     *
+     * Previously, we had to call `addKey` in a loop
+     * to achieve the same result.
+     *
+     * @param keys - an array of keys
      */
-    getValue(key: OnyxKey, shouldReindexCache?: boolean): OnyxValue<OnyxKey>;
-    /** Check whether cache has data for the given key */
-    hasCacheForKey(key: OnyxKey): boolean;
+    setAllKeys(keys: OnyxKey[]): void;
     /** Saves a key in the storage keys list
      * Serves to keep the result of `getAllKeys` up to date
      */
     addKey(key: OnyxKey): void;
+    /** Used to set keys that are null/undefined in storage without adding null to the storage map */
+    addNullishStorageKey(key: OnyxKey): void;
+    /** Used to clear keys that are null/undefined in cache */
+    clearNullishStorageKeys(): void;
+    /** Check whether cache has data for the given key */
+    hasCacheForKey(key: OnyxKey): boolean;
+    /**
+     * Get a cached value from storage
+     * @param [shouldReindexCache] – This is an LRU cache, and by default accessing a value will make it become last in line to be evicted. This flag can be used to skip that and just access the value directly without side-effects.
+     */
+    get(key: OnyxKey, shouldReindexCache?: boolean): OnyxValue<OnyxKey>;
     /**
      * Set's a key value in cache
      * Adds the key to the storage keys list as well
@@ -43,18 +61,6 @@ declare class OnyxCache {
      * @param data - a map of (cache) key - values
      */
     merge(data: Record<OnyxKey, OnyxValue<OnyxKey>>): void;
-    /**
-     * Allows to set all the keys at once.
-     * This is useful when we are getting
-     * all the keys from the storage provider
-     * and we want to keep the cache in sync.
-     *
-     * Previously, we had to call `addKey` in a loop
-     * to achieve the same result.
-     *
-     * @param keys - an array of keys
-     */
-    setAllKeys(keys: OnyxKey[]): void;
     /**
      * Check whether the given task is already running
      * @param taskName - unique name given for the task

package/dist/OnyxCache.js

@@ -15,29 +15,30 @@ class OnyxCache {
         /** Maximum size of the keys store din cache */
         this.maxRecentKeysSize = 0;
         this.storageKeys = new Set();
+        this.nullishStorageKeys = new Set();
         this.recentKeys = new Set();
         this.storageMap = {};
         this.pendingPromises = new Map();
         // bind all public methods to prevent problems with `this`
-        (0, bindAll_1.default)(this, 'getAllKeys', 'getValue', 'hasCacheForKey', 'addKey', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit', 'setAllKeys');
+        (0, bindAll_1.default)(this, 'getAllKeys', 'get', 'hasCacheForKey', 'addKey', 'addNullishStorageKey', 'clearNullishStorageKeys', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit', 'setAllKeys');
     }
     /** Get all the storage keys */
     getAllKeys() {
         return this.storageKeys;
     }
     /**
-     * Get a cached value from storage
-     * @param [shouldReindexCache] – This is an LRU cache, and by default accessing a value will make it become last in line to be evicted. This flag can be used to skip that and just access the value directly without side-effects.
+     * Allows to set all the keys at once.
+     * This is useful when we are getting
+     * all the keys from the storage provider
+     * and we want to keep the cache in sync.
+     *
+     * Previously, we had to call `addKey` in a loop
+     * to achieve the same result.
+     *
+     * @param keys - an array of keys
      */
-    getValue(key, shouldReindexCache = true) {
-        if (shouldReindexCache) {
-            this.addToAccessedKeys(key);
-        }
-        return this.storageMap[key];
-    }
-    /** Check whether cache has data for the given key */
-    hasCacheForKey(key) {
-        return this.storageMap[key] !== undefined;
+    setAllKeys(keys) {
+        this.storageKeys = new Set(keys);
     }
     /** Saves a key in the storage keys list
      * Serves to keep the result of `getAllKeys` up to date
@@ -45,6 +46,28 @@ class OnyxCache {
     addKey(key) {
         this.storageKeys.add(key);
     }
+    /** Used to set keys that are null/undefined in storage without adding null to the storage map */
+    addNullishStorageKey(key) {
+        this.nullishStorageKeys.add(key);
+    }
+    /** Used to clear keys that are null/undefined in cache */
+    clearNullishStorageKeys() {
+        this.nullishStorageKeys = new Set();
+    }
+    /** Check whether cache has data for the given key */
+    hasCacheForKey(key) {
+        return this.storageMap[key] !== undefined || this.nullishStorageKeys.has(key);
+    }
+    /**
+     * Get a cached value from storage
+     * @param [shouldReindexCache] – This is an LRU cache, and by default accessing a value will make it become last in line to be evicted. This flag can be used to skip that and just access the value directly without side-effects.
+     */
+    get(key, shouldReindexCache = true) {
+        if (shouldReindexCache) {
+            this.addToAccessedKeys(key);
+        }
+        return this.storageMap[key];
+    }
     /**
      * Set's a key value in cache
      * Adds the key to the storage keys list as well
@@ -52,6 +75,13 @@ class OnyxCache {
     set(key, value) {
         this.addKey(key);
         this.addToAccessedKeys(key);
+        // When a key is explicitly set in cache, we can remove it from the list of nullish keys,
+        // since it will either be set to a non nullish value or removed from the cache completely.
+        this.nullishStorageKeys.delete(key);
+        if (value === null || value === undefined) {
+            delete this.storageMap[key];
+            return undefined;
+        }
         this.storageMap[key] = value;
         return value;
     }
@@ -69,25 +99,17 @@ class OnyxCache {
         if (typeof data !== 'object' || Array.isArray(data)) {
             throw new Error('data passed to cache.merge() must be an Object of onyx key/value pairs');
         }
-        this.storageMap = Object.assign({}, utils_1.default.fastMerge(this.storageMap, data, false));
-        const storageKeys = this.getAllKeys();
-        const mergedKeys = Object.keys(data);
-        this.storageKeys = new Set([...storageKeys, ...mergedKeys]);
-        mergedKeys.forEach((key) => this.addToAccessedKeys(key));
-    }
-    /**
-     * Allows to set all the keys at once.
-     * This is useful when we are getting
-     * all the keys from the storage provider
-     * and we want to keep the cache in sync.
-     *
-     * Previously, we had to call `addKey` in a loop
-     * to achieve the same result.
-     *
-     * @param keys - an array of keys
-     */
-    setAllKeys(keys) {
-        this.storageKeys = new Set(keys);
+        this.storageMap = Object.assign({}, utils_1.default.fastMerge(this.storageMap, data));
+        Object.entries(data).forEach(([key, value]) => {
+            this.addKey(key);
+            this.addToAccessedKeys(key);
+            if (value === null || value === undefined) {
+                this.addNullishStorageKey(key);
+            }
+            else {
+                this.nullishStorageKeys.delete(key);
+            }
+        });
     }
     /**
      * Check whether the given task is already running

package/dist/OnyxUtils.d.ts

@@ -1,6 +1,6 @@
 import type { ValueOf } from 'type-fest';
-import type { DeepRecord, Mapping, CollectionKey, CollectionKeyBase, NullableKeyValueMapping, OnyxKey, OnyxValue, OnyxCollection, WithOnyxConnectOptions, OnyxEntry, KeyValueMapping } from './types';
 import type Onyx from './Onyx';
+import type { CollectionKey, CollectionKeyBase, DeepRecord, KeyValueMapping, Mapping, NullableKeyValueMapping, OnyxCollection, OnyxEntry, OnyxKey, OnyxValue, WithOnyxConnectOptions } from './types';
 declare const METHOD: {
     readonly SET: "set";
     readonly MERGE: "merge";
@@ -107,7 +107,7 @@ declare function getCachedCollection<TKey extends CollectionKeyBase>(collectionK
 /**
  * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
  */
-declare function keysChanged<TKey extends CollectionKeyBase>(collectionKey: TKey, partialCollection: OnyxCollection<KeyValueMapping[TKey]>, previousPartialCollection: OnyxCollection<KeyValueMapping[TKey]> | undefined, notifyRegularSubscibers?: boolean, notifyWithOnyxSubscibers?: boolean): void;
+declare function keysChanged<TKey extends CollectionKeyBase>(collectionKey: TKey, partialCollection: OnyxCollection<KeyValueMapping[TKey]>, partialPreviousCollection: OnyxCollection<KeyValueMapping[TKey]> | undefined, notifyRegularSubscibers?: boolean, notifyWithOnyxSubscibers?: boolean): void;
 /**
  * When a key change happens, search for any callbacks matching the key or collection key and trigger those callbacks
  *
@@ -120,7 +120,7 @@ declare function keyChanged<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TK
  *     - sets state on the withOnyxInstances
  *     - triggers the callback function
  */
-declare function sendDataToConnection<TKey extends OnyxKey>(mapping: Mapping<TKey>, val: OnyxValue<TKey>, matchedKey: TKey | undefined, isBatched: boolean): void;
+declare function sendDataToConnection<TKey extends OnyxKey>(mapping: Mapping<TKey>, value: OnyxValue<TKey> | null, matchedKey: TKey | undefined, isBatched: boolean): void;
 /**
  * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
  * run out of storage the least recently accessed key can be removed.
@@ -157,10 +157,10 @@ declare function evictStorageAndRetry<TMethod extends typeof Onyx.set | typeof O
 /**
  * Notifies subscribers and writes current value to cache
  */
-declare function broadcastUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, hasChanged?: boolean, wasRemoved?: boolean): Promise<void>;
+declare function broadcastUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, hasChanged?: boolean): Promise<void>;
 declare function hasPendingMergeForKey(key: OnyxKey): boolean;
-type RemoveNullValuesOutput = {
-    value: Record<string, unknown> | unknown[] | null;
+type RemoveNullValuesOutput<Value extends OnyxValue<OnyxKey> | null> = {
+    value: Value | null;
     wasRemoved: boolean;
 };
 /**
@@ -170,7 +170,7 @@ type RemoveNullValuesOutput = {
  *
  * @returns The value without null values and a boolean "wasRemoved", which indicates if the key got removed completely
  */
-declare function removeNullValues(key: OnyxKey, value: OnyxValue<OnyxKey>, shouldRemoveNestedNulls?: boolean): RemoveNullValuesOutput;
+declare function removeNullValues<Value extends OnyxValue<OnyxKey>>(key: OnyxKey, value: Value | null, shouldRemoveNestedNulls?: boolean): RemoveNullValuesOutput<Value>;
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
  * This method transforms an object like {'@MyApp_user': myUserValue, '@MyApp_key': myKeyValue}