react-native-onyx 3.0.100 → 3.0.102

package/dist/Onyx.js

@@ -103,7 +103,7 @@ function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], shouldSync
     OnyxUtils_1.default.initStoreValues(keys, initialKeyStates, evictableKeys);
     // Initialize all of our keys with data provided then give green light to any pending connections.
     // addEvictableKeysToRecentlyAccessedList must run after initializeWithDefaultKeyStates because
-    // eager cache loading populates the key index (cache.setAllKeys) inside initializeWithDefaultKeyStates,
+    // eager cache loading populates the key index (cache.hydrate) inside initializeWithDefaultKeyStates,
     // and the evictable keys list depends on that index being populated.
     OnyxUtils_1.default.initializeWithDefaultKeyStates()
         .then(() => OnyxCache_1.default.addEvictableKeysToRecentlyAccessedList(OnyxKeys_1.default.isCollectionKey, OnyxUtils_1.default.getAllKeys))

package/dist/OnyxCache.d.ts

@@ -66,6 +66,13 @@ declare class OnyxCache {
     set(key: OnyxKey, value: OnyxValue<OnyxKey>): OnyxValue<OnyxKey>;
     /** Forget the cached value for the given key */
     drop(key: OnyxKey): void;
+    /**
+     * Bulk-loads values into a cache that's expected to be empty, skipping merge()'s per-key clone when
+     * safe. Falls back to a real merge for any key that already has a value, in case the cache wasn't
+     * empty after all. Used only by `Onyx.init()`.
+     * @param data - a map of (cache) key - values
+     */
+    hydrate(data: Record<OnyxKey, OnyxValue<OnyxKey>>): void;
     /**
      * Deep merge data to cache, any non existing keys will be created
      * @param data - a map of (cache) key - values

package/dist/OnyxCache.js

@@ -14,6 +14,15 @@ const OnyxKeys_1 = __importDefault(require("./OnyxKeys"));
  * which relies on === equality to detect changes.
  */
 const FROZEN_EMPTY_COLLECTION = Object.freeze({});
+/**
+ * Merge options shared by every cache write path (`merge()` and `hydrate()`'s fallback), so the
+ * three call sites can't drift apart. Cached values must never hold nested nulls, and a source
+ * object carrying the replace mark must replace the target object rather than merge into it.
+ */
+const CACHE_MERGE_OPTIONS = {
+    shouldRemoveNestedNulls: true,
+    objectRemovalMode: 'replace',
+};
 // Task constants
 const TASK = {
     GET: 'get',
@@ -38,7 +47,7 @@ class OnyxCache {
         this.collectionSnapshots = new Map();
         this.dirtyCollections = new Set();
         // 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', 'setAllKeys', 'setEvictionAllowList', 'isEvictableKey', 'removeLastAccessedKey', 'addLastAccessedKey', 'addEvictableKeysToRecentlyAccessedList', 'getKeyForEviction', 'setCollectionKeys', 'hasValueChanged', 'getCollectionData');
+        (0, bindAll_1.default)(this, 'getAllKeys', 'get', 'hasCacheForKey', 'addKey', 'addNullishStorageKey', 'hasNullishStorageKey', 'clearNullishStorageKeys', 'set', 'drop', 'merge', 'hydrate', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'setAllKeys', 'setEvictionAllowList', 'isEvictableKey', 'removeLastAccessedKey', 'addLastAccessedKey', 'addEvictableKeysToRecentlyAccessedList', 'getKeyForEviction', 'setCollectionKeys', 'hasValueChanged', 'getCollectionData');
     }
     /** Get all the storage keys */
     getAllKeys() {
@@ -126,6 +135,69 @@ class OnyxCache {
         this.storageKeys.delete(key);
         OnyxKeys_1.default.deregisterMemberKey(key);
     }
+    /**
+     * Bulk-loads values into a cache that's expected to be empty, skipping merge()'s per-key clone when
+     * safe. Falls back to a real merge for any key that already has a value, in case the cache wasn't
+     * empty after all. Used only by `Onyx.init()`.
+     * @param data - a map of (cache) key - values
+     */
+    hydrate(data) {
+        if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+            throw new Error('data passed to cache.hydrate() must be an Object of onyx key/value pairs');
+        }
+        const affectedCollections = new Set();
+        // Use for-in loop to avoid an unnecessary array allocation from Object.keys()
+        // eslint-disable-next-line no-restricted-syntax, guard-for-in
+        for (const key in data) {
+            const value = data[key];
+            this.addKey(key);
+            if (value === undefined) {
+                this.addNullishStorageKey(key);
+                // undefined means "no change" — skip storageMap modification
+                continue;
+            }
+            const collectionKey = OnyxKeys_1.default.getCollectionKey(key);
+            if (value === null) {
+                this.addNullishStorageKey(key);
+                delete this.storageMap[key];
+                if (collectionKey) {
+                    affectedCollections.add(collectionKey);
+                }
+            }
+            else {
+                this.nullishStorageKeys.delete(key);
+                const existing = this.storageMap[key];
+                if (existing !== undefined) {
+                    // Key already has a value, so the empty-cache assumption doesn't hold here (e.g. a write
+                    // landed while storage was still being read). Fall back to a real merge, which has exactly
+                    // the same semantics as the old `cache.merge(allDataFromStorage)` init path: the value
+                    // loaded from disk is the merge source, so it wins on any overlapping leaf key.
+                    // Note: this only covers non-null writes. A `cache.set(key, null)` that lands before hydrate
+                    // clears the nullish marker too, so a deletion racing init is still undone - same as before.
+                    const merged = utils_1.default.fastMerge(existing, value, CACHE_MERGE_OPTIONS).result;
+                    // fastMerge is reference-stable: returns the original target when
+                    // nothing changed, so a simple === check detects no-ops.
+                    if (merged === existing) {
+                        continue;
+                    }
+                    this.storageMap[key] = merged;
+                }
+                else if (utils_1.default.needsNormalization(value)) {
+                    this.storageMap[key] = utils_1.default.fastMerge(undefined, value, CACHE_MERGE_OPTIONS).result;
+                }
+                else {
+                    this.storageMap[key] = value;
+                }
+                if (collectionKey) {
+                    affectedCollections.add(collectionKey);
+                }
+            }
+        }
+        // Mark affected collections as dirty — snapshots will be lazily rebuilt on next read
+        for (const collectionKey of affectedCollections) {
+            this.dirtyCollections.add(collectionKey);
+        }
+    }
     /**
      * Deep merge data to cache, any non existing keys will be created
      * @param data - a map of (cache) key - values
@@ -135,7 +207,10 @@ class OnyxCache {
             throw new Error('data passed to cache.merge() must be an Object of onyx key/value pairs');
         }
         const affectedCollections = new Set();
-        for (const [key, value] of Object.entries(data)) {
+        // Use for-in loop to avoid an unnecessary array allocation from Object.entries()
+        // eslint-disable-next-line no-restricted-syntax, guard-for-in
+        for (const key in data) {
+            const value = data[key];
             this.addKey(key);
             const collectionKey = OnyxKeys_1.default.getCollectionKey(key);
             if (value === undefined) {
@@ -154,10 +229,7 @@ class OnyxCache {
                 this.nullishStorageKeys.delete(key);
                 // Per-key merge instead of spreading the entire storageMap
                 const existing = this.storageMap[key];
-                const merged = utils_1.default.fastMerge(existing, value, {
-                    shouldRemoveNestedNulls: true,
-                    objectRemovalMode: 'replace',
-                }).result;
+                const merged = utils_1.default.fastMerge(existing, value, CACHE_MERGE_OPTIONS).result;
                 // fastMerge is reference-stable: returns the original target when
                 // nothing changed, so a simple === check detects no-ops.
                 if (merged === existing) {

package/dist/OnyxUtils.js

@@ -858,9 +858,12 @@ function initializeWithDefaultKeyStates() {
             }
             allDataFromStorage[key] = value;
         }
-        // Load all storage data into cache silently (no subscriber notifications)
-        OnyxCache_1.default.setAllKeys(Object.keys(allDataFromStorage));
-        OnyxCache_1.default.merge(allDataFromStorage);
+        // Load all storage data into cache silently (no subscriber notifications).
+        // hydrate() rather than merge(): the cache is empty at this point, so a per-key fastMerge
+        // would only deep-clone every row it was handed.
+        // No setAllKeys() call is needed: hydrate() calls addKey() for every key, which populates the
+        // key index and registers collection member keys itself.
+        OnyxCache_1.default.hydrate(allDataFromStorage);
         // For keys that have a developer-defined default (via `initialKeyStates`), merge the
         // persisted value with the default so new properties added in code updates are applied
         // without wiping user data that already exists in storage.
@@ -1017,13 +1020,28 @@ function updateSnapshots(data, mergeFn) {
         return [];
     const promises = [];
     const snapshotCollection = getCachedCollection(snapshotCollectionKey);
+    // Multiset entries are keyless but update every key of their payload, so expand them into
+    // per-key entries to keep cached snapshots in sync with the real Onyx data.
+    const flattenedData = data.flatMap((entry) => {
+        if (entry.onyxMethod === METHOD.MULTI_SET && typeof entry.key !== 'string' && entry.value && typeof entry.value === 'object' && !Array.isArray(entry.value)) {
+            return Object.entries(entry.value).map(([key, value]) => ({ onyxMethod: METHOD.SET, key, value }));
+        }
+        return entry;
+    });
     for (const [snapshotEntryKey, snapshotEntryValue] of Object.entries(snapshotCollection)) {
         // Snapshots may not be present in cache. We don't know how to update them so we skip.
         if (!snapshotEntryValue) {
             continue;
         }
         let updatedData = {};
-        for (const { key, value } of data) {
+        for (const { key, value, onyxMethod } of flattenedData) {
+            if (typeof key !== 'string') {
+                // clear entries legitimately carry no key, and malformed multiset payloads are already logged by update() itself
+                if (onyxMethod !== METHOD.CLEAR && onyxMethod !== METHOD.MULTI_SET) {
+                    Logger.logHmmm(`Invalid ${typeof key} key (method: ${onyxMethod}, key: ${String(key).slice(0, 50)}) provided in Onyx update. Skipping snapshot update for this entry.`);
+                }
+                continue;
+            }
             // snapshots are normal keys so we want to skip update if they are written to Onyx
             if (OnyxKeys_1.default.isCollectionMemberKey(snapshotCollectionKey, key)) {
                 continue;

package/dist/utils.d.ts

@@ -37,6 +37,11 @@ type FastMergeResult<TValue> = {
 declare function fastMerge<TValue>(target: TValue, source: TValue, options?: FastMergeOptions, metadata?: FastMergeMetadata, basePath?: string[]): FastMergeResult<TValue>;
 /** Checks whether the given object is an object and not null/undefined. */
 declare function isEmptyObject<T>(obj: T | EmptyValue): obj is EmptyValue;
+/**
+ * Reports whether a value needs cleaning (nested null/undefined, or the replace-object mark) before it's
+ * safe to store by reference. Read-only, non-allocating.
+ */
+declare function needsNormalization(value: unknown): boolean;
 /** Deep removes the nested null values from the given value. Returns the original reference if no nulls were found. */
 declare function removeNestedNullValues<TValue extends OnyxInput<OnyxKey> | null>(value: TValue): TValue;
 /** Formats the action name by uppercasing and adding the key if provided. */
@@ -73,6 +78,7 @@ declare const _default: {
     isEmptyObject: typeof isEmptyObject;
     formatActionName: typeof formatActionName;
     removeNestedNullValues: typeof removeNestedNullValues;
+    needsNormalization: typeof needsNormalization;
     checkCompatibilityWithExistingValue: typeof checkCompatibilityWithExistingValue;
     pick: typeof pick;
     omit: typeof omit;

package/dist/utils.js

@@ -129,6 +129,30 @@ function isMergeableObject(value) {
     const isNonNullObject = value != null ? typeof value === 'object' : false;
     return isNonNullObject && !(value instanceof RegExp) && !(value instanceof Date) && !Array.isArray(value);
 }
+/**
+ * Reports whether a value needs cleaning (nested null/undefined, or the replace-object mark) before it's
+ * safe to store by reference. Read-only, non-allocating.
+ */
+function needsNormalization(value) {
+    if (value === null || value === undefined || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    // Use for-in loop to avoid an unnecessary array allocation from Object.keys()
+    // eslint-disable-next-line no-restricted-syntax, guard-for-in
+    for (const key in value) {
+        if (key === ONYX_INTERNALS__REPLACE_OBJECT_MARK) {
+            return true;
+        }
+        const propertyValue = value[key];
+        if (propertyValue === null || propertyValue === undefined) {
+            return true;
+        }
+        if (typeof propertyValue === 'object' && !Array.isArray(propertyValue) && needsNormalization(propertyValue)) {
+            return true;
+        }
+    }
+    return false;
+}
 /** Deep removes the nested null values from the given value. Returns the original reference if no nulls were found. */
 function removeNestedNullValues(value) {
     if (value === null || value === undefined || typeof value !== 'object' || Array.isArray(value)) {
@@ -259,6 +283,7 @@ exports.default = {
     isEmptyObject,
     formatActionName,
     removeNestedNullValues,
+    needsNormalization,
     checkCompatibilityWithExistingValue,
     pick,
     omit,

package/package.json

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