How do I read custom middleware configuration?

[ISensuiI]

How do I read custom middleware configuration?
I have defined the relevant configuration, and I have also built the middleware and loaded it successfully, but currently I can only create middleware through default values, and I can't customize the middleware configuration in yaml. I understand that I can use serialized yaml files to read, but does loco have built-in reading? Or do I need to define the entire Server part structure myself, manually serialize it, and then read it?

---

yaml config

# Web服务器配置
server:
  # 服务器将监听的端口。服务器绑定为0.0.0.0:{PORT}
  port: 5150
  # 服务器的绑定地址（绑定到哪个接口）
  binding: localhost
  # 邮件系统将指向的UI主机名或IP地址
  host: http://localhost
  # 内置中间件配置。要禁用中间件，您可以将`enable`字段更改为`false`或注释掉中间件块
  middlewares:
    # CORS 跨域资源共享配置 | Cross-Origin Resource Sharing
    cors:
      enable: false  # 是否启用 CORS 中间件 | Enable/disable CORS middleware
    # 异常捕获中间件 | Panic catching middleware
    catch_panic:
      enable: false  # 是否自动捕获 panic 并返回 500 错误 | Automatically catch panics and return 500 errors
    # ETag 缓存中间件 | ETag caching middleware
    etag:
      enable: false  # 是否启用 ETag 缓存验证 | Enable ETag cache validation
    # 请求日志中间件 | Request logging middleware
    logger:
      enable: false  # 是否记录 HTTP 请求日志 | Enable HTTP request logging
    # 请求 ID 中间件 | Request ID middleware
    request_id:
      enable: false  # 是否为每个请求生成唯一 ID | Generate unique ID for each request
    # 后备路由中间件 | Fallback route middleware
    fallback:
      enable: false  # 是否启用未匹配路由的兜底处理 | Handle unmatched routes with fallback

    # 自定义中间件

    # 幂等性中间件配置
    idempotency:
      # 启用或禁用中间件
      enable: true
      # 幂等键的请求头名称
      header_name: "Idempotency-Key"
      # 幂等键的有效期（秒）
      expiry_seconds: 88888  # 24小时
      # 是否启用缓存
      cache_enabled: true
      # 缓存键前缀
      cache_prefix: "idempotent:http:"

---

 app 
 
    fn middlewares(ctx: &AppContext) -> Vec<Box<dyn MiddlewareLayer>> {

        let mut stack = middleware::default_middleware_stack(ctx); // 保留系统中间件

        let middlewares = &ctx.config.server.middlewares;
        
        println!("middlewares{:?}",middlewares);
        
        stack.push(Box::new(IdempotencyMiddleware::new(IdempotencyConfig::default(),ctx.cache.clone()))); // 追加自定义中间件
        
        stack
    }

---

idempotency  middleware 

use axum::{body::Body, extract::{Request, Extension}, http, http::{StatusCode, Response as AxumResponse}, middleware::Next, response::Response};
use loco_rs::{
    controller::middleware::MiddlewareLayer,
    prelude::*,
    app::AppContext,
};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use std::time::Duration;
use std::sync::Arc;
use std::collections::HashMap;
use educe::Educe;
use loco_rs::cache::Cache;

// 幂等键的配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IdempotencyConfig {
    // 是否启用幂等性中间件
    #[serde(default = "default_enabled")]
    pub enable: bool,
    // 幂等键的请求头名称
    #[serde(default = "default_header_name")]
    pub header_name: String,
    // 幂等键的有效期（秒）
    #[serde(default = "default_expiry")]
    pub expiry_seconds: u64,
    // 是否启用缓存
    #[serde(default = "default_cache_enabled")]
    pub cache_enabled: bool,
    // 缓存键前缀
    #[serde(default = "default_cache_prefix")]
    pub cache_prefix: String,
}

// 默认值函数
fn default_enabled() -> bool {
    true
}

fn default_header_name() -> String {
    "Idempotency-Key".to_string()
}

