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

package/lib/types/internal.ts

@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * 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.
+ *
+ */
+
+import type {
+  ConfigUpdateObserver,
+  FetchStatus,
+  RemoteConfig,
+  RemoteConfigSettings,
+  Unsubscribe,
+  Value,
+  ValueSource,
+} from './remote-config';
+import type { FirebaseRemoteConfigTypes } from './namespaced';
+
+export type ConfigValueSourceInternal = ValueSource;
+
+export type LastFetchStatusInternal = FetchStatus;
+
+export type RemoteConfigModularDeprecationArg = string;
+
+export type WithRemoteConfigDeprecationArg<F> = F extends (...args: infer P) => infer R
+  ? (...args: [...P, RemoteConfigModularDeprecationArg?]) => R
+  : never;
+
+export interface AppWithRemoteConfigInternal {
+  remoteConfig(deprecationArg?: RemoteConfigModularDeprecationArg): RemoteConfig;
+}
+
+export interface ConfigSettingsStateInternal {
+  fetchTimeoutMillis: number;
+  minimumFetchIntervalMillis: number;
+}
+
+export interface StoredConfigValueInternal {
+  value: string | number | boolean;
+  source: ConfigValueSourceInternal;
+}
+
+export interface NativeRemoteConfigConstants {
+  fetchTimeout?: number;
+  minimumFetchInterval?: number;
+  lastFetchTime?: number;
+  lastFetchStatus?: LastFetchStatusInternal;
+  values?: Record<string, StoredConfigValueInternal>;
+}
+
+export interface NativeRemoteConfigResult<T> {
+  result: T;
+  constants: NativeRemoteConfigConstants;
+}
+
+export interface RemoteConfigUpdateErrorInternal {
+  code?: string;
+  message?: string;
+  nativeErrorMessage?: string;
+}
+
+export interface RemoteConfigUpdateSuccessEventInternal {
+  resultType: 'success';
+  updatedKeys: string[];
+}
+
+export interface RemoteConfigUpdateErrorEventInternal extends RemoteConfigUpdateErrorInternal {
+  resultType?: string;
+}
+
+export interface RNFBConfigModule {
+  activate(): Promise<NativeRemoteConfigResult<boolean>>;
+  setConfigSettings(settings: {
+    fetchTimeout: number;
+    minimumFetchInterval: number;
+  }): Promise<NativeRemoteConfigResult<void>>;
+  fetch(expirationDurationSeconds: number): Promise<NativeRemoteConfigResult<void>>;
+  fetchAndActivate(): Promise<NativeRemoteConfigResult<boolean>>;
+  ensureInitialized(): Promise<NativeRemoteConfigResult<void>>;
+  setDefaults(
+    defaults: Record<string, string | number | boolean>,
+  ): Promise<NativeRemoteConfigResult<null>>;
+  setDefaultsFromResource(resourceName: string): Promise<NativeRemoteConfigResult<null>>;
+  reset(): Promise<NativeRemoteConfigResult<void>>;
+  onConfigUpdated(): void;
+  removeConfigUpdateRegistration(): void;
+  setCustomSignals(
+    customSignals: Record<string, string | number | null>,
+  ): Promise<NativeRemoteConfigResult<void>>;
+}
+
+export interface RemoteConfigInternal extends RemoteConfig {
+  settings: RemoteConfigSettings & {
+    fetchTimeMillis: number;
+  };
+  defaultConfig: {
+    [key: string]: string | number | boolean;
+  };
+  activate(deprecationArg?: RemoteConfigModularDeprecationArg): Promise<boolean>;
+  ensureInitialized(deprecationArg?: RemoteConfigModularDeprecationArg): Promise<void>;
+  fetchAndActivate(deprecationArg?: RemoteConfigModularDeprecationArg): Promise<boolean>;
+  fetch(
+    expirationDurationSeconds?: number,
+    deprecationArg?: RemoteConfigModularDeprecationArg,
+  ): Promise<void>;
+  getAll(deprecationArg?: RemoteConfigModularDeprecationArg): Record<string, Value>;
+  getBoolean(key: string, deprecationArg?: RemoteConfigModularDeprecationArg): boolean;
+  getNumber(key: string, deprecationArg?: RemoteConfigModularDeprecationArg): number;
+  getString(key: string, deprecationArg?: RemoteConfigModularDeprecationArg): string;
+  getValue(key: string, deprecationArg?: RemoteConfigModularDeprecationArg): Value;
+  reset(deprecationArg?: RemoteConfigModularDeprecationArg): Promise<void>;
+  setConfigSettings(
+    settings:
+      | RemoteConfigSettings
+      | {
+          minimumFetchIntervalMillis?: number;
+          fetchTimeMillis?: number;
+          fetchTimeoutMillis?: number;
+        },
+    deprecationArg?: RemoteConfigModularDeprecationArg,
+  ): Promise<void>;
+  setDefaults(
+    defaults: {
+      [key: string]: string | number | boolean;
+    },
+    deprecationArg?: RemoteConfigModularDeprecationArg,
+  ): Promise<null>;
+  setDefaultsFromResource(
+    resourceName: string,
+    deprecationArg?: RemoteConfigModularDeprecationArg,
+  ): Promise<null>;
+  onConfigUpdate(
+    observer: ConfigUpdateObserver,
+    deprecationArg?: RemoteConfigModularDeprecationArg,
+  ): Unsubscribe;
+  onConfigUpdated(
+    listenerOrObserver: FirebaseRemoteConfigTypes.CallbackOrObserver<FirebaseRemoteConfigTypes.OnConfigUpdatedListenerCallback>,
+    deprecationArg?: RemoteConfigModularDeprecationArg,
+  ): Unsubscribe;
+  readonly native: RNFBConfigModule;
+  _promiseWithConstants(
+    promise: Promise<NativeRemoteConfigResult<void>>,
+    deprecationArg?: RemoteConfigModularDeprecationArg,
+  ): Promise<void>;
+  _promiseWithConstants<T>(
+    promise: Promise<NativeRemoteConfigResult<T>>,
+    deprecationArg?: RemoteConfigModularDeprecationArg,
+  ): Promise<T>;
+}
+
+declare module '@react-native-firebase/app/dist/module/internal/NativeModules' {
+  interface ReactNativeFirebaseNativeModules {
+    RNFBConfigModule: RNFBConfigModule;
+  }
+}

