@react-native-firebase/app 23.7.0 → 23.8.1

package/lib/internal/asyncStorage.ts

@@ -0,0 +1,76 @@
+/*
+ * 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 type { AsyncStorageStatic } from '../types/internal';
+
+// Memory storage Map instance
+export const memoryStorage = new Map<string, string>();
+
+// Storage key prefix
+export const prefix = '@react-native-firebase:';
+
+const asyncStorageMemory: AsyncStorageStatic = {
+  setItem(key: string, value: string): Promise<void> {
+    memoryStorage.set(key, value);
+    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);
+  },
+  removeItem(key: string): Promise<void> {
+    memoryStorage.delete(key);
+    return Promise.resolve();
+  },
+};
+
+let asyncStorage: AsyncStorageStatic = asyncStorageMemory;
+
+// Get the current AsyncStorage instance (either React Native AsyncStorage or memory storage)
+export async function getReactNativeAsyncStorageInternal(): Promise<AsyncStorageStatic> {
+  return asyncStorage;
+}
+
+// Set the AsyncStorage instance to use (React Native AsyncStorage or fallback to memory storage)
+export function setReactNativeAsyncStorageInternal(
+  asyncStorageInstance?: AsyncStorageStatic,
+): void {
+  asyncStorage = asyncStorageInstance || asyncStorageMemory;
+}
+
+// Check if currently using memory storage (fallback)
+export function isMemoryStorage(): boolean {
+  return asyncStorage === asyncStorageMemory;
+}
+
+// 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);
+}
+
+// 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);
+}
+
+// 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);
+}

package/lib/internal/{constants.js → constants.ts}

@@ -39,4 +39,6 @@ export const KNOWN_NAMESPACES = [
   'notifications',
   'perf',
   'utils',
-];
+] as const;
+
+export type KnownNamespace = (typeof KNOWN_NAMESPACES)[number];

package/lib/internal/global.d.ts

@@ -0,0 +1,33 @@
+/*
+ * 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.
+ *
+ */
+
+/**
+ * Global RNFB properties for debugging and testing
+ */
+declare global {
+  // Debug and testing flags
+  var RNFBDebug: boolean | undefined;
+  var RNFBTest: boolean | undefined;
+  var RNFBDebugInTestLeakDetection: boolean | undefined;
+  var RNFBDebugLastTest: string | undefined;
+
+  // Modular API deprecation flags
+  var RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS: boolean | undefined;
+  var RNFB_MODULAR_DEPRECATION_STRICT_MODE: boolean | undefined;
+}
+
+export {};

package/lib/internal/{index.js → index.ts}

@@ -19,8 +19,10 @@ export { default as FirebaseApp } from '../FirebaseApp';
 export * from './constants';
 export { default as FirebaseModule } from './FirebaseModule';
 export { default as NativeFirebaseError } from './NativeFirebaseError';
+export * from './NativeModules';
 export * from './registry/app';
 export * from './registry/namespace';
 export * from './registry/nativeModule';
 export { default as SharedEventEmitter } from './SharedEventEmitter';
 export { Logger } from './logger';
+export type { ModuleConfig } from '../types/internal';

package/lib/internal/logger.ts

