@react-native-firebase/app 23.7.0 → 23.8.1

package/lib/internal/registry/app.ts

@@ -0,0 +1,278 @@
+/*
+ * 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 {
+  isIOS,
+  isOther,
+  isNull,
+  warnIfNotModularCall,
+  isObject,
+  isFunction,
+  isString,
+  isUndefined,
+} from '../../common';
+import FirebaseApp from '../../FirebaseApp';
+import { DEFAULT_APP_NAME } from '../constants';
+import { setReactNativeAsyncStorageInternal } from '../asyncStorage';
+import { getAppModule } from './nativeModule';
+import { setLogLevelInternal } from '../logger';
+import type { ReactNativeFirebase } from '../../types/app';
+
+type FirebaseAppConfig = ReactNativeFirebase.FirebaseAppConfig;
+type FirebaseAppOptions = ReactNativeFirebase.FirebaseAppOptions;
+type ReactNativeAsyncStorage = ReactNativeFirebase.ReactNativeAsyncStorage;
+
+const APP_REGISTRY: Record<string, FirebaseApp> = {};
+let onAppCreateFn: ((app: FirebaseApp) => void) | null = null;
+let onAppDestroyFn: ((app: FirebaseApp) => void) | null = null;
+let initializedNativeApps = false;
+
+/**
+ * This was needed to avoid metro require cycles...
+ * @param fn
+ */
+export function setOnAppCreate(fn: (app: FirebaseApp) => void): void {
+  onAppCreateFn = fn;
+}
+
+/**
+ * This was needed to avoid metro require cycles...
+ * @param fn
+ */
+export function setOnAppDestroy(fn: (app: FirebaseApp) => void): void {
+  onAppDestroyFn = fn;
+}
+
+/**
+ * Initializes all apps that were created natively (android/ios),
+ * e.g. the Default firebase app from plist/json google services file.
+ */
+export function initializeNativeApps(): void {
+  const nativeModule = getAppModule();
+  const { NATIVE_FIREBASE_APPS } = nativeModule;
+
+  if (NATIVE_FIREBASE_APPS && NATIVE_FIREBASE_APPS.length) {
+    for (let i = 0; i < NATIVE_FIREBASE_APPS.length; i++) {
+      const nativeApp = NATIVE_FIREBASE_APPS[i];
+      if (!nativeApp) continue;
+      const { appConfig, options } = nativeApp;
+      const name = appConfig.name as string;
+      APP_REGISTRY[name] = new FirebaseApp(
+        options as FirebaseAppOptions,
+        appConfig as FirebaseAppConfig,
+        true,
+        deleteApp.bind(null, name, true),
+      );
+      onAppCreateFn?.(APP_REGISTRY[name]);
+    }
+  }
+
+  initializedNativeApps = true;
+}
+
+/**
+ * Get an app by name; or the default app.
+ *
+ * On first call of this method it will initialize any
+ * natively created apps in JS. This makes this 'lazy load'.
+ *
+ * @param name
+ */
+export function getApp(name: string = DEFAULT_APP_NAME): ReactNativeFirebase.FirebaseApp {
+  warnIfNotModularCall(arguments, 'getApp()');
+  if (!initializedNativeApps) {
+    initializeNativeApps();
+  }
+  const app = APP_REGISTRY[name];
+
+  if (!app) {
+    throw new Error(`No Firebase App '${name}' has been created - call firebase.initializeApp()`);
+  }
+
+  return app as unknown as ReactNativeFirebase.FirebaseApp;
+}
+
+/**
+ * Gets all app instances, used for `firebase.apps`
+ */
+export function getApps(): ReactNativeFirebase.FirebaseApp[] {
+  warnIfNotModularCall(arguments, 'getApps()');
+  if (!initializedNativeApps) {
+    initializeNativeApps();
+  }
+  return Object.values(APP_REGISTRY) as unknown as ReactNativeFirebase.FirebaseApp[];
+}
+
+/**
+ *
+ * @param options
+ * @param configOrName
+ */
+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)) {
+    appConfig = {
+      name: configOrName as string,
+      automaticResourceManagement: false,
+      automaticDataCollectionEnabled: true,
+    };
+  }
+
+  if (isUndefined(appConfig.name)) {
+    appConfig.name = DEFAULT_APP_NAME;
+  }
+
+  const { name } = appConfig;
+
+  if (!name || !isString(name)) {
+    return Promise.reject(new Error(`Illegal App name: '${name}'`));
+  }
+
+  if (APP_REGISTRY[name]) {
+    return Promise.reject(new Error(`Firebase App named '${name}' already exists`));
+  }
+
+  // VALIDATE OPTIONS
+  if (!isObject(options)) {
+    return Promise.reject(
+      new Error(`firebase.initializeApp(options, <- expects an Object but got '${typeof options}'`),
+    );
+  }
+
+  if (!isString(options.apiKey)) {
+    return Promise.reject(new Error("Missing or invalid FirebaseOptions property 'apiKey'."));
+  }
+
+  if (!isString(options.appId)) {
+    return Promise.reject(new Error("Missing or invalid FirebaseOptions property 'appId'."));
+  }
+
+  // TODO - make required only if database module exists - init app on native ios&android needs changing also
+  if (!isString(options.databaseURL)) {
+    return Promise.reject(new Error("Missing or invalid FirebaseOptions property 'databaseURL'."));
+  }
+
+  // TODO - make required only if messaging/notifications module exists - init app on native ios&android needs changing also
+  if (!isString(options.messagingSenderId)) {
+    return Promise.reject(
+      new Error("Missing or invalid FirebaseOptions property 'messagingSenderId'."),
+    );
+  }
+
+  if (!isString(options.projectId)) {
+    return Promise.reject(new Error("Missing or invalid FirebaseOptions property 'projectId'."));
+  }
+
+  // TODO - make required only if database module exists - init app on native ios&android needs changing also
+  if (!isString(options.storageBucket)) {
+    return Promise.reject(
+      new Error("Missing or invalid FirebaseOptions property 'storageBucket'."),
+    );
+  }
+
+  const app = new FirebaseApp(
+    options as FirebaseAppOptions,
+    appConfig,
+    false,
+    deleteApp.bind(null, name, true),
+  );
+
+  // Note these initialization actions with side effects are performed prior to knowledge of
+  // successful initialization in the native code. Native code *may* throw an error.
+  APP_REGISTRY[name] = app;
+  onAppCreateFn?.(APP_REGISTRY[name]);
+
+  return getAppModule()
+    .initializeApp(options as FirebaseAppOptions, appConfig)
+    .then(() => {
+      app._initialized = true;
+      return app as unknown as ReactNativeFirebase.FirebaseApp;
+    })
+    .catch((e: any) => {
+      // we need to clean the app entry from registry as the app does not actually exist
+      // There are still possible side effects from `onAppCreateFn` to consider but as existing
+      // code may rely on that function running prior to native create, re-ordering it is a semantic change
+      // and will be avoided
+      delete APP_REGISTRY[name];
+
+      // Now allow calling code to handle the initialization issue
+      throw e;
+    });
+}
+
+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"');
+  }
+  // This is setting LogLevel for VertexAI which does not wrap around native SDK
+  setLogLevelInternal(logLevel);
+
+  if (isIOS || isOther) {
+    getAppModule().setLogLevel(logLevel);
+  }
+}
+
+export function setReactNativeAsyncStorage(asyncStorage: ReactNativeAsyncStorage): void {
+  warnIfNotModularCall(arguments, 'setReactNativeAsyncStorage()');
+
+  if (!isObject(asyncStorage)) {
+    throw new Error("setReactNativeAsyncStorage(*) 'asyncStorage' must be an object.");
+  }
+
+  if (!isFunction(asyncStorage.setItem)) {
+    throw new Error("setReactNativeAsyncStorage(*) 'asyncStorage.setItem' must be a function.");
+  }
+
+  if (!isFunction(asyncStorage.getItem)) {
+    throw new Error("setReactNativeAsyncStorage(*) 'asyncStorage.getItem' must be a function.");
+  }
+
+  if (!isFunction(asyncStorage.removeItem)) {
+    throw new Error("setReactNativeAsyncStorage(*) 'asyncStorage.removeItem' must be a function.");
+  }
+
+  setReactNativeAsyncStorageInternal(asyncStorage as any);
+}
+
+/**
+ *
+ */
+export function deleteApp(name: string, nativeInitialized: boolean): Promise<void> {
+  if (name === DEFAULT_APP_NAME && nativeInitialized) {
+    return Promise.reject(new Error('Unable to delete the default native firebase app instance.'));
+  }
+
+  const app = APP_REGISTRY[name];
+
+  if (app === undefined) {
+    throw new Error(`Firebase App named '${name}' already deleted`);
+  }
+
+  const nativeModule = getAppModule();
+
+  return nativeModule.deleteApp(name).then(() => {
+    (app as any)._deleted = true;
+    onAppDestroyFn?.(app);
+    delete APP_REGISTRY[name];
+  });
+}