package/lib/types/namespaced.ts

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * 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.
+ *
+ */
+
+import { ReactNativeFirebase } from '@react-native-firebase/app';
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace FirebaseRemoteConfigTypes {
+  import FirebaseModule = ReactNativeFirebase.FirebaseModule;
+
+  /**
+   * @deprecated Use modular log-level types instead.
+   */
+  export type RemoteConfigLogLevel = 'debug' | 'error' | 'silent';
+
+  /**
+   * @deprecated Use modular constants instead.
+   */
+  export interface LastFetchStatus {
+    SUCCESS: 'success';
+    FAILURE: 'failure';
+    THROTTLED: 'throttled';
+    NO_FETCH_YET: 'no_fetch_yet';
+  }
+
+  /**
+   * @deprecated Use modular constants instead.
+   */
+  export interface ValueSource {
+    REMOTE: 'remote';
+    DEFAULT: 'default';
+    STATIC: 'static';
+  }
+
+  /**
+   * @deprecated Namespaced statics remain for backwards compatibility.
+   */
+  export interface Statics {
+    ValueSource: ValueSource;
+    LastFetchStatus: LastFetchStatus;
+    SDK_VERSION: string;
+  }
+
+  /**
+   * @deprecated Use modular `Value` access patterns instead.
+   */
+  export interface ConfigValue {
+    getSource(): 'remote' | 'default' | 'static';
+    asBoolean(): true | false;
+    asNumber(): number;
+    asString(): string;
+  }
+
+  /**
+   * @deprecated Use modular APIs instead.
+   */
+  export interface ConfigValues {
+    [key: string]: ConfigValue;
+  }
+
+  /**
+   * @deprecated Use modular APIs instead.
+   */
+  export interface ConfigSettings {
+    minimumFetchIntervalMillis?: number;
+    fetchTimeMillis?: number;
+  }
+
+  /**
+   * @deprecated Use modular APIs instead.
+   */
+  export interface ConfigDefaults {
+    [key: string]: number | string | boolean;
+  }
+
+  export type LastFetchStatusType = 'success' | 'failure' | 'no_fetch_yet' | 'throttled';
+
+  export interface ConfigUpdate {
+    getUpdatedKeys(): Set<string>;
+  }
+
+  export interface ConfigUpdateObserver {
+    next: (configUpdate: ConfigUpdate) => void;
+    error: (error: ReactNativeFirebase.NativeFirebaseError) => void;
+    complete: () => void;
+  }
+
+  export type Unsubscribe = () => void;
+
+  /**
+   * @deprecated Use the package default export or modular APIs instead.
+   */
+  export declare class Module extends FirebaseModule {
+    app: ReactNativeFirebase.FirebaseApp;
+    fetchTimeMillis: number;
+    lastFetchStatus: LastFetchStatusType;
+    settings: ConfigSettings;
+    defaultConfig: ConfigDefaults;
+    setConfigSettings(configSettings: ConfigSettings): Promise<void>;
+    setDefaults(defaults: ConfigDefaults): Promise<null>;
+    setDefaultsFromResource(resourceName: string): Promise<null>;
+    onConfigUpdate(observer: ConfigUpdateObserver): Unsubscribe;
+    onConfigUpdated(listener: CallbackOrObserver<OnConfigUpdatedListenerCallback>): () => void;
+    activate(): Promise<boolean>;
+    ensureInitialized(): Promise<void>;
+    fetch(expirationDurationSeconds?: number): Promise<void>;
+    fetchAndActivate(): Promise<boolean>;
+    getAll(): ConfigValues;
+    getValue(key: string): ConfigValue;
+    getBoolean(key: string): boolean;
+    getString(key: string): string;
+    getNumber(key: string): number;
+    reset(): Promise<void>;
+  }
+
+  export type CallbackOrObserver<T extends (...args: any[]) => any> = T | { next: T };
+
+  export type OnConfigUpdatedListenerCallback = (
+    event?: { updatedKeys: string[] },
+    error?: {
+      code: string;
+      message: string;
+      nativeErrorMessage: string;
+    },
+  ) => void;
+}
+
+declare module '@react-native-firebase/app' {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace ReactNativeFirebase {
+    import FirebaseModuleWithStatics = ReactNativeFirebase.FirebaseModuleWithStatics;
+
+    interface Module {
+      /**
+       * @deprecated Use the package default export or modular APIs instead.
+       */
+      remoteConfig: FirebaseModuleWithStatics<
+        FirebaseRemoteConfigTypes.Module,
+        FirebaseRemoteConfigTypes.Statics
+      >;
+    }
+
+    interface FirebaseApp {
+      /**
+       * @deprecated Use the package default export or modular APIs instead.
+       */
+      remoteConfig(): FirebaseRemoteConfigTypes.Module;
+    }
+  }
+}

