@react-native-firebase/remote-config 24.1.0 → 25.0.0

package/lib/namespaced.ts

@@ -0,0 +1,552 @@
+/*
+ * 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 {
+  hasOwnProperty,
+  isFunction,
+  isIOS,
+  isNumber,
+  isObject,
+  isString,
+  isUndefined,
+  parseListenerOrObserver,
+} from '@react-native-firebase/app/dist/module/common';
+import {
+  createModuleNamespace,
+  FirebaseModule,
+  getFirebaseRoot,
+  type ModuleConfig,
+} from '@react-native-firebase/app/dist/module/internal';
+import NativeFirebaseError from '@react-native-firebase/app/dist/module/internal/NativeFirebaseError';
+import { setReactNativeModule } from '@react-native-firebase/app/dist/module/internal/nativeModule';
+import type { ReactNativeFirebase } from '@react-native-firebase/app';
+import RemoteConfigValue from './RemoteConfigValue';
+import { LastFetchStatus, ValueSource } from './statics';
+import type {
+  ConfigUpdate,
+  ConfigUpdateObserver,
+  FetchStatus,
+  RemoteConfigSettings,
+} from './types/remote-config';
+import type { FirebaseRemoteConfigTypes } from './types/namespaced';
+import type {
+  ConfigSettingsStateInternal,
+  NativeRemoteConfigConstants,
+  NativeRemoteConfigResult,
+  RemoteConfigUpdateErrorEventInternal,
+  RemoteConfigUpdateErrorInternal,
+  RemoteConfigUpdateSuccessEventInternal,
+  StoredConfigValueInternal,
+} from './types/internal';
+import { version } from './version';
+import fallBackModule from './web/RNFBConfigModule';
+
+type ConfigDefaults = FirebaseRemoteConfigTypes.ConfigDefaults;
+type ConfigSettings = FirebaseRemoteConfigTypes.ConfigSettings;
+type ConfigValue = FirebaseRemoteConfigTypes.ConfigValue;
+type ConfigValues = FirebaseRemoteConfigTypes.ConfigValues;
+type LastFetchStatusType = FirebaseRemoteConfigTypes.LastFetchStatusType;
+
+function isSuccessEvent(
+  event: RemoteConfigUpdateSuccessEventInternal | RemoteConfigUpdateErrorEventInternal,
+): event is RemoteConfigUpdateSuccessEventInternal {
+  return event.resultType === 'success';
+}
+
+function toConfigUpdate(updatedKeys: string[]): ConfigUpdate {
+  return {
+    getUpdatedKeys: () => new Set(updatedKeys),
+  };
+}
+
+function toNativeFirebaseError(
+  errorEvent: RemoteConfigUpdateErrorInternal,
+): ReactNativeFirebase.NativeFirebaseError {
+  return NativeFirebaseError.fromEvent(
+    errorEvent,
+    namespace,
+  ) as ReactNativeFirebase.NativeFirebaseError;
+}
+
+const statics = {
+  LastFetchStatus,
+  ValueSource,
+};
+
+const namespace = 'remoteConfig';
+const nativeModuleName = 'RNFBConfigModule' as const;
+
+class FirebaseConfigModule extends FirebaseModule<typeof nativeModuleName> {
+  private _settings: ConfigSettingsStateInternal;
+  private _lastFetchTime: number;
+  private _lastFetchStatus: FetchStatus;
+  private _values: Record<string, StoredConfigValueInternal>;
+  private _configUpdateListenerCount: number;
+  private _nativeMutationQueue: Promise<void>;
+
+  constructor(
+    app: ReactNativeFirebase.FirebaseAppBase,
+    config: ModuleConfig,
+    customUrlOrRegion?: string | null,
+  ) {
+    super(app, config, customUrlOrRegion);
+    this._settings = {
+      // defaults to 1 minute.
+      fetchTimeoutMillis: 60000,
+      // defaults to 12 hours.
+      minimumFetchIntervalMillis: 43200000,
+    };
+    this._lastFetchTime = -1;
+    this._lastFetchStatus = 'no_fetch_yet';
+    this._values = {};
+    this._configUpdateListenerCount = 0;
+    this._nativeMutationQueue = Promise.resolve();
+  }
+
+  get defaultConfig(): ConfigDefaults {
+    const updatedDefaultConfig: ConfigDefaults = {};
+    Object.keys(this._values).forEach(key => {
+      // Need to make it an object with key and literal value. Not `Value` instance.
+      const configValue = this._values[key];
+      if (configValue) {
+        updatedDefaultConfig[key] = configValue.value;
+      }
+    });
+
+    return updatedDefaultConfig;
+  }
+
+  set defaultConfig(defaults: ConfigDefaults) {
+    if (!isObject(defaults)) {
+      throw new Error("firebase.remoteConfig().defaultConfig: 'defaults' must be an object.");
+    }
+
+    // To make Firebase web v9 API compatible, we update the config first so it immediately
+    // updates defaults on the instance. We then pass to underlying SDK to update. We do this because
+    // there is no way to "await" a setter.
+    const nonDefaultValues = Object.fromEntries(
+      Object.entries(this._values).filter(([, configValue]) => configValue?.source !== 'default'),
+    );
+
+    this._values = Object.freeze({
+      ...Object.fromEntries(
+        Object.entries(defaults).map(([key, value]) => [
+          key,
+          { value, source: 'default' as const },
+        ]),
+      ),
+      ...nonDefaultValues,
+    });
+    void this.setDefaults(defaults, true);
+  }
+
+  get settings(): RemoteConfigSettings & { fetchTimeMillis: number } {
+    return {
+      minimumFetchIntervalMillis: this._settings.minimumFetchIntervalMillis,
+      fetchTimeoutMillis: this._settings.fetchTimeoutMillis,
+      fetchTimeMillis: this._settings.fetchTimeoutMillis,
+    };
+  }
+
+  set settings(settings: ConfigSettings | RemoteConfigSettings) {
+    // To make Firebase web v9 API compatible, we update the settings first so it immediately
+    // updates settings on the instance. We then pass to underlying SDK to update. We do this because
+    // there is no way to "await" a setter. We can't delegate to `setConfigSettings()` as it is setup
+    // for native.
+    this._settings = {
+      minimumFetchIntervalMillis:
+        settings.minimumFetchIntervalMillis ?? this._settings.minimumFetchIntervalMillis,
+      fetchTimeoutMillis:
+        ('fetchTimeoutMillis' in settings ? settings.fetchTimeoutMillis : undefined) ??
+        ('fetchTimeMillis' in settings ? settings.fetchTimeMillis : undefined) ??
+        this._settings.fetchTimeoutMillis,
+    };
+    void this.setConfigSettings(settings, true);
+  }
+
+  getValue(key: string): ConfigValue {
+    if (!isString(key)) {
+      throw new Error("firebase.remoteConfig().getValue(): 'key' must be a string value.");
+    }
+
+    if (typeof this._values === 'undefined' || !hasOwnProperty(this._values, key)) {
+      return new RemoteConfigValue({
+        value: '',
+        source: 'static',
+      });
+    }
+
+    const configValue = this._values[key]!;
+    return new RemoteConfigValue({ value: `${configValue.value}`, source: configValue.source });
+  }
+
+  getBoolean(key: string): boolean {
+    return this.getValue(key).asBoolean();
+  }
+
+  getNumber(key: string): number {
+    return this.getValue(key).asNumber();
+  }
+
+  getString(key: string): string {
+    return this.getValue(key).asString();
+  }
+
+  getAll(): ConfigValues {
+    const values: ConfigValues = {};
+    Object.keys(this._values).forEach(key => {
+      values[key] = this.getValue(key);
+    });
+    return values;
+  }
+
+  get fetchTimeMillis(): number {
+    // android returns -1 if no fetch yet and iOS returns 0
+    return this._lastFetchTime;
+  }
+
+  get lastFetchStatus(): LastFetchStatusType {
+    return this._lastFetchStatus;
+  }
+
+  /**
+   * Deletes all activated, fetched and defaults configs and resets all Firebase Remote Config settings.
+   * @returns {Promise<void>}
+   */
+  reset(): Promise<void> {
+    if (isIOS) {
+      return Promise.resolve();
+    }
+
+    return this._enqueueNativeMutation(() => this._promiseWithConstants(this.native.reset()));
+  }
+
+  setConfigSettings(
+    settings: ConfigSettings | RemoteConfigSettings,
+    fromSettingsSetter = false,
+  ): Promise<void> {
+    const updatedSettings: {
+      fetchTimeout: number;
+      minimumFetchInterval: number;
+    } = {
+      fetchTimeout: this._settings.fetchTimeoutMillis / 1000,
+      minimumFetchInterval: this._settings.minimumFetchIntervalMillis / 1000,
+    };
+
+    const apiCalled = fromSettingsSetter ? 'settings' : 'setConfigSettings';
+    if (!isObject(settings)) {
+      throw new Error(`firebase.remoteConfig().${apiCalled}(*): settings must set an object.`);
+    }
+
+    if (hasOwnProperty(settings, 'minimumFetchIntervalMillis')) {
+      if (!isNumber(settings.minimumFetchIntervalMillis)) {
+        throw new Error(
+          `firebase.remoteConfig().${apiCalled}(): 'settings.minimumFetchIntervalMillis' must be a number type in milliseconds.`,
+        );
+      } else {
+        updatedSettings.minimumFetchInterval = settings.minimumFetchIntervalMillis / 1000;
+      }
+    }
+
+    if (hasOwnProperty(settings, 'fetchTimeMillis')) {
+      if (!isNumber(settings.fetchTimeMillis)) {
+        throw new Error(
+          `firebase.remoteConfig().${apiCalled}(): 'settings.fetchTimeMillis' must be a number type in milliseconds.`,
+        );
+      }
+
+      updatedSettings.fetchTimeout = settings.fetchTimeMillis / 1000;
+    } else if (hasOwnProperty(settings, 'fetchTimeoutMillis')) {
+      if (!isNumber(settings.fetchTimeoutMillis)) {
+        throw new Error(
+          `firebase.remoteConfig().${apiCalled}(): 'settings.fetchTimeoutMillis' must be a number type in milliseconds.`,
+        );
+      }
+
+      updatedSettings.fetchTimeout = settings.fetchTimeoutMillis / 1000;
+    }
+
+    const nextSettings = {
+      fetchTimeoutMillis: updatedSettings.fetchTimeout * 1000,
+      minimumFetchIntervalMillis: updatedSettings.minimumFetchInterval * 1000,
+    };
+
+    // Keep JS reads in sync immediately. Native can report stale settings constants
+    // for this call because native setConfigSettingsAsync completes after the bridge resolves.
+    this._settings = nextSettings;
+
+    return this._enqueueNativeMutation(() =>
+      this.native.setConfigSettings(updatedSettings).then(({ result, constants }) => {
+        // Preserve the eagerly computed settings above and only refresh the rest of the cache.
+        this._updateFromConstants({
+          ...constants,
+          fetchTimeout: undefined,
+          minimumFetchInterval: undefined,
+        });
+        return result;
+      }),
+    );
+  }
+
+  /**
+   * Activates the Fetched RemoteConfig, so that the fetched key-values take effect.
+   * @returns {Promise<boolean>}
+   */
+  activate(): Promise<boolean> {
+    return this._promiseWithConstants(this.native.activate());
+  }
+
+  /**
+   * Fetches parameter values for your app.
+   *
+   * @param expirationDurationSeconds
+   * @returns {Promise}
+   */
+  fetch(expirationDurationSeconds?: number): Promise<void> {
+    if (!isUndefined(expirationDurationSeconds) && !isNumber(expirationDurationSeconds)) {
+      throw new Error(
+        "firebase.remoteConfig().fetch(): 'expirationDurationSeconds' must be a number value.",
+      );
+    }
+
+    return this._promiseWithConstants(
+      this.native.fetch(expirationDurationSeconds !== undefined ? expirationDurationSeconds : -1),
+    );
+  }
+
+  fetchAndActivate(): Promise<boolean> {
+    return this._promiseWithConstants(this.native.fetchAndActivate());
+  }
+
+  ensureInitialized(): Promise<void> {
+    return this._promiseWithConstants(this.native.ensureInitialized());
+  }
+
+  /**
+   * Sets defaults.
+   *
+   * @param defaults
+   */
+  setDefaults(defaults: ConfigDefaults, fromDefaultConfigSetter = false): Promise<null> {
+    const apiCalled = fromDefaultConfigSetter ? 'defaultConfig' : 'setDefaults';
+    if (!isObject(defaults)) {
+      throw new Error(`firebase.remoteConfig().${apiCalled}(): 'defaults' must be an object.`);
+    }
+
+    return this._enqueueNativeMutation(() =>
+      this._promiseWithConstants(this.native.setDefaults(defaults)),
+    );
+  }
+
+  /**
+   * Sets defaults based on resource.
+   * @param resourceName
+   */
+  setDefaultsFromResource(resourceName: string): Promise<null> {
+    if (!isString(resourceName)) {
+      throw new Error(
+        "firebase.remoteConfig().setDefaultsFromResource(): 'resourceName' must be a string value.",
+      );
+    }
+
+    return this._enqueueNativeMutation(() =>
+      this._promiseWithConstants(this.native.setDefaultsFromResource(resourceName)),
+    );
+  }
+
+  /**
+   * Registers an observer to changes in the configuration.
+   *
+   * @param observer - The observer to be notified of config updates.
+   * @returns An unsubscribe function to remove the listener.
+   */
+  onConfigUpdate(observer: ConfigUpdateObserver): () => void {
+    if (!isObject(observer) || !isFunction(observer.next) || !isFunction(observer.error)) {
+      throw new Error("'observer' expected an object with 'next' and 'error' functions.");
+    }
+
+    // We maintaine our pre-web-support native interface but bend it to match
+    // the official JS SDK API by assuming the callback is an Observer, and sending it a ConfigUpdate
+    // compatible parameter that implements the `getUpdatedKeys` method
+    let unsubscribed = false;
+    const subscription = this.emitter.addListener(
+      this.eventNameForApp('on_config_updated'),
+      (event: RemoteConfigUpdateSuccessEventInternal | RemoteConfigUpdateErrorEventInternal) => {
+        if (isSuccessEvent(event)) {
+          observer.next(toConfigUpdate(event.updatedKeys));
+          return;
+        }
+
+        observer.error(toNativeFirebaseError(event));
+      },
+    );
+
+    if (this._configUpdateListenerCount === 0) {
+      this.native.onConfigUpdated();
+    }
+
+    this._configUpdateListenerCount++;
+
+    return () => {
+      if (unsubscribed) {
+        // there is no harm in calling this multiple times to unsubscribe,
+        // but anything after the first call is a no-op
+        return;
+      }
+
+      unsubscribed = true;
+      subscription.remove();
+      this._configUpdateListenerCount--;
+
+      if (this._configUpdateListenerCount === 0) {
+        this.native.removeConfigUpdateRegistration();
+      }
+    };
+  }
+
+  /**
+   * Registers a listener to changes in the configuration.
+   *
+   * @param listenerOrObserver - function called on config change
+   * @returns unsubscribe listener
+   * @deprecated use official firebase-js-sdk onConfigUpdate now that web supports realtime
+   */
+  onConfigUpdated(listenerOrObserver: unknown): () => void {
+    const listener = parseListenerOrObserver(
+      listenerOrObserver as FirebaseRemoteConfigTypes.CallbackOrObserver<FirebaseRemoteConfigTypes.OnConfigUpdatedListenerCallback>,
+    ) as (event?: { updatedKeys: string[] }, error?: RemoteConfigUpdateErrorInternal) => void;
+    let unsubscribed = false;
+    const subscription = this.emitter.addListener(
+      this.eventNameForApp('on_config_updated'),
+      (event: RemoteConfigUpdateSuccessEventInternal | RemoteConfigUpdateErrorEventInternal) => {
+        if (isSuccessEvent(event)) {
+          listener({ updatedKeys: event.updatedKeys }, undefined);
+          return;
+        }
+
+        listener(undefined, {
+          code: event.code,
+          message: event.message,
+          nativeErrorMessage: event.nativeErrorMessage,
+        });
+      },
+    );
+
+    if (this._configUpdateListenerCount === 0) {
+      this.native.onConfigUpdated();
+    }
+
+    this._configUpdateListenerCount++;
+
+    return () => {
+      if (unsubscribed) {
+        // there is no harm in calling this multiple times to unsubscribe,
+        // but anything after the first call is a no-op
+        return;
+      }
+
+      unsubscribed = true;
+      subscription.remove();
+      this._configUpdateListenerCount--;
+
+      if (this._configUpdateListenerCount === 0) {
+        this.native.removeConfigUpdateRegistration();
+      }
+    };
+  }
+
+  private _updateFromConstants(constants: NativeRemoteConfigConstants): void {
+    // Wrapped this as we update using sync getters initially for `defaultConfig` & `settings`
+    if (constants.lastFetchTime !== undefined) {
+      this._lastFetchTime = constants.lastFetchTime;
+    }
+
+    // Wrapped this as we update using sync getters initially for `defaultConfig` & `settings`
+    if (constants.lastFetchStatus !== undefined) {
+      this._lastFetchStatus = constants.lastFetchStatus;
+    }
+
+    if (constants.fetchTimeout !== undefined && constants.minimumFetchInterval !== undefined) {
+      this._settings = {
+        fetchTimeoutMillis: constants.fetchTimeout * 1000,
+        minimumFetchIntervalMillis: constants.minimumFetchInterval * 1000,
+      };
+    }
+
+    if (constants.values !== undefined) {
+      this._values = Object.freeze(constants.values);
+    }
+  }
+
+  private _promiseWithConstants<T>(promise: Promise<NativeRemoteConfigResult<T>>): Promise<T> {
+    return promise.then(({ result, constants }) => {
+      this._updateFromConstants(constants);
+      return result;
+    });
+  }
+
+  private _enqueueNativeMutation<T>(task: () => Promise<T>): Promise<T> {
+    // Some callers (like property setters) discard the returned promise; serialize all mutations
+    // so later writes like reset() cannot be overwritten by an earlier async completion.
+    const next = this._nativeMutationQueue.then(task, task);
+    this._nativeMutationQueue = next.then(
+      () => undefined,
+      () => undefined,
+    );
+    return next;
+  }
+}
+
+// import { SDK_VERSION } from '@react-native-firebase/remote-config';
+export const SDK_VERSION = version;
+
+const remoteConfigNamespace = createModuleNamespace({
+  statics,
+  version,
+  namespace,
+  nativeModuleName,
+  nativeEvents: ['on_config_updated'],
+  hasMultiAppSupport: true,
+  hasCustomUrlOrRegionSupport: false,
+  ModuleClass: FirebaseConfigModule,
+});
+
+type RemoteConfigNamespace = ReactNativeFirebase.FirebaseModuleWithStaticsAndApp<
+  FirebaseRemoteConfigTypes.Module,
+  FirebaseRemoteConfigTypes.Statics
+> & {
+  firebase: ReactNativeFirebase.Module;
+  app(name?: string): ReactNativeFirebase.FirebaseApp;
+};
+
+// import remoteConfig from '@react-native-firebase/remote-config';
+// remoteConfig().X(...);
+export default remoteConfigNamespace as unknown as RemoteConfigNamespace;
+
+// import remoteConfig, { firebase } from '@react-native-firebase/remote-config';
+// remoteConfig().X(...);
+// firebase.remoteConfig().X(...);
+export const firebase =
+  getFirebaseRoot() as unknown as ReactNativeFirebase.FirebaseNamespacedExport<
+    'remoteConfig',
+    FirebaseRemoteConfigTypes.Module,
+    FirebaseRemoteConfigTypes.Statics,
+    false
+  >;
+
+// Register the interop module for non-native platforms.
+setReactNativeModule(nativeModuleName, fallBackModule as unknown as Record<string, unknown>);