@@ -0,0 +1,270 @@
+/*
+ * 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 type { LogCallback, LogOptions } from '../types/app';
+
+type LogLevelString = 'debug' | 'verbose' | 'info' | 'warn' | 'error' | 'silent';
+
+/**
+ * The JS SDK supports 5 log levels and also allows a user the ability to
+ * silence the logs altogether.
+ *
+ * The order is a follows:
+ * DEBUG < VERBOSE < INFO < WARN < ERROR
+ *
+ * All of the log types above the current log level will be captured (i.e. if
+ * you set the log level to `INFO`, errors will still be logged, but `DEBUG` and
+ * `VERBOSE` logs will not)
+ */
+export enum LogLevel {
+  DEBUG = 0,
+  VERBOSE = 1,
+  INFO = 2,
+  WARN = 3,
+  ERROR = 4,
+  SILENT = 5,
+}
+
+// mimic the LogLevel in firebase-js-sdk TS
+const reverseLogLevel = (obj: typeof LogLevel): Record<number, string> => {
+  const reversed: Record<number, string> = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === 'number') {
+      reversed[value] = key;
+    }
+  }
+  return reversed;
+};
+
+const LogLevelReversed = reverseLogLevel(LogLevel);
+
+type LevelStringToEnum = {
+  [K in LogLevelString]: LogLevel;
+};
+
+const levelStringToEnum: LevelStringToEnum = {
+  debug: LogLevel.DEBUG,
+  verbose: LogLevel.VERBOSE,
+  info: LogLevel.INFO,
+  warn: LogLevel.WARN,
+  error: LogLevel.ERROR,
+  silent: LogLevel.SILENT,
+};
+
+/**
+ * By default, `console.debug` is not displayed in the developer console (in
+ * chrome). To avoid forcing users to have to opt-in to these logs twice
+ * (i.e. once for firebase, and once in the console), we are sending `DEBUG`
+ * logs to the `console.log` function.
+ */
+const ConsoleMethod: Record<LogLevel, 'log' | 'info' | 'warn' | 'error'> = {
+  [LogLevel.DEBUG]: 'log',
+  [LogLevel.VERBOSE]: 'log',
+  [LogLevel.INFO]: 'info',
+  [LogLevel.WARN]: 'warn',
+  [LogLevel.ERROR]: 'error',
+  [LogLevel.SILENT]: 'error', // fallback, should never be used
+};
+
+/**
+ * We allow users the ability to pass their own log handler. We will pass the
+ * type of log, the current log level, and any other arguments passed (i.e. the
+ * messages that the user wants to log) to this function.
+ */
+export type LogHandler = (loggerInstance: Logger, logType: LogLevel, ...args: unknown[]) => void;
+
+/**
+ * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR
+ * messages on to their corresponding console counterparts (if the log method
+ * is supported by the current log level)
+ */
+const defaultLogHandler: LogHandler = (instance, logType, ...args) => {
+  if (logType < instance.logLevel) {
+    return;
+  }
+  const now = new Date().toISOString();
+  const method = ConsoleMethod[logType];
+  if (method) {
+    // 'log' | 'info' | 'warn' | 'error'
+    (console as any)[method](`[${now}]  ${instance.name}:`, ...args);
+  } else {
+    throw new Error(`Attempted to log a message with an invalid logType (value: ${logType})`);
+  }
+};
+
+const defaultLogLevel = LogLevel.INFO;
+
+/**
+ * A container for all of the Logger instances
+ */
+export const instances: Logger[] = [];
+
+/**
+ * Logger class for Firebase
+ */
+export class Logger {
+  name: string;
+  private _logLevel: LogLevel = defaultLogLevel;
+  private _logHandler: LogHandler = defaultLogHandler;
+  private _userLogHandler: LogHandler | null = null;
+
+  /**
+   * Gives you an instance of a Logger to capture messages according to
+   * Firebase's logging scheme.
+   *
+   * @param name The name that the logs will be associated with
+   */
+  constructor(name: string) {
+    /**
+     * Capture the current instance for later use
+     */
+    this.name = name;
+    instances.push(this);
+  }
+
+  /**
+   * The log level of the given Logger instance.
+   */
+  get logLevel(): LogLevel {
+    return this._logLevel;
+  }
+
+  set logLevel(val: LogLevel) {
+    if (!(val in LogLevel)) {
+      throw new TypeError(`Invalid value "${val}" assigned to \`logLevel\``);
+    }
+    this._logLevel = val;
+  }
+
+  // Workaround for setter/getter having to be the same type.
+  setLogLevel(val: LogLevel | LogLevelString): void {
+    this._logLevel = typeof val === 'string' ? levelStringToEnum[val] : val;
+  }
+
+  /**
+   * The main (internal) log handler for the Logger instance.
+   * Can be set to a new function in internal package code but not by user.
+   */
+  get logHandler(): LogHandler {
+    return this._logHandler;
+  }
+
+  set logHandler(val: LogHandler) {
+    if (typeof val !== 'function') {
+      throw new TypeError('Value assigned to `logHandler` must be a function');
+    }
+    this._logHandler = val;
+  }
+
+  /**
+   * The optional, additional, user-defined log handler for the Logger instance.
+   */
+  get userLogHandler(): LogHandler | null {
+    return this._userLogHandler;
+  }
+
+  set userLogHandler(val: LogHandler | null) {
+    this._userLogHandler = val;
+  }
+
+  /**
+   * The functions below are all based on the `console` interface
+   */
+
+  debug(...args: unknown[]): void {
+    this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);
+    this._logHandler(this, LogLevel.DEBUG, ...args);
+  }
+
+  log(...args: unknown[]): void {
+    this._userLogHandler && this._userLogHandler(this, LogLevel.VERBOSE, ...args);
+    this._logHandler(this, LogLevel.VERBOSE, ...args);
+  }
+
+  info(...args: unknown[]): void {
+    this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);
+    this._logHandler(this, LogLevel.INFO, ...args);
+  }
+
+  warn(...args: unknown[]): void {
+    this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);
+    this._logHandler(this, LogLevel.WARN, ...args);
+  }
+
+  error(...args: unknown[]): void {
+    this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);
+    this._logHandler(this, LogLevel.ERROR, ...args);
+  }
+}
+
+/**
+ * Sets the log level for all Logger instances
+ */
+export function setLogLevel(level: LogLevelString | LogLevel): void {
+  instances.forEach(inst => {
+    inst.setLogLevel(level);
+  });
+}
+
+// Alias for compatibility
+export const setLogLevelInternal = setLogLevel;
+
+/**
+ * Sets a custom user log handler for all Logger instances
+ */
+export function setUserLogHandler(logCallback: LogCallback | null, options?: LogOptions): void {
+  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,
+          });
+        }
+      };
+    }
+  }
+}

