@react-native-firebase/app 23.7.0 → 23.8.0

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;
 }

package/lib/internal/registry/nativeModule.ts

@@ -0,0 +1,282 @@
+/*
+ * 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 { APP_NATIVE_MODULE } from '../constants';
+import NativeFirebaseError from '../NativeFirebaseError';
+import type { NativeError } from '../../types/internal';
+import RNFBNativeEventEmitter from '../RNFBNativeEventEmitter';
+import SharedEventEmitter from '../SharedEventEmitter';
+import { getReactNativeModule } from '../nativeModule';
+import { isAndroid, isIOS } from '../../common';
+import FirebaseModule from '../FirebaseModule';
+import type { WrappedNativeModule, RNFBAppModuleInterface } from '../NativeModules';
+import { encodeNullValues } from '../nullSerialization';
+
+interface NativeEvent {
+  appName?: string;
+  databaseId?: string;
+  [key: string]: unknown;
+}
+
+const NATIVE_MODULE_REGISTRY: Record<string, WrappedNativeModule> = {};
+const NATIVE_MODULE_EVENT_SUBSCRIPTIONS: Record<string, boolean> = {};
+
+function nativeModuleKey(module: FirebaseModule): string {
+  return `${module._customUrlOrRegion || ''}:${module.app.name}:${module._config.namespace}`;
+}
+
+/**
+ * Wraps a native module method to provide
+ * auto prepended args and custom Error classes.
+ *
+ * @param namespace
+ * @param method
+ * @param argToPrepend
+ * @returns {Function}
+ */
+function nativeModuleMethodWrapped(
+  namespace: string,
+  method: (...args: unknown[]) => unknown,
+  argToPrepend: unknown[],
+  isTurboModule: boolean,
+): (...args: unknown[]) => unknown {
+  return (...args: unknown[]) => {
+    // For iOS TurboModules, encode null values in arguments to work around
+    // the limitation where null values in object properties get stripped during serialization
+    // See: https://github.com/facebook/react-native/issues/52802
+    const processedArgs = isIOS && isTurboModule ? args.map(arg => encodeNullValues(arg)) : args;
+    const allArgs = [...argToPrepend, ...processedArgs];
+    const possiblePromise = method(...allArgs);
+
+    if (possiblePromise && typeof possiblePromise === 'object' && 'then' in possiblePromise) {
+      const jsStack = new Error().stack;
+      return (possiblePromise as Promise<unknown>).catch((nativeError: NativeError) =>
+        Promise.reject(new NativeFirebaseError(nativeError, jsStack as string, namespace)),
+      );
+    }
+
+    return possiblePromise;
+  };
+}
+
+/**
+ * Prepends all arguments in prependArgs to all native method calls
+ *
+ * @param namespace
+ * @param NativeModule - Raw native module from React Native
+ * @param argToPrepend
+ */
+function nativeModuleWrapped(
+  namespace: string,
+  NativeModule: Record<string, unknown> | undefined,
+  argToPrepend: unknown[],
+  isTurboModule: boolean,
+): WrappedNativeModule {
+  const native: Record<string, unknown> = {};
+  if (!NativeModule) {
+    return NativeModule as unknown as WrappedNativeModule;
+  }
+
+  const nativeModuleObj = NativeModule;
+  let properties = Object.keys(Object.getPrototypeOf(nativeModuleObj));
+  if (!properties.length) properties = Object.keys(nativeModuleObj);
+
+  for (let i = 0, len = properties.length; i < len; i++) {
+    const property = properties[i];
+    if (!property) continue;
+    if (typeof nativeModuleObj[property] === 'function') {
+      native[property] = nativeModuleMethodWrapped(
+        namespace,
+        nativeModuleObj[property] as (...args: unknown[]) => unknown,
+        argToPrepend,
+        isTurboModule,
+      );
+    } else {
+      native[property] = nativeModuleObj[property];
+    }
+  }
+
+  return native;
+}
+
+/**
+ * Initialises and wraps all the native module methods.
+ *
+ * @param module
+ * @returns {*}
+ */
+function initialiseNativeModule(module: FirebaseModule): WrappedNativeModule {
+  const config = module._config;
+  const key = nativeModuleKey(module);
+  const {
+    namespace,
+    nativeEvents,
+    nativeModuleName,
+    hasMultiAppSupport,
+    hasCustomUrlOrRegionSupport,
+    disablePrependCustomUrlOrRegion,
+    turboModule,
+  } = config;
+  const multiModuleRoot: WrappedNativeModule = {};
+  const isTurboModule = !!turboModule;
+  const multiModule = Array.isArray(nativeModuleName);
+  const nativeModuleNames = multiModule ? nativeModuleName : [nativeModuleName];
+
+  for (let i = 0; i < nativeModuleNames.length; i++) {
+    const moduleName = nativeModuleNames[i];
+    if (!moduleName) continue;
+
+    const nativeModule = getReactNativeModule(moduleName);
+
+    // only error if there's a single native module
+    // as multi modules can mean some are optional
+    if (!multiModule && !nativeModule) {
+      throw new Error(getMissingModuleHelpText(namespace));
+    }
+
+    if (multiModule) {
+      multiModuleRoot[moduleName] = !!nativeModule;
+    }
+
+    const argToPrepend: Array<string> = [];
+
+    if (hasMultiAppSupport) {
+      argToPrepend.push(module.app.name);
+    }
+
+    if (hasCustomUrlOrRegionSupport && !disablePrependCustomUrlOrRegion) {
+      argToPrepend.push(module._customUrlOrRegion as string);
+    }
+
+    Object.assign(
+      multiModuleRoot,
+      nativeModuleWrapped(namespace, nativeModule, argToPrepend, isTurboModule),
+    );
+  }
+
+  if (nativeEvents && Array.isArray(nativeEvents) && nativeEvents.length) {
+    for (let i = 0, len = nativeEvents.length; i < len; i++) {
+      const eventName = nativeEvents[i];
+      if (eventName) {
+        subscribeToNativeModuleEvent(eventName);
+      }
+    }
+  }
+
+  Object.freeze(multiModuleRoot);
+
+  NATIVE_MODULE_REGISTRY[key] = multiModuleRoot;
+
+  return NATIVE_MODULE_REGISTRY[key];
+}
+
+/**
+ * Subscribe to a native event for js side distribution by appName
+ *    React Native events are hard set at compile - cant do dynamic event names
+ *    so we use a single event send it to js and js then internally can prefix it
+ *    and distribute dynamically.
+ *
+ * @param eventName
+ * @private
+ */
+function subscribeToNativeModuleEvent(eventName: string): void {
+  if (!NATIVE_MODULE_EVENT_SUBSCRIPTIONS[eventName]) {
+    RNFBNativeEventEmitter.addListener(eventName, (...args: unknown[]) => {
+      const event = args[0] as NativeEvent;
+      if (event.appName && event.databaseId) {
+        // Firestore requires both appName and databaseId to prefix
+        SharedEventEmitter.emit(`${event.appName}-${event.databaseId}-${eventName}`, event);
+      } else if (event.appName) {
+        // native event has an appName property - auto prefix and internally emit
+        SharedEventEmitter.emit(`${event.appName}-${eventName}`, event);
+      } else {
+        // standard event - no need to prefix
+        SharedEventEmitter.emit(eventName, event);
+      }
+    });
+
+    NATIVE_MODULE_EVENT_SUBSCRIPTIONS[eventName] = true;
+  }
+}
+
+/**
+ * Help text for integrating the native counter parts for each firebase module.
+ *
+ * @param namespace
+ * @returns {string}
+ */
+function getMissingModuleHelpText(namespace: string): string {
+  const snippet = `firebase.${namespace}()`;
+
+  if (isIOS || isAndroid) {
+    return (
+      `You attempted to use a Firebase module that's not installed natively on your project by calling ${snippet}.` +
+      `\r\n\r\nEnsure you have installed the npm package '@react-native-firebase/${namespace}',` +
+      ' have imported it in your project, and have rebuilt your native application.'
+    );
+  }
+
+  return (
+    `You attempted to use a Firebase module that's not installed on your project by calling ${snippet}.` +
+    `\r\n\r\nEnsure you have installed the npm package '@react-native-firebase/${namespace}' and` +
+    ' have imported it in your project.'
+  );
+}
+
+/**
+ * Gets a wrapped native module instance for the provided firebase module.
+ * Will attempt to create a new instance if non previously created.
+ *
+ * @param module
+ * @returns {*}
+ */
+export function getNativeModule(module: FirebaseModule): WrappedNativeModule {
+  const key = nativeModuleKey(module);
+
+  if (NATIVE_MODULE_REGISTRY[key]) {
+    return NATIVE_MODULE_REGISTRY[key];
+  }
+
+  return initialiseNativeModule(module);
+}
+
+/**
+ * Custom wrapped app module as it does not have it's own FirebaseModule based class.
+ *
+ * @returns {*}
+ */
+export function getAppModule(): RNFBAppModuleInterface {
+  if (NATIVE_MODULE_REGISTRY[APP_NATIVE_MODULE]) {
+    return NATIVE_MODULE_REGISTRY[APP_NATIVE_MODULE] as unknown as RNFBAppModuleInterface;
+  }
+
+  const namespace = 'app';
+  const nativeModule = getReactNativeModule(APP_NATIVE_MODULE);
+
+  if (!nativeModule) {
+    throw new Error(getMissingModuleHelpText(namespace));
+  }
+
+  NATIVE_MODULE_REGISTRY[APP_NATIVE_MODULE] = nativeModuleWrapped(
+    namespace,
+    nativeModule,
+    [],
+    // TODO: change to true when we use TurboModules for app package
+    false,
+  );
+
+  return NATIVE_MODULE_REGISTRY[APP_NATIVE_MODULE] as unknown as RNFBAppModuleInterface;
+}