feat: Introduce ConfigurationProvider trait (#74)

I want to hide the concept of a `Configuration` as an implementation
detail and instead introduce a trait (`ConfigurationProvider`) that
offers the functionality to provide features and properties. This trait
will then be implemented by many of the structs we already have:
app-configuration clients, the `Configuration` itself,... and it will be
easier to mock (/dependency injection).

I also think this will help us to narrow the API of the crate: we can
hide `Configuration` and some other structs together with it.

---------

Signed-off-by: Javier G. Sogo <[email protected]>

Author: jgsogo

.secrets.baseline

@@ -3,7 +3,7 @@
     "files": "^.secrets.baseline$",
     "lines": null
   },
-  "generated_at": "2025-05-05T10:55:39Z",
+  "generated_at": "2025-05-08T08:31:42Z",
   "plugins_used": [
     {
       "name": "AWSKeyDetector"
@@ -81,7 +81,7 @@
       {
         "hashed_secret": "fb34629c9af1ed4045b5d6f287426276b2be3a1e",
         "is_verified": false,
-        "line_number": 46,
+        "line_number": 44,
         "type": "Secret Keyword",
         "verified_result": null
       }

README.md

@@ -30,7 +30,7 @@ Create your client with the context (environment and collection) you want to con
 
 ```rust
 use appconfiguration::{
-    AppConfigurationClient, AppConfigurationClientIBMCloud,
+    ConfigurationProvider, AppConfigurationClientIBMCloud,
     ConfigurationId, Entity, Result, Value, Feature, OfflineMode
 };
 

src/client/app_configuration_client.rs

@@ -12,13 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::Result;
-
 use crate::client::feature_proxy::FeatureProxy;
 use crate::client::feature_snapshot::FeatureSnapshot;
 use crate::client::property_proxy::PropertyProxy;
 use crate::client::property_snapshot::PropertySnapshot;
-
+use crate::Result;
 /// Identifies a configuration
 #[derive(Debug, Clone)]
 pub struct ConfigurationId {
@@ -40,12 +38,11 @@ impl ConfigurationId {
     }
 }
 
-/// AppConfiguration client for browsing, and evaluating features and properties.
-pub trait AppConfigurationClient {
+pub trait ConfigurationProvider {
     /// Returns the list of features.
     ///
-    /// The list contains the `id`s that can be used in [`get_feature`](AppConfigurationClient::get_feature)
-    /// or [`get_feature_proxy`](AppConfigurationClient::get_feature_proxy) to retrieve the actual features.
+    /// The list contains the `id`s that can be used in other methods to return
+    /// concrete features, like [`get_feature`](ConfigurationProvider::get_feature).
     fn get_feature_ids(&self) -> Result<Vec<String>>;
 
     /// Returns a snapshot for a [`Feature`](crate::Feature).
@@ -55,16 +52,10 @@ pub trait AppConfigurationClient {
     /// will be received from the server.
     fn get_feature(&self, feature_id: &str) -> Result<FeatureSnapshot>;
 
-    /// Returns a proxied [`Feature`](crate::Feature).
-    ///
-    /// This proxied feature will envaluate entities using the latest information
-    /// available if the client implementation support some kind of live-updates.
-    fn get_feature_proxy<'a>(&'a self, feature_id: &str) -> Result<FeatureProxy<'a>>;
-
     /// Returns the list of properties.
     ///
-    /// The list contains the `id`s that can be used in [`get_property`](AppConfigurationClient::get_property)
-    /// or [`get_property_proxy`](AppConfigurationClient::get_property_proxy) to retrieve the actual features.
+    /// The list contains the `id`s that can be used in other methods to return
+    /// concrete properties, like [`get_property`](ConfigurationProvider::get_property).
     fn get_property_ids(&self) -> Result<Vec<String>>;
 
     /// Returns a snapshot for a [`Property`](crate::Property).
@@ -73,10 +64,32 @@ pub trait AppConfigurationClient {
     /// will always evaluate the same entities to the same values, no updates
     /// will be received from the server
     fn get_property(&self, property_id: &str) -> Result<PropertySnapshot>;
+}
+
+/// AppConfiguration client for browsing, and evaluating features and properties.
+pub trait AppConfigurationClient: ConfigurationProvider {
+    /// Returns a proxied [`Feature`](crate::Feature).
+    ///
+    /// This proxied feature will envaluate entities using the latest information
+    /// available if the client implementation support some kind of live-updates.
+    fn get_feature_proxy<'a>(&'a self, feature_id: &str) -> Result<FeatureProxy<'a>>;
 
     /// Returns a proxied [`Property`](crate::Property).
     ///
     /// This proxied property will envaluate entities using the latest information
     /// available if the client implementation support some kind of live-updates.
     fn get_property_proxy(&self, property_id: &str) -> Result<PropertyProxy>;
 }
+
+impl<T: ConfigurationProvider> AppConfigurationClient for T {
+    fn get_feature_proxy<'a>(&'a self, feature_id: &str) -> Result<FeatureProxy<'a>> {
+        // FIXME: there is and was no validation happening if the feature exists.
+        // Comments and error messages in FeatureProxy suggest that this should happen here.
+        // same applies for properties.
+        Ok(FeatureProxy::new(self, feature_id.to_string()))
+    }
+
+    fn get_property_proxy(&self, property_id: &str) -> Result<PropertyProxy> {
+        Ok(PropertyProxy::new(self, property_id.to_string()))
+    }
+}

src/client/app_configuration_http.rs

@@ -12,17 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-pub use crate::client::feature_proxy::FeatureProxy;
 use crate::client::feature_snapshot::FeatureSnapshot;
-pub use crate::client::property_proxy::PropertyProxy;
 use crate::client::property_snapshot::PropertySnapshot;
 use crate::errors::Result;
 
 use crate::network::live_configuration::{CurrentMode, LiveConfiguration, LiveConfigurationImpl};
 use crate::network::{ServiceAddress, TokenProvider};
-use crate::{OfflineMode, ServerClientImpl};
+use crate::{ConfigurationProvider, OfflineMode, ServerClientImpl};
 
-use super::{AppConfigurationClient, ConfigurationId};
+use super::ConfigurationId;
 
 /// AppConfiguration client implementation that connects to a server
 #[derive(Debug)]
@@ -62,48 +60,21 @@ impl<T: LiveConfiguration> AppConfigurationClientHttp<T> {
     }
 }
 
-impl<T: LiveConfiguration> AppConfigurationClient for AppConfigurationClientHttp<T> {
+impl<T: LiveConfiguration> ConfigurationProvider for AppConfigurationClientHttp<T> {
     fn get_feature_ids(&self) -> Result<Vec<String>> {
-        Ok(self
-            .live_configuration
-            .get_configuration()?
-            .get_feature_ids()
-            .into_iter()
-            .cloned()
-            .collect())
+        self.live_configuration.get_feature_ids()
     }
 
     fn get_feature(&self, feature_id: &str) -> Result<FeatureSnapshot> {
-        self.live_configuration
-            .get_configuration()?
-            .get_feature(feature_id)
-    }
-
-    fn get_feature_proxy<'a>(&'a self, feature_id: &str) -> Result<FeatureProxy<'a>> {
-        // FIXME: there is and was no validation happening if the feature exists.
-        // Comments and error messages in FeatureProxy suggest that this should happen here.
-        // same applies for properties.
-        Ok(FeatureProxy::new(self, feature_id.to_string()))
+        self.live_configuration.get_feature(feature_id)
     }
 
     fn get_property_ids(&self) -> Result<Vec<String>> {
-        Ok(self
-            .live_configuration
-            .get_configuration()?
-            .get_property_ids()
-            .into_iter()
-            .cloned()
-            .collect())
+        self.live_configuration.get_property_ids()
     }
 
     fn get_property(&self, property_id: &str) -> Result<PropertySnapshot> {
-        self.live_configuration
-            .get_configuration()?
-            .get_property(property_id)
-    }
-
-    fn get_property_proxy(&self, property_id: &str) -> Result<PropertyProxy> {
-        Ok(PropertyProxy::new(self, property_id.to_string()))
+        self.live_configuration.get_property(property_id)
     }
 }
 
@@ -122,11 +93,24 @@ mod tests {
     struct LiveConfigurationMock {
         configuration: Configuration,
     }
-    impl LiveConfiguration for LiveConfigurationMock {
-        fn get_configuration(&self) -> crate::network::live_configuration::Result<Configuration> {
-            Ok(self.configuration.clone())
+    impl ConfigurationProvider for LiveConfigurationMock {
+        fn get_feature_ids(&self) -> Result<Vec<String>> {
+            self.configuration.get_feature_ids()
+        }
+
+        fn get_feature(&self, feature_id: &str) -> Result<FeatureSnapshot> {
+            self.configuration.get_feature(feature_id)
+        }
+
+        fn get_property_ids(&self) -> Result<Vec<String>> {
+            self.configuration.get_property_ids()
         }
 
+        fn get_property(&self, property_id: &str) -> Result<PropertySnapshot> {
+            self.configuration.get_property(property_id)
+        }
+    }
+    impl LiveConfiguration for LiveConfigurationMock {
         fn get_thread_status(
             &mut self,
         ) -> ThreadStatus<crate::network::live_configuration::Result<()>> {

src/client/app_configuration_ibm_cloud.rs

@@ -12,17 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-pub use crate::client::feature_proxy::FeatureProxy;
 use crate::client::feature_snapshot::FeatureSnapshot;
-pub use crate::client::property_proxy::PropertyProxy;
 use crate::client::property_snapshot::PropertySnapshot;
 use crate::errors::Result;
 use crate::network::live_configuration::LiveConfigurationImpl;
 use crate::network::ServiceAddress;
-use crate::{IBMCloudTokenProvider, OfflineMode};
+use crate::{ConfigurationProvider, IBMCloudTokenProvider, OfflineMode};
 
 use super::AppConfigurationClientHttp;
-use super::{AppConfigurationClient, ConfigurationId};
+use super::ConfigurationId;
 
 /// AppConfiguration client connection to IBM Cloud.
 #[derive(Debug)]
@@ -69,7 +67,7 @@ impl AppConfigurationClientIBMCloud {
     }
 }
 
-impl AppConfigurationClient for AppConfigurationClientIBMCloud {
+impl ConfigurationProvider for AppConfigurationClientIBMCloud {
     fn get_feature_ids(&self) -> Result<Vec<String>> {
         self.client.get_feature_ids()
     }
@@ -78,21 +76,13 @@ impl AppConfigurationClient for AppConfigurationClientIBMCloud {
         self.client.get_feature(feature_id)
     }
 
-    fn get_feature_proxy<'a>(&'a self, feature_id: &str) -> Result<FeatureProxy<'a>> {
-        self.client.get_feature_proxy(feature_id)
-    }
-
     fn get_property_ids(&self) -> Result<Vec<String>> {
         self.client.get_property_ids()
     }
 
     fn get_property(&self, property_id: &str) -> Result<PropertySnapshot> {
         self.client.get_property(property_id)
     }
-
-    fn get_property_proxy(&self, property_id: &str) -> Result<PropertyProxy> {
-        self.client.get_property_proxy(property_id)
-    }
 }
 
 #[cfg(test)]

src/client/app_configuration_offline.rs

@@ -13,14 +13,12 @@
 // limitations under the License.
 
 use crate::client::configuration::Configuration;
-pub use crate::client::feature_proxy::FeatureProxy;
+
 use crate::client::feature_snapshot::FeatureSnapshot;
-pub use crate::client::property_proxy::PropertyProxy;
 use crate::client::property_snapshot::PropertySnapshot;
 use crate::errors::Result;
 use crate::models::ConfigurationJson;
-
-use super::AppConfigurationClient;
+use crate::ConfigurationProvider;
 
 /// AppConfiguration client using a local file with a configuration snapshot
 #[derive(Debug)]
@@ -42,41 +40,20 @@ impl AppConfigurationOffline {
     }
 }
 
-impl AppConfigurationClient for AppConfigurationOffline {
+impl ConfigurationProvider for AppConfigurationOffline {
     fn get_feature_ids(&self) -> Result<Vec<String>> {
-        Ok(self
-            .config_snapshot
-            .get_feature_ids()
-            .into_iter()
-            .cloned()
-            .collect())
+        self.config_snapshot.get_feature_ids()
     }
 
     fn get_feature(&self, feature_id: &str) -> Result<FeatureSnapshot> {
         self.config_snapshot.get_feature(feature_id)
     }
 
-    fn get_feature_proxy<'a>(&'a self, feature_id: &str) -> Result<FeatureProxy<'a>> {
-        // FIXME: there is and was no validation happening if the feature exists.
-        // Comments and error messages in FeatureProxy suggest that this should happen here.
-        // same applies for properties.
-        Ok(FeatureProxy::new(self, feature_id.to_string()))
-    }
-
     fn get_property_ids(&self) -> Result<Vec<String>> {
-        Ok(self
-            .config_snapshot
-            .get_property_ids()
-            .into_iter()
-            .cloned()
-            .collect())
+        self.config_snapshot.get_property_ids()
     }
 
     fn get_property(&self, property_id: &str) -> Result<PropertySnapshot> {
         self.config_snapshot.get_property(property_id)
     }
-
-    fn get_property_proxy(&self, property_id: &str) -> Result<PropertyProxy> {
-        Ok(PropertyProxy::new(self, property_id.to_string()))
-    }
 }