@react-native-firebase/app 23.7.0 → 23.8.0

package/lib/modular.ts

@@ -0,0 +1,219 @@
+/*
+ * 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 { MODULAR_DEPRECATION_ARG } from './common';
+import type { ReactNativeFirebase, LogCallback, LogOptions } from './types/app';
+import {
+  deleteApp as deleteAppCompat,
+  getApp as getAppCompat,
+  getApps as getAppsCompat,
+  initializeApp as initializeAppCompat,
+  setLogLevel as setLogLevelCompat,
+  setReactNativeAsyncStorage as setReactNativeAsyncStorageCompat,
+} from './internal/registry/app';
+import { setUserLogHandler } from './internal/logger';
+import { version as sdkVersion } from './version';
+import { getReactNativeModule } from './internal/nativeModule';
+import { APP_NATIVE_MODULE } from './internal/constants';
+import type { RNFBAppModuleInterface } from './internal/NativeModules';
+/**
+ * Renders this app unusable and frees the resources of all associated services.
+ * @param app - The app to delete.
+ * @returns Promise<void>
+ */
+export function deleteApp(app: ReactNativeFirebase.FirebaseApp): Promise<void> {
+  return deleteAppCompat.call(
+    null,
+    app.name,
+    (app as any)._nativeInitialized,
+    // @ts-expect-error - Extra arg used by deprecation proxy to detect modular calls
+    MODULAR_DEPRECATION_ARG,
+  );
+}
+
+/**
+ * Registers a library's name and version for platform logging purposes.
+ * @param _libraryKeyOrName - library name or key.
+ * @param _version - library version.
+ * @param _variant - library variant. Optional.
+ * @returns Promise<void>
+ */
+export function registerVersion(
+  _libraryKeyOrName: string,
+  _version: string,
+  _variant?: string,
+): Promise<void> {
+  throw new Error('registerVersion is only supported on Web');
+}
+
+/**
+ * Sets log handler for VertexAI only currently.
+ * @param logCallback - The callback function to handle logs.
+ * @param options - Optional settings for log handling.
+ * @returns void
+ */
+export function onLog(logCallback: LogCallback | null, options?: LogOptions): void {
+  setUserLogHandler(logCallback, options);
+}
+
+/**
+ * Gets the list of all initialized apps.
+ * @returns An array of all initialized Firebase apps.
+ */
+export function getApps(): ReactNativeFirebase.FirebaseApp[] {
+  return getAppsCompat.call(
+    null,
+    // @ts-expect-error - Extra arg used by deprecation proxy to detect modular calls
+    MODULAR_DEPRECATION_ARG,
+  );
+}
+
+/**
+ * Initializes a Firebase app with the provided options and name.
+ * @param options - Options to configure the services used in the app.
+ * @param configOrName - The optional name of the app, or config for the app to initialize (a name of '[DEFAULT]' will be used if omitted).
+ * @returns The initialized Firebase app.
+ */
+export function initializeApp(
+  options: ReactNativeFirebase.FirebaseAppOptions,
+  configOrName?: string | ReactNativeFirebase.FirebaseAppConfig,
+): Promise<ReactNativeFirebase.FirebaseApp> {
+  return initializeAppCompat.call(
+    null,
+    options,
+    configOrName,
+    // @ts-expect-error - Extra arg used by deprecation proxy to detect modular calls
+    MODULAR_DEPRECATION_ARG,
+  );
+}
+
+/**
+ * Retrieves an instance of a Firebase app.
+ * @param name - The optional name of the app to return ('[DEFAULT]' if omitted).
+ * @returns The requested Firebase app instance.
+ */
+export function getApp(name?: string): ReactNativeFirebase.FirebaseApp {
+  return getAppCompat.call(
+    null,
+    name,
+    // @ts-expect-error - Extra arg used by deprecation proxy to detect modular calls
+    MODULAR_DEPRECATION_ARG,
+  );
+}
+
+/**
+ * Sets the log level across all Firebase SDKs.
+ * @param logLevel - The log level to set ('debug', 'verbose', 'info', 'warn', 'error', 'silent').
+ * @returns void
+ */
+export function setLogLevel(logLevel: ReactNativeFirebase.LogLevelString): void {
+  return setLogLevelCompat.call(
+    null,
+    logLevel,
+    // @ts-expect-error - Extra arg used by deprecation proxy to detect modular calls
+    MODULAR_DEPRECATION_ARG,
+  );
+}
+
+/**
+ * The `AsyncStorage` implementation to use for persisting data on 'Other' platforms.
+ * If not specified, in memory persistence is used.
+ *
+ * This is required if you want to persist things like Auth sessions, Analytics device IDs, etc.
+ */
+export function setReactNativeAsyncStorage(
+  asyncStorage: ReactNativeFirebase.ReactNativeAsyncStorage,
+): void {
+  return setReactNativeAsyncStorageCompat.call(
+    null,
+    asyncStorage,
+    // @ts-expect-error - Extra arg used by deprecation proxy to detect modular calls
+    MODULAR_DEPRECATION_ARG,
+  );
+}
+
+/**
+ * Gets react-native-firebase specific "meta" data from native Info.plist / AndroidManifest.xml
+ * @returns map of key / value pairs containing native meta data
+ */
+export function metaGetAll(): Promise<{ [key: string]: string | boolean }> {
+  const RNFBAppModule = getReactNativeModule(
+    APP_NATIVE_MODULE,
+  ) as unknown as RNFBAppModuleInterface;
+  return RNFBAppModule.metaGetAll();
+}
+
+/**
+ * Gets react-native-firebase specific "firebase.json" data
+ * @returns map of key / value pairs containing native firebase.json constants
+ */
+export function jsonGetAll(): Promise<{ [key: string]: string | boolean }> {
+  const RNFBAppModule = getReactNativeModule(
+    APP_NATIVE_MODULE,
+  ) as unknown as RNFBAppModuleInterface;
+  return RNFBAppModule.jsonGetAll();
+}
+
+/**
+ * Clears react-native-firebase specific native preferences
+ * @returns Promise<void>
+ */
+export function preferencesClearAll(): Promise<void> {
+  const RNFBAppModule = getReactNativeModule(
+    APP_NATIVE_MODULE,
+  ) as unknown as RNFBAppModuleInterface;
+  return RNFBAppModule.preferencesClearAll();
+}
+
+/**
+ * Gets react-native-firebase specific native preferences
+ * @returns map of key / value pairs containing native preferences data
+ */
+export function preferencesGetAll(): Promise<{ [key: string]: string | boolean }> {
+  const RNFBAppModule = getReactNativeModule(
+    APP_NATIVE_MODULE,
+  ) as unknown as RNFBAppModuleInterface;
+  return RNFBAppModule.preferencesGetAll();
+}
+
+/**
+ * Sets react-native-firebase specific native boolean preference
+ * @param key the name of the native preference to set
+ * @param value the value of the native preference to set
+ * @returns Promise<void>
+ */
+export function preferencesSetBool(key: string, value: boolean): Promise<void> {
+  const RNFBAppModule = getReactNativeModule(
+    APP_NATIVE_MODULE,
+  ) as unknown as RNFBAppModuleInterface;
+  return RNFBAppModule.preferencesSetBool(key, value);
+}
+
+/**
+ * Sets react-native-firebase specific native string preference
+ * @param key the name of the native preference to set
+ * @param value the value of the native preference to set
+ * @returns Promise<void>
+ */
+export function preferencesSetString(key: string, value: string): Promise<void> {
+  const RNFBAppModule = getReactNativeModule(
+    APP_NATIVE_MODULE,
+  ) as unknown as RNFBAppModuleInterface;
+  return RNFBAppModule.preferencesSetString(key, value);
+}
+
+export const SDK_VERSION = sdkVersion;

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

