configuration

⚙️ RUST CONFIGURATION MANAGEMENT

TL;DR: Comprehensive patterns for configuration management in Rust applications, including multi-format parsing, validation, hot-reloading, and environment-based overrides.

🔍 CONFIGURATION STRATEGY

graph TD
    Start["Configuration Needs"] --> Format{"Configuration<br>Format?"}

    Format -->|Single| SingleFormat["Single Format Parsing"]
    Format -->|Multiple| MultiFormat["Multi-Format Support"]

    SingleFormat --> Validation["Configuration Validation"]
    MultiFormat --> Validation

    Validation --> Environment["Environment Overrides"]
    Environment --> Runtime{"Runtime<br>Updates?"}

    Runtime -->|Static| StaticConfig["Static Configuration"]
    Runtime -->|Dynamic| HotReload["Hot Reloading"]

    StaticConfig --> Testing["Configuration Testing"]
    HotReload --> Watching["File System Watching"]
    Watching --> AtomicUpdate["Atomic Updates"]
    AtomicUpdate --> Testing

    Testing --> Production["Production Configuration"]

    style Start fill:#4da6ff,stroke:#0066cc,color:white
    style MultiFormat fill:#4dbb5f,stroke:#36873f,color:white
    style HotReload fill:#ffa64d,stroke:#cc7a30,color:white
    style AtomicUpdate fill:#d94dbb,stroke:#a3378a,color:white

🎯 CONFIGURATION PRINCIPLES

Multi-Format Configuration Support

use figment::{Figment, providers::{Format, Yaml, Toml, Json, Env}};
use serde::{Deserialize, Serialize};
use validator::{Validate, ValidationError};

// ✅ Configuration structure with validation
#[derive(Debug, Clone, Serialize, Deserialize, Validate)]
#[serde(rename_all = "snake_case")]
pub struct AppConfig {
    #[validate(length(min = 1, max = 100))]
    pub name: String,

    #[validate(range(min = 1, max = 65535))]
    pub port: u16,

    #[serde(default = "default_host")]
    #[validate(length(min = 1))]
    pub host: String,

    #[serde(default)]
    pub features: Vec<String>,

    #[validate(nested)]
    pub database: DatabaseConfig,

    #[serde(default)]
    #[validate(nested)]
    pub logging: LoggingConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Validate)]
pub struct DatabaseConfig {
    #[validate(url)]
    pub url: String,

    #[validate(range(min = 1, max = 1000))]
    #[serde(default = "default_pool_size")]
    pub pool_size: u32,

    #[serde(default = "default_timeout")]
    pub timeout_seconds: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize, Validate)]
pub struct LoggingConfig {
    #[serde(default = "default_log_level")]
    pub level: String,

    #[serde(default)]
    pub json_format: bool,
}

// Default value functions
fn default_host() -> String { "0.0.0.0".to_string() }
fn default_pool_size() -> u32 { 10 }
fn default_timeout() -> u64 { 30 }
fn default_log_level() -> String { "info".to_string() }

impl AppConfig {
    /// Load configuration from multiple sources with precedence:
    /// 1. Environment variables (highest priority)
    /// 2. config.yaml file
    /// 3. config.toml file
    /// 4. Default values (lowest priority)
    pub fn load() -> Result<Self, ConfigError> {
        let config = Figment::new()
            .merge(Toml::file("config.toml"))
            .merge(Yaml::file("config.yaml"))
            .merge(Json::file("config.json"))
            .merge(Env::prefixed("APP_"))
            .extract()?;

        // Validate the configuration
        config.validate()
            .map_err(ConfigError::Validation)?;

        Ok(config)
    }

    /// Load from a specific file path
    pub fn from_file<P: AsRef<std::path::Path>>(path: P) -> Result<Self, ConfigError> {
        let path = path.as_ref();
        let extension = path.extension()
            .and_then(|ext| ext.to_str())
            .ok_or_else(|| ConfigError::UnsupportedFormat("Unknown file extension".to_string()))?;

        let figment = match extension.to_lowercase().as_str() {
            "yaml" | "yml" => Figment::new().merge(Yaml::file(path)),
            "toml" => Figment::new().merge(Toml::file(path)),
            "json" => Figment::new().merge(Json::file(path)),
            ext => return Err(ConfigError::UnsupportedFormat(ext.to_string())),
        };

        let config = figment
            .merge(Env::prefixed("APP_"))
            .extract()?;

        config.validate()
            .map_err(ConfigError::Validation)?;

        Ok(config)
    }
}