fix: config endpoint

Signed-off-by: bkioshn <[email protected]>

catalyst-gateway/bin/src/db/event/config/key.rs

@@ -2,7 +2,7 @@
 
 use std::{net::IpAddr, sync::LazyLock};
 
-use serde_json::Value;
+use serde_json::{json, Value};
 use tracing::error;
 
 /// Configuration key
@@ -15,19 +15,21 @@ pub(crate) enum ConfigKey {
 }
 
 /// Frontend schema configuration.
-static FRONTEND_SCHEMA: LazyLock<Option<Value>> =
+static FRONTEND_SCHEMA: LazyLock<Value> =
     LazyLock::new(|| load_json_lazy(include_str!("jsonschema/frontend.json")));
 
 /// Frontend default configuration.
-static FRONTEND_DEFAULT: LazyLock<Option<Value>> =
+static FRONTEND_DEFAULT: LazyLock<Value> =
     LazyLock::new(|| load_json_lazy(include_str!("default/frontend.json")));
 
 /// Helper function to convert a JSON string to a JSON value.
-fn load_json_lazy(data: &str) -> Option<Value> {
-    let json = serde_json::from_str(data);
-
-    json.inspect_err(|e| error!("Error parsing JSON : {e}"))
-        .ok()
+fn load_json_lazy(data: &str) -> Value {
+    serde_json::from_str(data).unwrap_or_else(|e| {
+        // Log the error
+        error!("Error parsing JSON: {}", e);
+        // And return an empty JSON object
+        json!({})
+    })
 }
 
 impl ConfigKey {
@@ -48,25 +50,20 @@ impl ConfigKey {
             ConfigKey::Frontend | ConfigKey::FrontendForIp(_) => &*FRONTEND_SCHEMA,
         };
 
-        let Some(schema) = schema else {
-            return Err(anyhow::anyhow!("Failed to retrieve JSON schema"));
-        };
         let validator = jsonschema::validator_for(schema)
             .map_err(|e| anyhow::anyhow!("Failed to create JSON validator: {:?}", e))?;
 
         // Validate the value against the schema
-        anyhow::ensure!(validator.is_valid(value), "Invalid configuration");
+        anyhow::ensure!(validator.is_valid(value), "Failed schema validation");
         Ok(())
     }
 
     /// Retrieve the default configuration value.
-    pub(super) fn default(&self) -> Option<Value> {
+    pub(super) fn default(&self) -> Value {
         // Retrieve the default value based on the ConfigKey
-        let default = match self {
-            ConfigKey::Frontend | ConfigKey::FrontendForIp(_) => &*FRONTEND_DEFAULT,
-        };
-
-        default.clone()
+        match self {
+            ConfigKey::Frontend | ConfigKey::FrontendForIp(_) => FRONTEND_DEFAULT.clone(),
+        }
     }
 }
 
@@ -88,6 +85,6 @@ mod tests {
     #[test]
     fn test_default() {
         let result = ConfigKey::Frontend.default();
-        assert!(result.is_some());
+        assert!(result.is_object());
     }
 }

catalyst-gateway/bin/src/db/event/config/mod.rs

@@ -31,8 +31,7 @@ impl Config {
             Ok(value)
         } else {
             // If data not found return default config value
-            id.default()
-                .ok_or(anyhow::anyhow!("Default value not found for {:?}", id))
+            Ok(id.default())
         }
     }
 

catalyst-gateway/bin/src/service/api/config/mod.rs

@@ -2,12 +2,10 @@
 
 use std::{net::IpAddr, str::FromStr};
 
-use poem_openapi::{
-    param::{Header, Query},
-    payload::Json,
-    ApiResponse, OpenApi,
-};
+use poem::web::RealIp;
+use poem_openapi::{param::Query, payload::Json, ApiResponse, OpenApi};
 use serde_json::Value;
+use tracing::info;
 
 use crate::{
     db::event::config::{key::ConfigKey, Config},
@@ -34,35 +32,22 @@ enum Responses {
 #[OpenApi(tag = "ApiTags::Config")]
 impl ConfigApi {
     /// Get the configuration for the frontend.
-    /// Retrieving IP from X-Forwarded-For header if provided.
-    /// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For
+    ///
+    /// Retrieving IP from X-Real-IP, Forwarded, X-Forwarded-For or Remote Address.
     #[oai(
         path = "/draft/config/frontend",
         method = "get",
         operation_id = "get_config_frontend"
     )]
-    async fn get_frontend(
-        &self, #[oai(name = "X-Forwarded-For")] header: Header<Option<String>>,
-    ) -> Responses {
-        // Retrieve the IP address from the header
-        // According to the X-Forwarded-For header spec, the first value is the IP address
-        let ip_address = header
-            .0
-            .as_ref()
-            .and_then(|h| h.split(',').next())
-            .map(String::from);
+    async fn get_frontend(&self, ip_address: RealIp) -> Responses {
+        info!("IP Address: {:?}", ip_address.0);
 
         // Fetch the general configuration
         let general_config = Config::get(ConfigKey::Frontend).await;
 
         // Attempt to fetch the IP configuration
-        let ip_config = if let Some(ip) = ip_address {
-            match IpAddr::from_str(&ip) {
-                Ok(parsed_ip) => Config::get(ConfigKey::FrontendForIp(parsed_ip)).await.ok(),
-                Err(_) => {
-                    return Responses::BadRequest(Json(format!("Invalid IP address: {ip}")));
-                },
-            }
+        let ip_config = if let Some(ip) = ip_address.0 {
+            Config::get(ConfigKey::FrontendForIp(ip)).await.ok()
         } else {
             None
         };
@@ -84,7 +69,7 @@ impl ConfigApi {
         }
     }
 
-    /// Insert or update the frontend configuration.
+    /// Set the frontend configuration.
     #[oai(
         path = "/draft/config/frontend",
         method = "put",