[refact] Refact/models (#61)

Following #56, this PR moves the `FeatureSnapshot` and
`PropertySnapshot` inside `Configuration` (closer to JSON data), this
way the json-models doesn't leak into the application.

---------

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

Author: jgsogo

src/client/app_configuration_http.rs

@@ -176,23 +176,7 @@ impl AppConfigurationClient for AppConfigurationClientHttp {
     }
 
     fn get_feature(&self, feature_id: &str) -> Result<FeatureSnapshot> {
-        let config_snapshot = self.latest_config_snapshot.lock()?;
-
-        // Get the feature from the snapshot
-        let feature = config_snapshot.get_feature(feature_id)?;
-
-        // Get the segment rules that apply to this feature
-        let segments = config_snapshot.get_segments_for_segment_rules(&feature.segment_rules);
-
-        // Integrity DB check: all segment_ids should be available in the snapshot
-        if feature.segment_rules.len() != segments.len() {
-            return Err(ConfigurationAccessError::MissingSegments {
-                resource_id: feature_id.to_string(),
-            }
-            .into());
-        }
-
-        Ok(FeatureSnapshot::new(feature.clone(), segments))
+        self.latest_config_snapshot.lock()?.get_feature(feature_id)
     }
 
     fn get_feature_proxy<'a>(&'a self, feature_id: &str) -> Result<FeatureProxy<'a>> {
@@ -214,23 +198,9 @@ impl AppConfigurationClient for AppConfigurationClientHttp {
     }
 
     fn get_property(&self, property_id: &str) -> Result<PropertySnapshot> {
-        let config_snapshot = self.latest_config_snapshot.lock()?;
-
-        // Get the property from the snapshot
-        let property = config_snapshot.get_property(property_id)?;
-
-        // Get the segment rules that apply to this property
-        let segments = config_snapshot.get_segments_for_segment_rules(&property.segment_rules);
-
-        // Integrity DB check: all segment_ids should be available in the snapshot
-        if property.segment_rules.len() != segments.len() {
-            return Err(ConfigurationAccessError::MissingSegments {
-                resource_id: property_id.to_string(),
-            }
-            .into());
-        }
-
-        Ok(PropertySnapshot::new(property.clone(), segments))
+        self.latest_config_snapshot
+            .lock()?
+            .get_property(property_id)
     }
 
     fn get_property_proxy(&self, property_id: &str) -> Result<PropertyProxy> {

src/client/app_configuration_offline.rs

@@ -65,15 +65,7 @@ impl AppConfigurationClient for AppConfigurationOffline {
     }
 
     fn get_feature(&self, feature_id: &str) -> Result<FeatureSnapshot> {
-        // Get the feature from the snapshot
-        let feature = self.config_snapshot.get_feature(feature_id)?;
-
-        // Get the segment rules that apply to this feature
-        let segments = self
-            .config_snapshot
-            .get_segments_for_segment_rules(&feature.segment_rules);
-
-        Ok(FeatureSnapshot::new(feature.clone(), segments))
+        self.config_snapshot.get_feature(feature_id)
     }
 
     fn get_feature_proxy<'a>(&'a self, feature_id: &str) -> Result<FeatureProxy<'a>> {
