@react-native-firebase/app 26.3.3 → 26.4.0

package/ios/RNFBAppUnitTests/RNFBHandleMapTests.m

@@ -0,0 +1,238 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import <XCTest/XCTest.h>
+
+#import "RNFBHandleMap.h"
+
+/**
+ * XCTest coverage for RNFBHandleMap. Tests must not invoke methods on stored values — the map only
+ * moves pointers.
+ */
+@interface RNFBHandleMapTests : XCTestCase
+@property(nonatomic, strong) RNFBHandleMap *map;
+@end
+
+@implementation RNFBHandleMapTests
+
+- (void)setUp {
+  [super setUp];
+  self.map = [[RNFBHandleMap alloc] init];
+}
+
+- (void)testPutGetTake_happyPath {
+  NSObject *handle = [[NSObject alloc] init];
+  NSError *error = nil;
+  XCTAssertTrue([self.map put:@1 value:handle error:&error]);
+  XCTAssertNil(error);
+
+  XCTAssertEqual(handle, [self.map get:@1]);
+  XCTAssertEqual(handle, [self.map take:@1]);
+  XCTAssertNil([self.map get:@1]);
+}
+
+- (void)testTake_missingKey_returnsNil {
+  XCTAssertNil([self.map take:@99]);
+  XCTAssertNil([self.map get:@99]);
+}
+
+- (void)testTakeAll_returnsSnapshotAndLeavesMapEmpty {
+  NSObject *a = [[NSObject alloc] init];
+  NSObject *b = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:a error:nil]);
+  XCTAssertTrue([self.map put:@2 value:b error:nil]);
+
+  NSArray *snapshot = [self.map takeAll];
+
+  XCTAssertEqual(snapshot.count, 2u);
+  XCTAssertTrue([snapshot containsObject:a]);
+  XCTAssertTrue([snapshot containsObject:b]);
+  XCTAssertNil([self.map get:@1]);
+  XCTAssertNil([self.map get:@2]);
+  XCTAssertEqual([self.map takeAll].count, 0u);
+}
+
+- (void)testPut_occupiedId_returnsCollision {
+  NSObject *first = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:first error:nil]);
+
+  NSError *error = nil;
+  XCTAssertFalse([self.map put:@1 value:[[NSObject alloc] init] error:&error]);
+  XCTAssertNotNil(error);
+  XCTAssertEqualObjects(error.domain, RNFBHandleMapErrorDomain);
+  XCTAssertEqual(error.code, RNFBHandleMapErrorCollision);
+  XCTAssertTrue([error.localizedDescription containsString:@"1"]);
+  XCTAssertEqual(first, [self.map get:@1]);
+
+  XCTAssertFalse([self.map put:@1 value:[[NSObject alloc] init] error:nil]);
+  XCTAssertEqual(first, [self.map get:@1]);
+}
+
+- (void)testPutIfAbsent_whenFree_storesAndReturnsYes {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertTrue([self.map putIfAbsent:@1 value:handle]);
+  XCTAssertEqual(handle, [self.map get:@1]);
+}
+
+- (void)testPutIfAbsent_whenOccupied_keepsExistingAndReturnsNo {
+  NSObject *first = [[NSObject alloc] init];
+  NSObject *second = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:first error:nil]);
+  XCTAssertFalse([self.map putIfAbsent:@1 value:second]);
+  XCTAssertEqual(first, [self.map get:@1]);
+}
+
+- (void)testPutIfAbsentOrSame_whenAbsent_storesAndReturnsYes {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertTrue([self.map putIfAbsentOrSame:@1 value:handle]);
+  XCTAssertEqual(handle, [self.map get:@1]);
+}
+
+- (void)testPutIfAbsentOrSame_whenSameInstance_returnsYes {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:handle error:nil]);
+  XCTAssertTrue([self.map putIfAbsentOrSame:@1 value:handle]);
+  XCTAssertEqual(handle, [self.map get:@1]);
+}
+
+- (void)testPutIfAbsentOrSame_whenDifferent_returnsNo {
+  NSObject *first = [[NSObject alloc] init];
+  NSObject *second = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:first error:nil]);
+  XCTAssertFalse([self.map putIfAbsentOrSame:@1 value:second]);
+  XCTAssertEqual(first, [self.map get:@1]);
+}
+
+- (void)testPutReplacing_whenFree_storesAndReturnsNil {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertNil([self.map putReplacing:@1 value:handle]);
+  XCTAssertEqual(handle, [self.map get:@1]);
+}
+
+- (void)testPutReplacing_whenOccupied_replacesLastWins {
+  NSObject *first = [[NSObject alloc] init];
+  NSObject *second = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:first error:nil]);
+  XCTAssertEqual(first, [self.map putReplacing:@1 value:second]);
+  XCTAssertEqual(second, [self.map get:@1]);
+}
+
+- (void)testPut_afterTake_allowsReuse {
+  NSObject *first = [[NSObject alloc] init];
+  NSObject *second = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:first error:nil]);
+  XCTAssertEqual(first, [self.map take:@1]);
+  XCTAssertTrue([self.map put:@1 value:second error:nil]);
+  XCTAssertEqual(second, [self.map get:@1]);
+}
+
+- (void)testTakeIf_whenConditionYes_removesAndReturns {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:handle error:nil]);
+  XCTAssertEqual(handle, [self.map takeIf:@1
+                                     when:^BOOL(id value) {
+                                       return value == handle;
+                                     }]);
+  XCTAssertNil([self.map get:@1]);
+}
+
+- (void)testTakeIf_whenConditionNo_leavesMapping {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:handle error:nil]);
+  XCTAssertNil([self.map takeIf:@1
+                           when:^BOOL(id value) {
+                             return NO;
+                           }]);
+  XCTAssertEqual(handle, [self.map get:@1]);
+}
+
+- (void)testTakeIf_whenMissing_returnsNil {
+  XCTAssertNil([self.map takeIf:@99
+                           when:^BOOL(id value) {
+                             return YES;
+                           }]);
+}
+
+- (void)testTake_sameIdFromTwoThreads_onlyOneReturnsNonNull {
+  NSObject *handle = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:handle error:nil]);
+
+  dispatch_semaphore_t start = dispatch_semaphore_create(0);
+  dispatch_semaphore_t done = dispatch_semaphore_create(0);
+  __block id first = [NSNull null];
+  __block id second = [NSNull null];
+
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    dispatch_semaphore_wait(start, DISPATCH_TIME_FOREVER);
+    first = [self.map take:@1];
+    dispatch_semaphore_signal(done);
+  });
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    dispatch_semaphore_wait(start, DISPATCH_TIME_FOREVER);
+    second = [self.map take:@1];
+    dispatch_semaphore_signal(done);
+  });
+
+  dispatch_semaphore_signal(start);
+  dispatch_semaphore_signal(start);
+  XCTAssertEqual(dispatch_semaphore_wait(done, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC)),
+                 0);
+  XCTAssertEqual(dispatch_semaphore_wait(done, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC)),
+                 0);
+
+  BOOL onlyFirst = first == handle && second == nil;
+  BOOL onlySecond = second == handle && first == nil;
+  XCTAssertTrue(onlyFirst || onlySecond);
+  XCTAssertNil([self.map get:@1]);
+}
+
+- (void)testPutReplacing_sameIdFromTwoThreads_lastWins {
+  NSObject *first = [[NSObject alloc] init];
+  NSObject *second = [[NSObject alloc] init];
+  NSObject *third = [[NSObject alloc] init];
+  XCTAssertTrue([self.map put:@1 value:first error:nil]);
+
+  dispatch_semaphore_t start = dispatch_semaphore_create(0);
+  dispatch_semaphore_t done = dispatch_semaphore_create(0);
+  __block id prevA = [NSNull null];
+  __block id prevB = [NSNull null];
+
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    dispatch_semaphore_wait(start, DISPATCH_TIME_FOREVER);
+    prevA = [self.map putReplacing:@1 value:second];
+    dispatch_semaphore_signal(done);
+  });
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    dispatch_semaphore_wait(start, DISPATCH_TIME_FOREVER);
+    prevB = [self.map putReplacing:@1 value:third];
+    dispatch_semaphore_signal(done);
+  });
+
+  dispatch_semaphore_signal(start);
+  dispatch_semaphore_signal(start);
+  XCTAssertEqual(dispatch_semaphore_wait(done, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC)),
+                 0);
+  XCTAssertEqual(dispatch_semaphore_wait(done, dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC)),
+                 0);
+
+  id winner = [self.map get:@1];
+  XCTAssertTrue(winner == second || winner == third);
+  id returnedFirst = prevA == first ? prevA : prevB;
+  XCTAssertEqual(first, returnedFirst);
+}
+
+@end

