feat(cat-gateway): config API

.config/dictionaries/project.dic

@@ -119,6 +119,7 @@ Joaquín
 jorm
 jormungandr
 Jörmungandr
+jsonschema
 junitreport
 junitxml
 Keyhash

catalyst-gateway/bin/Cargo.toml

@@ -93,6 +93,7 @@ base64 = "0.22.1"
 dashmap = "6.1.0"
 x509-cert = "0.2.5"
 der-parser = "9.0.0"
+jsonschema = "0.22.3"
 
 [dev-dependencies]
 proptest = "1.5.0"

catalyst-gateway/bin/src/db/event/config/default/frontend.json

@@ -0,0 +1 @@
+{}

catalyst-gateway/bin/src/db/event/config/jsonschema/frontend.json

@@ -0,0 +1,4 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object"
+}

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

@@ -0,0 +1,90 @@
+//! Configuration Key
+
+use std::net::IpAddr;
+
+use serde_json::Value;
+
+/// Configuration key
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) enum ConfigKey {
+    /// Frontend general configuration
+    Frontend,
+    /// Frontend configuration for a specific IP address
+    FrontendForIp(IpAddr),
+}
+
+/// Frontend JSON schema
+const FRONTEND_JSON_SCHEMA: &str = include_str!("jsonschema/frontend.json");
+/// Default frontend configuration
+const FRONTEND_DEFAULT: &str = include_str!("default/frontend.json");
+
+impl ConfigKey {
+    /// Create a `ConfigKey` from ids.
+    pub(crate) fn from_id(id1: &str, id2: &str, id3: &str) -> Option<Self> {
+        match (id1, id2, id3) {
+            ("frontend", "", "") => Some(ConfigKey::Frontend),
+            ("frontend", "ip", ip) => ip.parse().ok().map(ConfigKey::FrontendForIp),
+            _ => None,
+        }
+    }
+
+    /// Convert a `ConfigKey` to its ids.
+    pub(super) fn to_id(&self) -> (String, String, String) {
+        match self {
+            ConfigKey::Frontend => ("frontend".to_string(), String::new(), String::new()),
+            ConfigKey::FrontendForIp(ip) => {
+                ("frontend".to_string(), "ip".to_string(), ip.to_string())
+            },
+        }
+    }
+
+    /// Validate the provided value against the JSON schema.
+    pub(super) fn validate(&self, value: &Value) -> anyhow::Result<()> {
+        let schema: Value = serde_json::from_str(FRONTEND_JSON_SCHEMA)
+            .map_err(|e| anyhow::anyhow!("Failed to parse JSON schema: {:?}", e))?;
+
+        let validator = jsonschema::validator_for(&schema)
+            .map_err(|e| anyhow::anyhow!("Failed to create JSON validator: {:?}", e))?;
+
+        if validator.is_valid(value) {
+            Ok(())
+        } else {
+            Err(anyhow::anyhow!(
+                "Provided JSON value does not match the schema for {:?}.",
+                self
+            ))
+        }
+    }
+
+    /// Retrieve the default configuration value.
+    pub(super) fn default(&self) -> anyhow::Result<Value> {
+        let default_value: Value = serde_json::from_str(FRONTEND_DEFAULT)
+            .map_err(|e| anyhow::anyhow!("Failed to parse default JSON: {:?}", e))?;
+
+        match self {
+            ConfigKey::Frontend | ConfigKey::FrontendForIp(_) => Ok(default_value),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    #[test]
+    fn test_validate() {
+        let value = json!({
+            "test": "test"
+        });
+        let result = ConfigKey::Frontend.validate(&value);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_default() {
+        let result = ConfigKey::Frontend.default();
+        assert!(result.is_ok());
+    }
+}

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

@@ -0,0 +1,48 @@
+//! Configuration query
+
+use key::ConfigKey;
+use serde_json::Value;
+
+use crate::db::event::EventDB;
+
+pub(crate) mod key;
+
+/// Configuration struct
+pub(crate) struct Config {}
+
+/// SQL get configuration
+const GET_CONFIG: &str = include_str!("sql/get.sql");
+/// SQL insert configuration
+const INSERT_CONFIG: &str = include_str!("sql/insert.sql");
+
+impl Config {
+    /// Retrieve configuration based on the given `ConfigKey`.
+    ///
+    /// # Returns
+    ///
+    /// - A JSON value of the configuration, if not found, returns the default value.
+    pub(crate) async fn get(id: ConfigKey) -> anyhow::Result<Value> {
+        let (id1, id2, id3) = id.to_id();
+        let rows = EventDB::query(GET_CONFIG, &[&id1, &id2, &id3]).await?;
+
+        if let Some(row) = rows.first() {
+            let value: Value = row.get(0);
+            id.validate(&value).map_err(|e| anyhow::anyhow!(e))?;
+            return Ok(value);
+        }
+
+        // If data not found return default config value
+        id.default()
+    }
+
+    /// Insert configuration for the given `ConfigKey`.
+    pub(crate) async fn insert(id: ConfigKey, value: Value) -> anyhow::Result<()> {
+        // Validate the value before inserting
+        id.validate(&value)?;
+
+        let (id1, id2, id3) = id.to_id();
+        EventDB::query(INSERT_CONFIG, &[&id1, &id2, &id3, &value]).await?;
+
+        Ok(())
+    }
+}

catalyst-gateway/bin/src/db/event/config/sql/get.sql

@@ -0,0 +1,3 @@
+SELECT value
+FROM config
+WHERE id1 = $1 AND id2 = $2 AND id3 = $3;

catalyst-gateway/bin/src/db/event/config/sql/insert.sql

@@ -0,0 +1,2 @@
+INSERT INTO config (id1, id2, id3, value)
+VALUES ($1, $2, $3, $4)

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

@@ -14,6 +14,7 @@ use tracing::{debug, debug_span, error, Instrument};
 
 use crate::settings::Settings;
 
+pub(crate) mod config;
 pub(crate) mod error;
 pub(crate) mod legacy;
 pub(crate) mod schema_check;

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

@@ -0,0 +1,100 @@
+//! Configuration Endpoints
+
+use std::{net::IpAddr, str::FromStr};
+
+use poem_openapi::{param::Path, payload::Json, ApiResponse, Multipart, OpenApi};
+
+use crate::{
+    db::event::config::{key::ConfigKey, Config},
+    service::common::tags::ApiTags,
+};
+
+/// Configuration API struct
+pub(crate) struct ConfigApi;
+
+/// Endpoint responses
+#[derive(ApiResponse)]
+enum Responses {
+    /// Configuration result
+    #[oai(status = 200)]
+    Ok(Json<String>),
+    /// Configuration not found
+    #[oai(status = 404)]
+    NotFound(Json<String>),
+    /// Bad request
+    #[oai(status = 400)]
+    BadRequest(Json<String>),
+}
+
+/// Configuration insert request
+#[derive(Multipart)]
+struct ConfigInsertRequest {
+    /// ID1 of config table
+    id1: String,
+    /// ID2 of config table
+    id2: Option<String>,
+    /// ID3 of config table
+    id3: Option<String>,
+    /// Value of config table
+    value: String,
+}
+
+#[OpenApi(prefix_path = "/config", tag = "ApiTags::Config")]
+impl ConfigApi {
+    /// Get the general configuration
+    #[oai(path = "/", method = "get", operation_id = "get_general_config")]
+    async fn get_general(&self) -> Responses {
+        match Config::get(ConfigKey::Frontend).await {
+            Ok(config) => Responses::Ok(Json(config.to_string())),
+            Err(err) => Responses::NotFound(Json(err.to_string())),
+        }
+    }
+
+    /// Get configuration for a specific IP
+    #[oai(path = "/:ip", method = "get", operation_id = "get_ip_config")]
+    async fn get_with_ip(&self, ip: Path<String>) -> Responses {
+        match IpAddr::from_str(&ip.0) {
+            Ok(parsed_ip) => {
+                match Config::get(ConfigKey::FrontendForIp(parsed_ip)).await {
+                    Ok(config) => Responses::Ok(Json(config.to_string())),
+                    Err(err) => Responses::NotFound(Json(err.to_string())),
+                }
+            },
+            Err(err) => Responses::BadRequest(Json(format!("Invalid IP address: {err}"))),
+        }
+    }
+
+    /// Insert configuration
+    #[oai(path = "/insert", method = "post", operation_id = "insert_config")]
+    async fn insert(&self, payload: ConfigInsertRequest) -> Responses {
+        let config_key = ConfigKey::from_id(
+            &payload.id1,
+            &payload.id2.unwrap_or_default(),
+            &payload.id3.unwrap_or_default(),
+        );
+
+        if let Some(config_key) = config_key {
+            match serde_json::from_str(&payload.value) {
+                Ok(parsed_value) => {
+                    match Config::insert(config_key, parsed_value).await {
+                        Ok(()) => {
+                            Responses::Ok(Json("Configuration inserted successfully.".to_string()))
+                        },
+                        Err(err) => {
+                            Responses::BadRequest(Json(format!(
+                                "Failed to insert configuration: {err}"
+                            )))
+                        },
+                    }
+                },
+                Err(err) => {
+                    Responses::BadRequest(Json(format!("Failed to parse JSON value: {err}")))
+                },
+            }
+        } else {
+            Responses::BadRequest(Json(
+                "Invalid configuration key derives from ids.".to_string(),
+            ))
+        }
+    }
+}

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

@@ -4,6 +4,7 @@
 //! It however does NOT contain any processing for them, that is defined elsewhere.
 use std::net::IpAddr;
 
+use config::ConfigApi;
 use gethostname::gethostname;
 use health::HealthApi;
 use legacy::LegacyApi;
@@ -15,6 +16,7 @@ use crate::settings::Settings;
 /// Auth
 mod auth;
 pub(crate) mod cardano;
+mod config;
 mod health;
 mod legacy;
 
@@ -59,11 +61,12 @@ const TERMS_OF_SERVICE: &str =
     "https://github.com/input-output-hk/catalyst-voices/blob/main/CODE_OF_CONDUCT.md";
 
 /// Create the `OpenAPI` definition
-pub(crate) fn mk_api() -> OpenApiService<(HealthApi, CardanoApi, LegacyApi), ()> {
+pub(crate) fn mk_api() -> OpenApiService<(HealthApi, CardanoApi, ConfigApi, LegacyApi), ()> {
     let mut service = OpenApiService::new(
         (
             HealthApi,
             CardanoApi,
+            ConfigApi,
             (legacy::RegistrationApi, legacy::V0Api, legacy::V1Api),
         ),
         API_TITLE,

catalyst-gateway/bin/src/service/common/tags.rs

@@ -17,4 +17,6 @@ pub(crate) enum ApiTags {
     V0,
     /// API Version 1 Endpoints
     V1,
+    /// Config
+    Config,
 }