use serde::{Deserialize, Serialize};
fn fluxweir_config_message(
key: &str,
english: impl std::fmt::Display,
args: &[(&str, String)],
) -> String {
match crate::i18n::startup_i18n() {
Some((locale, bundle)) => crate::i18n::t_with_args(locale, bundle, key, args),
None => english.to_string(),
}
}
#[derive(Clone, Deserialize, Serialize, confers::Config)]
#[config(env_prefix = "CRAWLRS__FLUXWEIR__")]
pub struct FluxweirSettings {
#[config(default = false)]
pub enabled: bool,
#[config(default = "embedded".to_string())]
pub mode: String,
#[config(default = "127.0.0.1:8900".to_string())]
pub listen_addr: String,
#[config(default = String::new())]
pub api_key_env: String,
#[config(default = String::new())]
pub config_path: String,
#[config(default = String::new())]
pub external_base_url: String,
#[config(default = false)]
pub trusted_proxy: bool,
#[config(default = 120)]
pub request_timeout_secs: u64,
#[config(default = true)]
pub rag_fallback: bool,
pub(crate) api_key: Option<String>,
}
impl std::fmt::Debug for FluxweirSettings {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("FluxweirSettings")
.field("enabled", &self.enabled)
.field("mode", &self.mode)
.field("listen_addr", &self.listen_addr)
.field("api_key_env", &self.api_key_env)
.field("config_path", &self.config_path)
.field("external_base_url", &self.external_base_url)
.field("trusted_proxy", &self.trusted_proxy)
.field("request_timeout_secs", &self.request_timeout_secs)
.field("rag_fallback", &self.rag_fallback)
.field("api_key", &"[REDACTED]")
.finish()
}
}
impl FluxweirSettings {
pub fn api_key(&self) -> Option<String> {
if let Some(key) = self.api_key.as_deref() {
if !key.trim().is_empty() {
return Some(key.to_string());
}
}
let env_name = self.api_key_env.trim();
if env_name.is_empty() {
return None;
}
std::env::var(env_name)
.ok()
.filter(|value| !value.trim().is_empty())
}
pub fn validate(&self) -> Result<(), String> {
if !self.enabled {
return Ok(());
}
self.validate_mode_and_endpoint()?;
self.validate_credentials_and_timeout()
}
fn validate_mode_and_endpoint(&self) -> Result<(), String> {
match self.mode.as_str() {
"embedded" | "external" => {}
other => {
return Err(fluxweir_config_message(
"fluxweir-config-mode-invalid",
format!(
"invalid fluxweir.mode value \"{other}\" (supported: embedded/external)"
),
&[("value", other.to_string())],
));
}
}
if self.mode == "embedded" && self.listen_addr.trim().is_empty() {
return Err(fluxweir_config_message(
"fluxweir-config-listen-addr-empty",
"fluxweir.listen_addr cannot be empty when fluxweir.mode = \"embedded\"",
&[],
));
}
if self.mode == "external" && self.external_base_url.trim().is_empty() {
return Err(fluxweir_config_message(
"fluxweir-config-external-base-url-empty",
"fluxweir.external_base_url cannot be empty when fluxweir.mode = \"external\"",
&[],
));
}
Ok(())
}
fn validate_credentials_and_timeout(&self) -> Result<(), String> {
if self.api_key().is_none() {
return Err(fluxweir_config_message(
"fluxweir-config-api-key-missing",
"fluxweir requires an API key: set fluxweir.api_key_env to the environment \
variable holding the key, or configure the key directly",
&[],
));
}
if self.request_timeout_secs == 0 || self.request_timeout_secs > 600 {
return Err(fluxweir_config_message(
"fluxweir-config-timeout-invalid",
"fluxweir.request_timeout_secs must be within 1..=600",
&[],
));
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_default_all_disabled() {
let settings = FluxweirSettings::default();
assert!(!settings.enabled);
assert_eq!(settings.mode, "embedded");
assert_eq!(settings.listen_addr, "127.0.0.1:8900");
assert!(!settings.trusted_proxy);
assert!(settings.rag_fallback);
assert_eq!(settings.request_timeout_secs, 120);
assert!(settings.validate().is_ok());
}
#[test]
fn test_validate_mode_invalid() {
let settings = FluxweirSettings {
enabled: true,
mode: "sidecar".to_string(),
api_key: Some("k".to_string()),
..FluxweirSettings::default()
};
let err = settings.validate().unwrap_err();
assert!(err.contains("sidecar"), "error must name the value: {err}");
}
#[test]
fn test_validate_enabled_requires_key() {
let settings = FluxweirSettings {
enabled: true,
api_key: None,
api_key_env: String::new(),
..FluxweirSettings::default()
};
let err = settings.validate().unwrap_err();
assert!(
err.contains("api_key_env") || err.contains("API key"),
"error must point at key configuration: {err}"
);
}
#[test]
fn test_validate_embedded_requires_listen_addr() {
let settings = FluxweirSettings {
enabled: true,
mode: "embedded".to_string(),
listen_addr: String::new(),
api_key: Some("k".to_string()),
..FluxweirSettings::default()
};
let err = settings.validate().unwrap_err();
assert!(
err.contains("listen_addr"),
"error must name listen_addr: {err}"
);
}
#[test]
fn test_validate_external_skips_listen_addr() {
let settings = FluxweirSettings {
enabled: true,
mode: "external".to_string(),
listen_addr: String::new(),
external_base_url: "http://llm-gw:8080".to_string(),
api_key: Some("k".to_string()),
..FluxweirSettings::default()
};
assert!(settings.validate().is_ok());
}
#[test]
fn test_validate_external_requires_base_url() {
let settings = FluxweirSettings {
enabled: true,
mode: "external".to_string(),
external_base_url: String::new(),
api_key: Some("k".to_string()),
..FluxweirSettings::default()
};
let err = settings.validate().unwrap_err();
assert!(
err.contains("external_base_url"),
"error must name external_base_url: {err}"
);
}
#[test]
fn test_validate_timeout_bounds() {
let base = FluxweirSettings {
enabled: true,
api_key: Some("k".to_string()),
..FluxweirSettings::default()
};
let zero = FluxweirSettings {
request_timeout_secs: 0,
..base.clone()
};
assert!(zero.validate().is_err());
let over = FluxweirSettings {
request_timeout_secs: 601,
..base
};
assert!(over.validate().is_err());
}
#[test]
fn test_debug_redacts_api_key() {
let settings = FluxweirSettings {
api_key: Some("super-secret".to_string()), ..FluxweirSettings::default()
};
let rendered = format!("{settings:?}");
assert!(
!rendered.contains("super-secret"),
"debug must redact: {rendered}"
);
assert!(rendered.contains("[REDACTED]"));
}
#[test]
fn test_api_key_resolution_direct_first() {
let settings = FluxweirSettings {
api_key: Some("direct".to_string()), api_key_env: "CRAWLRS_TEST_FLUXWEIR_UNSET_ENV".to_string(), ..FluxweirSettings::default()
};
assert_eq!(settings.api_key().as_deref(), Some("direct"));
}
#[test]
fn test_api_key_resolution_env_fallback() {
let env_name = "CRAWLRS_TEST_FLUXWEIR_KEY_RESOLVE";
std::env::set_var(env_name, "from-env");
let settings = FluxweirSettings {
api_key_env: env_name.to_string(),
..FluxweirSettings::default()
};
assert_eq!(settings.api_key().as_deref(), Some("from-env"));
std::env::remove_var(env_name);
}
#[test]
fn test_api_key_resolution_empty_direct_falls_through() {
let settings = FluxweirSettings {
api_key: Some(" ".to_string()),
api_key_env: "CRAWLRS_TEST_FLUXWEIR_UNSET_ENV".to_string(), ..FluxweirSettings::default()
};
assert_eq!(settings.api_key(), None);
}
}