@react-native-firebase/remote-config 16.7.0 → 17.1.0

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [17.1.0](https://github.com/invertase/react-native-firebase/compare/v17.0.0...v17.1.0) (2023-02-09)
+
+### Features
+
+- **remote-config:** Expose modular API that matches the Firebase web JS SDK v9 API ([#6868](https://github.com/invertase/react-native-firebase/issues/6868)) ([e1504aa](https://github.com/invertase/react-native-firebase/commit/e1504aabd6ffba5c7d4b85c46ed44e12e0b9f916))
+
+### Bug Fixes
+
+- **remote-config:** incorrect if condition & doc update ([#6892](https://github.com/invertase/react-native-firebase/issues/6892)) ([1a1488c](https://github.com/invertase/react-native-firebase/commit/1a1488ced6aac8e6886cfd73033757a97e6e1abd))
+
+## [17.0.0](https://github.com/invertase/react-native-firebase/compare/v16.7.0...v17.0.0) (2023-02-02)
+
+**Note:** Version bump only for package @react-native-firebase/remote-config
+
 ## [16.7.0](https://github.com/invertase/react-native-firebase/compare/v16.6.0...v16.7.0) (2023-01-28)
 
 **Note:** Version bump only for package @react-native-firebase/remote-config

package/lib/index.d.ts

@@ -55,7 +55,10 @@ import { ReactNativeFirebase } from '@react-native-firebase/app';
  */
 export namespace FirebaseRemoteConfigTypes {
   import FirebaseModule = ReactNativeFirebase.FirebaseModule;
-
+  /**
+   * Defines levels of Remote Config logging. Web only.
+   */
+  export declare type RemoteConfigLogLevel = 'debug' | 'error' | 'silent';
   /**
    * A pseudo-enum for usage with ConfigSettingsRead.lastFetchStatus to determine the last fetch status.
    *
@@ -283,6 +286,11 @@ export namespace FirebaseRemoteConfigTypes {
     [key: string]: number | string | boolean;
   }
 
+  /**
+   * The status of the latest Remote RemoteConfig fetch action.
+   */
+  type LastFetchStatusType = 'success' | 'failure' | 'no_fetch_yet' | 'throttled';
+
   /**
    * The Firebase Remote RemoteConfig service interface.
    *
@@ -306,7 +314,7 @@ export namespace FirebaseRemoteConfigTypes {
      *
      * See the `LastFetchStatus` statics definition.
      */
-    lastFetchStatus: 'success' | 'failure' | 'no_fetch_yet' | 'throttled';
+    lastFetchStatus: LastFetchStatusType;
 
     /**
      * Provides an object which provides the properties `minimumFetchIntervalMillis` & `fetchTimeMillis` if they have been set
@@ -314,7 +322,12 @@ export namespace FirebaseRemoteConfigTypes {
      * can be found above
      *
      */
-    settings: { fetchTimeMillis: number; minimumFetchIntervalMillis: number };
+    settings: ConfigSettings;
+
+    /**
+     * Provides an object with the type ConfigDefaults for default configuration values
+     */
+    defaultConfig: ConfigDefaults;
 
     /**
      * Set the Remote RemoteConfig settings, currently able to set `fetchTimeMillis` & `minimumFetchIntervalMillis`

package/lib/index.js

@@ -30,6 +30,30 @@ import {
   getFirebaseRoot,
 } from '@react-native-firebase/app/lib/internal';
 import version from './version';
+import { Platform } from 'react-native';
+
+export {
+  getRemoteConfig,
+  activate,
+  ensureInitialized,
+  fetchAndActivate,
+  fetchConfig,
+  getAll,
+  getBoolean,
+  getNumber,
+  getString,
+  getValue,
+  setLogLevel,
+  isSupported,
+  fetchTimeMillis,
+  settings,
+  lastFetchStatus,
+  reset,
+  setConfigSettings,
+  fetch,
+  setDefaults,
+  setDefaultsFromResource,
+} from './modular/index';
 
 const statics = {
   LastFetchStatus: {
@@ -59,6 +83,41 @@ class FirebaseConfigModule extends FirebaseModule {
     };
     this._lastFetchTime = -1;
     this._values = {};
+    this._isWeb = Platform.OS !== 'ios' && Platform.OS !== 'android';
+  }
+
+  get defaultConfig() {
+    const updatedDefaultConfig = {};
+    Object.keys(this._values).forEach(key => {
+      // Need to make it an object with key and literal value. Not `Value` instance.
+      updatedDefaultConfig[key] = this._values[key].value;
+    });
+
+    return updatedDefaultConfig;
+  }
+
+  set defaultConfig(defaults) {
+    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.
+    this._updateFromConstants(defaults);
+    this.setDefaults.call(this, defaults, true);
+  }
+
+  get settings() {
+    return this._settings;
+  }
+
+  set settings(settings) {
+    // 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._updateFromConstants(settings);
+    this.setConfigSettings.call(this, settings, true);
   }
 
   getValue(key) {
@@ -94,10 +153,6 @@ class FirebaseConfigModule extends FirebaseModule {
     return values;
   }
 
-  get settings() {
-    return this._settings;
-  }
-
   get fetchTimeMillis() {
     // android returns -1 if no fetch yet and iOS returns 0
     return this._lastFetchTime;
@@ -120,38 +175,49 @@ class FirebaseConfigModule extends FirebaseModule {
   }
 
   setConfigSettings(settings) {
-    const nativeSettings = {
-      //iOS & Android expect seconds
-      fetchTimeout: this._settings.fetchTimeMillis / 1000,
-      minimumFetchInterval: this._settings.minimumFetchIntervalMillis / 1000,
-    };
-
+    const updatedSettings = {};
+    if (this._isWeb) {
+      updatedSettings.fetchTimeMillis = this._settings.fetchTimeMillis;
+      updatedSettings.minimumFetchIntervalMillis = this._settings.minimumFetchIntervalMillis;
+    } else {
+      //iOS & Android expect seconds & different property names
+      updatedSettings.fetchTimeout = this._settings.fetchTimeMillis / 1000;
+      updatedSettings.minimumFetchInterval = this._settings.minimumFetchIntervalMillis / 1000;
+    }
+    const apiCalled = arguments[1] == true ? 'settings' : 'setConfigSettings';
     if (!isObject(settings)) {
-      throw new Error('firebase.remoteConfig().setConfigSettings(*): settings must set an object.');
+      throw new Error(`firebase.remoteConfig().${apiCalled}(*): settings must set an object.`);
     }
 
     if (hasOwnProperty(settings, 'minimumFetchIntervalMillis')) {
       if (!isNumber(settings.minimumFetchIntervalMillis)) {
         throw new Error(
-          "firebase.remoteConfig().setConfigSettings(): 'settings.minimumFetchIntervalMillis' must be a number type in milliseconds.",
+          `firebase.remoteConfig().${apiCalled}(): 'settings.minimumFetchIntervalMillis' must be a number type in milliseconds.`,
         );
       } else {
-        nativeSettings.minimumFetchInterval = settings.minimumFetchIntervalMillis / 1000;
+        if (this._isWeb) {
+          updatedSettings.minimumFetchIntervalMillis = settings.minimumFetchIntervalMillis;
+        } else {
+          updatedSettings.minimumFetchInterval = settings.minimumFetchIntervalMillis / 1000;
+        }
       }
     }
 
     if (hasOwnProperty(settings, 'fetchTimeMillis')) {
       if (!isNumber(settings.fetchTimeMillis)) {
         throw new Error(
-          "firebase.remoteConfig().setConfigSettings(): 'settings.fetchTimeMillis' must be a number type in milliseconds.",
+          `firebase.remoteConfig().${apiCalled}(): 'settings.fetchTimeMillis' must be a number type in milliseconds.`,
         );
       } else {
-        nativeSettings.fetchTimeout = settings.fetchTimeMillis / 1000;
+        if (this._isWeb) {
+          updatedSettings.fetchTimeMillis = settings.fetchTimeMillis;
+        } else {
+          updatedSettings.fetchTimeout = settings.fetchTimeMillis / 1000;
+        }
       }
     }
 
-    // this._settings = settings;
-    return this._promiseWithConstants(this.native.setConfigSettings(nativeSettings));
+    return this._promiseWithConstants(this.native.setConfigSettings(updatedSettings));
   }
 
   /**
@@ -194,8 +260,9 @@ class FirebaseConfigModule extends FirebaseModule {
    * @param {object} defaults
    */
   setDefaults(defaults) {
+    const apiCalled = arguments[1] === true ? 'defaultConfig' : 'setDefaults';
     if (!isObject(defaults)) {
-      throw new Error("firebase.remoteConfig().setDefaults(): 'defaults' must be an object.");
+      throw new Error(`firebase.remoteConfig().${apiCalled}(): 'defaults' must be an object.`);
     }
 
     return this._promiseWithConstants(this.native.setDefaults(defaults));
@@ -216,13 +283,27 @@ class FirebaseConfigModule extends FirebaseModule {
   }
 
   _updateFromConstants(constants) {
-    this._lastFetchTime = constants.lastFetchTime;
-    this._lastFetchStatus = constants.lastFetchStatus;
+    // Wrapped this as we update using sync getters initially for `defaultConfig` & `settings`
+    if (constants.lastFetchTime) {
+      this._lastFetchTime = constants.lastFetchTime;
+    }
 
-    this._settings = {
-      fetchTimeMillis: constants.fetchTimeout * 1000,
-      minimumFetchIntervalMillis: constants.minimumFetchInterval * 1000,
-    };
+    // Wrapped this as we update using sync getters initially for `defaultConfig` & `settings`
+    if (constants.lastFetchStatus) {
+      this._lastFetchStatus = constants.lastFetchStatus;
+    }
+
+    if (this._isWeb) {
+      this._settings = {
+        fetchTimeMillis: constants.fetchTimeMillis,
+        minimumFetchIntervalMillis: constants.minimumFetchIntervalMillis,
+      };
+    } else {
+      this._settings = {
+        fetchTimeMillis: constants.fetchTimeout * 1000,
+        minimumFetchIntervalMillis: constants.minimumFetchInterval * 1000,
+      };
+    }
 
     this._values = Object.freeze(constants.values);
   }

package/lib/modular/index.js

@@ -0,0 +1,223 @@
+/*
+ * 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 { firebase } from '..';
+
+/**
+ * Returns a RemoteConfig instance for the given app.
+ * @param app - FirebaseApp. Optional.
+ * @returns {RemoteConfig}
+ */
+export function getRemoteConfig(app) {
+  if (app) {
+    return firebase.app(app.name).remoteConfig();
+  }
+
+  return firebase.app().remoteConfig();
+}
+
+/**
+ * Returns a Boolean which resolves to true if the current call
+ * activated the fetched configs.
+ * @param remoteConfig - RemoteConfig instance
+ * @returns {Promise<boolean>}
+ */
+export function activate(remoteConfig) {
+  return remoteConfig.activate();
+}
+
+/**
+ * Ensures the last activated config are available to the getters.
+ * @param remoteConfig - RemoteConfig instance
+ * @returns {Promise<void>}
+ */
+export function ensureInitialized(remoteConfig) {
+  return remoteConfig.ensureInitialized();
+}
+
+/**
+ * Performs a fetch and returns a Boolean which resolves to true
+ * if the current call activated the fetched configs.
+ * @param remoteConfig - RemoteConfig instance
+ * @returns {Promise<boolean>}
+ */
+export function fetchAndActivate(remoteConfig) {
+  return remoteConfig.fetchAndActivate();
+}
+
+/**
+ * Fetches and caches configuration from the Remote Config service.
+ * @param remoteConfig - RemoteConfig instance
+ * @returns {Promise<void>}
+ */
+export function fetchConfig(remoteConfig) {
+  return remoteConfig.fetchConfig();
+}
+
+/**
+ * Gets all config.
+ * @param remoteConfig - RemoteConfig instance
+ * @returns {Promise<ConfigValues>}
+ */
+export function getAll(remoteConfig) {
+  return remoteConfig.getAll();
+}
+
+/**
+ * Gets the value for the given key as a boolean.
+ * @param remoteConfig - RemoteConfig instance
+ * @param key - key for boolean value
+ * @returns {boolean}
+ */
+export function getBoolean(remoteConfig, key) {
+  return remoteConfig.getBoolean(key);
+}
+
+/**
+ * Gets the value for the given key as a number.
+ * @param remoteConfig - RemoteConfig instance
+ * @param key - key for number value
+ * @returns {number}
+ */
+export function getNumber(remoteConfig, key) {
+  return remoteConfig.getNumber(key);
+}
+
+/**
+ * Gets the value for the given key as a string.
+ * @param remoteConfig - RemoteConfig instance
+ * @param key - key for string value
+ * @returns {string}
+ */
+export function getString(remoteConfig, key) {
+  return remoteConfig.getString(key);
+}
+
+/**
+ * Gets the value for the given key
+ * @param remoteConfig - RemoteConfig instance
+ * @param key - key for the given value
+ * @returns {ConfigValue}
+ */
+export function getValue(remoteConfig, key) {
+  return remoteConfig.getValue(key);
+}
+
+/**
+ * Defines the log level to use.
+ * @param remoteConfig - RemoteConfig instance
+ * @param logLevel - The log level to set
+ * @returns {RemoteConfigLogLevel}
+ */
+// eslint-disable-next-line
+export function setLogLevel(remoteConfig, logLevel) {
+  // always return the "error" log level for now as the setter is ignored on native. Web only.
+  return 'error';
+}
+
+/**
+ * Checks two different things.
+ * 1. Check if IndexedDB exists in the browser environment.
+ * 2. Check if the current browser context allows IndexedDB open() calls.
+ * @returns {Promise<boolean>}
+ */
+export function isSupported() {
+  // always return "true" for now. Web only.
+  return Promise.resolve(true);
+}
+
+/**
+ * Indicates the default value in milliseconds to abandon a pending fetch
+ * request made to the Remote Config server. Defaults to 60000 (One minute).
+ * @param remoteConfig - RemoteConfig instance
+ * @returns {number}
+ */
+export function fetchTimeMillis(remoteConfig) {
+  return remoteConfig.fetchTimeMillis;
+}
+
+/**
+ * Returns a ConfigSettings object which provides the properties `minimumFetchIntervalMillis` & `fetchTimeMillis` if they have been set
+ * using setConfigSettings({ fetchTimeMillis: number, minimumFetchIntervalMillis: number }).
+ * @param remoteConfig - RemoteConfig instance
+ * @returns {ConfigSettings}
+ */
+export function settings(remoteConfig) {
+  return remoteConfig.settings;
+}
+
+/**
+ * The status of the latest Remote RemoteConfig fetch action.
+ * @param remoteConfig - RemoteConfig instance
+ * @returns {LastFetchStatusType}
+ */
+export function lastFetchStatus(remoteConfig) {
+  return remoteConfig.lastFetchStatus;
+}
+
+/**
+ * Deletes all activated, fetched and defaults configs and
+ * resets all Firebase Remote Config settings.
+ * Android only. iOS does not reset anything.
+ * @param remoteConfig - RemoteConfig instance
+ * @returns {Promise<void>}
+ */
+export function reset(remoteConfig) {
+  return remoteConfig.reset();
+}
+
+/**
+ * Set the Remote RemoteConfig settings, currently able to set
+ * `fetchTimeMillis` & `minimumFetchIntervalMillis`
+ * Android only. iOS does not reset anything.
+ * @param remoteConfig - RemoteConfig instance
+ * @param settings - ConfigSettings instance
+ * @returns {Promise<void>}
+ */
+export function setConfigSettings(remoteConfig, settings) {
+  return remoteConfig.setConfigSettings(settings);
+}
+
+/**
+ * Fetches parameter values for your app.
+ * @param remoteConfig - RemoteConfig instance
+ * @param expirationDurationSeconds - number
+ * @returns {Promise<void>}
+ */
+export function fetch(remoteConfig, expirationDurationSeconds) {
+  return remoteConfig.fetch(expirationDurationSeconds);
+}
+
+/**
+ * Fetches parameter values for your app.
+ * @param remoteConfig - RemoteConfig instance
+ * @param defaults - ConfigDefaults
+ * @returns {Promise<void>}
+ */
+export function setDefaults(remoteConfig, defaults) {
+  return remoteConfig.setDefaults(defaults);
+}
+
+/**
+ * Fetches parameter values for your app.
+ * @param remoteConfig - RemoteConfig instance
+ * @param resourceName - string
+ * @returns {Promise<null>}
+ */
+export function setDefaultsFromResource(remoteConfig, resourceName) {
+  return remoteConfig.setDefaultsFromResource(resourceName);
+}

package/lib/version.js

@@ -1,2 +1,2 @@
 // Generated by genversion.
-module.exports = '16.7.0';
+module.exports = '17.1.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/remote-config",
-  "version": "16.7.0",
+  "version": "17.1.0",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "React Native Firebase - React Native Firebase provides native integration with Remote Config, allowing you to change the appearance and/or functionality of your app without requiring an app update.",
   "main": "lib/index.js",
@@ -24,11 +24,11 @@
     "remote-config"
   ],
   "peerDependencies": {
-    "@react-native-firebase/analytics": "16.7.0",
-    "@react-native-firebase/app": "16.7.0"
+    "@react-native-firebase/analytics": "17.1.0",
+    "@react-native-firebase/app": "17.1.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a94f371da16f9bf873c18b09541cbeb19960978d"
+  "gitHead": "635d595389bfb224fc530681627fb2180fea6e26"
 }