fn default_expiry() -> u64 {
    86400 // 默认24小时
}

fn default_cache_enabled() -> bool {
    true
}

fn default_cache_prefix() -> String {
    "idempotent:http:".to_string()
}

// 实现默认值
impl Default for IdempotencyConfig {
    fn default() -> Self {
        Self {
            enable: default_enabled(),
            header_name: default_header_name(),
            expiry_seconds: default_expiry(),
            cache_enabled: default_cache_enabled(),
            cache_prefix: default_cache_prefix(),
        }
    }
}

// 缓存的响应元数据
#[derive(Debug, Clone, Serialize, Deserialize)]
struct CachedResponseMetadata {
    status: u16,
    headers: HashMap<String, String>,
    body: String,
    cached_at: String,
}

// 幂等性中间件结构
#[derive(Educe)]
#[educe(Debug,Clone)]
pub struct IdempotencyMiddleware {
    pub config: IdempotencyConfig,
    #[educe(Debug(ignore))]
    pub cache: Arc<Cache>,
}

// 幂等键结构，用于在请求中传递
#[derive(Debug, Clone)]
pub struct IdempotencyKey(pub Option<String>);

impl IdempotencyMiddleware {
    // 创建新的幂等性中间件实例
    pub fn new(config: IdempotencyConfig, cache: Arc<Cache>) -> Self {
        Self { config, cache }
    }

    // 空配置，用于测试
    pub fn empty(cache: Arc<Cache>) -> Self {
        Self {
            config: IdempotencyConfig::default(),
            cache,
        }
    }

    // 生成缓存键
    fn cache_key(&self, idempotency_key: &str) -> String {
        format!("{}{}", self.config.cache_prefix, idempotency_key)
    }

