@react-native-firebase/app 23.6.0 → 23.8.0

package/lib/common/validate.ts

@@ -0,0 +1,232 @@
+/*
+ * 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 { Platform } from 'react-native';
+
+const AlphaNumericUnderscore = /^[a-zA-Z0-9_]+$/;
+
+/**
+ * Validates that all key-value pairs in an object are strings.
+ */
+export function objectKeyValuesAreStrings(object: unknown): boolean {
+  if (!isObject(object)) {
+    return false;
+  }
+
+  const entries = Object.entries(object);
+
+  for (let i = 0; i < entries.length; i++) {
+    const [key, value] = entries[i]!;
+    if (!isString(key) || !isString(value)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Simple is null check.
+ *
+ * @param value
+ * @returns {boolean}
+ */
+export function isNull(value: unknown): value is null {
+  return value === null;
+}
+
+/**
+ * Simple is object check.
+ *
+ * @param value
+ * @returns {boolean}
+ */
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return value ? typeof value === 'object' && !Array.isArray(value) && !isNull(value) : false;
+}
+
+/**
+ * Simple is date check
+ * https://stackoverflow.com/a/44198641
+ * @param value
+ * @returns {boolean}
+ */
+export function isDate(value: unknown): value is Date {
+  // use the global isNaN() and not Number.isNaN() since it will validate an Invalid Date
+  return value &&
+    Object.prototype.toString.call(value) === '[object Date]' &&
+    !isNaN(value as number)
+    ? true
+    : false;
+}
+
+/**
+ * Simple is function check
+ *
+ * @param value
+ * @returns {*|boolean}
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+export function isFunction(value: unknown): value is Function {
+  return value ? typeof value === 'function' : false;
+}
+
+/**
+ * Simple is string check
+ * @param value
+ * @return {boolean}
+ */
+export function isString(value: unknown): value is string {
+  return typeof value === 'string';
+}
+
+/**
+ * Simple is number check
+ * @param value
+ * @return {boolean}
+ */
+export function isNumber(value: unknown): value is number {
+  return typeof value === 'number';
+}
+
+/**
+ * Simple is phone number check for E.164 format
+ * @param value
+ * @return {boolean}
+ */
+export function isE164PhoneNumber(value: unknown): boolean {
+  if (!isString(value)) {
+    return false;
+  }
+  const PHONE_NUMBER = /^\+[1-9]\d{1,14}$/; // E.164
+  return PHONE_NUMBER.test(value);
+}
+
+/**
+ * Simple finite check
+ * @param value
+ * @returns {boolean}
+ */
+export function isFinite(value: unknown): boolean {
+  return Number.isFinite(value);
+}
+
+/**
+ * Simple integer check
+ * @param value
+ * @returns {boolean}
+ */
+export function isInteger(value: unknown): boolean {
+  return Number.isInteger(value);
+}
+
+/**
+ * Simple is boolean check
+ *
+ * @param value
+ * @return {boolean}
+ */
+export function isBoolean(value: unknown): value is boolean {
+  return typeof value === 'boolean';
+}
+
+/**
+ *
+ * @param value
+ * @returns {arg is Array<unknown>}
+ */
+export function isArray(value: unknown): value is Array<unknown> {
+  return Array.isArray(value);
+}
+
+/**
+ *
+ * @param value
+ * @returns {boolean}
+ */
+export function isUndefined(value: unknown): value is undefined {
+  return typeof value === 'undefined';
+}
+
+/**
+ * /^[a-zA-Z0-9_]+$/
+ *
+ * @param value
+ * @returns {boolean}
+ */
+export function isAlphaNumericUnderscore(value: unknown): boolean {
+  if (!isString(value)) {
+    return false;
+  }
+  return AlphaNumericUnderscore.test(value);
+}
+
+/**
+ * URL test
+ * @param url
+ * @returns {boolean}
+ */
+const IS_VALID_URL_REGEX = /^(http|https):\/\/[^ "]+$/;
+export function isValidUrl(url: unknown): boolean {
+  if (!isString(url)) {
+    return false;
+  }
+  return IS_VALID_URL_REGEX.test(url);
+}
+
+/**
+ * Array includes
+ *
+ * @param value
+ * @param oneOf
+ * @returns {boolean}
+ */
+export function isOneOf(value: unknown, oneOf: unknown[] = []): boolean {
+  if (!isArray(oneOf)) {
+    return false;
+  }
+  return oneOf.includes(value);
+}
+
+export function noop(): void {
+  // noop-🐈
+}
+
+export function validateOptionalNativeDependencyExists(
+  firebaseJsonKey: string,
+  apiName: string,
+  nativeFnExists: boolean,
+): void {
+  if (nativeFnExists) {
+    return;
+  }
+  let errorMessage =
+    "You attempted to use an optional API that's not enabled natively. \n\n To enable ";
+
+  errorMessage += apiName;
+  errorMessage += ` please set the 'react-native' -> '${firebaseJsonKey}' key to true in your firebase.json file`;
+
+  if (Platform.OS === 'android') {
+    errorMessage += ' and rebuild your Android app.';
+  } else {
+    errorMessage +=
+      ', re-run pod install and rebuild your iOS app. ' +
+      "If you're not using Pods then make sure you've have downloaded the necessary Firebase iOS SDK dependencies for this API.";
+  }
+
+  throw new Error(errorMessage);
+}

package/lib/index.ts

@@ -0,0 +1,27 @@
+/*
+ * 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 { firebase, utils, default } from './namespaced';
+export * from './modular';
+export type {
+  ReactNativeFirebase,
+  Utils,
+  FirebaseApp,
+  LogCallbackParams,
+  LogCallback,
+  LogOptions,
+} from './types/app';

package/lib/internal/FirebaseModule.ts

@@ -0,0 +1,78 @@
+/*
+ * 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 { getAppModule, getNativeModule } from './registry/nativeModule';
+import SharedEventEmitter from './SharedEventEmitter';
+import type { ReactNativeFirebase } from '../types/app';
+import type { FirebaseJsonConfig, ModuleConfig } from '../types/internal';
+import type { ReactNativeFirebaseNativeModules } from './NativeModules';
+import type EventEmitter from 'react-native/Libraries/vendor/emitter/EventEmitter';
+
+let firebaseJson: FirebaseJsonConfig | null = null;
+
+export default class FirebaseModule<
+  NativeModuleName extends keyof ReactNativeFirebaseNativeModules = any,
+> {
+  _app: ReactNativeFirebase.FirebaseAppBase;
+  _nativeModule: ReactNativeFirebaseNativeModules[NativeModuleName] | null;
+  _customUrlOrRegion: string | null;
+  _config: ModuleConfig;
+
+  constructor(
+    app: ReactNativeFirebase.FirebaseAppBase,
+    config: ModuleConfig,
+    customUrlOrRegion?: string | null,
+  ) {
+    this._app = app;
+    this._nativeModule = null;
+    this._customUrlOrRegion = customUrlOrRegion || null;
+    this._config = Object.assign({}, config);
+  }
+
+  get app(): ReactNativeFirebase.FirebaseApp {
+    return this._app as unknown as ReactNativeFirebase.FirebaseApp;
+  }
+
+  get firebaseJson(): FirebaseJsonConfig {
+    if (firebaseJson) {
+      return firebaseJson;
+    }
+    firebaseJson = JSON.parse(getAppModule().FIREBASE_RAW_JSON);
+    return firebaseJson as FirebaseJsonConfig;
+  }
+
+  get emitter(): EventEmitter {
+    return SharedEventEmitter;
+  }
+
+  eventNameForApp(...args: Array<string | number>): string {
+    return `${this.app.name}-${args.join('-')}`;
+  }
+
+  get native(): ReactNativeFirebaseNativeModules[NativeModuleName] {
+    if (this._nativeModule) {
+      return this._nativeModule;
+    }
+    this._nativeModule = getNativeModule(
+      this,
+    ) as unknown as ReactNativeFirebaseNativeModules[NativeModuleName];
+    return this._nativeModule;
+  }
+}
+
+// Instance of checks don't work once compiled
+(FirebaseModule as any).__extended__ = {};

package/lib/internal/NativeFirebaseError.ts

@@ -0,0 +1,111 @@
+/*
+ * 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 { NativeErrorUserInfo, NativeError } from '../types/internal';
+
+export default class NativeFirebaseError extends Error {
+  readonly namespace!: string;
+  readonly code!: string;
+  readonly jsStack!: string;
+  readonly userInfo!: NativeErrorUserInfo;
+  readonly customData: any;
+  readonly operationType!: string | null;
+  readonly nativeErrorCode!: string | number | null;
+  readonly nativeErrorMessage!: string | null;
+
+  static fromEvent(
+    errorEvent: NativeErrorUserInfo,
+    namespace: string,
+    stack?: string,
+  ): NativeFirebaseError {
+    return new NativeFirebaseError(
+      { userInfo: errorEvent },
+      stack || new Error().stack!,
+      namespace,
+    );
+  }
+
+  constructor(nativeError: NativeError, jsStack: string, namespace: string) {
+    super();
+    const { userInfo } = nativeError;
+
+    Object.defineProperty(this, 'namespace', {
+      enumerable: false,
+      value: namespace,
+    });
+
+    Object.defineProperty(this, 'code', {
+      enumerable: false,
+      value: `${this.namespace}/${userInfo.code || 'unknown'}`,
+    });
+
+    Object.defineProperty(this, 'message', {
+      enumerable: false,
+      value: `[${this.code}] ${userInfo.message || nativeError.message}`,
+    });
+
+    Object.defineProperty(this, 'jsStack', {
+      enumerable: false,
+      value: jsStack,
+    });
+
+    Object.defineProperty(this, 'userInfo', {
+      enumerable: false,
+      value: userInfo,
+    });
+
+    // Needed for MFA processing of errors on web
+    Object.defineProperty(this, 'customData', {
+      enumerable: false,
+      value: nativeError.customData || null,
+    });
+
+    // Needed for MFA processing of errors on web
+    Object.defineProperty(this, 'operationType', {
+      enumerable: false,
+      value: nativeError.operationType || null,
+    });
+
+    Object.defineProperty(this, 'nativeErrorCode', {
+      enumerable: false,
+      value: userInfo.nativeErrorCode || null,
+    });
+
+    Object.defineProperty(this, 'nativeErrorMessage', {
+      enumerable: false,
+      value: userInfo.nativeErrorMessage || null,
+    });
+
+    this.stack = NativeFirebaseError.getStackWithMessage(
+      `NativeFirebaseError: ${this.message}`,
+      this.jsStack,
+    );
+
+    // Unused
+    // this.nativeStackIOS = nativeError.nativeStackIOS;
+    // this.nativeStackAndroid = nativeError.nativeStackAndroid;
+  }
+
+  /**
+   * Build a stack trace that includes JS stack prior to calling the native method.
+   *
+   * @returns {string}
+   */
+  static getStackWithMessage(message: string, jsStack: string): string {
+    return [message, ...jsStack.split('\n').slice(2, 13)].join('\n');
+  }
+}

package/lib/internal/NativeModules.ts

@@ -0,0 +1,116 @@
+/*
+ * 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 } from '../types/app';
+
+/**
+ * Base type for all React Native Firebase native modules.
+ * Each package can extend this interface via module augmentation to add their own native methods.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface ReactNativeFirebaseNativeModules {
+  // Base interface - packages will augment this
+}
+
+/**
+ * Interface for wrapped native modules returned by getAppModule() and getNativeModule()
+ * This represents the native module after wrapping with error handling
+ */
+export interface WrappedNativeModule {
+  [key: string]: unknown;
+}
+
+/**
+ * App Module native methods that are always available
+ */
+export interface RNFBAppModuleInterface {
+  // Constants
+  NATIVE_FIREBASE_APPS: Array<{
+    appConfig: ReactNativeFirebase.FirebaseAppConfig;
+    options: ReactNativeFirebase.FirebaseAppOptions;
+  }>;
+  FIREBASE_RAW_JSON: string;
+
+  // Methods
+  initializeApp(
+    options: ReactNativeFirebase.FirebaseAppOptions,
+    appConfig: ReactNativeFirebase.FirebaseAppConfig,
+  ): Promise<void>;
+  deleteApp(name: string): Promise<void>;
+  setLogLevel(logLevel: string): void;
+  metaGetAll(): Promise<{ [key: string]: string | boolean }>;
+  jsonGetAll(): Promise<{ [key: string]: string | boolean }>;
+  preferencesClearAll(): Promise<void>;
+  preferencesGetAll(): Promise<{ [key: string]: string | boolean }>;
+  preferencesSetBool(key: string, value: boolean): Promise<void>;
+  preferencesSetString(key: string, value: string): Promise<void>;
+  setAutomaticDataCollectionEnabled(name: string, enabled: boolean): void;
+
+  // Event emitter methods
+  eventsNotifyReady(ready: boolean): void;
+  eventsAddListener(eventType: string): void;
+  eventsRemoveListener(eventType: string, removeAll: boolean): void;
+
+  // React Native EventEmitter compatibility
+  addListener?: (eventName: string) => void;
+  removeListeners?: (count: number) => void;
+}
+
+/**
+ * Utils Module native methods (from the app package)
+ */
+export interface RNFBUtilsModuleInterface {
+  // Android-only properties and methods
+  isRunningInTestLab: boolean;
+  androidPlayServices: {
+    isAvailable: boolean;
+    status: number;
+    hasResolution: boolean;
+    isUserResolvableError: boolean;
+    error: string | undefined;
+  };
+  androidGetPlayServicesStatus(): Promise<{
+    isAvailable: boolean;
+    status: number;
+    hasResolution: boolean;
+    isUserResolvableError: boolean;
+    error: string | undefined;
+  }>;
+  androidPromptForPlayServices(): Promise<void>;
+  androidMakePlayServicesAvailable(): Promise<void>;
+  androidResolutionForPlayServices(): Promise<void>;
+}
+
+// Augment the base interface with app package's native modules
+declare module './NativeModules' {
+  interface ReactNativeFirebaseNativeModules {
+    RNFBUtilsModule: RNFBUtilsModuleInterface;
+    RNFBAppModule: RNFBAppModuleInterface;
+  }
+}
+
+/**
+ * Helper type to get a specific native module type by name
+ */
+export type GetNativeModule<T extends keyof ReactNativeFirebaseNativeModules> =
+  ReactNativeFirebaseNativeModules[T];
+
+/**
+ * Union type of all available native module types
+ */
+export type AnyNativeModule =
+  ReactNativeFirebaseNativeModules[keyof ReactNativeFirebaseNativeModules];

package/lib/internal/RNFBNativeEventEmitter.ts

@@ -0,0 +1,139 @@
+/*
+ * 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 EmitterSubscription, NativeEventEmitter } from 'react-native';
+import { getReactNativeModule } from './nativeModule';
+import type { RNFBAppModuleInterface } from './NativeModules';
+
+/**
+ * Type for the eventsNotifyReady native method
+ */
+type EventsNotifyReadyMethod = (ready: boolean) => void;
+
+/**
+ * Type for the eventsAddListener native method
+ */
+type EventsAddListenerMethod = (eventType: string) => void;
+
+/**
+ * Type for the eventsRemoveListener native method
+ */
+type EventsRemoveListenerMethod = (eventType: string, removeAll: boolean) => void;
+
+class RNFBNativeEventEmitter extends NativeEventEmitter {
+  ready: boolean;
+
+  constructor() {
+    const RNFBAppModule = getReactNativeModule('RNFBAppModule');
+    if (!RNFBAppModule) {
+      throw new Error(
+        'Native module RNFBAppModule 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
+    super(RNFBAppModule as any);
+    this.ready = false;
+  }
+
+  addListener(
+    eventType: string,
+    listener: (...args: unknown[]) => unknown,
+    context?: object,
+  ): EmitterSubscription {
+    const RNFBAppModule = getReactNativeModule(
+      'RNFBAppModule',
+    ) as unknown as RNFBAppModuleInterface;
+    if (!this.ready) {
+      (RNFBAppModule.eventsNotifyReady as EventsNotifyReadyMethod)(true);
+      this.ready = true;
+    }
+    (RNFBAppModule.eventsAddListener as EventsAddListenerMethod)(eventType);
+    if (globalThis.RNFBDebug) {
+      // eslint-disable-next-line no-console
+      console.debug(`[RNFB-->Event][👂] ${eventType} -> listening`);
+    }
+    const listenerDebugger = (...args: unknown[]) => {
+      if (globalThis.RNFBDebug) {
+        // eslint-disable-next-line no-console
+        console.debug(`[RNFB<--Event][📣] ${eventType} <-`, JSON.stringify(args[0]));
+        // Possible leaking test if events are still being received after the test.
+        // This is not super accurate but it's better than nothing, e.g. if doing setup/teardown
+        // logic outside of a test this may cause false positives.
+        if (globalThis.RNFBTest && !globalThis.RNFBDebugInTestLeakDetection) {
+          // eslint-disable-next-line no-console
+          console.debug(
+            `[TEST--->Leak][💡] Possible leaking test detected! An event (☝️) ` +
+              `was received outside of any running tests which may indicates that some ` +
+              `listeners/event subscriptions that have not been unsubscribed from in your ` +
+              `test code. The last test that ran was: "${globalThis.RNFBDebugLastTest}".`,
+          );
+        }
+      }
+      return listener(...args);
+    };
+
+    let subscription = super.addListener(`rnfb_${eventType}`, listenerDebugger, context);
+
+    // React Native 0.65+ altered EventEmitter:
+    // - removeSubscription is gone
+    // - addListener returns an unsubscriber instead of a more complex object with eventType etc
+
+    // make sure eventType for backwards compatibility just in case
+    (subscription as any).eventType = `rnfb_${eventType}`;
+
+    // New style is to return a remove function on the object, just in case people call that,
+    // 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;
+      (module.eventsRemoveListener as EventsRemoveListenerMethod)(eventType, false);
+      const superClass = Object.getPrototypeOf(Object.getPrototypeOf(this));
+      if (superClass.removeSubscription != null) {
+        // This is for RN <= 0.64 - 65 and greater no longer have removeSubscription
+        superClass.removeSubscription(subscription);
+      } else if (originalRemove != null) {
+        // This is for RN >= 0.65
+        originalRemove();
+      }
+    };
+    subscription.remove = newRemove;
+    return subscription;
+  }
+
+  removeAllListeners(eventType: string): void {
+    const RNFBAppModule = getReactNativeModule(
+      'RNFBAppModule',
+    ) as unknown as RNFBAppModuleInterface;
+    (RNFBAppModule.eventsRemoveListener as EventsRemoveListenerMethod)(eventType, true);
+    super.removeAllListeners(`rnfb_${eventType}`);
+  }
+
+  // This is likely no longer ever called, but it is here for backwards compatibility with RN <= 0.64
+  removeSubscription(subscription: EmitterSubscription & { eventType?: string }): void {
+    const RNFBAppModule = getReactNativeModule(
+      'RNFBAppModule',
+    ) as unknown as RNFBAppModuleInterface;
+    const eventType = subscription.eventType?.replace('rnfb_', '') || '';
+    (RNFBAppModule.eventsRemoveListener as EventsRemoveListenerMethod)(eventType, false);
+    const superClass = Object.getPrototypeOf(Object.getPrototypeOf(this));
+    if (superClass.removeSubscription) {
+      superClass.removeSubscription(subscription);
+    }
+  }
+}
+
+export default new RNFBNativeEventEmitter();