eeff292
use std::path::{Path, PathBuf};
use std::{env, fs};
use figment::Figment;
use figment::providers::{Env, Serialized};
use serde::de::DeserializeOwned;
use crate::AppConfig;
use crate::error::{ConfigError, ConfigLoadError};
pub const ENV_PREFIX: &str = "APP_";
pub const ENV_SEPARATOR: &str = "__";
pub const CONFIG_DIR: &str = "config";
pub const DEFAULT_PROFILE: &str = "default";
pub const LOCAL_PROFILE: &str = "local";
pub const PROD_PROFILE: &str = "prod";
pub const PROFILE_VAR: &str = "APP_ENV";
pub fn figment() -> Result<Figment, ConfigError> {
let _ = dotenvy::dotenv();
let profile = profile()?;
let mut figment = Figment::new();
figment = merge_profile(figment, DEFAULT_PROFILE)?;
if profile != DEFAULT_PROFILE {
figment = merge_profile(figment, &profile)?;
}
Ok(figment.merge(Env::prefixed(ENV_PREFIX).split(ENV_SEPARATOR)))
}
pub fn profile() -> Result<String, ConfigError> {
let profile = env::var(PROFILE_VAR)
.ok()
.map(|value| value.trim().to_ascii_lowercase())
.filter(|value| !value.is_empty())
.unwrap_or_else(|| LOCAL_PROFILE.to_owned());
match profile.as_str() {
DEFAULT_PROFILE | LOCAL_PROFILE | PROD_PROFILE => Ok(profile),
other => Err(ConfigError::Validation(format!(
"{PROFILE_VAR} must be one of {DEFAULT_PROFILE}, {LOCAL_PROFILE}, {PROD_PROFILE}; got `{other}`"
))),
}
}
fn merge_profile(mut figment: Figment, profile: &str) -> Result<Figment, ConfigError> {
let dir = Path::new(CONFIG_DIR).join(profile);
let entries = match fs::read_dir(&dir) {
Ok(entries) => entries,
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(figment),
Err(error) => return Err(ConfigError::Io(error)),
};
let mut files: Vec<PathBuf> = entries
.filter_map(Result::ok)
.map(|entry| entry.path())
.filter(|path| {
path.extension()
.and_then(|extension| extension.to_str())
.is_some_and(|extension| extension.eq_ignore_ascii_case("json"))
})
.collect();
files.sort();
for path in files {
let Some(key) = path.file_stem().and_then(|stem| stem.to_str()) else {
continue;
};
let text = fs::read_to_string(&path)?;
let value: serde_json::Value = serde_json::from_str(&text).map_err(|error| {
ConfigError::Validation(format!("failed to parse {}: {error}", path.display()))
})?;
let mut domain = serde_json::Map::new();
domain.insert(key.to_owned(), value);
figment = figment.merge(Serialized::defaults(serde_json::Value::Object(domain)));
}
Ok(figment)
}
pub fn load_default() -> Result<AppConfig, ConfigError> {
let cfg: AppConfig = figment()?.extract().map_err(ConfigError::from)?;
cfg.validate()?;
Ok(cfg)
}
pub trait Section {
const KEY: &'static str;
}
#[derive(Debug, Clone)]
pub struct Config {
path: PathBuf,
figment: Figment,
}
impl Config {
pub fn from_value(value: serde_json::Value) -> Self {
Self {
path: PathBuf::from(CONFIG_DIR),
figment: Figment::from(Serialized::defaults(value)),
}
}
pub fn path(&self) -> &Path {
&self.path
}
pub fn section<T: Section + DeserializeOwned>(&self) -> Result<T, ConfigLoadError> {
if !self.has(T::KEY) {
return Err(ConfigLoadError::Section {
key: T::KEY.to_owned(),
path: self.path.clone(),
});
}
self.get(T::KEY)
}
pub fn get<T: DeserializeOwned>(&self, key: &str) -> Result<T, ConfigLoadError> {
self.figment
.extract_inner(key)
.map_err(|error| ConfigLoadError::Load {
path: self.path.clone(),
message: format!("{key}: {error}"),
})
}
pub fn has(&self, key: &str) -> bool {
self.figment.find_value(key).is_ok()
}
}