package/lib/internal/nativeModuleAndroidIos.ts

@@ -0,0 +1,55 @@
+/* eslint-disable no-console */
+import { NativeModules } from 'react-native';
+
+/**
+ * This is used by Android and iOS to get a native module.
+ * We additionally add a Proxy to the module to intercept calls
+ * and log them to the console for debugging purposes, if enabled.
+ * @param moduleName
+ * @returns Raw native module from React Native (object with methods/properties or undefined)
+ */
+export function getReactNativeModule(moduleName: string): Record<string, unknown> | undefined {
+  const nativeModule = NativeModules[moduleName];
+  if (!globalThis.RNFBDebug) {
+    return nativeModule;
+  }
+  return new Proxy(nativeModule, {
+    ownKeys(target) {
+      return Object.keys(target);
+    },
+    get: (_, name) => {
+      const prop = nativeModule[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)(...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;
+      };
+    },
+  });
+}
+
+export function setReactNativeModule(): void {
+  // No-op
+}

package/lib/internal/nativeModuleWeb.ts

@@ -0,0 +1,60 @@
+/* eslint-disable no-console */
+import RNFBAppModule from './web/RNFBAppModule';
+
+const nativeModuleRegistry: Record<string, Record<string, unknown>> = {};
+
+export function getReactNativeModule(moduleName: string): Record<string, unknown> | undefined {
+  const nativeModule = nativeModuleRegistry[moduleName];
+  // Throw an error if the module is not registered.
+  if (!nativeModule) {
+    throw new Error(`Native module ${moduleName} is not registered.`);
+  }
+  if (!globalThis.RNFBDebug) {
+    return nativeModule;
+  }
+  return new Proxy(nativeModule, {
+    ownKeys(target) {
+      // FIXME - test in new arch context - I don't think Object.keys works
+      return Object.keys(target);
+    },
+    get: (_, name) => {
+      const prop = nativeModule[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)(...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;
+      };
+    },
+  });
+}
+
+export function setReactNativeModule(
+  moduleName: string,
+  nativeModule: Record<string, unknown>,
+): void {
+  nativeModuleRegistry[moduleName] = nativeModule;
+}
+
+setReactNativeModule('RNFBAppModule', RNFBAppModule);

package/lib/internal/nullSerialization.ts

