fbc_starter/

config.rs

use serde::{Deserialize, Serialize};
use std::net::SocketAddr;

/// 应用配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
    /// 服务器配置
    pub server: ServerConfig,
    /// 日志配置
    pub log: LogConfig,
    /// CORS 配置
    pub cors: CorsConfig,
    /// 数据库配置（可选，需要启用 database 特性）
    #[serde(default)]
    #[cfg(feature = "database")]
    pub database: Option<DatabaseConfig>,
    /// Redis 配置（可选，需要启用 redis 特性）
    #[serde(default)]
    #[cfg(feature = "redis")]
    pub redis: Option<RedisConfig>,
}

/// 服务器配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServerConfig {
    /// 监听地址
    pub addr: String,
    /// 端口
    pub port: u16,
    /// 工作线程数（0 表示使用默认值）
    pub workers: Option<usize>,
    /// 上下文路径（可选），例如 "/api"，如果不配置则为空
    #[serde(default)]
    pub context_path: Option<String>,
}

impl ServerConfig {
    /// 获取完整的 SocketAddr
    pub fn socket_addr(&self) -> Result<SocketAddr, std::net::AddrParseError> {
        format!("{}:{}", self.addr, self.port).parse()
    }
}

/// 日志配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LogConfig {
    /// 日志级别 (trace, debug, info, warn, error)
    pub level: String,
    /// 是否使用 JSON 格式
    pub json: bool,
}

/// CORS 配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CorsConfig {
    /// 允许的源（* 表示允许所有）
    pub allowed_origins: Vec<String>,
    /// 允许的方法
    pub allowed_methods: Vec<String>,
    /// 允许的请求头
    pub allowed_headers: Vec<String>,
    /// 是否允许凭证
    pub allow_credentials: bool,
}

/// 数据库配置（需要启用 database 特性）
#[cfg(feature = "database")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DatabaseConfig {
    /// 数据库 URL（例如：postgres://user:password@localhost/dbname）
    pub url: String,
    /// 最大连接数
    #[serde(default = "default_max_connections")]
    pub max_connections: u32,
    /// 最小连接数
    #[serde(default = "default_min_connections")]
    pub min_connections: u32,
}

#[cfg(feature = "database")]
fn default_max_connections() -> u32 {
    100
}

#[cfg(feature = "database")]
fn default_min_connections() -> u32 {
    10
}

/// Redis 配置（需要启用 redis 特性）
#[cfg(feature = "redis")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RedisConfig {
    /// Redis URL（例如：redis://127.0.0.1:6379 或 redis://:password@127.0.0.1:6379）
    pub url: String,
    /// Redis 密码（可选，如果 URL 中已包含密码则不需要）
    #[serde(default)]
    pub password: Option<String>,
    /// 连接池大小
    #[serde(default = "default_pool_size")]
    pub pool_size: usize,
}

#[cfg(feature = "redis")]
fn default_pool_size() -> usize {
    10
}

impl Default for Config {
    fn default() -> Self {
        Self {
            server: ServerConfig {
                addr: "127.0.0.1".to_string(),
                port: 3000,
                workers: None,
                context_path: None,
            },
            log: LogConfig {
                level: "info".to_string(),
                json: false,
            },
            cors: CorsConfig {
                allowed_origins: vec!["*".to_string()],
                allowed_methods: vec![
                    "GET".to_string(),
                    "POST".to_string(),
                    "PUT".to_string(),
                    "DELETE".to_string(),
                    "PATCH".to_string(),
                    "OPTIONS".to_string(),
                ],
                allowed_headers: vec!["*".to_string()],
                // 注意：当 allowed_origins 或 allowed_headers 为 * 时，allow_credentials 会自动设置为 false
                allow_credentials: false,
            },
            #[cfg(feature = "database")]
            database: None,
            #[cfg(feature = "redis")]
            redis: None,
        }
    }
}