@@ -88,15 +80,7 @@ impl AppConfigurationClient for AppConfigurationOffline {
     }
 
     fn get_property(&self, property_id: &str) -> Result<PropertySnapshot> {
-        // Get the property from the snapshot
-        let property = self.config_snapshot.get_property(property_id)?;
-
-        // Get the segment rules that apply to this feature
-        let segments = self
-            .config_snapshot
-            .get_segments_for_segment_rules(&property.segment_rules);
-
-        Ok(PropertySnapshot::new(property.clone(), segments))
+        self.config_snapshot.get_property(property_id)
     }
 
     fn get_property_proxy(&self, property_id: &str) -> Result<PropertyProxy> {

src/client/configuration.rs

@@ -16,6 +16,11 @@ use std::collections::{HashMap, HashSet};
 
 use crate::errors::{ConfigurationAccessError, Result};
 use crate::models::{ConfigurationJson, Feature, Property, Segment, TargetingRule};
+use crate::segment_evaluation::SegmentRules;
+use crate::Error;
+
+use super::feature_snapshot::FeatureSnapshot;
+use super::property_snapshot::PropertySnapshot;
 
 /// Represents all the configuration data needed for the client to perform
 /// feature/propery evaluation.
@@ -28,22 +33,63 @@ pub(crate) struct Configuration {
 }
 
 impl Configuration {
-    pub fn get_feature(&self, feature_id: &str) -> Result<&Feature> {
-        self.features.get(feature_id).ok_or_else(|| {
-            ConfigurationAccessError::FeatureNotFound {
+    pub fn get_feature(&self, feature_id: &str) -> Result<FeatureSnapshot> {
+        // Get the feature from the snapshot
+        let feature = self.features.get(feature_id).ok_or_else(|| {
+            Error::ConfigurationAccessError(ConfigurationAccessError::FeatureNotFound {
                 feature_id: feature_id.to_string(),
+            })
+        })?;
+
+        // Get the segment rules that apply to this feature
+        let segments = self.get_segments_for_segment_rules(&feature.segment_rules);
+
+        // Integrity DB check: all segment_ids should be available in the snapshot
+        if feature.segment_rules.len() != segments.len() {
+            return Err(ConfigurationAccessError::MissingSegments {
+                resource_id: feature_id.to_string(),
             }
-            .into()
-        })
+            .into());
+        }
+
+        let segment_rules =
+            SegmentRules::new(segments, feature.segment_rules.clone(), feature.kind);
+        let enabled_value = (feature.kind, feature.enabled_value.clone()).try_into()?;
+        let disabled_value = (feature.kind, feature.disabled_value.clone()).try_into()?;
+        Ok(FeatureSnapshot::new(
+            feature.enabled,
+            enabled_value,
+            disabled_value,
+            feature.rollout_percentage,
+            &feature.name,
+            feature_id,
+            segment_rules,
+        ))
     }
 
-    pub fn get_property(&self, property_id: &str) -> Result<&Property> {
-        self.properties.get(property_id).ok_or_else(|| {
-            ConfigurationAccessError::PropertyNotFound {
+    pub fn get_property(&self, property_id: &str) -> Result<PropertySnapshot> {
+        // Get the property from the snapshot
+        let property = self.properties.get(property_id).ok_or_else(|| {
+            Error::ConfigurationAccessError(ConfigurationAccessError::PropertyNotFound {
                 property_id: property_id.to_string(),
+            })
+        })?;
+
+        // Get the segment rules that apply to this property
+        let segments = self.get_segments_for_segment_rules(&property.segment_rules);
+
+        // Integrity DB check: all segment_ids should be available in the snapshot
+        if property.segment_rules.len() != segments.len() {
+            return Err(ConfigurationAccessError::MissingSegments {
+                resource_id: property_id.to_string(),
             }
-            .into()
-        })
+            .into());
+        }
+
+        let value = (property.kind, property.value.clone()).try_into()?;
+        let segment_rules =
+            SegmentRules::new(segments, property.segment_rules.clone(), property.kind);
+        Ok(PropertySnapshot::new(value, segment_rules, &property.name))
     }
 
     /// Constructs the Configuration, by consuming and filtering data in exchange format

src/client/feature_proxy.rs

@@ -39,7 +39,7 @@ impl<'a> FeatureProxy<'a> {
     }
 }
 
-impl<'a> Feature for FeatureProxy<'a> {
+impl Feature for FeatureProxy<'_> {
     fn get_name(&self) -> crate::errors::Result<String> {
         self.client.get_feature(&self.feature_id)?.get_name()
     }