@react-native-firebase/app 25.0.1 → 26.0.0

package/lib/common/unitTestUtils.ts

@@ -1,74 +1,18 @@
-import { expect, jest } from '@jest/globals';
-import { createMessage } from './index';
+/*
+ * 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.
+ *
+ */
 
-export const checkV9Deprecation = (modularFunction: () => void, nonModularFunction: () => void) => {
-  const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-  consoleWarnSpy.mockRestore();
-  modularFunction();
-  expect(consoleWarnSpy).not.toHaveBeenCalled();
-  consoleWarnSpy.mockClear();
-  const consoleWarnSpy2 = jest.spyOn(console, 'warn').mockImplementation(() => {});
-  nonModularFunction();
-
-  expect(consoleWarnSpy2).toHaveBeenCalledTimes(1);
-  consoleWarnSpy2.mockClear();
-};
-
-export type CheckV9DeprecationFunction = (
-  modularFunction: () => void,
-  nonModularFunction: () => void,
-  methodNameKey: string,
-  uniqueMessage?: string | null,
-  ignoreFirebaseAppDeprecationWarning?: boolean,
-) => void;
-
-export const withDeprecationWarningsSilenced = <T>(fn: () => T): T => {
-  const previous = globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS;
-  globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS = true;
-  try {
-    return fn();
-  } finally {
-    globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS = previous;
-  }
-};
-
-export const createCheckV9Deprecation = (moduleNames: string[]): CheckV9DeprecationFunction => {
-  return (
-    modularFunction: () => void,
-    nonModularFunction: () => void,
-    methodNameKey: string,
-    uniqueMessage?: string | null,
-    checkFirebaseAppDeprecationWarning: boolean = false,
-  ) => {
-    const moduleName = moduleNames[0] as string; // firestore, database, etc
-    const instanceName = moduleNames[1] || 'default'; // default, FirestoreCollectionReference, etc
-    const consoleWarnSpy = jest.spyOn(console, 'warn');
-    consoleWarnSpy.mockReset();
-
-    consoleWarnSpy.mockImplementation(warnMessage => {
-      const firebaseAppDeprecationMessage = warnMessage.includes('Please use `getApp()` instead.');
-      if (checkFirebaseAppDeprecationWarning) {
-        throw new Error(`Console warn was called unexpectedly with: ${warnMessage}`);
-      } else {
-        if (!firebaseAppDeprecationMessage) {
-          // we want to ignore all firebase app deprecation warnings (e.g. "Please use `getApp()` instead.") unless actually testing for it which we do above
-          throw new Error(`Console warn was called unexpectedly with: ${warnMessage}`);
-        }
-      }
-    });
-    // Do not call `mockRestore()` unless removing the spy
-    modularFunction();
-    consoleWarnSpy.mockReset();
-    consoleWarnSpy.mockRestore();
-    const consoleWarnSpy2 = jest.spyOn(console, 'warn').mockImplementation(warnMessage => {
-      const message = createMessage(moduleName, methodNameKey, instanceName, uniqueMessage);
-      if (message) {
-        expect(warnMessage).toMatch(message);
-      }
-    });
-    nonModularFunction();
-
-    expect(consoleWarnSpy2).toHaveBeenCalledTimes(1);
-    consoleWarnSpy2.mockReset();
-  };
-};
+export {};

package/lib/index.ts

@@ -15,7 +15,6 @@
  *
  */
 
