use std::time::Duration;
use serde::{Deserialize, Serialize};
use crate::{
http::{IdempotencyConfig, trusted_proxy::ForwardedHeadersPolicy},
settings::{SettingsIssues, SettingsValidationError},
};
use super::{
error::HttpMiddlewareError,
policy::{
CorsPolicy, DEFAULT_HTTP_TIMEOUT, HttpMiddlewareConfig, HttpRateLimitConfig,
HttpRequestPolicy, RequestBodyLimitPolicy,
},
route_settings::HttpRequestPolicySettings,
security::SecurityHeadersConfig,
settings::{
CorsSettings, ForwardedHeadersSettings, HttpIdempotencySettings, HttpRateLimitSettings,
SecurityHeadersSettings,
},
};
impl HttpMiddlewareConfig {
#[must_use]
pub fn standard() -> Self {
Self {
request_context: true,
forwarded_headers: ForwardedHeadersPolicy::never(),
trace: true,
cors: CorsPolicy::Disabled,
security_headers: Some(SecurityHeadersConfig::api_defaults()),
timeout: Some(DEFAULT_HTTP_TIMEOUT),
compression: true,
rate_limit: None,
idempotency: None,
request_policy: HttpRequestPolicy::default(),
}
}
#[must_use]
pub fn minimal() -> Self {
Self {
request_context: false,
forwarded_headers: ForwardedHeadersPolicy::never(),
trace: false,
cors: CorsPolicy::Disabled,
security_headers: None,
timeout: None,
compression: false,
rate_limit: None,
idempotency: None,
request_policy: HttpRequestPolicy::disabled(),
}
}
#[must_use]
pub const fn request_context_enabled(&self) -> bool {
self.request_context
}
#[must_use]
pub fn forwarded_headers_enabled(&self) -> bool {
!self.forwarded_headers.is_disabled()
}
#[must_use]
pub const fn forwarded_headers_policy(&self) -> &ForwardedHeadersPolicy {
&self.forwarded_headers
}
#[must_use]
pub const fn trace_enabled(&self) -> bool {
self.trace
}
#[must_use]
pub const fn cors(&self) -> &CorsPolicy {
&self.cors
}
#[must_use]
pub const fn security_headers(&self) -> Option<&SecurityHeadersConfig> {
self.security_headers.as_ref()
}
#[must_use]
pub const fn timeout(&self) -> Option<Duration> {
self.timeout
}
#[must_use]
pub const fn request_body_limit(&self) -> Option<usize> {
self.request_policy
.default_request_body_limit()
.as_optional()
}
#[must_use]
pub const fn request_body_limit_policy(&self) -> RequestBodyLimitPolicy {
self.request_policy.default_request_body_limit()
}
#[must_use]
pub const fn compression_enabled(&self) -> bool {
self.compression
}
#[must_use]
pub const fn rate_limit(&self) -> Option<&HttpRateLimitConfig> {
self.rate_limit.as_ref()
}
#[must_use]
pub const fn idempotency(&self) -> Option<&IdempotencyConfig> {
self.idempotency.as_ref()
}
#[must_use]
pub const fn request_policy(&self) -> &HttpRequestPolicy {
&self.request_policy
}
}
impl Default for HttpMiddlewareConfig {
fn default() -> Self {
Self::standard()
}
}
#[cfg_attr(feature = "tier", derive(tier::TierConfig))]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
#[non_exhaustive]
pub struct HttpMiddlewareSettings {
pub request_context: bool,
pub trace: bool,
pub forwarded_headers: ForwardedHeadersSettings,
pub cors: CorsSettings,
pub security_headers: SecurityHeadersSettings,
#[serde(with = "crate::settings::human_duration::option")]
pub timeout: Option<Duration>,
pub compression: bool,
pub rate_limit: HttpRateLimitSettings,
pub idempotency: HttpIdempotencySettings,
pub request_policy: HttpRequestPolicySettings,
}
impl Default for HttpMiddlewareSettings {
fn default() -> Self {
Self {
request_context: true,
trace: true,
forwarded_headers: ForwardedHeadersSettings::default(),
cors: CorsSettings::default(),
security_headers: SecurityHeadersSettings::default(),
timeout: Some(DEFAULT_HTTP_TIMEOUT),
compression: true,
rate_limit: HttpRateLimitSettings::default(),
idempotency: HttpIdempotencySettings::default(),
request_policy: HttpRequestPolicySettings::default(),
}
}
}
impl HttpMiddlewareSettings {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub const fn with_request_context(mut self, request_context: bool) -> Self {
self.request_context = request_context;
self
}
#[must_use]
pub const fn with_trace(mut self, trace: bool) -> Self {
self.trace = trace;
self
}
#[must_use]
pub fn with_forwarded_headers(mut self, forwarded_headers: ForwardedHeadersSettings) -> Self {
self.forwarded_headers = forwarded_headers;
self
}
#[must_use]
pub fn with_cors(mut self, cors: CorsSettings) -> Self {
self.cors = cors;
self
}
#[must_use]
pub fn with_security_headers(mut self, security_headers: SecurityHeadersSettings) -> Self {
self.security_headers = security_headers;
self
}
#[must_use]
pub const fn with_timeout(mut self, timeout: Option<Duration>) -> Self {
self.timeout = timeout;
self
}
#[must_use]
pub const fn with_request_body_limit(mut self, request_body_limit: Option<usize>) -> Self {
self.request_policy.default_request_body_limit = match request_body_limit {
Some(bytes) => super::route_settings::RequestBodyLimitSettings::Bytes(bytes),
None => super::route_settings::RequestBodyLimitSettings::Disabled,
};
self
}
#[must_use]
pub const fn with_compression(mut self, compression: bool) -> Self {
self.compression = compression;
self
}
#[must_use]
pub fn with_rate_limit(mut self, rate_limit: HttpRateLimitSettings) -> Self {
self.rate_limit = rate_limit;
self
}
#[must_use]
pub fn with_idempotency(mut self, idempotency: HttpIdempotencySettings) -> Self {
self.idempotency = idempotency;
self
}
#[must_use]
pub fn with_request_policy(mut self, request_policy: HttpRequestPolicySettings) -> Self {
self.request_policy = request_policy;
self
}
pub fn build(self) -> Result<HttpMiddlewareConfig, SettingsValidationError> {
self.validate()?;
let materialize = |path: &'static str, error: HttpMiddlewareError| {
SettingsValidationError::single(path, error.to_string())
};
Ok(HttpMiddlewareConfig {
request_context: self.request_context,
forwarded_headers: ForwardedHeadersPolicy::try_from(&self.forwarded_headers)
.map_err(|error| materialize("http.forwarded_headers", error))?,
trace: self.trace,
cors: CorsPolicy::try_from(&self.cors)
.map_err(|error| materialize("http.cors", error))?,
security_headers: SecurityHeadersSettings::try_config(&self.security_headers)
.map_err(|error| materialize("http.security_headers", error))?,
timeout: self.timeout,
compression: self.compression,
rate_limit: self
.rate_limit
.config()
.map_err(|error| materialize("http.rate_limit", error))?,
idempotency: self
.idempotency
.config()
.map_err(|error| materialize("http.idempotency", error))?,
request_policy: HttpRequestPolicy::try_from(&self.request_policy)
.map_err(|error| materialize("http.request_policy", error))?,
})
}
pub fn validate(&self) -> Result<(), SettingsValidationError> {
self.validate_at("http")
}
pub(crate) fn validate_at(&self, path: &str) -> Result<(), SettingsValidationError> {
let mut issues = SettingsIssues::new();
issues.require(
!self.idempotency.enabled || self.timeout.is_some(),
format!("{path}.timeout"),
"must be configured when idempotency is enabled",
);
if let Some(timeout) = self.timeout {
issues.require(
!timeout.is_zero(),
format!("{path}.timeout"),
"must be greater than zero",
);
if self.idempotency.enabled {
issues.require(
self.idempotency.processing_ttl > timeout,
format!("{path}.idempotency.processing_ttl"),
"must be greater than the HTTP request timeout",
);
}
}
issues.extend_result(self.cors.validate_at(&format!("{path}.cors")));
issues.extend_result(
self.forwarded_headers
.validate_at(&format!("{path}.forwarded_headers")),
);
issues.extend_result(
self.security_headers
.validate_at(&format!("{path}.security_headers")),
);
issues.extend_result(self.rate_limit.validate_at(&format!("{path}.rate_limit")));
issues.extend_result(self.idempotency.validate_at(&format!("{path}.idempotency")));
issues.extend_result(
self.request_policy
.validate_at(&format!("{path}.request_policy")),
);
issues.into_result()
}
}