@react-native-firebase/app 23.7.0 → 23.8.1

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

package/lib/internal/web/RNFBAppModule.ts

@@ -0,0 +1,318 @@
+/*
+ * 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 { initializeApp, setLogLevel, getApp, getApps, deleteApp } from './firebaseApp';
+import { DeviceEventEmitter } from 'react-native';
+import { type ReactNativeFirebase } from '../../index';
+
+// Types for internal state
+interface QueuedEvent {
+  eventName: string;
+  eventBody: any;
+}
+
+interface EventListeners {
+  [eventName: string]: number;
+}
+
+interface ListenersMap {
+  listeners: number;
+  queued: number;
+  events: EventListeners;
+}
+
+interface PreferencesStorage {
+  [key: string]: boolean | string;
+}
+
+interface InitializeAppResult {
+  options: ReactNativeFirebase.FirebaseAppOptions;
+  appConfig: ReactNativeFirebase.FirebaseAppConfig;
+}
+
+// Variables for events tracking.
+let jsReady = false;
+let jsListenerCount = 0;
+let queuedEvents: QueuedEvent[] = [];
+let jsListeners: EventListeners = {};
+
+// For compatibility we have a fake preferences storage,
+// it does not persist across app restarts.
+let fakePreferencesStorage: PreferencesStorage = {};
+
+function eventsGetListenersMap(): ListenersMap {
+  return {
+    listeners: jsListenerCount,
+    queued: queuedEvents.length,
+    events: jsListeners,
+  };
+}
+
+function eventsSendEvent(eventName: string, eventBody: any): void {
+  if (!jsReady || !jsListeners.hasOwnProperty(eventName)) {
+    const event: QueuedEvent = {
+      eventName,
+      eventBody,
+    };
+    queuedEvents.push(event);
+    return;
+  }
+  setImmediate(() => DeviceEventEmitter.emit('rnfb_' + eventName, eventBody));
+}
+
+function eventsSendQueuedEvents(): void {
+  if (queuedEvents.length === 0) {
+    return;
+  }
+  const events = Array.from(queuedEvents);
+  queuedEvents = [];
+  for (let i = 0; i < events.length; i++) {
+    const event = events[i];
+    if (event) {
+      eventsSendEvent(event.eventName, event.eventBody);
+    }
+  }
+}
+
+export default {
+  // Natively initialized apps, but in the case of web, we don't have any.
+  NATIVE_FIREBASE_APPS: [] as any[],
+  // The raw JSON string of the Firebase config, from the users firebase.json file.
+  // In the case of web, we can't support this.
+  FIREBASE_RAW_JSON: '{}',
+
+  /**
+   * Initializes a Firebase app.
+   *
+   * @param options - The Firebase app options.
+   * @param appConfig - The Firebase app config.
+   * @returns The Firebase app instance.
+   */
+  async initializeApp(
+    options: ReactNativeFirebase.FirebaseAppOptions,
+    appConfig: ReactNativeFirebase.FirebaseAppConfig,
+  ): Promise<InitializeAppResult> {
+    const name = appConfig.name;
+    const existingApp = getApps().find(app => app.name === name);
+    if (existingApp) {
+      return {
+        options,
+        appConfig,
+      };
+    }
+    const newAppConfig: any = {
+      name,
+    };
+    if (
+      appConfig.automaticDataCollectionEnabled === true ||
+      appConfig.automaticDataCollectionEnabled === false
+    ) {
+      newAppConfig.automaticDataCollectionEnabled = appConfig.automaticDataCollectionEnabled;
+    }
+    const optionsCopy = Object.assign({}, options);
+
+    delete (optionsCopy as any).clientId;
+    initializeApp(optionsCopy, newAppConfig);
+    return {
+      options,
+      appConfig,
+    };
+  },
+
+  /**
+   * Sets the log level for the Firebase app.
+   *
+   * @param logLevel - The log level to set.
+   */
+  setLogLevel(logLevel: ReactNativeFirebase.LogLevelString): void {
+    setLogLevel(logLevel as any);
+  },
+
+  /**
+   * Sets the automatic data collection for the Firebase app.
+   *
+   * @param appName - The name of the Firebase app.
+   * @param enabled - Whether to enable automatic data collection.
+   */
+  setAutomaticDataCollectionEnabled(appName: string, enabled: boolean): void {
+    (getApp(appName) as any).automaticDataCollectionEnabled = enabled;
+  },
+
+  /**
+   * Deletes a Firebase app.
+   *
+   * @param appName - The name of the Firebase app to delete.
+   */
+  async deleteApp(appName: string): Promise<void> {
+    if (getApp(appName)) {
+      await deleteApp(getApp(appName) as any);
+    }
+  },
+
+  /**
+   * Gets the meta data.
+   * Unsupported on web.
+   *
+   * @returns The meta data
+   */
+  metaGetAll(): Record<string, never> {
+    return {};
+  },
+
+  /**
+   * Gets the firebase.json data.
+   * Unsupported on web.
+   *
+   * @returns The JSON data for the firebase.json file.
+   */
+  jsonGetAll(): Record<string, never> {
+    return {};
+  },
+
+  /**
+   * Sets a boolean value for a preference.
+   * Unsupported on web.
+   *
+   * @param key - The key of the preference.
+   * @param value - The value to set.
+   */
+  async preferencesSetBool(key: string, value: boolean): Promise<void> {
+    fakePreferencesStorage[key] = value;
+  },
+
+  /**
+   * Sets a string value for a preference.
+   * Unsupported on web.
+   *
+   * @param key - The key of the preference.
+   * @param value - The value to set.
+   */
+  preferencesSetString(key: string, value: string): void {
+    fakePreferencesStorage[key] = value;
+  },
+
+  /**
+   * Gets all preferences.
+   * Unsupported on web.
+   *
+   * @returns The preferences.
+   */
+  preferencesGetAll(): PreferencesStorage {
+    return Object.assign({}, fakePreferencesStorage);
+  },
+
+  /**
+   * Clears all preferences.
+   * Unsupported on web.
+   */
+  preferencesClearAll(): void {
+    fakePreferencesStorage = {};
+  },
+
+  /**
+   * Adds a listener for an event.
+   * Unsupported on web.
+   *
+   * @param eventName - The name of the event to listen for.
+   */
+  addListener(): void {
+    // Keep: Required for RN built in Event Emitter Calls.
+  },
+  /**
+   * Removes a listener for an event.
+   * Unsupported on web.
+   *
+   * @param eventName - The name of the event to remove the listener for.
+   */
+  removeListeners(): void {
+    // Keep: Required for RN built in Event Emitter Calls.
+  },
+
+  /**
+   * Notifies the app that it is ready to receive events.
+   *
+   * @param ready - Whether the app is ready to receive events.
+   * @returns void
+   */
+  eventsNotifyReady(ready: boolean): void {
+    jsReady = ready;
+    if (jsReady) {
+      setImmediate(() => eventsSendQueuedEvents());
+    }
+  },
+
+  /**
+   * Gets all the listeners registered.
+   *
+   * @returns The listeners for the event.
+   */
+  eventsGetListeners(): ListenersMap {
+    return eventsGetListenersMap();
+  },
+
+  /**
+   * Sends an event to the app for testing purposes.
+   *
+   * @param eventName - The name of the event to send.
+   * @param eventBody - The body of the event to send.
+   * @returns void
+   */
+  eventsPing(eventName: string, eventBody: any): void {
+    eventsSendEvent(eventName, eventBody);
+  },
+
+  /**
+   * Adds a listener for an event.
+   *
+   * @param eventName - The name of the event to listen for.
+   */
+  eventsAddListener(eventName: string): void {
+    jsListenerCount++;
+    if (!jsListeners.hasOwnProperty(eventName)) {
+      jsListeners[eventName] = 1;
+    } else {
+      if (jsListeners[eventName] !== undefined) {
+        jsListeners[eventName]++;
+      }
+    }
+    setImmediate(() => eventsSendQueuedEvents());
+  },
+
+  /**
+   * Removes a single listener for an event or all listeners for an event.
+   *
+   * @param eventName - The name of the event to remove the listener for.
+   * @param all - Optional. Whether to remove all listeners for the event.
+   */
+  eventsRemoveListener(eventName: string, all?: boolean): void {
+    if (jsListeners.hasOwnProperty(eventName)) {
+      const count = jsListeners[eventName];
+      if (count !== undefined) {
+        if (count <= 1 || all) {
+          jsListenerCount -= count;
+          delete jsListeners[eventName];
+        } else {
+          jsListenerCount--;
+          const currentCount = jsListeners[eventName];
+          if (currentCount !== undefined) {
+            jsListeners[eventName] = currentCount - 1;
+          }
+        }
+      }
+    }
+  },
+};