-export { firebase, utils, default } from './namespaced';
 export * from './modular';
 export type {
   ReactNativeFirebase,

package/lib/internal/NativeFirebaseError.ts

@@ -22,7 +22,7 @@ export default class NativeFirebaseError extends Error {
   readonly code!: string;
   readonly jsStack!: string;
   readonly userInfo!: NativeErrorUserInfo;
-  readonly customData: any;
+  readonly customData!: Record<string, unknown> | null;
   readonly operationType!: string | null;
   readonly nativeErrorCode!: string | number | null;
   readonly nativeErrorMessage!: string | null;

package/lib/internal/RNFBNativeEventEmitter.ts

@@ -16,6 +16,7 @@
  */
 
 import { type EmitterSubscription, NativeEventEmitter } from 'react-native';
+import { APP_NATIVE_MODULE } from './constants';
 import { getReactNativeModule } from './nativeModule';
 import type { RNFBAppModuleInterface } from './NativeModules';
 
@@ -38,10 +39,11 @@ class RNFBNativeEventEmitter extends NativeEventEmitter {
   ready: boolean;
 
   constructor() {
-    const RNFBAppModule = getReactNativeModule('RNFBAppModule');
+    // NewArch-AD-18 E1: NativeEventEmitter must receive the same raw host that implements addListener/removeListeners.
+    const RNFBAppModule = getReactNativeModule(APP_NATIVE_MODULE);
     if (!RNFBAppModule) {
       throw new Error(
-        'Native module RNFBAppModule not found. Re-check module install, linking, configuration, build and install steps.',
+        `Native module ${APP_NATIVE_MODULE} not found. Re-check module install, linking, configuration, build and install steps.`,
       );
     }
     // Cast to any for NativeEventEmitter constructor which expects React Native's NativeModule type
@@ -54,8 +56,9 @@ class RNFBNativeEventEmitter extends NativeEventEmitter {
     listener: (...args: unknown[]) => unknown,
     context?: object,
   ): EmitterSubscription {
+    // NewArch-AD-18 E1: event bridge identity requires raw app-module host for listener registration.
     const RNFBAppModule = getReactNativeModule(
-      'RNFBAppModule',
+      APP_NATIVE_MODULE,
     ) as unknown as RNFBAppModuleInterface;
     if (!this.ready) {
       (RNFBAppModule.eventsNotifyReady as EventsNotifyReadyMethod)(true);
@@ -99,7 +102,8 @@ class RNFBNativeEventEmitter extends NativeEventEmitter {
     // we will modify it to do our native unsubscription then call the original
     const originalRemove = subscription.remove;
     const newRemove = () => {
-      const module = getReactNativeModule('RNFBAppModule') as unknown as RNFBAppModuleInterface;
+      // NewArch-AD-18 E1: raw host for eventsRemoveListener on unsubscribe.
+      const module = getReactNativeModule(APP_NATIVE_MODULE) as unknown as RNFBAppModuleInterface;
       (module.eventsRemoveListener as EventsRemoveListenerMethod)(eventType, false);
       const superClass = Object.getPrototypeOf(Object.getPrototypeOf(this));
       if (superClass.removeSubscription != null) {
@@ -115,8 +119,9 @@ class RNFBNativeEventEmitter extends NativeEventEmitter {
   }
 
   removeAllListeners(eventType: string): void {
+    // NewArch-AD-18 E1: raw host for eventsRemoveListener.
     const RNFBAppModule = getReactNativeModule(
-      'RNFBAppModule',
+      APP_NATIVE_MODULE,
     ) as unknown as RNFBAppModuleInterface;
     (RNFBAppModule.eventsRemoveListener as EventsRemoveListenerMethod)(eventType, true);
     super.removeAllListeners(`rnfb_${eventType}`);
@@ -124,8 +129,9 @@ class RNFBNativeEventEmitter extends NativeEventEmitter {
 
   // This is likely no longer ever called, but it is here for backwards compatibility with RN <= 0.64
   removeSubscription(subscription: EmitterSubscription & { eventType?: string }): void {
+    // NewArch-AD-18 E1: raw host for legacy removeSubscription path.
     const RNFBAppModule = getReactNativeModule(
-      'RNFBAppModule',
+      APP_NATIVE_MODULE,
     ) as unknown as RNFBAppModuleInterface;
     const eventType = subscription.eventType?.replace('rnfb_', '') || '';
     (RNFBAppModule.eventsRemoveListener as EventsRemoveListenerMethod)(eventType, false);

package/lib/internal/constants.ts

@@ -15,30 +15,8 @@
  *
  */
 
-export const APP_NATIVE_MODULE = 'RNFBAppModule';
+export const APP_NATIVE_MODULE = 'NativeRNFBTurboApp';
 
-export const DEFAULT_APP_NAME = '[DEFAULT]';
-
-export const KNOWN_NAMESPACES = [
-  'appCheck',
-  'appDistribution',
-  'auth',
-  'analytics',
-  'remoteConfig',
-  'crashlytics',
-  'database',
-  'inAppMessaging',
-  'installations',
-  'firestore',
-  'functions',
-  'indexing',
-  'storage',
-  'messaging',
-  'naturalLanguage',
-  'ml',
-  'notifications',
-  'perf',
-  'utils',
-] as const;
+export const UTILS_NATIVE_MODULE = 'NativeRNFBTurboUtils';
 
-export type KnownNamespace = (typeof KNOWN_NAMESPACES)[number];
+export const DEFAULT_APP_NAME = '[DEFAULT]';

package/lib/internal/global.d.ts

@@ -24,10 +24,6 @@ declare global {
   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.ts

@@ -21,7 +21,7 @@ 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/modular';
 export * from './registry/nativeModule';
 export { default as SharedEventEmitter } from './SharedEventEmitter';
 export { Logger } from './logger';

package/lib/internal/nativeModuleAndroidIos.ts

@@ -1,30 +1,85 @@
 /* eslint-disable no-console */
-import { NativeModules } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+const DYNAMIC_CONSTANT_KEYS = new Set(['androidPlayServices']);
+
+const memoizedModuleConstants = new Map<string, Record<string, unknown>>();
+const memoizedDebugProxies = new Map<string, Record<string, unknown>>();
+
+function withTurboConstants(
+  moduleName: string,
+  module: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+  if (!module) {
+    return module;
+  }
+
+  const getConstants = module.getConstants;
+  if (typeof getConstants !== 'function') {
+    return module;
+  }
+
+  let constants = memoizedModuleConstants.get(moduleName);
+  if (!constants) {
+    constants = (getConstants as () => Record<string, unknown>).call(module) || {};
+    memoizedModuleConstants.set(moduleName, constants);
+  }
+
+  const descriptors: PropertyDescriptorMap = {};
+  for (const key of Object.keys(constants)) {
+    if (DYNAMIC_CONSTANT_KEYS.has(key)) {
+      continue;
+    }
+    descriptors[key] = {
+      value: constants[key],
+      enumerable: true,
+      writable: true,
+      configurable: true,
+    };
+  }
+
+  return Object.create(module, descriptors);
+}
 
 /**
- * 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)
+ * Unified native module resolver — TurboModule only (NewArch-AD-6 Phase R).
  */
-export function getReactNativeModule(moduleName: string): Record<string, unknown> | undefined {
-  const nativeModule = NativeModules[moduleName];
+export function getReactNativeModule(moduleName: string): Record<string, unknown> {
+  const turboModule = TurboModuleRegistry.get(moduleName);
+  if (!turboModule) {
+    throw new Error(`Native module ${moduleName} is not registered.`);
+  }
+
+  const nativeModule = withTurboConstants(
+    moduleName,
+    turboModule as Record<string, unknown>,
+  ) as Record<string, unknown>;
+
   if (!globalThis.RNFBDebug) {
     return nativeModule;
   }
-  return new Proxy(nativeModule, {
+
+  let debugProxy = memoizedDebugProxies.get(moduleName);
+  if (debugProxy) {
+    return debugProxy;
+  }
+
+  debugProxy = new Proxy(nativeModule as Record<string, unknown>, {
     ownKeys(target) {
-      return Object.keys(target);
+      const keys: string[] = [];
+      for (const key in target) {
+        keys.push(key);
+      }
+      return keys;
     },
     get: (_, name) => {
-      const prop = nativeModule[name as string];
+      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)(...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) => {
@@ -48,6 +103,8 @@ export function getReactNativeModule(moduleName: string): Record<string, unknown
       };
     },
   });
+  memoizedDebugProxies.set(moduleName, debugProxy);
+  return debugProxy;
 }
 
 export function setReactNativeModule(): void {

package/lib/internal/nativeModuleWeb.ts

@@ -1,7 +1,12 @@
 /* eslint-disable no-console */
 import RNFBAppModule from './web/RNFBAppModule';
+import { APP_NATIVE_MODULE } from './constants';
 
-const nativeModuleRegistry: Record<string, Record<string, unknown>> = {};
+// Register before exporting getters — RNFBNativeEventEmitter instantiates during circular imports.
+const nativeModuleRegistry: Record<string, Record<string, unknown>> = {
+  RNFBAppModule: RNFBAppModule as unknown as Record<string, unknown>,
+  [APP_NATIVE_MODULE]: RNFBAppModule as unknown as Record<string, unknown>,
+};
 
 export function getReactNativeModule(moduleName: string): Record<string, unknown> | undefined {
   const nativeModule = nativeModuleRegistry[moduleName];
@@ -14,8 +19,11 @@ export function getReactNativeModule(moduleName: string): Record<string, unknown
   }
   return new Proxy(nativeModule, {
     ownKeys(target) {
-      // FIXME - test in new arch context - I don't think Object.keys works
-      return Object.keys(target);
+      const keys: string[] = [];
+      for (const key in target) {
+        keys.push(key);
+      }
+      return keys;
     },
     get: (_, name) => {
       const prop = nativeModule[name as string];
@@ -56,5 +64,3 @@ export function setReactNativeModule(
 ): void {
   nativeModuleRegistry[moduleName] = nativeModule;
 }
-
-setReactNativeModule('RNFBAppModule', RNFBAppModule);

package/lib/internal/registry/app.ts

@@ -15,16 +15,7 @@
  *
  */
 
-import {
-  isIOS,
-  isOther,
-  isNull,
-  warnIfNotModularCall,
-  isObject,
-  isFunction,
-  isString,
-  isUndefined,
-} from '../../common';
+import { isIOS, isOther, isNull, isObject, isFunction, isString, isUndefined } from '../../common';
 import FirebaseApp from '../../FirebaseApp';
 import { DEFAULT_APP_NAME } from '../constants';
 import { setReactNativeAsyncStorageInternal } from '../asyncStorage';
@@ -38,7 +29,7 @@ type ReactNativeAsyncStorage = ReactNativeFirebase.ReactNativeAsyncStorage;
 
 const APP_REGISTRY: Record<string, FirebaseApp> = {};
 let onAppCreateFn: ((app: FirebaseApp) => void) | null = null;
-let onAppDestroyFn: ((app: FirebaseApp) => void) | null = null;
+const onAppDestroyCallbacks: Array<(app: FirebaseApp) => void> = [];
 let initializedNativeApps = false;
 
 /**
@@ -50,11 +41,11 @@ export function setOnAppCreate(fn: (app: FirebaseApp) => void): void {
 }
 
 /**
- * This was needed to avoid metro require cycles...
+ * Registers an app-destroy listener.
  * @param fn
  */
-export function setOnAppDestroy(fn: (app: FirebaseApp) => void): void {
-  onAppDestroyFn = fn;
+export function addOnAppDestroy(fn: (app: FirebaseApp) => void): void {
+  onAppDestroyCallbacks.push(fn);
 }
 
 /**
@@ -93,7 +84,6 @@ export function initializeNativeApps(): void {
  * @param name
  */
 export function getApp(name: string = DEFAULT_APP_NAME): ReactNativeFirebase.FirebaseApp {
-  warnIfNotModularCall(arguments, 'getApp()');
   if (!initializedNativeApps) {
     initializeNativeApps();
   }
@@ -110,7 +100,6 @@ export function getApp(name: string = DEFAULT_APP_NAME): ReactNativeFirebase.Fir
  * Gets all app instances, used for `firebase.apps`
  */
 export function getApps(): ReactNativeFirebase.FirebaseApp[] {
-  warnIfNotModularCall(arguments, 'getApps()');
   if (!initializedNativeApps) {
     initializeNativeApps();
   }
@@ -126,7 +115,6 @@ export function initializeApp(
   options: Partial<FirebaseAppOptions> = {},
   configOrName?: string | FirebaseAppConfig,
 ): Promise<ReactNativeFirebase.FirebaseApp> {
-  warnIfNotModularCall(arguments, 'initializeApp()');
   let appConfig: FirebaseAppConfig = configOrName as FirebaseAppConfig;
 
   if (!isObject(configOrName) || isNull(configOrName)) {
@@ -220,7 +208,6 @@ export function initializeApp(
 }
 
 export function setLogLevel(logLevel: ReactNativeFirebase.LogLevelString): void {
-  warnIfNotModularCall(arguments, 'setLogLevel()');
   if (!['error', 'warn', 'info', 'debug', 'verbose'].includes(logLevel)) {
     throw new Error('LogLevel must be one of "error", "warn", "info", "debug", "verbose"');
   }
@@ -233,8 +220,6 @@ export function setLogLevel(logLevel: ReactNativeFirebase.LogLevelString): void
 }
 
 export function setReactNativeAsyncStorage(asyncStorage: ReactNativeAsyncStorage): void {
-  warnIfNotModularCall(arguments, 'setReactNativeAsyncStorage()');
-
   if (!isObject(asyncStorage)) {
     throw new Error("setReactNativeAsyncStorage(*) 'asyncStorage' must be an object.");
   }
@@ -272,7 +257,24 @@ export function deleteApp(name: string, nativeInitialized: boolean): Promise<voi
 
   return nativeModule.deleteApp(name).then(() => {
     (app as any)._deleted = true;
-    onAppDestroyFn?.(app);
-    delete APP_REGISTRY[name];
+    try {
+      for (let i = 0; i < onAppDestroyCallbacks.length; i++) {
+        try {
+          onAppDestroyCallbacks[i]?.(app);
+        } catch (e) {
+          // A failing destroy listener must not prevent the remaining listeners (or the
+          // registry cleanup below) from running. Surface it for diagnosis — partial cleanup
+          // here can leave a module's native/JS state stale for the deleted app.
+          // eslint-disable-next-line no-console
+          console.warn(
+            `Firebase: an onAppDestroy callback (index ${i}) for app '${name}' threw and was ` +
+              'skipped; remaining callbacks will still run. Inspect the offending listener:',
+            e,
+          );
+        }
+      }
+    } finally {
+      delete APP_REGISTRY[name];
+    }
   });
 }

package/lib/internal/registry/modular.ts

@@ -0,0 +1,97 @@
+/*
+ * 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 { DEFAULT_APP_NAME } from '../constants';
+import type FirebaseModule from '../FirebaseModule';
+import type { ReactNativeFirebase } from '../../types/app';
+import type { ModuleConfig } from '../../types/internal';
+import { addOnAppDestroy, getApp } from './app';
+
+/**
+ * Constructor signature shared by every {@link FirebaseModule} subclass.
+ */
+type ModularModuleClass<T extends FirebaseModule> = new (
+  app: ReactNativeFirebase.FirebaseAppBase,
+  config: ModuleConfig,
+  customUrlOrRegion?: string | null,
+) => T;
+
+// app.name -> instanceKey -> module instance
+const MODULAR_INSTANCES: Record<string, Record<string, FirebaseModule>> = {};
+
+let destroyHookRegistered = false;
+function ensureDestroyHook(): void {
+  if (destroyHookRegistered) {
+    return;
+  }
+  destroyHookRegistered = true;
+  addOnAppDestroy(app => {
+    delete MODULAR_INSTANCES[app.name];
+  });
+}
+
+/**
+ * Builds (and memoises per app) a Firebase service instance for the modular API.
+ *
+ * Each module's `index.ts` defines its own `ModuleClass` and `ModuleConfig` and calls this from
+ * `getX(app?)`.
+ *
+ * @param ModuleClass - The module's `FirebaseModule` subclass.
+ * @param config - Static `ModuleConfig` for the module (namespace, native module name, support flags).
+ * @param app - The `FirebaseApp` to use; defaults to the default app.
+ * @param customUrlOrRegion - Optional URL/region/databaseId for modules that support it.
+ * @returns The memoised module instance for that app + key.
+ */
+export function getOrCreateModularInstance<T extends FirebaseModule>(
+  ModuleClass: ModularModuleClass<T>,
+  config: ModuleConfig,
+  app?: ReactNativeFirebase.FirebaseApp,
+  customUrlOrRegion?: string | null,
+): T {
+  ensureDestroyHook();
+
+  const _app = getApp(app?.name);
+
+  const { namespace, hasMultiAppSupport } = config;
+
+  // Modules such as analytics only run on the default app.
+  if (!hasMultiAppSupport && _app.name !== DEFAULT_APP_NAME) {
+    throw new Error(
+      [
+        `You attempted to call "${namespace}" with a secondary Firebase App but; ${namespace} does not support multiple Firebase Apps.`,
+        '',
+        `Ensure you access ${namespace} from the default application only.`,
+      ].join('\r\n'),
+    );
+  }
+
+  const key = customUrlOrRegion ? `${customUrlOrRegion}:${namespace}` : namespace;
+
+  if (!MODULAR_INSTANCES[_app.name]) {
+    MODULAR_INSTANCES[_app.name] = {};
+  }
+
+  if (!MODULAR_INSTANCES[_app.name]![key]) {
+    MODULAR_INSTANCES[_app.name]![key] = new ModuleClass(
+      _app as unknown as ReactNativeFirebase.FirebaseAppBase,
+      Object.assign({}, config),
+      customUrlOrRegion,
+    );
+  }
+
+  return MODULAR_INSTANCES[_app.name]![key] as T;
+}