@@ -16,9 +16,9 @@
  */
 
 import { getFirebaseRoot } from './internal/registry/namespace';
+import utils from './utils';
 
 export const firebase = getFirebaseRoot();
-export * from './modular';
-export { default as utils } from './utils';
+export { utils };
 
 export default firebase;

package/lib/{index.d.ts → types/app.ts}

@@ -16,20 +16,11 @@
  */
 
 /**
- * Core React Native Firebase package.
- *
- * #### Example 1
- *
- * Access the default firebase app from the `app` package:
- *
- * ```js
- * import firebase from '@react-native-firebase/app';
- *
- * console.log(firebase.app().name);
- * ```
+ * Core React Native Firebase package types.
  *
  * @firebase app
  */
+// eslint-disable-next-line @typescript-eslint/no-namespace
 export namespace ReactNativeFirebase {
   export interface NativeFirebaseError extends Error {
     /**
@@ -138,7 +129,12 @@ export namespace ReactNativeFirebase {
     automaticResourceManagement?: boolean;
   }
 
-  export interface FirebaseApp {
+  /**
+   * Base interface for FirebaseApp containing core properties and methods.
+   * The concrete FirebaseApp class implements this interface.
+   * Module-specific methods (auth(), analytics(), etc.) are added to FirebaseApp via declaration merging.
+   */
+  export interface FirebaseAppBase {
     /**
      * The name (identifier) for this App. '[DEFAULT]' is the default App.
      */
@@ -162,6 +158,19 @@ export namespace ReactNativeFirebase {
     utils(): Utils.Module;
   }
 
+  /**
+   * Full FirebaseApp interface that extends the base interface.
+   * Module-specific methods (auth(), analytics(), etc.) are added here via declaration merging
+   * from individual package .d.ts files.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  export interface FirebaseApp extends FirebaseAppBase {
+    // Module methods are added here via declaration merging, e.g.:
+    // auth(): FirebaseAuthTypes.Module;
+    // analytics(): FirebaseAnalyticsTypes.Module;
+    // etc.
+  }
+
   /**
    * Interface for a supplied `AsyncStorage`.
    */
@@ -258,27 +267,17 @@ export namespace ReactNativeFirebase {
      * and related services inside React Native, e.g. Test Lab helpers
      * and Google Play Services version helpers.
      */
-    utils: typeof utils;
+    utils: Utils.Module;
   }
 
   /**
    * A class that all React Native Firebase modules extend from to provide default behaviour.
    */
-  export class FirebaseModule {
+  export abstract class FirebaseModule {
     /**
      * The current `FirebaseApp` instance for this Firebase service.
      */
-    app: FirebaseApp;
-
-    /**
-     * The native module instance for this Firebase service.
-     */
-    private native: any;
-
-    /**
-     * Returns the shared event emitter instance used for all JS event routing.
-     */
-    private emitter: any;
+    abstract app: FirebaseApp;
   }
 
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
@@ -300,11 +299,46 @@ export namespace ReactNativeFirebase {
      */
     readonly SDK_VERSION: string;
   } & S;
+
+  /**
+   * Type for the `firebase` named export from module packages.
+   * Provides complete typing for:
+   * - Root level access: `firebase.functions(app?)`
+   * - App level access: `firebase.app().functions(region?)`
+   * - Statics: `firebase.functions.HttpsErrorCode`
+   * - Root properties: `firebase.SDK_VERSION`, `firebase.app()`, etc.
+   *
+   * @typeParam Namespace - The module namespace (e.g., 'functions', 'auth', 'firestore')
+   * @typeParam M - The module instance type (must extend FirebaseModule with `app` property)
+   * @typeParam S - The module statics type
+   * @typeParam HasCustomArg - true if app-level accessor takes optional string (region/url/databaseId)
+   *
+   * @example
+   * // In functions package:
+   * export const firebase = getFirebaseRoot() as ReactNativeFirebase.FirebaseNamespacedExport<
+   *   'functions',
+   *   FunctionsModule,
+   *   FunctionsStatics,
+   *   true  // functions() takes regionOrCustomDomain
+   * >;
+   */
+  export type FirebaseNamespacedExport<
+    Namespace extends string,
+    M extends FirebaseModule,
+    S extends object = object,
+    HasCustomArg extends boolean = false,
+  > = Module &
+    Record<Namespace, FirebaseModuleWithStaticsAndApp<M, S>> & {
+      app(
+        name?: string,
+      ): FirebaseApp & Record<Namespace, HasCustomArg extends true ? (arg?: string) => M : () => M>;
+    };
 }
 
-/*
+/**
  * @firebase utils
  */
+// eslint-disable-next-line @typescript-eslint/no-namespace
 export namespace Utils {
   import FirebaseModule = ReactNativeFirebase.FirebaseModule;
 
@@ -431,6 +465,7 @@ export namespace Utils {
   }
 
   export interface Statics {
+    SDK_VERSION: string;
     FilePath: FilePath;
   }
 
@@ -533,7 +568,7 @@ export namespace Utils {
    * const defaultAppUtils = firebase.utils();
    * ```
    */
-  export class Module extends FirebaseModule {
+  export abstract class Module extends FirebaseModule {
     /**
      * Returns true if this app is running inside a Firebase Test Lab environment.
      *
@@ -544,7 +579,7 @@ export namespace Utils {
      * ```
      * @android Android only - iOS returns false
      */
-    isRunningInTestLab: boolean;
+    abstract isRunningInTestLab: boolean;
     /**
      * Returns PlayServicesAvailability properties
      *
@@ -556,7 +591,7 @@ export namespace Utils {
      *
      * @android Android only - iOS always returns { isAvailable: true, status: 0 }
      */
-    playServicesAvailability: PlayServicesAvailability;
+    abstract playServicesAvailability: PlayServicesAvailability;
 
     /**
      * Returns PlayServicesAvailability properties
@@ -569,7 +604,7 @@ export namespace Utils {
      *
      * @android Android only - iOS always returns { isAvailable: true, status: 0 }
      */
-    getPlayServicesStatus(): Promise<PlayServicesAvailability>;
+    abstract getPlayServicesStatus(): Promise<PlayServicesAvailability>;
 
     /**
      * A prompt appears on the device to ask the user to update play services
@@ -582,7 +617,7 @@ export namespace Utils {
      *
      * @android Android only - iOS returns undefined
      */
-    promptForPlayServices(): Promise<void>;
+    abstract promptForPlayServices(): Promise<void>;
     /**
      * Attempts to make Google Play services available on this device
      *
@@ -594,7 +629,7 @@ export namespace Utils {
      *
      * @android Android only - iOS returns undefined
      */
-    makePlayServicesAvailable(): Promise<void>;
+    abstract makePlayServicesAvailable(): Promise<void>;
     /**
      * Resolves an error by starting any intents requiring user interaction.
      *
@@ -606,16 +641,22 @@ export namespace Utils {
      *
      * @android Android only - iOS returns undefined
      */
-    resolutionForPlayServices(): Promise<void>;
+    abstract resolutionForPlayServices(): Promise<void>;
   }
 }
 
-/**
- * Add Utils module as a named export for `app`.
- */
-export const utils: ReactNativeFirebase.FirebaseModuleWithStatics<Utils.Module, Utils.Statics>;
+export interface LogCallbackParams {
+  level: ReactNativeFirebase.LogLevelString;
+  message: string;
+  args: unknown[];
+  type: string;
+}
+
+export type LogCallback = (callbackParams: LogCallbackParams) => void;
 
-export * from './modular';
+export interface LogOptions {
+  level?: ReactNativeFirebase.LogLevelString;
+}
 
-declare const module: ReactNativeFirebase.Module;
-export default module;
+// Re-export FirebaseApp as a named type for easier importing
+export type FirebaseApp = ReactNativeFirebase.FirebaseApp;

package/lib/types/internal.ts

@@ -0,0 +1,142 @@
+/*
+ * 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 { ReactNativeFirebase, Utils } from './app';
+
+/**
+ * Internal types for React Native Firebase
+ * These types are used internally across multiple files and should not be exported to consumers
+ */
+
+/**
+ * Firebase JSON configuration from firebase.json file
+ * Structure: { "react-native": { [key: string]: boolean | string }, ... }
+ */
+export type FirebaseJsonConfig = Record<string, unknown>;
+
+/**
+ * Configuration for module namespace registration
+ */
+export interface ModuleConfig {
+  namespace: string;
+  nativeModuleName?: string | string[];
+  hasMultiAppSupport?: boolean;
+  hasCustomUrlOrRegionSupport?: boolean;
+  nativeEvents?: boolean | string[];
+  disablePrependCustomUrlOrRegion?: boolean;
+  turboModule?: boolean;
+}
+
+/**
+ * Extended configuration for namespace registration including native module details
+ */
+export interface NamespaceConfig extends ModuleConfig {
+  nativeModuleName: string | string[];
+  nativeEvents: boolean | string[];
+  // ModuleClass can be FirebaseModule or any subclass of it
+  // Uses FirebaseAppBase (the concrete class type) rather than FirebaseApp (the augmented interface)
+  ModuleClass: new (
+    app: ReactNativeFirebase.FirebaseAppBase,
+    config: ModuleConfig,
+    customUrlOrRegion?: string | null,
+  ) => ReactNativeFirebase.FirebaseModule;
+  statics?: object;
+  version?: string;
+}
+
+/**
+ * Type for a Firebase module getter function that can optionally accept
+ * a custom URL/region/databaseId parameter
+ */
+export type ModuleGetter = {
+  (customUrlOrRegionOrDatabaseId?: string): ReactNativeFirebase.FirebaseModule;
+  [key: string]: unknown;
+};
+
+/**
+ * Type for Firebase root object with module getters
+ */
+export interface FirebaseRoot {
+  initializeApp: (
+    options: ReactNativeFirebase.FirebaseAppOptions,
+    configOrName?: string | ReactNativeFirebase.FirebaseAppConfig,
+  ) => Promise<ReactNativeFirebase.FirebaseApp>;
+  setReactNativeAsyncStorage: (asyncStorage: ReactNativeFirebase.ReactNativeAsyncStorage) => void;
+  app: (name?: string) => ReactNativeFirebase.FirebaseApp;
+  apps: ReactNativeFirebase.FirebaseApp[];
+  SDK_VERSION: string;
+  setLogLevel: (logLevel: ReactNativeFirebase.LogLevelString) => void;
+  utils: Utils.Statics & (() => Utils.Module);
+  [key: string]: unknown;
+}
+
+/**
+ * Native error types
+ */
+export interface NativeErrorUserInfo {
+  code?: string;
+  message?: string;
+  nativeErrorCode?: string | number;
+  nativeErrorMessage?: string;
+  [key: string]: any;
+}
+
+export interface NativeError {
+  userInfo: NativeErrorUserInfo;
+  message?: string;
+  customData?: any;
+  operationType?: string;
+}
+
+/**
+ * AsyncStorage interface compatible with React Native AsyncStorage
+ * Internal version used by the library
+ */
+export interface AsyncStorageStatic {
+  setItem: (key: string, value: string) => Promise<void>;
+  getItem: (key: string) => Promise<string | null>;
+  removeItem: (key: string) => Promise<void>;
+}
+
+/**
+ * Common utility types
+ */
+export interface DataUrlParts {
+  base64String: string | undefined;
+  mediaType: string | undefined;
+}
+
+export interface Observer<T> {
+  next: (value: T) => void;
+  error?: (error: Error) => void;
+  complete?: () => void;
+}
+
+export interface SerializedValue {
+  type: string;
+  value: any;
+}
+
+export interface Deferred<T> {
+  promise: Promise<T>;
+  resolve: ((value: T) => void) | null;
+  reject: ((reason?: any) => void) | null;
+}
+
+export type Callback<T> =
+  | ((error: Error | null, result?: T) => void)
+  | ((error: Error | null) => void);

package/lib/utils/{UtilsStatics.js → UtilsStatics.ts}

@@ -16,7 +16,9 @@
  */
 
 import { NativeModules } from 'react-native';
-import { stripTrailingSlash, isOther } from '../../lib/common';
+import { stripTrailingSlash, isOther } from '../common';
+import { Utils } from '../types/app';
+import { version } from '../version';
 
 const PATH_NAMES = [
   'MAIN_BUNDLE',
@@ -28,38 +30,44 @@ const PATH_NAMES = [
   'LIBRARY_DIRECTORY',
   'PICTURES_DIRECTORY',
   'MOVIES_DIRECTORY',
-];
+] as const;
 
-const PATH_FILE_TYPES = ['FILE_TYPE_REGULAR', 'FILE_TYPE_DIRECTORY'];
+const PATH_FILE_TYPES = ['FILE_TYPE_REGULAR', 'FILE_TYPE_DIRECTORY'] as const;
 
-const paths = {};
+const paths: Partial<Utils.FilePath> = {};
 let processedPathConstants = false;
 
-function processPathConstants(nativeModule) {
+function processPathConstants(nativeModule: any): Utils.FilePath {
   if (processedPathConstants || !nativeModule) {
-    return paths;
+    return paths as Utils.FilePath;
   }
   processedPathConstants = true;
 
   for (let i = 0; i < PATH_NAMES.length; i++) {
     const path = PATH_NAMES[i];
-    paths[path] = nativeModule[path] ? stripTrailingSlash(nativeModule[path]) : null;
+    if (path) {
+      (paths as any)[path] = nativeModule[path] ? stripTrailingSlash(nativeModule[path]) : null;
+    }
   }
 
   for (let i = 0; i < PATH_FILE_TYPES.length; i++) {
     const pathFileType = PATH_FILE_TYPES[i];
-    paths[pathFileType] = stripTrailingSlash(nativeModule[pathFileType]);
+    if (pathFileType) {
+      (paths as any)[pathFileType] = stripTrailingSlash(nativeModule[pathFileType]);
+    }
   }
 
   Object.freeze(paths);
 
-  return paths;
+  return paths as Utils.FilePath;
 }
 
-export default {
-  SDK_VERSION: require('./../version'),
-  get FilePath() {
+const statics: Utils.Statics = {
+  SDK_VERSION: version,
+  get FilePath(): Utils.FilePath {
     // We don't support path constants on non-native platforms.
     return processPathConstants(isOther ? {} : NativeModules.RNFBUtilsModule);
   },
 };
+
+export default statics;