package/lib/internal/web/firebaseApp.ts

@@ -0,0 +1,20 @@
+/*
+ * 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.
+ *
+ */
+
+// We need to share firebase imports between modules, otherwise
+// apps and instances of the firebase modules are not shared.
+export * from 'firebase/app';

package/lib/internal/web/firebaseAppCheck.ts

@@ -0,0 +1,23 @@
+/*
+ * 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.
+ *
+ */
+
+// We need to share firebase imports between modules, otherwise
+// apps and instances of the firebase modules are not shared.
+import 'firebase/app';
+export { getApp } from 'firebase/app';
+export * from 'firebase/app-check';
+export { makeIDBAvailable } from './memidb';

package/lib/internal/web/firebaseAuth.ts

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ *
+ */
+
+// We need to share firebase imports between modules, otherwise
+// apps and instances of the firebase modules are not shared.
+export * from 'firebase/app';
+export * from 'firebase/auth';

package/lib/internal/web/firebaseDatabase.ts

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ *
+ */
+
+// We need to share firebase imports between modules, otherwise
+// apps and instances of the firebase modules are not shared.
+export * from 'firebase/app';
+export * from 'firebase/database';

package/lib/internal/web/firebaseFirestore.ts

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ *
+ */
+
+// We need to share firebase imports between modules, otherwise
+// apps and instances of the firebase modules are not shared.
+export { getApp } from 'firebase/app';
+export * from 'firebase/firestore/lite';