use crate::{AppError, Result};
use figment::{
providers::{Env, Format, Serialized, Toml},
Figment,
};
use serde::{Deserialize, Serialize};
use std::{collections::BTreeMap, path::Path};
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct AppConfig {
#[serde(default)]
pub storage: crate::StorageSettings,
#[serde(default)]
pub mail: crate::MailSettings,
#[serde(default)]
pub jobs: crate::JobsSettings,
#[serde(default)]
pub auth: crate::AuthSettings,
pub app: AppSettings,
pub database: DatabaseSettings,
pub server: ServerSettings,
pub http: HttpSettings,
pub api: ApiSettings,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct ApiSettings {
pub require_documented_routes: bool,
pub title: Option<String>,
pub version: String,
pub openapi: bool,
pub docs: bool,
}
impl Default for ApiSettings {
fn default() -> Self {
Self {
require_documented_routes: false,
title: None,
version: "1.0.0".into(),
openapi: false,
docs: false,
}
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct ServerSettings {
pub host: Option<String>,
pub port: Option<u16>,
pub shutdown_timeout_seconds: u64,
}
impl Default for ServerSettings {
fn default() -> Self {
Self {
host: None,
port: None,
shutdown_timeout_seconds: 10,
}
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct HttpSettings {
pub client_ip: crate::ClientIpSettings,
pub request_timeout_seconds: u64,
pub readiness_timeout_seconds: u64,
pub max_body_bytes: usize,
pub compression: bool,
}
impl Default for HttpSettings {
fn default() -> Self {
Self {
client_ip: crate::ClientIpSettings::default(),
request_timeout_seconds: 30,
readiness_timeout_seconds: 2,
max_body_bytes: 2 * 1024 * 1024,
compression: true,
}
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct AppSettings {
pub url: Option<String>,
pub name: String,
pub environment: String,
pub host: String,
pub port: u16,
}
impl Default for AppSettings {
fn default() -> Self {
Self {
url: None,
name: "Capy".into(),
environment: "development".into(),
host: "127.0.0.1".into(),
port: 8000,
}
}
}
#[derive(Clone, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct DatabaseSettings {
pub url: String,
pub max_connections: u32,
pub connect_timeout_seconds: u64,
pub min_connections: u32,
pub acquire_timeout_seconds: u64,
pub idle_timeout_seconds: u64,
}
impl std::fmt::Debug for DatabaseSettings {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DatabaseSettings")
.field("url", &"[redacted]")
.field("max_connections", &self.max_connections)
.field("connect_timeout_seconds", &self.connect_timeout_seconds)
.field("min_connections", &self.min_connections)
.field("acquire_timeout_seconds", &self.acquire_timeout_seconds)
.field("idle_timeout_seconds", &self.idle_timeout_seconds)
.finish()
}
}
impl Default for DatabaseSettings {
fn default() -> Self {
Self {
url: String::new(),
max_connections: 10,
connect_timeout_seconds: 10,
min_connections: 0,
acquire_timeout_seconds: 10,
idle_timeout_seconds: 600,
}
}
}
impl AppConfig {
pub fn load() -> Result<Self> {
Self::load_from(".")
}
pub fn load_from(root: impl AsRef<Path>) -> Result<Self> {
Self::load_sections(root.as_ref(), true, false)
}
pub fn load_for_contracts() -> Result<Self> {
Self::load_sections(Path::new("."), false, false)
}
pub fn load_for_tests(root: impl AsRef<Path>) -> Result<Self> {
let root = root.as_ref();
let base = Self::load_sections(root, false, true)?;
let mut config: Self = Figment::from(Serialized::defaults(base))
.merge(Toml::file(root.join("config/test.toml")))
.extract()
.map_err(|_| {
AppError::Configuration("Invalid test settings in config/test.toml.".into())
})?;
config.app.environment = "test".into();
config.database.url = "sqlite::memory:".into();
config.validate()?;
Ok(config)
}
fn load_sections(root: &Path, require_database: bool, test: bool) -> Result<Self> {
let mut app_env = BTreeMap::new();
let mut db_env = BTreeMap::new();
let mut server_env = BTreeMap::new();
let mut http_env = serde_json::Map::new();
let mut client_ip_env = serde_json::Map::new();
let mut api_env = BTreeMap::new();
let mut auth_env = serde_json::Map::new();
let mut password_env = serde_json::Map::new();
let mut throttle_env = serde_json::Map::new();
let mut throttle_ip_env = serde_json::Map::new();
let mut throttle_account_env = serde_json::Map::new();
let mut jobs_env = BTreeMap::new();
let mut storage_env = BTreeMap::new();
let mut mail_env = serde_json::Map::new();
let mut smtp_env = serde_json::Map::new();
match dotenvy::from_path_iter(root.join(".env")) {
Ok(entries) => {
for entry in entries {
let (key, value) = entry.map_err(|_| {
AppError::Configuration("Could not parse .env. Check its syntax.".into())
})?;
let value = if matches!(
key.as_str(),
"MAIL_SMTP_USERNAME"
| "MAIL_SMTP_PASSWORD"
| "STORAGE_ACCESS_KEY_ID"
| "STORAGE_SECRET_ACCESS_KEY"
| "STORAGE_SESSION_TOKEN"
) {
serde_json::Value::String(value)
} else {
serde_json::from_str::<serde_json::Value>(&value)
.unwrap_or(serde_json::Value::String(value))
};
if let Some(key) = key.strip_prefix("MAIL_SMTP_") {
smtp_env.insert(key.to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("MAIL_") {
mail_env.insert(key.to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("JOBS_") {
jobs_env.insert(key.to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("STORAGE_") {
storage_env.insert(key.to_lowercase(), value);
} else if key.starts_with("AUTH_PASSWORD_")
&& key != "AUTH_PASSWORD_RESET_LIFETIME_SECONDS"
{
password_env.insert(key[14..].to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("AUTH_THROTTLE_IP_") {
throttle_ip_env.insert(key.to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("AUTH_THROTTLE_ACCOUNT_") {
throttle_account_env.insert(key.to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("AUTH_THROTTLE_") {
throttle_env.insert(key.to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("AUTH_") {
auth_env.insert(key.to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("APP_") {
app_env.insert(key.to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("DATABASE_") {
db_env.insert(key.to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("SERVER_") {
server_env.insert(key.to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("HTTP_CLIENT_IP_") {
client_ip_env.insert(key.to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("HTTP_") {
http_env.insert(key.to_lowercase(), value);
} else if let Some(key) = key.strip_prefix("API_") {
api_env.insert(key.to_lowercase(), value);
}
}
}
Err(dotenvy::Error::Io(e)) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(_) => return Err(AppError::Configuration("Could not read .env.".into())),
}
let app = Figment::from(Serialized::defaults(AppSettings::default()))
.merge(Toml::file(root.join("config/app.toml")))
.merge(Serialized::defaults(app_env))
.merge(Env::prefixed("APP_"))
.extract()
.map_err(|_| {
AppError::Configuration(
"Invalid application settings. Check config/app.toml and APP_* variables."
.into(),
)
})?;
let database = Figment::from(Serialized::defaults(DatabaseSettings::default()))
.merge(Toml::file(root.join("config/database.toml")))
.merge(Serialized::defaults(db_env))
.merge(Env::prefixed("DATABASE_"))
.extract()
.map_err(|_| AppError::Configuration(
"Invalid database settings. Check config/database.toml and DATABASE_* variables.".into(),
))?;
let server = Figment::from(Serialized::defaults(ServerSettings::default()))
.merge(Toml::file(root.join("config/server.toml")))
.merge(Serialized::defaults(server_env))
.merge(Env::prefixed("SERVER_"))
.extract()
.map_err(|_| AppError::Configuration(
"Invalid server settings. Check config/server.toml and SERVER_* variables; ports must be 0..=65535 and deadlines integer seconds.".into()))?;
http_env.insert("client_ip".into(), serde_json::Value::Object(client_ip_env));
let http = Figment::from(Serialized::defaults(HttpSettings::default()))
.merge(Toml::file(root.join("config/http.toml")))
.merge(Serialized::defaults(http_env))
.merge(Env::prefixed("HTTP_").map(|key| key.as_str().to_lowercase().replacen("client_ip_", "client_ip.", 1).into()))
.extract()
.map_err(|_| AppError::Configuration(
"Invalid HTTP settings. Check config/http.toml and HTTP_* variables: deadlines use integer seconds, body limits integer bytes; client_ip.strategy must be direct/forwarded/x-forwarded-for/x-real-ip, trusted_proxies a CIDR array, and require_proxy a boolean.".into()))?;
let api = Figment::from(Serialized::defaults(ApiSettings::default()))
.merge(Toml::file(root.join("config/api.toml")))
.merge(Serialized::defaults(api_env))
.merge(Env::prefixed("API_"))
.extract()
.map_err(|_| {
AppError::Configuration(
"Invalid API settings. Check config/api.toml and API_* variables.".into(),
)
})?;
throttle_env.insert("ip".into(), serde_json::Value::Object(throttle_ip_env));
throttle_env.insert(
"account".into(),
serde_json::Value::Object(throttle_account_env),
);
auth_env.insert("throttle".into(), serde_json::Value::Object(throttle_env));
auth_env.insert("password".into(), serde_json::Value::Object(password_env));
let auth = Figment::from(Serialized::defaults(crate::AuthSettings::default()))
.merge(Toml::file(root.join("config/auth.toml")))
.merge(Serialized::defaults(auth_env))
.merge(Env::prefixed("AUTH_").map(|key| {
let key = key.as_str().to_lowercase();
if let Some(setting) = key.strip_prefix("throttle_") {
return format!("throttle.{}", setting.replacen("ip_", "ip.", 1).replacen("account_", "account.", 1)).into();
}
match key.strip_prefix("password_") {
Some(setting) if setting != "reset_lifetime_seconds" => {
format!("password.{setting}").into()
}
_ => key.into(),
}
}))
.extract()
.map_err(|_| {
AppError::Configuration(
"Invalid auth settings. Check config/auth.toml and AUTH_* variables; use [password] hash_concurrency = \"auto\" or an integer, integer cost/queue limits, and AUTH_PASSWORD_* environment overrides.".into(),
)
})?;
let jobs = Figment::from(Serialized::defaults(crate::JobsSettings::default()))
.merge(Toml::file(root.join("config/jobs.toml")))
.merge(Serialized::defaults(jobs_env))
.merge(Env::prefixed("JOBS_"))
.extract()
.map_err(|_| {
AppError::Configuration(
"Invalid jobs settings. Check config/jobs.toml and JOBS_* variables.".into(),
)
})?;
for (key, variable) in [
("access_key_id", "STORAGE_ACCESS_KEY_ID"),
("secret_access_key", "STORAGE_SECRET_ACCESS_KEY"),
("session_token", "STORAGE_SESSION_TOKEN"),
] {
match std::env::var(variable) {
Ok(value) => {
storage_env.insert(key.into(), serde_json::Value::String(value));
}
Err(std::env::VarError::NotPresent) => {}
Err(_) => {
return Err(AppError::Configuration(
"Storage credentials must be valid UTF-8 (values redacted).".into(),
))
}
}
}
let storage = Figment::from(Serialized::defaults(crate::StorageSettings::default()))
.merge(Toml::file(root.join("config/storage.toml")))
.merge(Serialized::defaults(storage_env))
.merge(Env::prefixed("STORAGE_").ignore(&["access_key_id", "secret_access_key", "session_token"]))
.extract()
.map_err(|_| AppError::Configuration("Invalid storage settings. Check config/storage.toml and STORAGE_* variables (credentials redacted).".into()))?;
for (key, variable) in [
("username", "MAIL_SMTP_USERNAME"),
("password", "MAIL_SMTP_PASSWORD"),
] {
match std::env::var(variable) {
Ok(value) => {
smtp_env.insert(key.into(), serde_json::Value::String(value));
}
Err(std::env::VarError::NotPresent) => {}
Err(_) => {
return Err(AppError::Configuration(
"SMTP credentials must be valid UTF-8 (values redacted).".into(),
));
}
}
}
mail_env.insert("smtp".into(), serde_json::Value::Object(smtp_env));
let mail = Figment::from(Serialized::defaults(crate::MailSettings::default()))
.merge(Toml::file(root.join("config/mail.toml")))
.merge(Serialized::defaults(mail_env))
.merge(Env::prefixed("MAIL_").ignore(&["smtp_username", "smtp_password"]).map(|key| key.as_str().to_lowercase().replacen("smtp_", "smtp.", 1).into()))
.extract()
.map_err(|_| AppError::Configuration("Invalid mail settings. Check config/mail.toml and MAIL_* variables (credentials redacted).".into()))?;
let mut config = Self {
storage,
mail,
jobs,
auth,
app,
database,
server,
http,
api,
};
if test {
config.app.environment = "test".into();
config.database.url = "sqlite::memory:".into();
}
config.validate_application()?;
if require_database {
config.database.validate()?;
}
Ok(config)
}
pub fn validate(&self) -> Result<()> {
self.validate_application()?;
self.database.validate()
}
fn validate_application(&self) -> Result<()> {
self.http.client_ip.validate()?;
self.auth.password.concurrency()?;
self.auth.throttle.validate()?;
self.jobs.validate()?;
self.mail.validate()?;
self.storage
.validate(self.app.environment == "production")?;
if self
.api
.title
.as_ref()
.is_some_and(|title| title.trim().is_empty())
|| self.api.version.trim().is_empty()
{
return Err(AppError::Configuration(
"API_TITLE (when set) and API_VERSION must not be empty.".into(),
));
}
if self.app.name.trim().is_empty() || self.app.host.trim().is_empty() {
return Err(AppError::Configuration(
"APP_NAME and APP_HOST cannot be empty.".into(),
));
}
if !matches!(
self.app.environment.as_str(),
"development" | "test" | "production"
) {
return Err(AppError::Configuration(
"APP_ENVIRONMENT must be development, test, or production.".into(),
));
}
if self.host().trim().is_empty() || self.host().chars().any(char::is_whitespace) {
return Err(AppError::Configuration(
"SERVER_HOST must be a hostname or IP address without whitespace.".into(),
));
}
if self.app.environment == "production" && self.port() == 0 {
return Err(AppError::Configuration(
"The production server port must be 1..=65535.".into(),
));
}
if !(1..=3600).contains(&self.server.shutdown_timeout_seconds) {
return Err(AppError::Configuration(
"SERVER_SHUTDOWN_TIMEOUT_SECONDS must be 1..=3600.".into(),
));
}
if self.http.request_timeout_seconds > 86400 {
return Err(AppError::Configuration("HTTP_REQUEST_TIMEOUT_SECONDS must be 0..=86400 (0 intentionally disables the deadline).".into()));
}
if !(1..=30).contains(&self.http.readiness_timeout_seconds) {
return Err(AppError::Configuration(
"HTTP_READINESS_TIMEOUT_SECONDS must be 1..=30.".into(),
));
}
if !(1..=1024 * 1024 * 1024).contains(&self.http.max_body_bytes) {
return Err(AppError::Configuration(
"HTTP_MAX_BODY_BYTES must be 1..=1073741824.".into(),
));
}
Ok(())
}
pub fn host(&self) -> &str {
self.server.host.as_deref().unwrap_or(&self.app.host)
}
pub fn port(&self) -> u16 {
self.server.port.unwrap_or(self.app.port)
}
}
impl DatabaseSettings {
pub fn validate(&self) -> Result<()> {
if self.url.trim().is_empty() {
return Err(AppError::Configuration(
"Database configuration error: DATABASE_URL is missing.".into(),
));
}
if !(self.url.starts_with("postgres://")
|| self.url.starts_with("postgresql://")
|| self.url.starts_with("sqlite:"))
{
return Err(AppError::Configuration(
"DATABASE_URL must use PostgreSQL or SQLite.".into(),
));
}
if self.max_connections == 0
|| self.max_connections > 10_000
|| self.min_connections > self.max_connections
|| !(1..=3600).contains(&self.connect_timeout_seconds)
|| !(1..=3600).contains(&self.acquire_timeout_seconds)
|| !(1..=86400).contains(&self.idle_timeout_seconds)
{
return Err(AppError::Configuration(
"Invalid database pool: max_connections must be 1..=10000, min_connections <= max_connections, connect/acquire timeouts 1..=3600 seconds, idle timeout 1..=86400 seconds.".into(),
));
}
Ok(())
}
}