use std::path::PathBuf;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct FetchConfig {
pub allowed_hosts: Option<Vec<String>>,
pub allow_private_networks: bool,
pub private_hosts: Vec<String>,
pub max_response_bytes: u64,
pub max_concurrent: usize,
pub max_per_request: u32,
pub connect_timeout: f64,
pub timeout: f64,
pub pool_max_idle_per_host: usize,
pub max_retries: u32,
pub proxy: Option<String>,
pub no_proxy: bool,
pub propagate_trace_context: bool,
}
impl Default for FetchConfig {
fn default() -> Self {
let defaults = nitr_std::FetchOptions::default();
Self {
allowed_hosts: defaults.allowed_hosts,
allow_private_networks: defaults.allow_private_networks,
private_hosts: defaults.private_hosts,
max_response_bytes: defaults.max_response_bytes,
max_concurrent: defaults.max_concurrent,
max_per_request: defaults.max_per_request,
connect_timeout: defaults.connect_timeout.as_secs_f64(),
timeout: defaults.timeout.as_secs_f64(),
pool_max_idle_per_host: defaults.pool_max_idle_per_host,
max_retries: defaults.max_retries,
proxy: None,
no_proxy: false,
propagate_trace_context: false,
}
}
}
impl FetchConfig {
pub fn options(&self) -> nitr_std::FetchOptions {
nitr_std::FetchOptions {
allowed_hosts: self.allowed_hosts.clone(),
allow_private_networks: self.allow_private_networks,
private_hosts: self.private_hosts.clone(),
max_response_bytes: self.max_response_bytes,
max_concurrent: self.max_concurrent.max(1),
max_per_request: self.max_per_request,
connect_timeout: std::time::Duration::from_secs_f64(self.connect_timeout.max(0.1)),
timeout: std::time::Duration::from_secs_f64(self.timeout.max(0.1)),
pool_max_idle_per_host: self.pool_max_idle_per_host,
max_retries: self.max_retries,
proxy: self.proxy.clone(),
no_proxy: self.no_proxy,
propagate_trace_context: self.propagate_trace_context,
}
}
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct StaticConfig {
pub dir: Option<PathBuf>,
pub mount: Option<String>,
pub spa: bool,
pub cache_control: Option<String>,
pub dotfiles: bool,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct TemplatingConfig {
pub dir: Option<PathBuf>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum CookieSecure {
#[default]
Auto,
Always,
Never,
}
impl std::str::FromStr for CookieSecure {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"auto" => Ok(Self::Auto),
"always" => Ok(Self::Always),
"never" => Ok(Self::Never),
other => Err(format!(
"`{other}` is not a cookie policy: expected \"auto\", \"always\" or \"never\""
)),
}
}
}
impl CookieSecure {
pub fn resolve(self, tls_enabled: bool) -> bool {
match self {
Self::Auto => tls_enabled,
Self::Always => true,
Self::Never => false,
}
}
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CookiesConfig {
pub secure: CookieSecure,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct MultipartConfig {
pub upload_dir: Option<PathBuf>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CacheConfig {
pub max_entries: usize,
pub max_bytes: u64,
pub default_ttl: u64,
}
impl Default for CacheConfig {
fn default() -> Self {
Self {
max_entries: 10_000,
max_bytes: 32 * 1024 * 1024, default_ttl: 300,
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CompressionConfig {
pub enabled: bool,
pub algorithms: Vec<String>,
pub min_size: u64,
pub types: Vec<String>,
}
impl Default for CompressionConfig {
fn default() -> Self {
Self {
enabled: false,
algorithms: vec!["br".into(), "gzip".into()],
min_size: 1024,
types: [
"text/*",
"application/json",
"application/javascript",
"application/xml",
"image/svg+xml",
]
.map(String::from)
.to_vec(),
}
}
}