feat: Use Common db model types in frontend (#291)

crates/context_aware_config/Cargo.toml

@@ -33,7 +33,6 @@ superposition_macros = { path = "../superposition_macros" }
 superposition_types = { path = "../superposition_types", features = [
     "result",
     "diesel_derives",
-    "server",
 ] }
 uuid = { workspace = true }
 

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

@@ -1,11 +1,14 @@
-use actix_web::{get, web::Query, HttpResponse, Scope};
+use actix_web::{
+    get,
+    web::{Json, Query},
+    Scope,
+};
 use chrono::{Duration, Utc};
 use diesel::{ExpressionMethods, QueryDsl, RunQueryDsl};
-use serde_json::json;
 use service_utils::service::types::DbConnection;
 use superposition_types::{
     cac::{models::EventLog, schema::event_log::dsl as event_log},
-    result as superposition,
+    result as superposition, PaginatedResponse,
 };
 
 use crate::api::audit_log::types::AuditQueryFilters;
@@ -18,7 +21,7 @@ pub fn endpoints() -> Scope {
 async fn get_audit_logs(
     filters: Query<AuditQueryFilters>,
     db_conn: DbConnection,
-) -> superposition::Result<HttpResponse> {
+) -> superposition::Result<Json<PaginatedResponse<EventLog>>> {
     let DbConnection(mut conn) = db_conn;
 
     let query_builder = |filters: &AuditQueryFilters| {
@@ -57,9 +60,9 @@ async fn get_audit_logs(
 
     let total_pages = (log_count as f64 / limit as f64).ceil() as i64;
 
-    Ok(HttpResponse::Ok().json(json!({
-        "total_items": log_count,
-        "total_pages": total_pages,
-        "data": logs
-    })))
+    Ok(Json(PaginatedResponse {
+        total_items: log_count,
+        total_pages,
+        data: logs,
+    }))
 }

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

@@ -14,7 +14,8 @@ use superposition_macros::{bad_argument, db_error, not_found, unexpected_error};
 use superposition_types::{
     cac::{
         models::Dimension,
-        schema::{dimensions, dimensions::dsl::*},
+        schema::dimensions::{self, dsl::*},
+        types::DimensionWithMandatory,
     },
     custom_query::PaginationParams,
     result as superposition, PaginatedResponse, TenantConfig, User,
@@ -28,7 +29,7 @@ use crate::{
     helpers::validate_jsonschema,
 };
 
-use super::types::{DeleteReq, DimensionName, DimensionWithMandatory, UpdateReq};
+use super::types::{DeleteReq, DimensionName, UpdateReq};
 
 pub fn endpoints() -> Scope {
     Scope::new("")

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

@@ -1,8 +1,7 @@
-use chrono::{DateTime, NaiveDateTime, Utc};
 use derive_more::{AsRef, Deref, DerefMut, Into};
-use serde::{Deserialize, Deserializer, Serialize};
+use serde::{Deserialize, Deserializer};
 use serde_json::Value;
-use superposition_types::{cac::models::Dimension, RegexEnum};
+use superposition_types::RegexEnum;
 
 #[derive(Debug, Deserialize)]
 pub struct CreateReq {
@@ -88,35 +87,6 @@ impl TryFrom<String> for DimensionName {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct DimensionWithMandatory {
-    pub dimension: String,
-    pub position: i32,
-    pub created_at: DateTime<Utc>,
-    pub created_by: String,
-    pub schema: Value,
-    pub function_name: Option<String>,
-    pub last_modified_at: NaiveDateTime,
-    pub last_modified_by: String,
-    pub mandatory: bool,
-}
-
-impl DimensionWithMandatory {
-    pub fn new(value: Dimension, mandatory: bool) -> Self {
-        DimensionWithMandatory {
-            dimension: value.dimension,
-            position: value.position,
-            created_at: value.created_at,
-            created_by: value.created_by,
-            schema: value.schema,
-            function_name: value.function_name,
-            last_modified_at: value.last_modified_at,
-            last_modified_by: value.last_modified_by,
-            mandatory,
-        }
-    }
-}
-
 #[derive(Debug, Deserialize, AsRef, Deref, DerefMut, Into)]
 #[serde(try_from = "String")]
 pub struct DeleteReq(String);

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

@@ -6,9 +6,11 @@ use jsonschema::JSONSchema;
 use serde_json::Value;
 use service_utils::service::types::DbConnection;
 use superposition_macros::{bad_argument, db_error};
-use superposition_types::cac::models::TypeTemplates;
 use superposition_types::{
-    cac::schema::type_templates::{self, dsl},
+    cac::{
+        models::TypeTemplate,
+        schema::type_templates::{self, dsl},
+    },
     custom_query::PaginationParams,
     result as superposition, PaginatedResponse, User,
 };
@@ -49,7 +51,7 @@ async fn create_type(
             type_templates::created_by.eq(user.email.clone()),
             type_templates::last_modified_by.eq(user.email.clone()),
         ))
-        .get_result::<TypeTemplates>(&mut conn)
+        .get_result::<TypeTemplate>(&mut conn)
         .map_err(|err| {
             log::error!("failed to insert custom type with error: {}", err);
             db_error!(err)
@@ -86,7 +88,7 @@ async fn update_type(
             type_templates::last_modified_at.eq(timestamp),
             type_templates::last_modified_by.eq(user.email),
         ))
-        .get_result::<TypeTemplates>(&mut conn)
+        .get_result::<TypeTemplate>(&mut conn)
         .map_err(|err| {
             log::error!("failed to insert custom type with error: {}", err);
             db_error!(err)
@@ -111,19 +113,19 @@ async fn delete_type(
         .execute(&mut conn)?;
     let deleted_type =
         diesel::delete(dsl::type_templates.filter(dsl::type_name.eq(type_name)))
-            .get_result::<TypeTemplates>(&mut conn)?;
+            .get_result::<TypeTemplate>(&mut conn)?;
     Ok(HttpResponse::Ok().json(deleted_type))
 }
 
 #[get("")]
 async fn list_types(
     db_conn: DbConnection,
     filters: Query<PaginationParams>,
-) -> superposition::Result<Json<PaginatedResponse<TypeTemplates>>> {
+) -> superposition::Result<Json<PaginatedResponse<TypeTemplate>>> {
     let DbConnection(mut conn) = db_conn;
 
     if let Some(true) = filters.all {
-        let result: Vec<TypeTemplates> =
+        let result: Vec<TypeTemplate> =
             type_templates::dsl::type_templates.get_results(&mut conn)?;
         return Ok(Json(PaginatedResponse {
             total_pages: 1,
@@ -144,7 +146,7 @@ async fn list_types(
         let offset = (page - 1) * limit;
         builder = builder.offset(offset);
     }
-    let custom_types: Vec<TypeTemplates> = builder.load(&mut conn)?;
+    let custom_types: Vec<TypeTemplate> = builder.load(&mut conn)?;
     let total_pages = (n_types as f64 / limit as f64).ceil() as i64;
     Ok(Json(PaginatedResponse {
         total_pages,

crates/experimentation_client/Cargo.toml

@@ -11,7 +11,9 @@ once_cell = { workspace = true }
 reqwest = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-superposition_types = { path = "../superposition_types" }
+superposition_types = { path = "../superposition_types", features = [
+    "experimentation",
+] }
 tokio = { version = "1.29.1", features = ["full"] }
 
 [lib]

crates/experimentation_client/src/lib.rs

@@ -10,13 +10,16 @@ use std::{
 use chrono::{DateTime, TimeZone, Utc};
 use derive_more::{Deref, DerefMut};
 use serde_json::Value;
-use superposition_types::Overridden;
+use superposition_types::{
+    experimentation::models::{ExperimentStatusType, VariantType},
+    Overridden, PaginatedResponse,
+};
 use tokio::{
     sync::RwLock,
     time::{self, Duration},
 };
 pub use types::{Config, Experiment, Experiments, Variants};
-use types::{ExperimentStore, ListExperimentsResponse, Variant, VariantType};
+use types::{ExperimentStore, Variant};
 use utils::MapError;
 
 #[derive(Clone, Debug)]
@@ -32,7 +35,7 @@ pub struct Client {
 
 impl Client {
     pub fn new(config: Config) -> Self {
-        Client {
+        Self {
             client_config: Arc::new(config),
             experiments: Arc::new(RwLock::new(HashMap::new())),
             http_client: reqwest::Client::new(),
@@ -64,9 +67,7 @@ impl Client {
                 let mut exp_store = self.experiments.write().await;
                 for (exp_id, experiment) in experiments.into_iter() {
                     match experiment.status {
-                        types::ExperimentStatusType::Concluded => {
-                            exp_store.remove(&exp_id)
-                        }
+                        ExperimentStatusType::CONCLUDED => exp_store.remove(&exp_id),
                         _ => exp_store.insert(exp_id, experiment),
                     };
                 }
@@ -213,7 +214,7 @@ impl Client {
     ) -> Result<Option<Variant>, String> {
         if toss < 0 {
             for variant in applicable_variants.iter() {
-                if variant.variant_type == VariantType::Experimental {
+                if variant.variant_type == VariantType::EXPERIMENTAL {
                     return Ok(Some(variant.clone()));
                 }
             }
@@ -255,7 +256,7 @@ async fn get_experiments(
             .send()
             .await
             .map_err_to_string()?
-            .json::<ListExperimentsResponse>()
+            .json::<PaginatedResponse<Experiment>>()
             .await
             .map_err_to_string()?;
 

crates/experimentation_client/src/types.rs

@@ -2,7 +2,10 @@ use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use superposition_types::{Exp, Overridden, Overrides};
+use superposition_types::{
+    experimentation::models::{ExperimentStatusType, VariantType},
+    Exp, Overridden, Overrides,
+};
 
 #[derive(Clone, Debug)]
 pub struct Config {
@@ -11,21 +14,6 @@ pub struct Config {
     pub poll_frequency: u64,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Deserialize, Serialize)]
-#[serde(rename_all = "UPPERCASE")]
-pub(crate) enum ExperimentStatusType {
-    Created,
-    InProgress,
-    Concluded,
-}
-
-#[derive(Deserialize, Serialize, Clone, Debug, PartialEq)]
-#[serde(rename_all = "UPPERCASE")]
-pub(crate) enum VariantType {
-    Control,
-    Experimental,
-}
-
 #[repr(C)]
 #[derive(Deserialize, Serialize, Clone, Debug)]
 pub struct Variant {
@@ -56,10 +44,3 @@ pub struct Experiment {
 pub type Experiments = Vec<Experiment>;
 
 pub(crate) type ExperimentStore = HashMap<String, Experiment>;
-
-#[derive(Serialize, Deserialize, Default)]
-pub(crate) struct ListExperimentsResponse {
-    pub(crate) total_items: i64,
-    pub(crate) total_pages: i64,
-    pub(crate) data: Experiments,
-}

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

@@ -31,7 +31,7 @@ use superposition_types::{
     },
     result::{self as superposition},
     webhook::{WebhookConfig, WebhookEvent},
-    Condition, Exp, Overrides, SortBy, TenantConfig, User,
+    Condition, Exp, Overrides, PaginatedResponse, SortBy, TenantConfig, User,
 };
 
 use super::{
@@ -44,7 +44,7 @@ use super::{
         ApplicableVariantsQuery, AuditQueryFilters, ConcludeExperimentRequest,
         ContextAction, ContextBulkResponse, ContextMoveReq, ContextPutReq,
         ExperimentCreateRequest, ExperimentCreateResponse, ExperimentListFilters,
-        ExperimentResponse, ExperimentsResponse, OverrideKeysUpdateRequest, RampRequest,
+        ExperimentResponse, OverrideKeysUpdateRequest, RampRequest,
     },
 };
 use crate::api::experiments::{helpers::construct_header_map, types::ExperimentSortOn};
@@ -534,11 +534,13 @@ async fn list_experiments(
 
     if let Some(true) = pagination_params.all {
         let result = experiments::experiments.get_results::<Experiment>(&mut conn)?;
-        return Ok(HttpResponse::Ok().json(ExperimentsResponse {
-            total_pages: 1,
-            total_items: result.len() as i64,
-            data: result.into_iter().map(ExperimentResponse::from).collect(),
-        }));
+        return Ok(
+            HttpResponse::Ok().json(PaginatedResponse::<ExperimentResponse> {
+                total_pages: 1,
+                total_items: result.len() as i64,
+                data: result.into_iter().map(ExperimentResponse::from).collect(),
+            }),
+        );
     }
 
     let max_event_timestamp: Option<NaiveDateTime> = event_log::event_log
@@ -615,14 +617,16 @@ async fn list_experiments(
     let query = base_query.limit(limit).offset(offset);
     let experiment_list = query.load::<Experiment>(&mut conn)?;
     let total_pages = (number_of_experiments as f64 / limit as f64).ceil() as i64;
-    Ok(HttpResponse::Ok().json(ExperimentsResponse {
-        total_pages,
-        total_items: number_of_experiments,
-        data: experiment_list
-            .into_iter()
-            .map(ExperimentResponse::from)
-            .collect(),
-    }))
+    Ok(
+        HttpResponse::Ok().json(PaginatedResponse::<ExperimentResponse> {
+            total_pages,
+            total_items: number_of_experiments,
+            data: experiment_list
+                .into_iter()
+                .map(ExperimentResponse::from)
+                .collect(),
+        }),
+    )
 }
 
 #[get("/{id}")]
@@ -962,7 +966,7 @@ async fn update_overrides(
 async fn get_audit_logs(
     filters: Query<AuditQueryFilters>,
     db_conn: DbConnection,
-) -> superposition::Result<HttpResponse> {
+) -> superposition::Result<Json<PaginatedResponse<EventLog>>> {
     let DbConnection(mut conn) = db_conn;
 
     let query_builder = |filters: &AuditQueryFilters| {
@@ -1001,9 +1005,9 @@ async fn get_audit_logs(
 
     let total_pages = (log_count as f64 / limit as f64).ceil() as i64;
 
-    Ok(HttpResponse::Ok().json(json!({
-        "total_items": log_count,
-        "total_pages": total_pages,
-        "data": logs
-    })))
+    Ok(Json(PaginatedResponse {
+        total_items: log_count,
+        total_pages: total_pages,
+        data: logs,
+    }))
 }