fix: cac,exp type wrapper

crates/context_aware_config/src/api/config/handlers.rs

@@ -23,10 +23,7 @@ use diesel::{
 };
 use serde_json::{json, Map, Value};
 use superposition_macros::{bad_argument, db_error, unexpected_error};
-use superposition_types::{
-    get_db_cac_validation_type, result as superposition, Condition, Overrides, User,
-    ValidationType,
-};
+use superposition_types::{result as superposition, Cac, Condition, Overrides, User};
 
 use itertools::Itertools;
 use jsonschema::JSONSchema;
@@ -335,7 +332,12 @@ fn construct_new_payload(
                 log::error!("construct new payload Context not present");
                 Err(bad_argument!("Context not present"))
             },
-            |val| Condition::new(val.to_owned(), ValidationType::CAC),
+            |val| {
+                Cac::<Condition>::try_from(val.to_owned()).map_err(|err| {
+                    log::error!("failed to decode condition with error : {}", err);
+                    bad_argument!(err)
+                })
+            },
         )?;
 
     let override_ = res
@@ -346,7 +348,12 @@ fn construct_new_payload(
                 log::error!("construct new payload Override not present");
                 Err(bad_argument!("Override not present"))
             },
-            |val| Overrides::new(val.to_owned(), ValidationType::CAC),
+            |val| {
+                Cac::<Overrides>::try_from(val.to_owned()).map_err(|err| {
+                    log::error!("failed to decode override with error : {}", err);
+                    bad_argument!(err)
+                })
+            },
         )?;
 
     return Ok(web::Json(PutReq {
@@ -425,10 +432,18 @@ async fn reduce_config_key(
                 Some(Value::Bool(to_be_deleted)),
                 Some(override_val),
             ) => {
-                let override_val = Overrides::new(
+                let override_val = Cac::<Overrides>::try_from_db(
                     override_val.as_object().unwrap_or(&Map::new()).clone(),
-                    get_db_cac_validation_type(),
-                )?;
+                )
+                .map_err(|err| {
+                    log::error!(
+                        "reduce_config_key: failed to decode overrides from db {}",
+                        err
+                    );
+                    unexpected_error!(err)
+                })?
+                .into_inner();
+
                 if *to_be_deleted {
                     if is_approve {
                         let _ = delete_context_api(cid.clone(), user.clone(), conn);

crates/context_aware_config/src/api/config/helpers.rs

@@ -3,9 +3,7 @@ use super::types::{Config, Context};
 use actix_web::web::Query;
 use serde_json::{json, Map, Value};
 use superposition_macros::{bad_argument, unexpected_error};
-use superposition_types::{
-    get_db_cac_validation_type, result as superposition, Overrides,
-};
+use superposition_types::{result as superposition, Cac, Overrides};
 
 pub fn filter_context(
     contexts: &[Context],
@@ -53,7 +51,12 @@ pub fn filter_config_by_prefix(
         if !filtered_overrides_map.is_empty() {
             filtered_overrides.insert(
                 key.clone(),
-                Overrides::new(filtered_overrides_map, get_db_cac_validation_type())?,
+                Cac::<Overrides>::try_from_db(filtered_overrides_map)
+                    .map_err(|err| {
+                        log::error!("filter_config_by_prefix : failed to decode overrides from db with error {}", err);
+                        unexpected_error!(err)
+                    })?
+                    .into_inner(),
             );
         }
     }

crates/context_aware_config/src/api/context/handlers.rs

@@ -193,12 +193,13 @@ fn create_ctx_from_put_req(
     conn: &mut DBConnection,
     user: &User,
 ) -> superposition::Result<Context> {
-    let ctx_condition = req.context.to_owned();
+    let ctx_condition = req.context.to_owned().into_inner();
     let condition_val = json!(ctx_condition);
-    let ctx_override = json!(req.r#override.to_owned());
-    validate_override_with_default_configs(conn, &req.r#override)?;
+    let r_override = req.r#override.clone().into_inner();
+    let ctx_override = json!(r_override.to_owned());
+    validate_override_with_default_configs(conn, &r_override)?;
     validate_condition_with_functions(conn, &ctx_condition)?;
-    validate_override_with_functions(conn, &req.r#override)?;
+    validate_override_with_functions(conn, &r_override)?;
 
     let dimension_schema_map = get_all_dimension_schema_map(conn)?;
 
@@ -400,7 +401,7 @@ fn r#move(
 ) -> superposition::Result<PutResp> {
     use contexts::dsl;
     let req = req.into_inner();
-    let ctx_condition = Value::Object(req.context);
+    let ctx_condition = json!(req.context.into_inner());
     let new_ctx_id = hash(&ctx_condition);
     let dimension_schema_map = get_all_dimension_schema_map(conn)?;
     let priority = validate_dimensions_and_calculate_priority(

crates/context_aware_config/src/api/context/types.rs

@@ -1,18 +1,18 @@
 use serde::{Deserialize, Serialize};
-use serde_json::{Map, Value};
-use superposition_types::{Condition, Overrides, ValidationType};
+use serde_json::Value;
+use superposition_types::{Cac, Condition, Overrides};
 
 #[cfg_attr(test, derive(Debug, PartialEq))] // Derive traits only when running tests
 #[derive(Deserialize, Clone)]
 pub struct PutReq {
-    pub context: Condition,
-    pub r#override: Overrides,
+    pub context: Cac<Condition>,
+    pub r#override: Cac<Overrides>,
 }
 
 #[cfg_attr(test, derive(Debug, PartialEq))] // Derive traits only when running tests
 #[derive(Deserialize, Clone)]
 pub struct MoveReq {
-    pub context: Map<String, Value>,
+    pub context: Cac<Condition>,
 }
 
 #[derive(Deserialize, Clone)]
@@ -67,7 +67,8 @@ pub struct PriorityRecomputeResponse {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use serde_json::json;
+    use serde_json::{json, Map};
+    use superposition_types::Cac;
 
     #[test]
     fn test_deserialize_context_action() {
@@ -91,12 +92,12 @@ mod tests {
         let mut expected_condition = Map::new();
         expected_condition.insert("foo".to_string(), json!("bar"));
         expected_condition.insert("bar".to_string(), json!({ "baz": "baz"}));
-        let condition = Condition::new(expected_condition, ValidationType::CAC)
+        let condition = Cac::<Condition>::try_from(expected_condition)
             .expect("Invalid context condition");
 
         let mut expected_override = Map::new();
         expected_override.insert("foo".to_string(), json!("baz"));
-        let override_ = Overrides::new(expected_override, ValidationType::CAC)
+        let override_ = Cac::<Overrides>::try_from(expected_override)
             .expect("Invalid context override");
 
         let expected_action = ContextAction::Put(PutReq {

crates/context_aware_config/src/helpers.rs

@@ -25,10 +25,8 @@ use service_utils::{
     service::types::AppState,
 };
 
-use superposition_macros::{db_error, validation_error};
-use superposition_types::{
-    get_db_cac_validation_type, result as superposition, Condition, Overrides,
-};
+use superposition_macros::{db_error, unexpected_error, validation_error};
+use superposition_types::{result as superposition, Cac, Condition, Overrides};
 
 use std::collections::HashMap;
 
@@ -331,14 +329,23 @@ pub fn generate_cac(
     let mut overrides: HashMap<String, Overrides> = HashMap::new();
 
     for (id, condition, priority_, override_id, override_) in contexts_vec.iter() {
-        let condition = Condition::new(
+        let condition = Cac::<Condition>::try_from_db(
             condition.as_object().unwrap_or(&Map::new()).clone(),
-            get_db_cac_validation_type(),
-        )?;
-        let override_ = Overrides::new(
+        )
+        .map_err(|err| {
+            log::error!("generate_cac : failed to decode context from db {}", err);
+            unexpected_error!(err)
+        })?
+        .into_inner();
+
+        let override_ = Cac::<Overrides>::try_from_db(
             override_.as_object().unwrap_or(&Map::new()).clone(),
-            get_db_cac_validation_type(),
-        )?;
+        )
+        .map_err(|err| {
+            log::error!("generate_cac : failed to decode overrides from db {}", err);
+            unexpected_error!(err)
+        })?
+        .into_inner();
         let ctxt = Context {
             id: id.to_owned(),
             condition,

crates/experimentation_platform/src/api/experiments/handlers.rs

@@ -21,8 +21,7 @@ use service_utils::service::types::{
 };
 use superposition_macros::{bad_argument, response_error, unexpected_error};
 use superposition_types::{
-    get_db_experiment_validation_type, result as superposition, Condition, Overrides,
-    SuperpositionUser, User, ValidationType,
+    result as superposition, Condition, Exp, Overrides, SuperpositionUser, User,
 };
 
 use super::{
@@ -171,9 +170,13 @@ async fn create(
     let variant_overrides = variants
         .iter()
         .map(|variant| {
-            Overrides::new(variant.overrides.clone(), ValidationType::EXPERIMENTAL)
+            Exp::<Overrides>::try_from(variant.overrides.clone()).map(|a| a.into_inner())
         })
-        .collect::<superposition::Result<Vec<Overrides>>>()?;
+        .collect::<Result<Vec<Overrides>, String>>()
+        .map_err(|err| {
+            log::error!("failed to decode overrides with error {}", err);
+            bad_argument!(err)
+        })?;
     let are_valid_variants =
         check_variants_override_coverage(&variant_overrides, &unique_override_keys);
     if !are_valid_variants {
@@ -185,7 +188,12 @@ async fn create(
     }
 
     // validating context
-    let exp_context = Condition::new(req.context.clone(), ValidationType::EXPERIMENTAL)?;
+    let exp_context = Exp::<Condition>::try_from(req.context.clone())
+        .map_err(|err| {
+            log::error!("failed to decode condition with error {}", err);
+            bad_argument!(err)
+        })?
+        .into_inner();
 
     // validating experiment against other active experiments based on permission flags
     let flags = &state.experimentation_flags;
@@ -665,9 +673,13 @@ async fn update_overrides(
     let variant_overrides = new_variants
         .iter()
         .map(|variant| {
-            Overrides::new(variant.overrides.clone(), ValidationType::EXPERIMENTAL)
+            Exp::<Overrides>::try_from(variant.overrides.clone()).map(|a| a.into_inner())
         })
-        .collect::<superposition::Result<Vec<Overrides>>>()?;
+        .collect::<Result<Vec<Overrides>, String>>()
+        .map_err(|err| {
+            log::error!("failed to decode overrides with error {}", err);
+            bad_argument!(err)
+        })?;
     let are_valid_variants =
         check_variants_override_coverage(&variant_overrides, &override_keys);
     if !are_valid_variants {
@@ -678,14 +690,22 @@ async fn update_overrides(
             )
         )?;
     }
-    let experiment_condition = Condition::new(
+    let experiment_condition = Exp::<Condition>::try_from_db(
         experiment
             .context
             .as_object()
             .unwrap_or(&Map::new())
             .clone(),
-        get_db_experiment_validation_type(),
-    )?;
+    )
+    .map_err(|err| {
+        log::error!(
+            "update_overrides : failed to decode condition from db with error {}",
+            err
+        );
+        unexpected_error!(err)
+    })?
+    .into_inner();
+
     // validating experiment against other active experiments based on permission flags
     let flags = &state.experimentation_flags;
     let (valid, reason) = validate_experiment(

crates/experimentation_platform/src/api/experiments/helpers.rs

@@ -6,10 +6,8 @@ use serde_json::{json, Map, Value};
 use service_utils::helpers::extract_dimensions;
 use service_utils::service::types::ExperimentationFlags;
 use std::collections::HashSet;
-use superposition_macros::bad_argument;
-use superposition_types::{
-    get_db_experiment_validation_type, result as superposition, Condition, Overrides,
-};
+use superposition_macros::{bad_argument, unexpected_error};
+use superposition_types::{result as superposition, Condition, Exp, Overrides};
 
 pub fn check_variant_types(variants: &Vec<Variant>) -> superposition::Result<()> {
     let mut experimental_variant_cnt = 0;
@@ -125,14 +123,18 @@ pub fn is_valid_experiment(
     {
         let override_keys_set = HashSet::<&String>::from_iter(override_keys);
         for active_experiment in active_experiments {
-            let active_exp_context = Condition::new(
+            let active_exp_context = Exp::<Condition>::try_from_db(
                 active_experiment
                     .context
                     .as_object()
                     .unwrap_or(&Map::new())
                     .to_owned(),
-                get_db_experiment_validation_type(),
-            )?;
+            )
+            .map_err(|err| {
+                log::error!("is_valid_experiment : failed to decode overrides from db with error {}", err);
+                unexpected_error!(err)
+            })?
+            .into_inner();
             let are_overlapping =
                 are_overlapping_contexts(context, &active_exp_context)
                     .map_err(|e| {