impl Config {
    /// 从 .env 文件和环境变量加载配置
    ///
    /// 配置项命名规则：
    /// - APP__SERVER__ADDR -> server.addr
    /// - APP__SERVER__PORT -> server.port
    /// - APP__SERVER__CONTEXT_PATH -> server.context_path (可选，例如 "/api")
    /// - APP__LOG__LEVEL -> log.level
    /// - APP__LOG__JSON -> log.json
    /// - APP__CORS__ALLOWED_ORIGINS -> cors.allowed_origins (逗号分隔)
    /// - APP__CORS__ALLOWED_METHODS -> cors.allowed_methods (逗号分隔)
    /// - APP__CORS__ALLOWED_HEADERS -> cors.allowed_headers (逗号分隔)
    /// - APP__CORS__ALLOW_CREDENTIALS -> cors.allow_credentials
    /// - APP__DATABASE__URL -> database.url (可选，需要启用 database 特性)
    /// - APP__DATABASE__MAX_CONNECTIONS -> database.max_connections (可选，默认 100)
    /// - APP__DATABASE__MIN_CONNECTIONS -> database.min_connections (可选，默认 10)
    /// - APP__REDIS__URL -> redis.url (可选，需要启用 redis 特性)
    /// - APP__REDIS__PASSWORD -> redis.password (可选，如果 URL 中已包含密码则不需要)
    /// - APP__REDIS__POOL_SIZE -> redis.pool_size (可选，默认 10)
    /// 查找项目根目录（通过查找 Cargo.toml 或 .env 文件）
    ///
    /// 查找策略（按优先级）：
    /// 1. 从可执行文件路径推断项目目录（例如 target/debug/im-server -> im-server/）
    /// 2. 从可执行文件所在目录向上查找 .env 文件
    /// 3. 从当前工作目录向上查找 .env 文件
    fn find_project_root() -> Option<std::path::PathBuf> {
        // 策略 1: 从可执行文件路径推断项目目录
        // 例如：/path/to/hula-server/target/debug/im-server -> /path/to/hula-server/im-server/
        if let Ok(exe_path) = std::env::current_exe() {
            // 获取可执行文件名（例如 "im-server"）
            if let Some(exe_name) = exe_path.file_stem().and_then(|s| s.to_str()) {
                // 从可执行文件路径向上查找，直到找到 workspace 根目录或项目根目录
                if let Some(exe_dir) = exe_path.parent() {
                    let mut path = exe_dir.to_path_buf();
                    loop {
                        // 检查当前目录的父目录是否包含与可执行文件同名的目录
                        if let Some(parent) = path.parent() {
                            let project_dir = parent.join(exe_name);
                            // 如果找到同名目录且包含 .env 文件，这就是项目根目录
                            if project_dir.join(".env").exists() {
                                return Some(project_dir);
                            }
                            // 如果找到同名目录且包含 Cargo.toml（非 workspace），这也是项目根目录
                            let cargo_toml = project_dir.join("Cargo.toml");
                            if cargo_toml.exists() {
                                if let Ok(content) = std::fs::read_to_string(&cargo_toml) {
                                    if !content.contains("[workspace]") {
                                        return Some(project_dir);
                                    }
                                }
                            }
                        }
                        // 检查当前目录是否有 .env 文件
                        if path.join(".env").exists() {
                            return Some(path);
                        }
                        // 向上查找
                        match path.parent() {
                            Some(parent) => path = parent.to_path_buf(),
                            None => break,
                        }
                    }
                }
            }
        }

        // 策略 2: 从当前工作目录向上查找 .env 文件
        if let Ok(mut current_dir) = std::env::current_dir() {
            loop {
                if current_dir.join(".env").exists() {
                    // 检查是否是 workspace 根目录
                    let cargo_toml = current_dir.join("Cargo.toml");
                    if cargo_toml.exists() {
                        if let Ok(content) = std::fs::read_to_string(&cargo_toml) {
                            if content.contains("[workspace]") {
                                // 这是 workspace 根目录，但找到了 .env，返回当前目录
                                return Some(current_dir);
                            }
                        }
                    }
                    return Some(current_dir);
                }
                match current_dir.parent() {
                    Some(parent) => current_dir = parent.to_path_buf(),
                    None => break,
                }
            }
        }

        None
    }

