Merge branch 'main' into fix/idb-visibilitychange-probe

Author: elirangoshen

jestSetup.js

@@ -5,7 +5,6 @@ jest.mock('./lib/storage/platforms/index', () => require('./lib/storage/__mocks_
 jest.mock('react-native-device-info', () => ({getFreeDiskStorage: () => {}}));
 jest.mock('react-native-nitro-sqlite', () => ({
     open: () => ({execute: () => {}}),
-    enableSimpleNullHandling: () => undefined,
 }));
 
 jest.useRealTimers();

lib/OnyxSnapshotCache.ts

@@ -62,9 +62,9 @@ class OnyxSnapshotCache {
      * Other options like `reuseConnection` don't affect the data transformation
      * or timing behavior of getSnapshot, so they're excluded from the cache key for better cache hit rates.
      */
-    registerConsumer<TKey extends OnyxKey, TReturnValue>(options: Pick<UseOnyxOptions<TKey, TReturnValue>, 'selector'>): string {
+    registerConsumer<TKey extends OnyxKey, TReturnValue>(key: TKey, options: Pick<UseOnyxOptions<TKey, TReturnValue>, 'selector'>): string {
         const selectorID = options?.selector ? this.getSelectorID(options.selector) : 'no_selector';
-        const cacheKey = String(selectorID);
+        const cacheKey = `${key}_${selectorID}`;
 
         // Increment reference count for this cache key
         const currentCount = this.cacheKeyRefCounts.get(cacheKey) || 0;

lib/OnyxUtils.ts

@@ -347,9 +347,10 @@ function multiGet<TKey extends OnyxKey>(keys: CollectionKeyBase[]): Promise<Map<
             continue;
         }
 
-        const cacheValue = cache.get(key) as OnyxValue<TKey>;
-        if (cacheValue) {
-            dataMap.set(key, cacheValue);
+        // hasCacheForKey catches cached falsy values (0, '', false, null) as cache hits, which
+        // a truthy check on the value would miss.
+        if (cache.hasCacheForKey(key)) {
+            dataMap.set(key, cache.get(key) as OnyxValue<TKey>);
             continue;
         }
 
@@ -401,6 +402,13 @@ function multiGet<TKey extends OnyxKey>(keys: CollectionKeyBase[]): Promise<Map<
                         }
                     }
 
+                    // Prefer cache over stale storage if a concurrent write populated it during
+                    // the read — otherwise cache.merge(temp) below would resurrect dropped fields.
+                    if (cache.hasCacheForKey(key)) {
+                        dataMap.set(key, cache.get(key) as OnyxValue<TKey>);
+                        continue;
+                    }
+
                     dataMap.set(key, value as OnyxValue<TKey>);
                     temp[key] = value as OnyxValue<TKey>;
                 }
@@ -782,8 +790,12 @@ function remove<TKey extends OnyxKey>(key: TKey, isProcessingCollectionUpdate?:
 
 function reportStorageQuota(error?: Error): Promise<void> {
     return Storage.getDatabaseSize()
-        .then(({bytesUsed, bytesRemaining}) => {
-            Logger.logInfo(`Storage Quota Check -- bytesUsed: ${bytesUsed} bytesRemaining: ${bytesRemaining}. Original error: ${error}`);
+        .then(({bytesUsed, bytesRemaining, usageDetails}) => {
+            Logger.logInfo(
+                `Storage Quota Check -- bytesUsed: ${bytesUsed} bytesRemaining: ${bytesRemaining}${
+                    usageDetails ? ` usageDetails: ${JSON.stringify(usageDetails)}` : ''
+                }. Original error: ${error}`,
+            );
         })
         .catch((dbSizeError) => {
             Logger.logAlert(`Unable to get database size. getDatabaseSize error: ${dbSizeError}. Original error: ${error}`);
@@ -1597,12 +1609,17 @@ function mergeCollectionWithPatches<TKey extends CollectionKeyBase>(
             // finalMergedCollection contains all the keys that were merged, without the keys of incompatible updates
             const finalMergedCollection = {...existingKeyCollection, ...newCollection};
 
-            // Pre-warm cache for any existing storage keys that aren't yet in cache. get() is a no-op
-            // (sync-resolved) for cache hits, and on a cache miss it reads from storage and writes the
-            // value back to cache. This is required so the subsequent cache.merge() merges the new delta
-            // into the real previous storage value (rather than starting from `undefined` and dropping
-            // the existing keys).
-            return Promise.all(existingKeys.map((key) => get(key))).then(() => {
+            // Pre-warm cache for cache-miss existingKeys so cache.merge() merges the new delta into
+            // the real previous storage value. Fast path (all warm) skips the pre-warm to preserve
+            // promise-chain depth; slow path batches the misses into one Storage.multiGet.
+            const hasColdExistingKey = existingKeys.some((key) => !cache.hasCacheForKey(key));
+            // Swallow pre-warm read failures so a transient Storage.multiGet rejection doesn't
+            // skip the cache.merge() + keysChanged() below. Subscribers still see the merge even
+            // when storage reads fail.
+            const prewarmPromise = hasColdExistingKey
+                ? multiGet(existingKeys).catch((err) => Logger.logInfo(`mergeCollectionWithPatches pre-warm failed; proceeding with cache-only merge. Error: ${err}`))
+                : Promise.resolve();
+            return prewarmPromise.then(() => {
                 // Snapshot previous values from the (now-warm) cache for keysChanged's diff, then update
                 // cache and notify subscribers synchronously BEFORE issuing storage writes. This matches
                 // the cache-first / storage-second invariant followed by every other Onyx write method

lib/storage/providers/IDBKeyValProvider/createStore.ts

@@ -10,7 +10,7 @@ const HEAL_ATTEMPTS_MAX = 3;
  * internal recovery (RepairDB -> delete -> recreate) also fails.
  */
 function isBackingStoreError(error: unknown): boolean {
-    return error instanceof Error && error.message.includes('Internal error opening backing store');
+    return (error instanceof Error || error instanceof DOMException) && (error as Error).message.includes('Internal error opening backing store');
 }
 
 /**
@@ -19,22 +19,24 @@ function isBackingStoreError(error: unknown): boolean {
  * WebKit bugs: https://bugs.webkit.org/show_bug.cgi?id=197050, https://bugs.webkit.org/show_bug.cgi?id=201483
  */
 function isConnectionLostError(error: unknown): boolean {
-    if (!(error instanceof Error)) return false;
-    const msg = error.message.toLowerCase();
+    if (!(error instanceof Error || error instanceof DOMException)) return false;
+    const msg = (error as Error).message.toLowerCase();
     return msg.includes('connection to indexed database server lost') || msg.includes('connection is closing');
 }
 
 function isInvalidStateError(error: unknown): boolean {
-    return error instanceof Error && error.name === 'InvalidStateError';
+    return (error instanceof Error || error instanceof DOMException) && (error as Error).name === 'InvalidStateError';
 }
 
 /** Errors that trigger a budgeted heal-and-retry in store(). */
 function isBudgetedHealError(error: unknown): boolean {
     return isBackingStoreError(error) || isConnectionLostError(error);
 }
 
-function getBudgetedHealErrorLabel(error: unknown): 'backing store' | 'connection lost' {
-    return isBackingStoreError(error) ? 'backing store' : 'connection lost';
+function getBudgetedHealErrorLabel(error: unknown): string {
+    if (isBackingStoreError(error)) return 'backing store';
+    if (isConnectionLostError(error)) return 'connection lost';
+    return 'unknown';
 }
 
 /** Union of all error types indicating a stale/dead IDB connection. Used by the visibilitychange probe. */

lib/storage/providers/IDBKeyValProvider/index.ts

@@ -156,6 +156,7 @@ const provider: StorageProvider<UseStore | undefined> = {
             .then((value) => ({
                 bytesUsed: value.usage ?? 0,
                 bytesRemaining: (value.quota ?? 0) - (value.usage ?? 0),
+                usageDetails: (value as StorageEstimate & {usageDetails?: Record<string, number>}).usageDetails,
             }))
             .catch((error) => {
                 throw new Error(`Unable to estimate web storage quota. Original error: ${error}`);

lib/storage/providers/types.ts

@@ -7,6 +7,7 @@ type StorageKeyList = OnyxKey[];
 type DatabaseSize = {
     bytesUsed: number;
     bytesRemaining: number;
+    usageDetails?: Record<string, number>;
 };
 
 type OnStorageKeyChanged = <TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>) => void;

lib/useOnyx.ts

@@ -124,10 +124,10 @@ function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(
     // Cache the options key to avoid regenerating it every getSnapshot call
     const cacheKey = useMemo(
         () =>
-            onyxSnapshotCache.registerConsumer({
+            onyxSnapshotCache.registerConsumer(key, {
                 selector: options?.selector,
             }),
-        [options?.selector],
+        [key, options?.selector],
     );
 
     useEffect(() => () => onyxSnapshotCache.deregisterConsumer(key, cacheKey), [key, cacheKey]);