package/lib/internal/registry/{namespace.js → namespace.ts}

@@ -17,9 +17,10 @@
 
 import { isString, createDeprecationProxy } from '../../common';
 import FirebaseApp from '../../FirebaseApp';
-import SDK_VERSION from '../../version';
-import { DEFAULT_APP_NAME, KNOWN_NAMESPACES } from '../constants';
+import { version as SDK_VERSION } from '../../version';
+import { DEFAULT_APP_NAME, KNOWN_NAMESPACES, type KnownNamespace } from '../constants';
 import FirebaseModule from '../FirebaseModule';
+import type { ModuleGetter, FirebaseRoot, NamespaceConfig } from '../../types/internal';
 import {
   getApp,
   getApps,
@@ -31,12 +32,12 @@ import {
 } from './app';
 
 // firebase.X
-let FIREBASE_ROOT = null;
+let FIREBASE_ROOT: FirebaseRoot | null = null;
 
-const NAMESPACE_REGISTRY = {};
-const APP_MODULE_INSTANCE = {};
-const MODULE_GETTER_FOR_APP = {};
-const MODULE_GETTER_FOR_ROOT = {};
+const NAMESPACE_REGISTRY: Record<string, NamespaceConfig | undefined> = {};
+const APP_MODULE_INSTANCE: Record<string, Record<string, FirebaseModule<any>>> = {};
+const MODULE_GETTER_FOR_APP: Record<string, Record<string, ModuleGetter>> = {};
+const MODULE_GETTER_FOR_ROOT: Record<string, ModuleGetter> = {};
 
 /**
  * Attaches module namespace getters on every newly created app.
@@ -46,10 +47,12 @@ const MODULE_GETTER_FOR_ROOT = {};
 setOnAppCreate(app => {
   for (let i = 0; i < KNOWN_NAMESPACES.length; i++) {
     const moduleNamespace = KNOWN_NAMESPACES[i];
-    Object.defineProperty(app, moduleNamespace, {
-      enumerable: false,
-      get: firebaseAppModuleProxy.bind(null, app, moduleNamespace),
-    });
+    if (moduleNamespace) {
+      Object.defineProperty(app, moduleNamespace, {
+        enumerable: false,
+        get: firebaseAppModuleProxy.bind(null, app, moduleNamespace),
+      });
+    }
   }
 });
 
@@ -70,17 +73,20 @@ setOnAppDestroy(app => {
  * @param moduleNamespace
  * @returns {*}
  */
-function getOrCreateModuleForApp(app, moduleNamespace) {
-  if (MODULE_GETTER_FOR_APP[app.name] && MODULE_GETTER_FOR_APP[app.name][moduleNamespace]) {
-    return MODULE_GETTER_FOR_APP[app.name][moduleNamespace];
+function getOrCreateModuleForApp(app: FirebaseApp, moduleNamespace: KnownNamespace): ModuleGetter {
+  if (MODULE_GETTER_FOR_APP[app.name] && MODULE_GETTER_FOR_APP[app.name]?.[moduleNamespace]) {
+    return MODULE_GETTER_FOR_APP[app.name]![moduleNamespace]!;
   }
 
   if (!MODULE_GETTER_FOR_APP[app.name]) {
     MODULE_GETTER_FOR_APP[app.name] = {};
   }
 
-  const { hasCustomUrlOrRegionSupport, hasMultiAppSupport, ModuleClass } =
-    NAMESPACE_REGISTRY[moduleNamespace];
+  const config = NAMESPACE_REGISTRY[moduleNamespace];
+  if (!config) {
+    throw new Error(`Module namespace '${moduleNamespace}' is not registered.`);
+  }
+  const { hasCustomUrlOrRegionSupport, hasMultiAppSupport, ModuleClass } = config;
 
   // modules such as analytics only run on the default app
   if (!hasMultiAppSupport && app.name !== DEFAULT_APP_NAME) {
@@ -94,7 +100,7 @@ function getOrCreateModuleForApp(app, moduleNamespace) {
   }
 
   // e.g. firebase.storage(customUrlOrRegion), firebase.functions(customUrlOrRegion), firebase.firestore(databaseId), firebase.database(url)
-  function firebaseModuleWithArgs(customUrlOrRegionOrDatabaseId) {
+  function firebaseModuleWithArgs(customUrlOrRegionOrDatabaseId?: string): FirebaseModule<any> {
     if (customUrlOrRegionOrDatabaseId !== undefined) {
       if (!hasCustomUrlOrRegionSupport) {
         // TODO throw Module does not support arguments error
@@ -113,19 +119,24 @@ function getOrCreateModuleForApp(app, moduleNamespace) {
       APP_MODULE_INSTANCE[app.name] = {};
     }
 
-    if (!APP_MODULE_INSTANCE[app.name][key]) {
+    if (!APP_MODULE_INSTANCE[app.name]?.[key]) {
+      const moduleConfig = NAMESPACE_REGISTRY[moduleNamespace];
+      if (!moduleConfig) {
+        throw new Error(`Module namespace '${moduleNamespace}' is not registered.`);
+      }
       const module = createDeprecationProxy(
-        new ModuleClass(app, NAMESPACE_REGISTRY[moduleNamespace], customUrlOrRegionOrDatabaseId),
-      );
+        new ModuleClass(app, moduleConfig, customUrlOrRegionOrDatabaseId),
+      ) as unknown as FirebaseModule<any>;
 
-      APP_MODULE_INSTANCE[app.name][key] = module;
+      APP_MODULE_INSTANCE[app.name]![key] = module;
     }
 
-    return APP_MODULE_INSTANCE[app.name][key];
+    return APP_MODULE_INSTANCE[app.name]![key]!;
   }
 
-  MODULE_GETTER_FOR_APP[app.name][moduleNamespace] = firebaseModuleWithArgs;
-  return MODULE_GETTER_FOR_APP[app.name][moduleNamespace];
+  MODULE_GETTER_FOR_APP[app.name]![moduleNamespace] =
+    firebaseModuleWithArgs as unknown as ModuleGetter;
+  return MODULE_GETTER_FOR_APP[app.name]![moduleNamespace]!;
 }
 
 /**
@@ -133,18 +144,29 @@ function getOrCreateModuleForApp(app, moduleNamespace) {
  * @param moduleNamespace
  * @returns {*}
  */
-function getOrCreateModuleForRoot(moduleNamespace) {
+function getOrCreateModuleForRoot(moduleNamespace: KnownNamespace): ModuleGetter {
   if (MODULE_GETTER_FOR_ROOT[moduleNamespace]) {
     return MODULE_GETTER_FOR_ROOT[moduleNamespace];
   }
 
-  const { statics, hasMultiAppSupport, ModuleClass } = NAMESPACE_REGISTRY[moduleNamespace];
+  const config = NAMESPACE_REGISTRY[moduleNamespace];
+  if (!config) {
+    throw new Error(`Module namespace '${moduleNamespace}' is not registered.`);
+  }
+  const { statics, hasMultiAppSupport, ModuleClass } = config;
 
   // e.g. firebase.storage(app)
-  function firebaseModuleWithApp(app) {
+  function firebaseModuleWithApp(app?: FirebaseApp): FirebaseModule<any> {
     const _app = app || getApp();
 
-    if (!(_app instanceof FirebaseApp)) {
+    // Duck-type check for FirebaseApp (checking for required properties)
+    if (
+      !_app ||
+      typeof _app !== 'object' ||
+      !('name' in _app) ||
+      !('options' in _app) ||
+      typeof _app.name !== 'string'
+    ) {
       throw new Error(
         [
           `"firebase.${moduleNamespace}(app)" arg expects a FirebaseApp instance or undefined.`,
@@ -169,22 +191,28 @@ function getOrCreateModuleForRoot(moduleNamespace) {
       APP_MODULE_INSTANCE[_app.name] = {};
     }
 
-    if (!APP_MODULE_INSTANCE[_app.name][moduleNamespace]) {
+    if (!APP_MODULE_INSTANCE[_app.name]?.[moduleNamespace]) {
+      const moduleConfig = NAMESPACE_REGISTRY[moduleNamespace];
+      if (!moduleConfig) {
+        throw new Error(`Module namespace '${moduleNamespace}' is not registered.`);
+      }
       const module = createDeprecationProxy(
-        new ModuleClass(_app, NAMESPACE_REGISTRY[moduleNamespace]),
-      );
-      APP_MODULE_INSTANCE[_app.name][moduleNamespace] = module;
+        new ModuleClass(_app, moduleConfig),
+      ) as unknown as FirebaseModule<any>;
+      APP_MODULE_INSTANCE[_app.name]![moduleNamespace] = module;
     }
 
-    return APP_MODULE_INSTANCE[_app.name][moduleNamespace];
+    return APP_MODULE_INSTANCE[_app.name]![moduleNamespace]!;
   }
 
   Object.assign(firebaseModuleWithApp, statics || {});
   // Object.freeze(firebaseModuleWithApp);
   // Wrap around statics, e.g. firebase.firestore.FieldValue, removed freeze as it stops proxy working. it is deprecated anyway
-  MODULE_GETTER_FOR_ROOT[moduleNamespace] = createDeprecationProxy(firebaseModuleWithApp);
+  MODULE_GETTER_FOR_ROOT[moduleNamespace] = createDeprecationProxy(
+    firebaseModuleWithApp,
+  ) as unknown as ModuleGetter;
 
-  return MODULE_GETTER_FOR_ROOT[moduleNamespace];
+  return MODULE_GETTER_FOR_ROOT[moduleNamespace]!;
 }
 
 /**
@@ -193,12 +221,15 @@ function getOrCreateModuleForRoot(moduleNamespace) {
  * @param moduleNamespace
  * @returns {*}
  */
-function firebaseRootModuleProxy(_firebaseNamespace, moduleNamespace) {
+function firebaseRootModuleProxy(
+  _firebaseNamespace: FirebaseRoot,
+  moduleNamespace: string,
+): ModuleGetter {
   if (NAMESPACE_REGISTRY[moduleNamespace]) {
-    return getOrCreateModuleForRoot(moduleNamespace);
+    return getOrCreateModuleForRoot(moduleNamespace as KnownNamespace);
   }
 
-  moduleWithDashes = moduleNamespace
+  const moduleWithDashes = moduleNamespace
     .split(/(?=[A-Z])/)
     .join('-')
     .toLowerCase();
@@ -218,13 +249,14 @@ function firebaseRootModuleProxy(_firebaseNamespace, moduleNamespace) {
  * @param moduleNamespace
  * @returns {*}
  */
-export function firebaseAppModuleProxy(app, moduleNamespace) {
+export function firebaseAppModuleProxy(app: FirebaseApp, moduleNamespace: string): ModuleGetter {
   if (NAMESPACE_REGISTRY[moduleNamespace]) {
-    app._checkDestroyed();
-    return getOrCreateModuleForApp(app, moduleNamespace);
+    // Call private _checkDestroyed method
+    (app as unknown as { _checkDestroyed: () => void })._checkDestroyed();
+    return getOrCreateModuleForApp(app, moduleNamespace as KnownNamespace);
   }
 
-  moduleWithDashes = moduleNamespace
+  const moduleWithDashes = moduleNamespace
     .split(/(?=[A-Z])/)
     .join('-')
     .toLowerCase();
@@ -242,8 +274,9 @@ export function firebaseAppModuleProxy(app, moduleNamespace) {
  *
  * @returns {*}
  */
-export function createFirebaseRoot() {
-  FIREBASE_ROOT = {
+export function createFirebaseRoot(): FirebaseRoot {
+  // Create partial root object - module namespaces like 'utils' are added dynamically below
+  const root = {
     initializeApp,
     setReactNativeAsyncStorage,
     get app() {
@@ -254,24 +287,27 @@ export function createFirebaseRoot() {
     },
     SDK_VERSION,
     setLogLevel,
-  };
+  } as FirebaseRoot;
 
   for (let i = 0; i < KNOWN_NAMESPACES.length; i++) {
     const namespace = KNOWN_NAMESPACES[i];
-    Object.defineProperty(FIREBASE_ROOT, namespace, {
-      enumerable: false,
-      get: firebaseRootModuleProxy.bind(null, FIREBASE_ROOT, namespace),
-    });
+    if (namespace) {
+      Object.defineProperty(root, namespace, {
+        enumerable: false,
+        get: firebaseRootModuleProxy.bind(null, root, namespace),
+      });
+    }
   }
 
-  return FIREBASE_ROOT;
+  FIREBASE_ROOT = root;
+  return root;
 }
 
 /**
  *
  * @returns {*}
  */
-export function getFirebaseRoot() {
+export function getFirebaseRoot(): FirebaseRoot {
   if (FIREBASE_ROOT) {
     return FIREBASE_ROOT;
   }
@@ -283,17 +319,20 @@ export function getFirebaseRoot() {
  * @param options
  * @returns {*}
  */
-export function createModuleNamespace(options = {}) {
+export function createModuleNamespace(options: NamespaceConfig): ModuleGetter {
   const { namespace, ModuleClass } = options;
 
   if (!NAMESPACE_REGISTRY[namespace]) {
     // validation only for internal / module dev usage
-    if (FirebaseModule.__extended__ !== ModuleClass.__extended__) {
+    const firebaseModuleExtended = (FirebaseModule as unknown as { __extended__: object })
+      .__extended__;
+    const moduleClassExtended = (ModuleClass as unknown as { __extended__: object }).__extended__;
+    if (firebaseModuleExtended !== moduleClassExtended) {
       throw new Error('INTERNAL ERROR: ModuleClass must be an instance of FirebaseModule.');
     }
 
     NAMESPACE_REGISTRY[namespace] = Object.assign({}, options);
   }
 
-  return getFirebaseRoot()[namespace];
+  return getFirebaseRoot()[namespace] as ModuleGetter;
 }