@react-native-firebase/app 21.11.0 → 21.12.0

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [21.12.0](https://github.com/invertase/react-native-firebase/compare/v21.11.0...v21.12.0) (2025-03-03)
+
+### Features
+
+- vertexAI package support ([#8236](https://github.com/invertase/react-native-firebase/issues/8236)) ([a1d1361](https://github.com/invertase/react-native-firebase/commit/a1d13610f443a96a7195b3f769f77d9676c0e577))
+
 ## [21.11.0](https://github.com/invertase/react-native-firebase/compare/v21.10.1...v21.11.0) (2025-02-20)
 
 **Note:** Version bump only for package @react-native-firebase/app

package/android/src/reactnative/java/io/invertase/firebase/app/ReactNativeFirebaseVersion.java

@@ -18,5 +18,5 @@ package io.invertase.firebase.app;
  */
 // generated file - do not modify or commit
 public class ReactNativeFirebaseVersion {
-  public static String VERSION = "21.11.0";
+  public static String VERSION = "21.12.0";
 }

package/ios/RNFBApp/RNFBVersion.m

@@ -18,4 +18,4 @@
 #import <React/RCTVersion.h>
 
 // generated file - do not modify or commit
-NSString* const RNFBVersionString = @"21.11.0";
+NSString* const RNFBVersionString = @"21.12.0";

package/lib/internal/index.js

@@ -23,3 +23,4 @@ export * from './registry/app';
 export * from './registry/namespace';
 export * from './registry/nativeModule';
 export { default as SharedEventEmitter } from './SharedEventEmitter';
+export { Logger } from './logger';

package/lib/internal/logger.d.ts

@@ -0,0 +1,85 @@
+export type LogLevelString = 'debug' | 'verbose' | 'info' | 'warn' | 'error' | 'silent';
+
+export interface LogOptions {
+  level: LogLevelString;
+}
+
+export type LogCallback = (callbackParams: LogCallbackParams) => void;
+
+export interface LogCallbackParams {
+  level: LogLevelString;
+  message: string;
+  args: unknown[];
+  type: string;
+}
+
+/**
+ * A container for all of the Logger instances
+ */
+export const instances: Logger[] = [];
+
+/**
+ * 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,
+  VERBOSE,
+  INFO,
+  WARN,
+  ERROR,
+  SILENT,
+}
+
+type LevelStringToEnum = {
+  debug: LogLevel.DEBUG;
+  verbose: LogLevel.VERBOSE;
+  info: LogLevel.INFO;
+  warn: LogLevel.WARN;
+  error: LogLevel.ERROR;
+  silent: LogLevel.SILENT;
+};
+
+/**
+ * The default log level
+ */
+type DefaultLogLevel = LogLevel.INFO;
+
+/**
+ * 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;
+
+export class Logger {
+  constructor(name: string);
+
+  get logLevel(): LogLevel;
+  set logLevel(val: LogLevel);
+
+  setLogLevel(val: LogLevel | LogLevelString): void;
+
+  get logHandler(): LogHandler;
+  set logHandler(val: LogHandler);
+
+  get userLogHandler(): LogHandler | null;
+  set userLogHandler(val: LogHandler | null);
+
+  debug(...args: unknown[]): void;
+  log(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+}
+
+export const setLogLevel: (level: LogLevelString | LogLevel) => void;
+
+export const setUserLogHandler: (logCallback: LogCallback | null, options?: LogOptions) => void;

package/lib/internal/logger.js

@@ -0,0 +1,241 @@
+/*
+ * 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.
+ *
+ */
+
+/**
+ * @typedef {import('./logger').Logger} Logger
+ * @typedef {import('./logger').setLogLevel} setLogLevel
+ * @typedef {import('./logger').setUserLogHandler} setUserLogHandler
+ * @typedef {import('./logger').LogHandler} LogHandler
+ * @typedef {import('./logger').LogLevel} LogLevel
+ * @typedef {import('./logger').LevelStringToEnum} LevelStringToEnum
+ * @typedef {import('./logger').DefaultLogLevel} DefaultLogLevel
+ */
+
+const LogLevel = {
+  DEBUG: 0,
+  VERBOSE: 1,
+  INFO: 2,
+  WARN: 3,
+  ERROR: 4,
+  SILENT: 5,
+};
+
+// mimic the LogLevel in firebase-js-sdk TS
+const reverseLogLevel = obj => {
+  const reversed = {};
+  for (const [key, value] of Object.entries(obj)) {
+    reversed[value] = key;
+  }
+  return reversed;
+};
+
+const LogLevelReversed = reverseLogLevel(LogLevel);
+
+const 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 = {
+  [LogLevel.DEBUG]: 'log',
+  [LogLevel.VERBOSE]: 'log',
+  [LogLevel.INFO]: 'info',
+  [LogLevel.WARN]: 'warn',
+  [LogLevel.ERROR]: 'error',
+};
+
+/**
+ * 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)
+ * @type {LogHandler}
+ */
+const defaultLogHandler = (instance, logType, ...args) => {
+  if (logType < instance.logLevel) {
+    return;
+  }
+  const now = new Date().toISOString();
+  const method = ConsoleMethod[logType];
+  if (method) {
+    // 'log' | 'info' | 'warn' | 'error'
+    // eslint-disable-next-line no-console
+    console[method](`[${now}]  ${instance.name}:`, ...args);
+  } else {
+    throw new Error(`Attempted to log a message with an invalid logType (value: ${logType})`);
+  }
+};
+
+const defaultLogLevel = LogLevel.INFO;
+
+export const instances = [];
+
+/**
+ * @type {Logger}
+ */
+
+export class Logger {
+  /**
+   * 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) {
+    /**
+     * Capture the current instance for later use
+     */
+    this.name = name;
+    instances.push(this);
+  }
+
+  /**
+   * The log level of the given Logger instance.
+   */
+  _logLevel = defaultLogLevel;
+
+  get logLevel() {
+    return this._logLevel;
+  }
+
+  set logLevel(val) {
+    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) {
+    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.
+   */
+  _logHandler = defaultLogHandler;
+  get logHandler() {
+    return this._logHandler;
+  }
+  set logHandler(val) {
+    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.
+   */
+  _userLogHandler = null;
+  get userLogHandler() {
+    return this._userLogHandler;
+  }
+  set userLogHandler(val) {
+    this._userLogHandler = val;
+  }
+
+  /**
+   * The functions below are all based on the `console` interface
+   */
+
+  debug(...args) {
+    this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);
+    this._logHandler(this, LogLevel.DEBUG, ...args);
+  }
+  log(...args) {
+    this._userLogHandler && this._userLogHandler(this, LogLevel.VERBOSE, ...args);
+    this._logHandler(this, LogLevel.VERBOSE, ...args);
+  }
+  info(...args) {
+    this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);
+    this._logHandler(this, LogLevel.INFO, ...args);
+  }
+  warn(...args) {
+    this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);
+    this._logHandler(this, LogLevel.WARN, ...args);
+  }
+  error(...args) {
+    this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);
+    this._logHandler(this, LogLevel.ERROR, ...args);
+  }
+}
+
+/**
+ * @type {setLogLevel}
+ */
+export function setLogLevelInternal(level) {
+  instances.forEach(inst => {
+    inst.setLogLevel(level);
+  });
+}
+
+/**
+ * @type {setUserLogHandler}
+ */
+export function setUserLogHandler(logCallback, options) {
+  for (const instance of instances) {
+    let customLogLevel = null;
+    if (options && 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(),
+            message,
+            args,
+            type: instance.name,
+          });
+        }
+      };
+    }
+  }
+}

