@react-native-firebase/app 23.7.0 → 23.8.0

package/lib/internal/nullSerialization.ts

@@ -0,0 +1,186 @@
+/*
+ * 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.
+ *
+ */
+
+const NULL_SENTINEL = { __rnfbNull: true };
+
+type Encodable = string | number | boolean | null | EncodableObject | EncodableArray;
+type EncodableObject = { [key: string]: Encodable };
+type EncodableArray = Encodable[];
+
+type ArrayFrame = {
+  type: 'array';
+  original: unknown[];
+  encoded: unknown[];
+  index: number;
+};
+
+type ObjectFrame = {
+  type: 'object';
+  original: Record<string, unknown>;
+  encoded: Record<string, unknown>;
+  keys: string[];
+  index: number;
+};
+
+type StackFrame = ArrayFrame | ObjectFrame;
+
+/**
+ * Replaces null values in object properties with sentinel objects for iOS TurboModule compatibility.
+ * Uses iterative stack-based traversal to avoid stack overflow on deeply nested structures.
+ *
+ * iOS TurboModules strip null values from object properties during serialization,
+ * so we replace them with sentinel objects that can survive the serialization
+ * and be detected/restored on the native side.
+ *
+ * Note: Null values in arrays are preserved by iOS TurboModules, so we don't
+ * encode them (but we still process nested objects within arrays).
+ *
+ * @param data - The data to encode
+ * @returns The encoded data with null object properties replaced by sentinels
+ */
+export function encodeNullValues(data: unknown): unknown {
+  if (data === null) {
+    // only null values within objects are encoded
+    return null;
+  }
+  if (typeof data !== 'object') {
+    return data;
+  }
+
+  // Helper to process a child element and add it to the encoded container
+  function processArrayChild(
+    child: unknown,
+    encoded: unknown[],
+    index: number,
+    stack: StackFrame[],
+  ): void {
+    if (child === null) {
+      // Arrays preserve nulls as null
+      encoded[index] = null;
+    } else if (typeof child !== 'object') {
+      encoded[index] = child;
+    } else if (Array.isArray(child)) {
+      const childEncoded: unknown[] = new Array(child.length);
+      encoded[index] = childEncoded;
+      stack.push({
+        type: 'array',
+        original: child,
+        encoded: childEncoded,
+        index: 0,
+      });
+    } else {
+      const childEncoded: Record<string, unknown> = {};
+      encoded[index] = childEncoded;
+      stack.push({
+        type: 'object',
+        original: child as Record<string, unknown>,
+        encoded: childEncoded,
+        keys: Object.keys(child),
+        index: 0,
+      });
+    }
+  }
+
+  function processObjectChild(
+    child: unknown,
+    encoded: Record<string, unknown>,
+    key: string,
+    stack: StackFrame[],
+  ): void {
+    if (child === null) {
+      // Objects convert null to sentinel
+      encoded[key] = NULL_SENTINEL;
+    } else if (typeof child !== 'object') {
+      encoded[key] = child;
+    } else if (Array.isArray(child)) {
+      const childEncoded: unknown[] = new Array(child.length);
+      encoded[key] = childEncoded;
+      stack.push({
+        type: 'array',
+        original: child,
+        encoded: childEncoded,
+        index: 0,
+      });
+    } else {
+      const childEncoded: Record<string, unknown> = {};
+      encoded[key] = childEncoded;
+      stack.push({
+        type: 'object',
+        original: child as Record<string, unknown>,
+        encoded: childEncoded,
+        keys: Object.keys(child),
+        index: 0,
+      });
+    }
+  }
+
+  // Prepare root encoded container
+  let rootEncoded: unknown[] | Record<string, unknown>;
+  const stack: StackFrame[] = [];
+
+  if (Array.isArray(data)) {
+    rootEncoded = new Array(data.length);
+    stack.push({
+      type: 'array',
+      original: data,
+      encoded: rootEncoded,
+      index: 0,
+    });
+  } else {
+    rootEncoded = {};
+    stack.push({
+      type: 'object',
+      original: data as Record<string, unknown>,
+      encoded: rootEncoded,
+      keys: Object.keys(data),
+      index: 0,
+    });
+  }
+
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1]!; // Non-null assertion safe due to while condition
+
+    if (frame.type === 'array') {
+      const { original, encoded } = frame;
+
+      if (frame.index >= original.length) {
+        // Done with this array
+        stack.pop();
+        continue;
+      }
+
+      const i = frame.index++;
+      const item = original[i];
+      processArrayChild(item, encoded, i, stack);
+    } else {
+      // frame.type === 'object'
+      const { original, encoded, keys } = frame;
+
+      if (frame.index >= keys.length) {
+        // Done with this object
+        stack.pop();
+        continue;
+      }
+
+      const key = keys[frame.index++]!; // Non-null assertion safe due to length check above
+      const value = original[key];
+      processObjectChild(value, encoded, key, stack);
+    }
+  }
+
+  return rootEncoded;
+}

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