package/lib/types/remote-config.ts

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * 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.
+ *
+ */
+
+import type { FirebaseApp } from '@firebase/app';
+import type { ReactNativeFirebase } from '@react-native-firebase/app';
+
+export type LogLevel = 'debug' | 'error' | 'silent';
+
+export type FetchStatus = 'success' | 'failure' | 'no_fetch_yet' | 'throttled';
+
+export type ValueSource = 'static' | 'default' | 'remote';
+
+export interface Value {
+  getSource(): ValueSource;
+  asBoolean(): boolean;
+  asNumber(): number;
+  asString(): string;
+}
+
+export interface RemoteConfigSettings {
+  minimumFetchIntervalMillis: number;
+  fetchTimeoutMillis: number;
+}
+
+export interface ConfigUpdate {
+  getUpdatedKeys(): Set<string>;
+}
+
+export interface ConfigUpdateObserver {
+  next: (configUpdate: ConfigUpdate) => void;
+  error: (error: ReactNativeFirebase.NativeFirebaseError) => void;
+  complete: () => void;
+}
+
+export type Unsubscribe = () => void;
+
+export interface CustomSignals {
+  [key: string]: string | number | null;
+}
+
+export interface RemoteConfig {
+  app: FirebaseApp;
+  fetchTimeMillis: number;
+  lastFetchStatus: FetchStatus;
+  settings: RemoteConfigSettings;
+  defaultConfig: {
+    [key: string]: string | number | boolean;
+  };
+}

package/lib/version.ts

@@ -0,0 +1,2 @@
+// Generated by genversion.
+export const version = '25.0.0';

package/lib/web/RNFBConfigModule.android.ts

@@ -0,0 +1,4 @@
+// No-op for android.
+const noopNativeModule: Record<string, never> = {};
+
+export default noopNativeModule;

package/lib/web/RNFBConfigModule.ios.ts

@@ -0,0 +1,4 @@
+// No-op for ios.
+const noopNativeModule: Record<string, never> = {};
+
+export default noopNativeModule;

package/lib/web/RNFBConfigModule.ts