package/lib/common/Base64.ts

@@ -17,7 +17,6 @@
 
 // @ts-expect-error - No type declarations available
 import binaryToBase64 from 'react-native/Libraries/Utilities/binaryToBase64';
-import { promiseDefer } from './promise';
 
 const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
 
@@ -90,23 +89,18 @@ export interface Base64Result {
  */
 function fromData(data: Blob | ArrayBuffer | Uint8Array): Promise<Base64Result> {
   if (data instanceof Blob) {
-    const fileReader = new FileReader();
-    const { resolve, reject, promise } = promiseDefer<Base64Result>();
+    return new Promise<Base64Result>((resolve, reject) => {
+      const fileReader = new FileReader();
 
-    fileReader.readAsDataURL(data);
+      fileReader.onloadend = () => {
+        if (fileReader.result) {
+          resolve({ string: fileReader.result, format: 'data_url' });
+        }
+      };
 
-    fileReader.onloadend = () => {
-      if (fileReader?.result) {
-        resolve?.({ string: fileReader.result, format: 'data_url' });
-      }
-    };
-
-    fileReader.onerror = event => {
-      fileReader?.abort();
-      reject?.(event);
-    };
-
-    return promise;
+      fileReader.onerror = event => reject(event);
+      fileReader.readAsDataURL(data);
+    });
   }
 
   if (data instanceof ArrayBuffer || data instanceof Uint8Array) {

package/lib/common/index.ts

@@ -30,18 +30,29 @@ export { default as ReferenceBase } from './ReferenceBase';
 export type { DataUrlParts, Observer };
 
 export function getDataUrlParts(dataUrlString: string): DataUrlParts {
-  const isBase64 = dataUrlString.includes(';base64');
-  let [mediaType, base64String] = dataUrlString.split(',');
-  if (!mediaType || !base64String) {
+  const match = /^data:([^,]*?)(;base64)?,([\s\S]*)$/.exec(dataUrlString);
+  if (!match) {
     return { base64String: undefined, mediaType: undefined };
   }
-  mediaType = mediaType.replace('data:', '').replace(';base64', '');
-  if (base64String && base64String.includes('%')) {
-    base64String = decodeURIComponent(base64String);
-  }
-  if (!isBase64) {
-    base64String = Base64.btoa(base64String);
+
+  const mediaType = match[1] || undefined;
+  let base64String = match[3] ?? '';
+
+  try {
+    if (base64String.includes('%')) {
+      base64String = decodeURIComponent(base64String);
+    }
+    if (!match[2]) {
+      const binaryString = encodeURIComponent(base64String).replace(
+        /%([0-9A-F]{2})/g,
+        (_, hex: string) => String.fromCharCode(Number.parseInt(hex, 16)),
+      );
+      base64String = Base64.btoa(binaryString);
+    }
+  } catch (_) {
+    return { base64String: undefined, mediaType: undefined };
   }
+
   return { base64String, mediaType };
 }
 

package/lib/internal/asyncStorage.ts

@@ -29,11 +29,7 @@ const asyncStorageMemory: AsyncStorageStatic = {
     return Promise.resolve();
   },
   getItem(key: string): Promise<string | null> {
-    const hasValue = memoryStorage.has(key);
-    if (hasValue) {
-      return Promise.resolve(memoryStorage.get(key) || null);
-    }
-    return Promise.resolve(null);
+    return Promise.resolve(memoryStorage.get(key) ?? null);
   },
   removeItem(key: string): Promise<void> {
     memoryStorage.delete(key);
@@ -61,16 +57,16 @@ export function isMemoryStorage(): boolean {
 }
 
 // Set an item in storage with the React Native Firebase prefix
-export async function setItem(key: string, value: string): Promise<void> {
-  return await asyncStorage.setItem(prefix + key, value);
+export function setItem(key: string, value: string): Promise<void> {
+  return asyncStorage.setItem(prefix + key, value);
 }
 
 // Get an item from storage with the React Native Firebase prefix
-export async function getItem(key: string): Promise<string | null> {
-  return await asyncStorage.getItem(prefix + key);
+export function getItem(key: string): Promise<string | null> {
+  return asyncStorage.getItem(prefix + key);
 }
 
 // Remove an item from storage with the React Native Firebase prefix
-export async function removeItem(key: string): Promise<void> {
-  return await asyncStorage.removeItem(prefix + key);
+export function removeItem(key: string): Promise<void> {
+  return asyncStorage.removeItem(prefix + key);
 }

package/lib/internal/logger.ts

@@ -108,6 +108,50 @@ const defaultLogHandler: LogHandler = (instance, logType, ...args) => {
 
 const defaultLogLevel = LogLevel.INFO;
 
+let currentLogLevel = defaultLogLevel;
+let currentUserLogHandler: LogHandler | null = null;
+
+function createUserLogHandler(
+  logCallback: LogCallback | null,
+  options?: LogOptions,
+): LogHandler | null {
+  if (logCallback === null) {
+    return null;
+  }
+
+  const customLogLevel = options?.level ? levelStringToEnum[options.level] : null;
+  return (instance, level, ...args) => {
+    const message = args
+      .map(arg => {
+        if (arg == null) {
+          return null;
+        } else if (typeof arg === 'string') {
+          return arg;
+        } else if (typeof arg === 'number' || typeof arg === 'boolean') {
+          return arg.toString();
+        } else if (arg instanceof Error) {
+          return arg.message;
+        } else {
+          try {
+            return JSON.stringify(arg);
+          } catch (_ignored) {
+            return null;
+          }
+        }
+      })
+      .filter(arg => arg)
+      .join(' ');
+    if (level >= (customLogLevel ?? instance.logLevel)) {
+      logCallback({
+        level: LogLevelReversed[level]!.toLowerCase() as LogLevelString,
+        message,
+        args,
+        type: instance.name,
+      });
+    }
+  };
+}
+
 /**
  * A container for all of the Logger instances
  */
@@ -118,9 +162,9 @@ export const instances: Logger[] = [];
  */
 export class Logger {
   name: string;
-  private _logLevel: LogLevel = defaultLogLevel;
+  private _logLevel: LogLevel = currentLogLevel;
   private _logHandler: LogHandler = defaultLogHandler;
-  private _userLogHandler: LogHandler | null = null;
+  private _userLogHandler: LogHandler | null = currentUserLogHandler;
 
   /**
    * Gives you an instance of a Logger to capture messages according to
@@ -215,9 +259,11 @@ export class Logger {
  * Sets the log level for all Logger instances
  */
 export function setLogLevel(level: LogLevelString | LogLevel): void {
-  instances.forEach(inst => {
-    inst.setLogLevel(level);
-  });
+  const normalizedLevel = typeof level === 'string' ? levelStringToEnum[level] : level;
+  currentLogLevel = normalizedLevel;
+  for (const instance of instances) {
+    instance.setLogLevel(normalizedLevel);
+  }
 }
 
 // Alias for compatibility
@@ -227,44 +273,8 @@ export const setLogLevelInternal = setLogLevel;
  * Sets a custom user log handler for all Logger instances
  */
 export function setUserLogHandler(logCallback: LogCallback | null, options?: LogOptions): void {
+  currentUserLogHandler = createUserLogHandler(logCallback, options);
   for (const instance of instances) {
-    let customLogLevel: LogLevel | null = null;
-    if (options?.level) {
-      customLogLevel = levelStringToEnum[options.level];
-    }
-    if (logCallback === null) {
-      instance.userLogHandler = null;
-    } else {
-      instance.userLogHandler = (_instance, level, ...args) => {
-        const message = args
-          .map(arg => {
-            if (arg == null) {
-              return null;
-            } else if (typeof arg === 'string') {
-              return arg;
-            } else if (typeof arg === 'number' || typeof arg === 'boolean') {
-              return arg.toString();
-            } else if (arg instanceof Error) {
-              return arg.message;
-            } else {
-              try {
-                return JSON.stringify(arg);
-              } catch (_ignored) {
-                return null;
-              }
-            }
-          })
-          .filter(arg => arg)
-          .join(' ');
-        if (level >= (customLogLevel ?? _instance.logLevel)) {
-          logCallback({
-            level: LogLevelReversed[level]!.toLowerCase() as LogLevelString,
-            message,
-            args,
-            type: _instance.name,
-          });
-        }
-      };
-    }
+    instance.userLogHandler = currentUserLogHandler;
   }
 }

package/lib/internal/nativeModuleAndroidIos.ts

@@ -1,5 +1,5 @@
-/* eslint-disable no-console */
 import { TurboModuleRegistry } from 'react-native';
+import { createNativeModuleDebugProxy } from './nativeModuleDebug';
 
 const DYNAMIC_CONSTANT_KEYS = new Set(['androidPlayServices']);
 
@@ -64,45 +64,7 @@ export function getReactNativeModule(moduleName: string): Record<string, unknown
     return debugProxy;
   }
 
-  debugProxy = new Proxy(nativeModule as Record<string, unknown>, {
-    ownKeys(target) {
-      const keys: string[] = [];
-      for (const key in target) {
-        keys.push(key);
-      }
-      return keys;
-    },
-    get: (_, name) => {
-      const prop = (nativeModule as Record<string, unknown>)[name as string];
-      if (typeof prop !== 'function') return prop;
-      return (...args: unknown[]) => {
-        console.debug(
-          `[RNFB->Native][🔵] ${moduleName}.${String(name)} -> ${JSON.stringify(args)}`,
-        );
-        const result: unknown = (prop as (...args: unknown[]) => unknown).apply(nativeModule, args);
-        if (result && typeof result === 'object' && 'then' in result) {
-          return (result as Promise<unknown>).then(
-            (res: unknown) => {
-              console.debug(
-                `[RNFB<-Native][🟢] ${moduleName}.${String(name)} <- ${JSON.stringify(res)}`,
-              );
-              return res;
-            },
-            (err: unknown) => {
-              console.debug(
-                `[RNFB<-Native][🔴] ${moduleName}.${String(name)} <- ${JSON.stringify(err)}`,
-              );
-              throw err;
-            },
-          );
-        }
-        console.debug(
-          `[RNFB<-Native][🟢] ${moduleName}.${String(name)} <- ${JSON.stringify(result)}`,
-        );
-        return result;
-      };
-    },
-  });
+  debugProxy = createNativeModuleDebugProxy(moduleName, nativeModule);
   memoizedDebugProxies.set(moduleName, debugProxy);
   return debugProxy;
 }

package/lib/internal/nativeModuleDebug.ts

@@ -0,0 +1,97 @@
+/* eslint-disable no-console */
+
+function serializeDebugValue(value: unknown): string {
+  const seen = new WeakSet<object>();
+
+  try {
+    const serialized = JSON.stringify(value, (_key, currentValue: unknown) => {
+      if (typeof currentValue === 'bigint') {
+        return `${currentValue}n`;
+      }
+      if (currentValue instanceof Error) {
+        return { name: currentValue.name, message: currentValue.message };
+      }
+      if (currentValue && typeof currentValue === 'object') {
+        if (seen.has(currentValue)) {
+          return '[Circular]';
+        }
+        seen.add(currentValue);
+      }
+      return currentValue;
+    });
+    return serialized ?? String(value);
+  } catch (_error) {
+    return '[Unserializable]';
+  }
+}
+
+function logDebug(message: string): void {
+  try {
+    console.debug(message);
+  } catch (_error) {
+    // Debug logging must not change native module behavior.
+  }
+}
+
+export function createNativeModuleDebugProxy(
+  moduleName: string,
+  nativeModule: Record<string, unknown>,
+): Record<string, unknown> {
+  return new Proxy(nativeModule, {
+    ownKeys(target) {
+      const keys: string[] = [];
+      for (const key in target) {
+        keys.push(key);
+      }
+      return keys;
+    },
+    get: (_, name) => {
+      const prop = nativeModule[name as string];
+      if (typeof prop !== 'function') return prop;
+
+      return (...args: unknown[]) => {
+        logDebug(
+          `[RNFB->Native][🔵] ${moduleName}.${String(name)} -> ${serializeDebugValue(args)}`,
+        );
+
+        let result: unknown;
+        try {
+          result = Reflect.apply(prop, nativeModule, args);
+        } catch (error) {
+          logDebug(
+            `[RNFB<-Native][🔴] ${moduleName}.${String(name)} <- ${serializeDebugValue(error)}`,
+          );
+          throw error;
+        }
+
+        if (
+          result &&
+          typeof result === 'object' &&
+          typeof (result as Promise<unknown>).then === 'function'
+        ) {
+          return (result as Promise<unknown>).then(
+            resolvedValue => {
+              logDebug(
+                `[RNFB<-Native][🟢] ${moduleName}.${String(name)} <- ${serializeDebugValue(
+                  resolvedValue,
+                )}`,
+              );
+              return resolvedValue;
+            },
+            error => {
+              logDebug(
+                `[RNFB<-Native][🔴] ${moduleName}.${String(name)} <- ${serializeDebugValue(error)}`,
+              );
+              throw error;
+            },
+          );
+        }
+
+        logDebug(
+          `[RNFB<-Native][🟢] ${moduleName}.${String(name)} <- ${serializeDebugValue(result)}`,
+        );
+        return result;
+      };
+    },
+  });
+}