    // 中间件处理函数
    async fn handle_request(&self, mut req: Request<Body>, next: Next) -> Response {


        println!("handle_request self.config{:?}",self.config());

        // 如果未启用，直接传递给下一个中间件
        if !self.is_enabled() {
            return next.run(req).await;
        }

        // 从请求头提取幂等键
        let idempotency_key = req.headers()
            .get(&self.config.header_name)
            .and_then(|v| v.to_str().ok())
            .map(String::from);

        // 如果没有幂等键，则直接继续处理请求
        let Some(key) = idempotency_key.clone() else {
            // 将空的幂等键添加到请求扩展中
            req.extensions_mut().insert(IdempotencyKey(None));
            return next.run(req).await;
        };

        tracing::debug!(idempotency_key = key, "接收到幂等键请求");

        // 检查缓存中是否已有结果
        if self.config.cache_enabled {
            tracing::debug!(idempotency_key = key, "已开启缓存");
            let cache_key = self.cache_key(&key);
            
            match self.cache.get(&cache_key).await {
                Ok(Some(cached_json)) => {
                    tracing::debug!(idempotency_key = key, "找到缓存信息: {}", cached_json);

                    // 尝试解析缓存的元数据
                    match serde_json::from_str::<CachedResponseMetadata>(&cached_json) {
                        Ok(metadata) => {
                            tracing::debug!(idempotency_key = key, "解析成功");

                            // 构建响应头
                            let mut builder = Response::builder()
                                .status(StatusCode::from_u16(metadata.status).unwrap_or(StatusCode::OK));

                            // 添加响应头
                            // 添加响应头
                            for (name, value) in metadata.headers {
                                if let Ok(header_name) = name.parse::<http::header::HeaderName>() {
                                    builder = builder.header(header_name, value);
                                }
                            }

                            // 添加幂等缓存标记
                            builder = builder.header("X-Idempotent-Cached", "true");

                            // 构建响应体
                            let body = Body::from(metadata.body);

                            tracing::info!(
                                idempotency_key = key,
                                cached_at = metadata.cached_at,
                                "返回缓存的响应"
                            );

                            // 返回缓存的响应
                            return builder.body(body).unwrap_or_else(|_| {
                                Response::builder()
                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
                                    .body(Body::from("Error reconstructing cached response"))
                                    .unwrap()
                            });
                        }
                        Err(e) => {
                            tracing::warn!(
                                idempotency_key = key,
                                error = %e,
                                cached_json = %cached_json,
                                "解析缓存响应失败"
                            );
                        }
                    }
                }
                Ok(None) => {
                    // 缓存中没有找到，继续处理
                    tracing::debug!(idempotency_key = key, "缓存中未找到幂等键");
                }
                Err(e) => {
                    // 缓存访问出错，记录错误但继续处理
                    tracing::error!(
                        idempotency_key = key,
                        error = %e,
                        "访问缓存失败"
                    );
                }
            }
        }

        // 将幂等键添加到请求扩展中，以便在控制器中使用
        req.extensions_mut().insert(IdempotencyKey(Some(key.clone())));

        // 执行请求
        let mut response = next.run(req).await;

        // 缓存成功的响应
        if self.config.cache_enabled && response.status().is_success() {
            let cache_key = self.cache_key(&key);
            let expiry = Duration::from_secs(self.config.expiry_seconds);

            // 收集响应信息
            let status = response.status().as_u16();

            // 收集响应头
            let headers: HashMap<String, String> = response.headers()
                .iter()
                .filter_map(|(name, value)| {
                    value.to_str().ok().map(|v| (name.to_string(), v.to_string()))
                })
                .collect();

            // 我们不能直接读取原始响应体，因为这会消耗它
            // 所以我们只存储一个固定的响应体或空响应体
            let body = format!("{{\"message\":\"Idempotent operation completed successfully\",\"idempotency_key\":\"{}\"}}", key);

            // 创建缓存元数据
            let metadata = CachedResponseMetadata {
                status,
                headers,
                body: body.clone(),
                cached_at: chrono::Utc::now().to_rfc3339(),
            };

            // 将元数据序列化为JSON
            if let Ok(json) = serde_json::to_string(&metadata) {
                // 存储到缓存
                if let Err(e) = self.cache.insert_with_expiry(&cache_key, &json, expiry).await {
                    tracing::error!(
                        idempotency_key = key,
                        error = %e,
                        "将响应存储到缓存失败"
                    );
                } else {
                    tracing::debug!(
                        idempotency_key = key,
                        "已缓存响应，有效期{}秒",
                        self.config.expiry_seconds
                    );
                }
            }

            // 添加标记头
            response.headers_mut().insert(
                "X-Idempotent-Key",
                key.parse().unwrap_or_else(|_| "invalid-key".parse().unwrap())
            );
        }

        // 记录响应
        tracing::debug!(
            idempotency_key = key,
            status = ?response.status(),
            "幂等请求完成"
        );

        // 返回处理后的响应
        response
    }
}

// 实现MiddlewareLayer trait
impl MiddlewareLayer for IdempotencyMiddleware {
    // 中间件名称，与配置中的字段名匹配
    fn name(&self) -> &'static str {
        "idempotency"
    }

    // 返回中间件配置
    fn config(&self) -> serde_json::Result<Value> {
        serde_json::to_value(&self.config)
    }

    // 检查是否启用
    fn is_enabled(&self) -> bool {
        self.config.enable
    }

    // 应用中间件到路由器
    fn apply(&self, app: axum::Router<AppContext>) -> Result<axum::Router<AppContext>> {
        // 如果未启用，返回原始路由器
        if !self.is_enabled() {
            return Ok(app);
        }

        // 克隆self用于闭包
        let middleware_instance = self.clone();

        // 创建一个闭包作为中间件函数
        let middleware_fn = move |req: Request<Body>, next: Next| {
            let instance = middleware_instance.clone();
            async move { instance.handle_request(req, next).await }
        };

        // 将中间件应用到路由器
        let app = app.layer(axum::middleware::from_fn(middleware_fn));

        Ok(app)
    }
}

[kaplanelad]

Did you try:

cargo loco middleware --config

[pynixwang]

maybe you must use a separate config file.

[ISensuiI]

I really didn't find any relevant method