@@ -0,0 +1,186 @@
+/*
+ * 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.
+ *
+ */
+
+const NULL_SENTINEL = { __rnfbNull: true };
+
+type Encodable = string | number | boolean | null | EncodableObject | EncodableArray;
+type EncodableObject = { [key: string]: Encodable };
+type EncodableArray = Encodable[];
+
+type ArrayFrame = {
+  type: 'array';
+  original: unknown[];
+  encoded: unknown[];
+  index: number;
+};
+
+type ObjectFrame = {
+  type: 'object';
+  original: Record<string, unknown>;
+  encoded: Record<string, unknown>;
+  keys: string[];
+  index: number;
+};
+
+type StackFrame = ArrayFrame | ObjectFrame;
+
+/**
+ * Replaces null values in object properties with sentinel objects for iOS TurboModule compatibility.
+ * Uses iterative stack-based traversal to avoid stack overflow on deeply nested structures.
+ *
+ * iOS TurboModules strip null values from object properties during serialization,
+ * so we replace them with sentinel objects that can survive the serialization
+ * and be detected/restored on the native side.
+ *
+ * Note: Null values in arrays are preserved by iOS TurboModules, so we don't
+ * encode them (but we still process nested objects within arrays).
+ *
+ * @param data - The data to encode
+ * @returns The encoded data with null object properties replaced by sentinels
+ */
+export function encodeNullValues(data: unknown): unknown {
+  if (data === null) {
+    // only null values within objects are encoded
+    return null;
+  }
+  if (typeof data !== 'object') {
+    return data;
+  }
+
+  // Helper to process a child element and add it to the encoded container
+  function processArrayChild(
+    child: unknown,
+    encoded: unknown[],
+    index: number,
+    stack: StackFrame[],
+  ): void {
+    if (child === null) {
+      // Arrays preserve nulls as null
+      encoded[index] = null;
+    } else if (typeof child !== 'object') {
+      encoded[index] = child;
+    } else if (Array.isArray(child)) {
+      const childEncoded: unknown[] = new Array(child.length);
+      encoded[index] = childEncoded;
+      stack.push({
+        type: 'array',
+        original: child,
+        encoded: childEncoded,
+        index: 0,
+      });
+    } else {
+      const childEncoded: Record<string, unknown> = {};
+      encoded[index] = childEncoded;
+      stack.push({
+        type: 'object',
+        original: child as Record<string, unknown>,
+        encoded: childEncoded,
+        keys: Object.keys(child),
+        index: 0,
+      });
+    }
+  }
+
+  function processObjectChild(
+    child: unknown,
+    encoded: Record<string, unknown>,
+    key: string,
+    stack: StackFrame[],
+  ): void {
+    if (child === null) {
+      // Objects convert null to sentinel
+      encoded[key] = NULL_SENTINEL;
+    } else if (typeof child !== 'object') {
+      encoded[key] = child;
+    } else if (Array.isArray(child)) {
+      const childEncoded: unknown[] = new Array(child.length);
+      encoded[key] = childEncoded;
+      stack.push({
+        type: 'array',
+        original: child,
+        encoded: childEncoded,
+        index: 0,
+      });
+    } else {
+      const childEncoded: Record<string, unknown> = {};
+      encoded[key] = childEncoded;
+      stack.push({
+        type: 'object',
+        original: child as Record<string, unknown>,
+        encoded: childEncoded,
+        keys: Object.keys(child),
+        index: 0,
+      });
+    }
+  }
+
+  // Prepare root encoded container
+  let rootEncoded: unknown[] | Record<string, unknown>;
+  const stack: StackFrame[] = [];
+
+  if (Array.isArray(data)) {
+    rootEncoded = new Array(data.length);
+    stack.push({
+      type: 'array',
+      original: data,
+      encoded: rootEncoded,
+      index: 0,
+    });
+  } else {
+    rootEncoded = {};
+    stack.push({
+      type: 'object',
+      original: data as Record<string, unknown>,
+      encoded: rootEncoded,
+      keys: Object.keys(data),
+      index: 0,
+    });
+  }
+
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1]!; // Non-null assertion safe due to while condition
+
+    if (frame.type === 'array') {
+      const { original, encoded } = frame;
+
+      if (frame.index >= original.length) {
+        // Done with this array
+        stack.pop();
+        continue;
+      }
+
+      const i = frame.index++;
+      const item = original[i];
+      processArrayChild(item, encoded, i, stack);
+    } else {
+      // frame.type === 'object'
+      const { original, encoded, keys } = frame;
+
+      if (frame.index >= keys.length) {
+        // Done with this object
+        stack.pop();
+        continue;
+      }
+
+      const key = keys[frame.index++]!; // Non-null assertion safe due to length check above
+      const value = original[key];
+      processObjectChild(value, encoded, key, stack);
+    }
+  }
+
+  return rootEncoded;
+}