chore: combine workspace settings into workspace context

Author: ayushjain17

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

@@ -1,7 +1,7 @@
 use actix_web::{get, web::Json, Scope};
 use chrono::{Duration, Utc};
 use diesel::{BoolExpressionMethods, ExpressionMethods, QueryDsl, RunQueryDsl};
-use service_utils::service::types::{DbConnection, SchemaName};
+use service_utils::service::types::{DbConnection, WorkspaceContext};
 use superposition_derives::authorized;
 use superposition_types::{
     api::audit_log::AuditQueryFilters,
@@ -17,10 +17,10 @@ pub fn endpoints() -> Scope {
 #[authorized]
 #[get("")]
 async fn list_handler(
+    workspace_request: WorkspaceContext,
     filters: superposition_query::Query<AuditQueryFilters>,
     pagination_params: superposition_query::Query<PaginationParams>,
     db_conn: DbConnection,
-    schema_name: SchemaName,
 ) -> superposition::Result<Json<PaginatedResponse<EventLog>>> {
     let now = Utc::now();
     let from_date = filters.from_date.unwrap_or(now - Duration::days(7));
@@ -33,7 +33,9 @@ async fn list_handler(
     let DbConnection(mut conn) = db_conn;
 
     let query_builder = |filters: &AuditQueryFilters| {
-        let mut builder = event_log::event_log.schema_name(&schema_name).into_boxed();
+        let mut builder = event_log::event_log
+            .schema_name(&workspace_request.schema_name)
+            .into_boxed();
         if let Some(tables) = filters.table.clone() {
             builder = builder.filter(event_log::table_name.eq_any(tables.0));
         }

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

@@ -18,7 +18,7 @@ use serde_json::{json, Map, Value};
 use service_utils::helpers::extract_dimensions;
 #[cfg(feature = "high-performance-mode")]
 use service_utils::service::types::{AppHeader, AppState};
-use service_utils::service::types::{DbConnection, SchemaName, WorkspaceContext};
+use service_utils::service::types::{DbConnection, WorkspaceContext};
 use superposition_derives::authorized;
 #[cfg(feature = "high-performance-mode")]
 use superposition_macros::response_error;
@@ -35,7 +35,7 @@ use superposition_types::{
     database::{
         models::{
             cac::{ConfigVersion, ConfigVersionListItem},
-            ChangeReason, Workspace,
+            ChangeReason,
         },
         schema::config_versions::dsl as config_versions,
     },
@@ -294,8 +294,7 @@ async fn reduce_config_key(
     dimension_schema_map: &HashMap<String, DimensionInfo>,
     default_config: Map<String, Value>,
     is_approve: bool,
-    schema_name: &SchemaName,
-    workspace_settings: &Workspace,
+    workspace_request: &WorkspaceContext,
 ) -> superposition::Result<Config> {
     let default_config_val =
         default_config
@@ -356,12 +355,22 @@ async fn reduce_config_key(
             ) => {
                 if *to_be_deleted {
                     if is_approve {
-                        let _ = context::delete(cid.clone(), user, conn, schema_name);
+                        let _ = context::delete(
+                            cid.clone(),
+                            user,
+                            conn,
+                            &workspace_request.schema_name,
+                        );
                     }
                     og_contexts.retain(|x| x.id != *cid);
                 } else {
                     if is_approve {
-                        let _ = context::delete(cid.clone(), user, conn, schema_name);
+                        let _ = context::delete(
+                            cid.clone(),
+                            user,
+                            conn,
+                            &workspace_request.schema_name,
+                        );
                         if let Ok(put_req) = construct_new_payload(request_payload) {
                             let description = match put_req.description.clone() {
                                 Some(val) => val,
@@ -370,7 +379,7 @@ async fn reduce_config_key(
                                         put_req.context.clone().into_inner().into(),
                                     ),
                                     conn,
-                                    schema_name,
+                                    &workspace_request.schema_name,
                                 )?,
                             };
 
@@ -380,8 +389,7 @@ async fn reduce_config_key(
                                 conn,
                                 false,
                                 user,
-                                schema_name,
-                                workspace_settings,
+                                workspace_request,
                                 false,
                             );
                         }
@@ -436,21 +444,22 @@ async fn reduce_config_key(
 #[authorized]
 #[put("/reduce")]
 async fn reduce_handler(
+    workspace_request: WorkspaceContext,
     req: HttpRequest,
-    workspace_settings: Workspace,
     user: User,
     db_conn: DbConnection,
-    schema_name: SchemaName,
 ) -> superposition::Result<HttpResponse> {
+    let schema_name = &workspace_request.schema_name;
+
     let DbConnection(mut conn) = db_conn;
     let is_approve = req
         .headers()
         .get("x-approve")
         .and_then(|value| value.to_str().ok().and_then(|s| s.parse::<bool>().ok()))
         .unwrap_or(false);
 
-    let dimensions_info_map = fetch_dimensions_info_map(&mut conn, &schema_name)?;
-    let mut config = generate_cac(&mut conn, &schema_name)?;
+    let dimensions_info_map = fetch_dimensions_info_map(&mut conn, schema_name)?;
+    let mut config = generate_cac(&mut conn, schema_name)?;
     let default_config = (config.default_configs).clone();
     for (key, _) in default_config {
         let contexts = config.contexts;
@@ -465,12 +474,11 @@ async fn reduce_handler(
             &dimensions_info_map,
             default_config.clone(),
             is_approve,
-            &schema_name,
-            &workspace_settings,
+            &workspace_request,
         )
         .await?;
         if is_approve {
-            config = generate_cac(&mut conn, &schema_name)?;
+            config = generate_cac(&mut conn, schema_name)?;
         }
     }
 
@@ -480,10 +488,7 @@ async fn reduce_handler(
 #[cfg(feature = "high-performance-mode")]
 #[authorized]
 #[get("/fast")]
-async fn get_fast_handler(
-    schema_name: SchemaName,
-    state: Data<AppState>,
-) -> superposition::Result<HttpResponse> {
+async fn get_fast_handler(state: Data<AppState>) -> superposition::Result<HttpResponse> {
     use fred::interfaces::MetricsInterface;
 
     log::debug!("Started redis fetch");
@@ -577,11 +582,11 @@ async fn get_handler(
     db_conn: DbConnection,
     dimension_params: DimensionQuery<QueryMap>,
     query_filters: superposition_query::Query<ConfigQuery>,
-    workspace_context: WorkspaceContext,
+    workspace_request: WorkspaceContext,
 ) -> superposition::Result<HttpResponse> {
     let DbConnection(mut conn) = db_conn;
 
-    let max_created_at = get_max_created_at(&mut conn, &workspace_context.schema_name)
+    let max_created_at = get_max_created_at(&mut conn, &workspace_request.schema_name)
         .map_err(|e| log::error!("failed to fetch max timestamp from event_log: {e}"))
         .ok();
 
@@ -595,12 +600,12 @@ async fn get_handler(
 
     let query_filters = query_filters.into_inner();
     let mut version =
-        get_config_version(&query_filters.version, &workspace_context, &mut conn)?;
+        get_config_version(&query_filters.version, &workspace_request, &mut conn)?;
 
     let mut config = generate_config_from_version(
         &mut version,
         &mut conn,
-        &workspace_context.schema_name,
+        &workspace_request.schema_name,
     )?;
 
     config = apply_prefix_filter_to_config(&query_filters.prefix, config)?;
@@ -619,7 +624,7 @@ async fn get_handler(
 
     let mut response = HttpResponse::Ok();
     add_last_modified_to_header(max_created_at, is_smithy, &mut response);
-    add_audit_id_to_header(&mut conn, &mut response, &workspace_context.schema_name);
+    add_audit_id_to_header(&mut conn, &mut response, &workspace_request.schema_name);
     add_config_version_to_header(&version, &mut response);
     Ok(response.json(config))
 }
@@ -636,12 +641,12 @@ async fn resolve_handler(
     db_conn: DbConnection,
     dimension_params: DimensionQuery<QueryMap>,
     query_filters: superposition_query::Query<ResolveConfigQuery>,
-    workspace_context: WorkspaceContext,
+    workspace_request: WorkspaceContext,
 ) -> superposition::Result<HttpResponse> {
     let DbConnection(mut conn) = db_conn;
     let query_filters = query_filters.into_inner();
 
-    let max_created_at = get_max_created_at(&mut conn, &workspace_context.schema_name)
+    let max_created_at = get_max_created_at(&mut conn, &workspace_request.schema_name)
         .map_err(|e| log::error!("failed to fetch max timestamp from event_log : {e}"))
         .ok();
 
@@ -650,11 +655,11 @@ async fn resolve_handler(
     }
 
     let mut config_version =
-        get_config_version(&query_filters.version, &workspace_context, &mut conn)?;
+        get_config_version(&query_filters.version, &workspace_request, &mut conn)?;
     let mut config = generate_config_from_version(
         &mut config_version,
         &mut conn,
-        &workspace_context.schema_name,
+        &workspace_request.schema_name,
     )?;
     let (is_smithy, query_data) = setup_query_data(&req, &body, &dimension_params)?;
 
@@ -664,41 +669,41 @@ async fn resolve_handler(
         merge_strategy,
         &mut conn,
         &query_filters,
-        &workspace_context,
+        &workspace_request,
     )?;
 
     let mut resp = HttpResponse::Ok();
     add_last_modified_to_header(max_created_at, is_smithy, &mut resp);
-    add_audit_id_to_header(&mut conn, &mut resp, &workspace_context.schema_name);
+    add_audit_id_to_header(&mut conn, &mut resp, &workspace_request.schema_name);
     add_config_version_to_header(&config_version, &mut resp);
     Ok(resp.json(resolved_config))
 }
 
 #[authorized]
 #[get("/versions")]
 async fn list_version_handler(
+    workspace_request: WorkspaceContext,
     db_conn: DbConnection,
     filters: Query<PaginationParams>,
-    schema_name: SchemaName,
 ) -> superposition::Result<Json<PaginatedResponse<ConfigVersionListItem>>> {
     let DbConnection(mut conn) = db_conn;
 
     if let Some(true) = filters.all {
         let config_versions = config_versions::config_versions
-            .schema_name(&schema_name)
+            .schema_name(&workspace_request.schema_name)
             .select(ConfigVersionListItem::as_select())
             .get_results(&mut conn)?;
         return Ok(Json(PaginatedResponse::all(config_versions)));
     }
 
     let n_version: i64 = config_versions::config_versions
         .count()
-        .schema_name(&schema_name)
+        .schema_name(&workspace_request.schema_name)
         .get_result(&mut conn)?;
 
     let limit = filters.count.unwrap_or(10);
     let mut builder = config_versions::config_versions
-        .schema_name(&schema_name)
+        .schema_name(&workspace_request.schema_name)
         .into_boxed()
         .order(config_versions::created_at.desc())
         .limit(limit);
@@ -720,14 +725,14 @@ async fn list_version_handler(
 #[authorized]
 #[get("/version/{version}")]
 async fn get_version_handler(
+    workspace_request: WorkspaceContext,
     db_conn: DbConnection,
     version: Path<i64>,
-    schema_name: SchemaName,
 ) -> superposition::Result<Json<ConfigVersion>> {
     let DbConnection(mut conn) = db_conn;
 
     let config_version = config_versions::config_versions
-        .schema_name(&schema_name)
+        .schema_name(&workspace_request.schema_name)
         .find(version.into_inner())
         .get_result::<ConfigVersion>(&mut conn)?;
 

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

@@ -36,24 +36,24 @@ pub fn apply_prefix_filter_to_config(
 }
 
 fn get_config_version_from_workspace(
-    workspace_context: &WorkspaceContext,
+    workspace_request: &WorkspaceContext,
     conn: &mut DBConnection,
 ) -> Option<i64> {
     match workspaces::dsl::workspaces
         .select(workspaces::config_version)
         .filter(
             workspaces::organisation_id
-                .eq(&workspace_context.organisation_id.0)
-                .and(workspaces::workspace_name.eq(&workspace_context.workspace_id.0)),
+                .eq(&workspace_request.organisation_id.0)
+                .and(workspaces::workspace_name.eq(&workspace_request.workspace_id.0)),
         )
         .get_result::<Option<i64>>(conn)
     {
         Ok(version) => version,
         Err(e) => {
             log::error!(
                 "Failed to get config_version for org_id: {}, workspace_name: {} — {:?}",
-                workspace_context.organisation_id.0,
-                workspace_context.workspace_id.0,
+                workspace_request.organisation_id.0,
+                workspace_request.workspace_id.0,
                 e
             );
             None
@@ -63,11 +63,11 @@ fn get_config_version_from_workspace(
 
 pub fn get_config_version(
     version: &Option<String>,
-    workspace_context: &WorkspaceContext,
+    workspace_request: &WorkspaceContext,
     conn: &mut DBConnection,
 ) -> superposition::Result<Option<i64>> {
     version.as_ref().map_or_else(
-        || Ok(get_config_version_from_workspace(workspace_context, conn)),
+        || Ok(get_config_version_from_workspace(workspace_request, conn)),
         |version| {
             if *version == *"latest" {
                 log::trace!("latest config request");
@@ -235,7 +235,7 @@ pub fn resolve(
     merge_strategy: Header<MergeStrategy>,
     conn: &mut DBConnection,
     query_filters: &ResolveConfigQuery,
-    workspace_context: &WorkspaceContext,
+    workspace_request: &WorkspaceContext,
 ) -> superposition::Result<Map<String, Value>> {
     if let Some(context_id) = &query_filters.context_id {
         config.contexts = if let Some(index) = config
@@ -257,7 +257,7 @@ pub fn resolve(
             &config.dimensions,
             &query_data,
             conn,
-            &workspace_context.schema_name,
+            &workspace_request.schema_name,
         )?);
     }