package/lib/polyfills.ts

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file 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 { polyfillGlobal } = require('react-native/Libraries/Utilities/PolyfillFunctions') as {
+  polyfillGlobal: <T>(name: string, getValue: () => T) => void;
+};
+const { fetch, Headers, Request, Response } = require('react-native-fetch-api') as {
+  fetch: typeof globalThis.fetch;
+  Headers: typeof globalThis.Headers;
+  Request: typeof globalThis.Request;
+  Response: typeof globalThis.Response;
+};
+const { ReadableStream } = require('web-streams-polyfill/dist/ponyfill') as {
+  ReadableStream: typeof globalThis.ReadableStream;
+};
+
+type PolyfilledFetch = typeof fetch;
+type PolyfilledFetchArgs = Parameters<PolyfilledFetch>;
+type StreamingFetchInit = NonNullable<PolyfilledFetchArgs[1]> & {
+  reactNative?: {
+    textStreaming?: boolean;
+  };
+};
+
+const fetchWithTextStreaming: PolyfilledFetch = (...args) => {
+  const [input, init] = args;
+  const nextInit: StreamingFetchInit = {
+    ...(init as StreamingFetchInit | undefined),
+    reactNative: { textStreaming: true },
+  };
+
+  return fetch(input, nextInit);
+};
+
+polyfillGlobal('fetch', (): PolyfilledFetch => fetchWithTextStreaming);
+polyfillGlobal('Headers', () => Headers);
+polyfillGlobal('Request', () => Request);
+polyfillGlobal('Response', () => Response);
+polyfillGlobal('ReadableStream', () => ReadableStream);
+
+import 'text-encoding';

package/lib/statics.ts

@@ -0,0 +1,27 @@
+import type { ValueSource as ValueSourceType } from './types/remote-config';
+
+interface LastFetchStatusStatics {
+  SUCCESS: 'success';
+  FAILURE: 'failure';
+  THROTTLED: 'throttled';
+  NO_FETCH_YET: 'no_fetch_yet';
+}
+
+interface ValueSourceStatics {
+  REMOTE: ValueSourceType;
+  DEFAULT: ValueSourceType;
+  STATIC: ValueSourceType;
+}
+
+export const LastFetchStatus = {
+  SUCCESS: 'success',
+  FAILURE: 'failure',
+  THROTTLED: 'throttled',
+  NO_FETCH_YET: 'no_fetch_yet',
+} as const satisfies LastFetchStatusStatics;
+
+export const ValueSource = {
+  REMOTE: 'remote',
+  DEFAULT: 'default',
+  STATIC: 'static',
+} as const satisfies ValueSourceStatics;