package/lib/internal/registry/app.js

@@ -29,6 +29,7 @@ import FirebaseApp from '../../FirebaseApp';
 import { DEFAULT_APP_NAME } from '../constants';
 import { setReactNativeAsyncStorageInternal } from '../asyncStorage';
 import { getAppModule } from './nativeModule';
+import { setLogLevelInternal } from '../logger';
 
 const APP_REGISTRY = {};
 let onAppCreateFn = null;
@@ -208,6 +209,8 @@ export function setLogLevel(logLevel) {
   if (!['error', 'warn', 'info', 'debug', 'verbose'].includes(logLevel)) {
     throw new Error('LogLevel must be one of "error", "warn", "info", "debug", "verbose"');
   }
+  // This is setting LogLevel for VertexAI which does not wrap around native SDK
+  setLogLevelInternal(logLevel);
 
   if (isIOS || isOther) {
     getAppModule().setLogLevel(logLevel);

package/lib/modular/index.d.ts

@@ -25,13 +25,23 @@ export function registerVersion(
 ): Promise<void>;
 
 /**
- * Sets log handler for all Firebase SDKs.
+ * Sets log handler for all Firebase SDKs. Currently only supported on VertexAI.
  * @param logCallback - The callback function to handle logs.
  * @param options - Optional settings for log handling.
- * @returns Promise<void>
- * @throws Error - onLog is only supported on Web
+ * @returns <void>
  */
-export function onLog(logCallback: (logData: any) => void, options?: any): Promise<void>;
+
+interface LogCallbackParams {
+  level: LogLevelString;
+  message: string;
+  args: unknown[];
+  type: string;
+}
+
+export function onLog(
+  logCallback: (callbackParams: LogCallbackParams) => void,
+  options?: any,
+): void;
 
 /**
  * Gets the list of all initialized apps.

package/lib/modular/index.js

@@ -7,12 +7,15 @@ import {
   initializeApp as initializeAppCompat,
   setLogLevel as setLogLevelCompat,
 } from '../internal';
+import { setUserLogHandler } from '../internal/logger';
 import sdkVersion from '../version';
 
 /**
  * @typedef {import('..').ReactNativeFirebase.FirebaseApp} FirebaseApp
  * @typedef {import('..').ReactNativeFirebase.FirebaseAppOptions} FirebaseAppOptions
  * @typedef {import('..').ReactNativeFirebase.LogLevelString} LogLevelString
+ * @typedef {import('../internal/logger').LogCallback} LogCallback
+ * @typedef {import('../internal/logger').LogOptions} LogOptions
  */
 
 /**
@@ -36,13 +39,13 @@ export function registerVersion(libraryKeyOrName, version, variant) {
 }
 
 /**
- * Sets log handler for all Firebase SDKs.
- * @param {Function} logCallback - The callback function to handle logs.
- * @param {Object} [options] - Optional settings for log handling.
- * @returns {Promise<void>}
+ * Sets log handler for VertexAI only currently.
+ * @param {LogCallback | null} logCallback - The callback function to handle logs.
+ * @param {LogOptions} [options] - Optional settings for log handling.
+ * @returns {void}
  */
 export function onLog(logCallback, options) {
-  throw new Error('onLog is only supported on Web');
+  setUserLogHandler(logCallback, options);
 }
 
 /**

package/lib/version.js

@@ -1,2 +1,2 @@
 // Generated by genversion.
-module.exports = '21.11.0';
+module.exports = '21.12.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/app",
-  "version": "21.11.0",
+  "version": "21.12.0",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "A well tested, feature rich Firebase implementation for React Native, supporting iOS & Android. Individual module support for Admob, Analytics, Auth, Crash Reporting, Cloud Firestore, Database, Dynamic Links, Functions, Messaging (FCM), Remote Config, Storage and more.",
   "main": "lib/index.js",
@@ -90,5 +90,5 @@
       "firebaseAppDistributionGradle": "5.1.1"
     }
   },
-  "gitHead": "082a1e496cb1f8496f53869d9ab9e6f88ecbdc00"
+  "gitHead": "00a5540bc2d8007858dd01903d8f8c171587a766"
 }