use std::sync::{PoisonError, RwLock};
pub const DEFAULT_BASE_URL: &str = "https://app.loops.so/api";
pub const API_KEY_ENV_VAR: &str = "LOOPS_API_KEY";
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct LoopsConfig {
pub api_key: Option<String>,
pub base_url: String,
pub safe_mode: bool,
pub safe_mode_allowed_domains: Vec<String>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct ConfigureOptions {
pub api_key: Option<String>,
pub base_url: Option<String>,
pub safe_mode: Option<bool>,
pub safe_mode_allowed_domains: Option<Vec<String>>,
}
impl ConfigureOptions {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn api_key(mut self, api_key: impl Into<String>) -> Self {
self.api_key = Some(api_key.into());
self
}
#[must_use]
pub fn base_url(mut self, base_url: impl Into<String>) -> Self {
self.base_url = Some(base_url.into());
self
}
#[must_use]
pub fn safe_mode(mut self, safe_mode: bool) -> Self {
self.safe_mode = Some(safe_mode);
self
}
#[must_use]
pub fn safe_mode_allowed_domains<I, S>(mut self, domains: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.safe_mode_allowed_domains = Some(domains.into_iter().map(Into::into).collect());
self
}
}
#[derive(Debug, Clone)]
struct Stored {
api_key: Option<String>,
base_url: String,
safe_mode: bool,
safe_mode_allowed_domains: Vec<String>,
}
static STORED: RwLock<Stored> = RwLock::new(Stored {
api_key: None,
base_url: String::new(),
safe_mode: false,
safe_mode_allowed_domains: Vec::new(),
});
pub fn configure(options: ConfigureOptions) {
let mut stored = STORED.write().unwrap_or_else(PoisonError::into_inner);
if let Some(api_key) = options.api_key {
stored.api_key = Some(api_key);
}
if let Some(base_url) = options.base_url {
stored.base_url = base_url;
}
if let Some(safe_mode) = options.safe_mode {
stored.safe_mode = safe_mode;
}
if let Some(domains) = options.safe_mode_allowed_domains {
stored.safe_mode_allowed_domains = domains;
}
}
pub fn get_config() -> LoopsConfig {
let stored = STORED
.read()
.unwrap_or_else(PoisonError::into_inner)
.clone();
LoopsConfig {
api_key: stored.api_key.filter(|key| !key.is_empty()).or_else(|| {
std::env::var(API_KEY_ENV_VAR)
.ok()
.filter(|key| !key.is_empty())
}),
base_url: if stored.base_url.is_empty() {
DEFAULT_BASE_URL.to_owned()
} else {
stored.base_url
},
safe_mode: stored.safe_mode,
safe_mode_allowed_domains: stored.safe_mode_allowed_domains,
}
}
#[cfg(feature = "testing")]
pub(crate) fn snapshot() -> impl FnOnce() + Send + 'static {
let saved = STORED
.read()
.unwrap_or_else(PoisonError::into_inner)
.clone();
move || *STORED.write().unwrap_or_else(PoisonError::into_inner) = saved
}