@@ -0,0 +1,254 @@
+import '../polyfills';
+import {
+  activate,
+  ensureInitialized,
+  fetchAndActivate,
+  fetchConfig,
+  getAll,
+  getApp,
+  getRemoteConfig,
+  makeIDBAvailable,
+  onConfigUpdate,
+  setCustomSignals,
+} from '@react-native-firebase/app/dist/module/internal/web/firebaseRemoteConfig';
+import {
+  emitEvent,
+  getWebError,
+  guard,
+} from '@react-native-firebase/app/dist/module/internal/web/utils';
+import type { CustomSignals, RemoteConfig } from '../types/remote-config';
+import type {
+  NativeRemoteConfigConstants,
+  NativeRemoteConfigResult,
+  RNFBConfigModule,
+} from '../types/internal';
+
+interface WebRemoteConfigSettings {
+  minimumFetchIntervalMillis: number;
+  fetchTimeoutMillis: number;
+}
+
+type WebRemoteConfigSettingsOverrides = Partial<WebRemoteConfigSettings>;
+type WebRemoteConfig = ReturnType<typeof getRemoteConfig>;
+type RemoteConfigWithWebSettings = WebRemoteConfig &
+  RemoteConfig & {
+    settings: WebRemoteConfig['settings'] & WebRemoteConfigSettings;
+  };
+
+type ConfigSettingsForInstance = Partial<Record<string, WebRemoteConfigSettings>>;
+type DefaultConfigForInstance = Partial<Record<string, Record<string, string | number | boolean>>>;
+type ConfigUpdateListeners = Partial<Record<string, ReturnType<typeof onConfigUpdate>>>;
+
+type WithAppName<F> = F extends (...args: infer P) => infer R
+  ? (appName: string, ...args: P) => R
+  : never;
+
+interface RNFBConfigModuleWeb {
+  activate: WithAppName<RNFBConfigModule['activate']>;
+  setConfigSettings: WithAppName<RNFBConfigModule['setConfigSettings']>;
+  fetch: WithAppName<RNFBConfigModule['fetch']>;
+  fetchAndActivate: WithAppName<RNFBConfigModule['fetchAndActivate']>;
+  ensureInitialized: WithAppName<RNFBConfigModule['ensureInitialized']>;
+  setDefaults: WithAppName<RNFBConfigModule['setDefaults']>;
+  setCustomSignals: WithAppName<RNFBConfigModule['setCustomSignals']>;
+  onConfigUpdated: WithAppName<RNFBConfigModule['onConfigUpdated']>;
+  removeConfigUpdateRegistration: WithAppName<RNFBConfigModule['removeConfigUpdateRegistration']>;
+}
+
+const DEFAULT_CONFIG_SETTINGS: WebRemoteConfigSettings = {
+  minimumFetchIntervalMillis: 43200000,
+  fetchTimeoutMillis: 60000,
+};
+
+const configSettingsForInstance: ConfigSettingsForInstance = {};
+const defaultConfigForInstance: DefaultConfigForInstance = {};
+const onConfigUpdateListeners: ConfigUpdateListeners = {};
+
+function makeGlobalsAvailable(): void {
+  (navigator as Navigator & { onLine: boolean }).onLine = true;
+  makeIDBAvailable();
+}
+
+function getRemoteConfigInstanceForApp(
+  appName: string,
+  overrides: WebRemoteConfigSettingsOverrides = {},
+): RemoteConfigWithWebSettings {
+  makeGlobalsAvailable();
+
+  const configSettings: WebRemoteConfigSettings = {
+    ...(configSettingsForInstance[appName] ?? DEFAULT_CONFIG_SETTINGS),
+    ...overrides,
+  };
+  const defaultConfig = defaultConfigForInstance[appName] ?? {};
+
+  const app = getApp(appName);
+  const instance = getRemoteConfig(app) as unknown as RemoteConfigWithWebSettings;
+
+  Object.assign(instance.settings, configSettings);
+  instance.defaultConfig = defaultConfig;
+
+  return instance;
+}
+
+function toLastFetchStatus(
+  status: string,
+): NonNullable<NativeRemoteConfigConstants['lastFetchStatus']> {
+  switch (status) {
+    case 'success':
+    case 'failure':
+    case 'no_fetch_yet':
+    case 'throttled':
+      return status;
+    case 'no-fetch-yet':
+      return 'no_fetch_yet';
+    case 'throttle':
+      return 'throttled';
+    default:
+      return 'no_fetch_yet';
+  }
+}
+
+function resultAndConstants<T>(
+  instance: RemoteConfigWithWebSettings,
+  result: T,
+): NativeRemoteConfigResult<T> {
+  const valuesRaw = getAll(instance);
+  const values: NonNullable<NativeRemoteConfigConstants['values']> = {};
+
+  for (const key in valuesRaw) {
+    const raw = valuesRaw[key];
+
+    if (raw) {
+      values[key] = {
+        source: raw.getSource(),
+        value: raw.asString(),
+      };
+    }
+  }
+
+  return {
+    result,
+    constants: {
+      values,
+      lastFetchTime: instance.fetchTimeMillis === -1 ? 0 : instance.fetchTimeMillis,
+      lastFetchStatus: toLastFetchStatus(instance.lastFetchStatus),
+      minimumFetchInterval: instance.settings.minimumFetchIntervalMillis
+        ? instance.settings.minimumFetchIntervalMillis / 1000
+        : 43200,
+      fetchTimeout: instance.settings.fetchTimeoutMillis
+        ? instance.settings.fetchTimeoutMillis / 1000
+        : 60,
+    },
+  };
+}
+
+const remoteConfigWebModule: RNFBConfigModuleWeb = {
+  activate(appName) {
+    return guard(async () => {
+      const remoteConfig = getRemoteConfigInstanceForApp(appName);
+      return resultAndConstants(remoteConfig, await activate(remoteConfig));
+    });
+  },
+
+  setConfigSettings(appName, settings) {
+    return guard(async () => {
+      const webSettings: WebRemoteConfigSettings = {
+        minimumFetchIntervalMillis: settings.minimumFetchInterval * 1000,
+        fetchTimeoutMillis: settings.fetchTimeout * 1000,
+      };
+
+      configSettingsForInstance[appName] = webSettings;
+
+      const remoteConfig = getRemoteConfigInstanceForApp(appName, webSettings);
+      return resultAndConstants(remoteConfig, undefined);
+    });
+  },
+
+  fetch(appName, expirationDurationSeconds) {
+    return guard(async () => {
+      const overrides: WebRemoteConfigSettingsOverrides = {};
+
+      if (expirationDurationSeconds !== -1) {
+        overrides.minimumFetchIntervalMillis = expirationDurationSeconds * 1000;
+      }
+
+      const remoteConfig = getRemoteConfigInstanceForApp(appName, overrides);
+      await fetchConfig(remoteConfig);
+
+      return resultAndConstants(remoteConfig, undefined);
+    });
+  },
+
+  fetchAndActivate(appName) {
+    return guard(async () => {
+      const remoteConfig = getRemoteConfigInstanceForApp(appName);
+      return resultAndConstants(remoteConfig, await fetchAndActivate(remoteConfig));
+    });
+  },
+
+  ensureInitialized(appName) {
+    return guard(async () => {
+      const remoteConfig = getRemoteConfigInstanceForApp(appName);
+      await ensureInitialized(remoteConfig);
+
+      return resultAndConstants(remoteConfig, undefined);
+    });
+  },
+
+  setDefaults(appName, defaults) {
+    return guard(async () => {
+      defaultConfigForInstance[appName] = defaults;
+
+      const remoteConfig = getRemoteConfigInstanceForApp(appName);
+      return resultAndConstants(remoteConfig, null);
+    });
+  },
+
+  setCustomSignals(appName, customSignals: CustomSignals) {
+    return guard(async () => {
+      const remoteConfig = getRemoteConfigInstanceForApp(appName);
+      await setCustomSignals(remoteConfig, customSignals);
+
+      return resultAndConstants(remoteConfig, undefined);
+    });
+  },
+
+  onConfigUpdated(appName) {
+    if (onConfigUpdateListeners[appName]) {
+      return;
+    }
+
+    const remoteConfig = getRemoteConfigInstanceForApp(appName);
+    const nativeObserver: Parameters<typeof onConfigUpdate>[1] = {
+      next(configUpdate) {
+        emitEvent('on_config_updated', {
+          appName,
+          resultType: 'success',
+          updatedKeys: Array.from(configUpdate.getUpdatedKeys()),
+        });
+      },
+      error(firebaseError) {
+        emitEvent('on_config_updated', {
+          appName,
+          event: getWebError(firebaseError),
+        });
+      },
+      complete() {},
+    };
+
+    onConfigUpdateListeners[appName] = onConfigUpdate(remoteConfig, nativeObserver);
+  },
+
+  removeConfigUpdateRegistration(appName) {
+    const unsubscribe = onConfigUpdateListeners[appName];
+
+    if (!unsubscribe) {
+      return;
+    }
+
+    unsubscribe();
+    delete onConfigUpdateListeners[appName];
+  },
+};
+
+export default remoteConfigWebModule;