    pub fn from_env() -> Result<Self, config::ConfigError> {
        // 加载 .env 文件（如果存在）
        // 优先从项目根目录加载，确保当库被其他项目使用时能正确找到 .env 文件

        // 方法 1: 使用 CARGO_MANIFEST_DIR 环境变量（编译时设置，最可靠）
        if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
            let env_path = std::path::Path::new(&manifest_dir).join(".env");
            if env_path.exists() {
                if dotenvy::from_path(&env_path).is_ok() {
                    eprintln!(
                        "✓ 从 CARGO_MANIFEST_DIR 加载 .env 文件: {}",
                        env_path.display()
                    );
                    return Self::load_config_from_env();
                }
            }
        }

        // 方法 2: 从项目根目录加载（通过查找逻辑）
        if let Some(project_root) = Self::find_project_root() {
            let env_path = project_root.join(".env");
            if env_path.exists() {
                if dotenvy::from_path(&env_path).is_ok() {
                    eprintln!("✓ 从项目根目录加载 .env 文件: {}", env_path.display());
                    return Self::load_config_from_env();
                }
            }
        }

        // 方法 3: 使用 dotenvy::dotenv() 从当前工作目录向上查找（备用方案）
        match dotenvy::dotenv() {
            Ok(path) => {
                eprintln!("✓ 从当前工作目录向上查找加载 .env 文件: {}", path.display());
            }
            Err(_) => {
                eprintln!("⚠ 未找到 .env 文件，将使用环境变量和默认配置");
            }
        }

        Self::load_config_from_env()
    }

    /// 从环境变量加载配置（内部方法）
    fn load_config_from_env() -> Result<Self, config::ConfigError> {
        // 先手动处理数组类型的配置项，设置默认值
        let mut default_origins = vec!["*".to_string()];
        let mut default_methods = vec![
            "GET".to_string(),
            "POST".to_string(),
            "PUT".to_string(),
            "DELETE".to_string(),
            "PATCH".to_string(),
            "OPTIONS".to_string(),
        ];
        let mut default_headers = vec!["*".to_string()];

        // 从环境变量读取数组配置
        if let Ok(origins_str) = std::env::var("APP__CORS__ALLOWED_ORIGINS") {
            default_origins = origins_str
                .split(',')
                .map(|s| s.trim().to_string())
                .collect();
        }

        if let Ok(methods_str) = std::env::var("APP__CORS__ALLOWED_METHODS") {
            default_methods = methods_str
                .split(',')
                .map(|s| s.trim().to_string())
                .collect();
        }

        if let Ok(headers_str) = std::env::var("APP__CORS__ALLOWED_HEADERS") {
            default_headers = headers_str
                .split(',')
                .map(|s| s.trim().to_string())
                .collect();
        }

        // 临时移除这些环境变量，避免 config crate 尝试解析它们
        let origins_backup = std::env::var("APP__CORS__ALLOWED_ORIGINS").ok();
        let methods_backup = std::env::var("APP__CORS__ALLOWED_METHODS").ok();
        let headers_backup = std::env::var("APP__CORS__ALLOWED_HEADERS").ok();

        if origins_backup.is_some() {
            std::env::remove_var("APP__CORS__ALLOWED_ORIGINS");
        }
        if methods_backup.is_some() {
            std::env::remove_var("APP__CORS__ALLOWED_METHODS");
        }
        if headers_backup.is_some() {
            std::env::remove_var("APP__CORS__ALLOWED_HEADERS");
        }

        let builder = config::Config::builder()
            .set_default("server.addr", "127.0.0.1")?
            .set_default("server.port", 3000)?
            .set_default("log.level", "info")?
            .set_default("log.json", false)?
            .set_default("cors.allowed_origins", default_origins.clone())?
            .set_default("cors.allowed_methods", default_methods.clone())?
            .set_default("cors.allowed_headers", default_headers.clone())?
            .set_default("cors.allow_credentials", false)?
            .add_source(config::Environment::with_prefix("APP").separator("__"));

        let config = builder.build()?;
        let result: Config = config.try_deserialize()?;

        Ok(result)
    }
}