footing 0.1.3

Feature-gated foundations for Rust backend services
Documentation
//! Adapters between Footing component settings and Tier.
//!
//! Footing settings keep their own invariant checks. Register those checks as
//! Tier validators by converting the returned error:
//!
//! ```rust
//! # #[cfg(feature = "tls")]
//! # {
//! use footing::tls::TlsTrustSettings;
//! use tier::ConfigLoader;
//!
//! let defaults = TlsTrustSettings::default();
//! let loader = ConfigLoader::new(defaults)
//!     .derive_metadata()
//!     .validator("tls", |settings| settings.validate().map_err(Into::into));
//! # let _ = loader;
//! # }
//! ```

use super::SettingsValidationError;

#[cfg(feature = "secrets")]
impl crate::secret::ExposeSecret<str> for ::tier::Secret<String> {
    fn expose_secret(&self) -> &str {
        self.expose_ref()
    }
}

/// Tier-loadable PostgreSQL bootstrap settings.
///
/// Convert this input into Footing's non-serializable runtime-secret form with
/// [`crate::db::PostgresBootstrapSettings::into_runtime`].
#[cfg(feature = "postgres")]
pub type PostgresBootstrapInput = crate::db::PostgresBootstrapSettings<::tier::Secret<String>>;

/// Tier-loadable PostgreSQL reset settings.
///
/// Convert this input into Footing's non-serializable runtime-secret form with
/// [`crate::db::admin::PostgresResetSettings::into_runtime`].
#[cfg(feature = "postgres-admin")]
pub type PostgresResetInput = crate::db::admin::PostgresResetSettings<::tier::Secret<String>>;

#[cfg(feature = "postgres")]
impl crate::db::PostgresBootstrapSettings<::tier::Secret<String>> {
    /// Moves a Tier input into Footing's non-serializable secret representation.
    #[must_use]
    pub fn into_runtime(self) -> crate::db::PostgresBootstrapSettings {
        self.map_database_url(|secret| crate::secret::SecretString::new(secret.into_inner()))
    }
}

#[cfg(feature = "postgres-admin")]
impl crate::db::admin::PostgresResetSettings<::tier::Secret<String>> {
    /// Moves a Tier input into Footing's non-serializable secret representation.
    #[must_use]
    pub fn into_runtime(self) -> crate::db::admin::PostgresResetSettings {
        self.map_database_url(|secret| crate::secret::SecretString::new(secret.into_inner()))
    }
}

impl From<&SettingsValidationError> for ::tier::ValidationErrors {
    fn from(error: &SettingsValidationError) -> Self {
        let mut errors = Self::new();
        errors.extend(error.issues().iter().map(|issue| {
            ::tier::ValidationError::new(issue.path(), issue.message())
                .with_rule("footing.settings")
        }));
        if error.is_truncated() {
            errors.push(
                ::tier::ValidationError::new("settings", "additional issues omitted")
                    .with_rule("footing.settings.truncated"),
            );
        }
        errors
    }
}

impl From<SettingsValidationError> for ::tier::ValidationErrors {
    fn from(error: SettingsValidationError) -> Self {
        Self::from(&error)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::settings::SettingsIssues;

    fn assert_tier_metadata<T: ::tier::TierMetadata>() {}

    #[test]
    fn validation_conversion_preserves_paths_and_truncation() {
        let mut issues = SettingsIssues::new();
        for index in 0..=crate::settings::MAX_SETTINGS_ISSUES {
            issues.push(format!("worker.{index}"), "is invalid");
        }

        let source = SettingsValidationError::new(issues);
        let converted = ::tier::ValidationErrors::from(&source);

        assert_eq!(converted.len(), crate::settings::MAX_SETTINGS_ISSUES + 1);
        assert_eq!(converted.iter().next().unwrap().path, "worker.0");
        assert_eq!(
            converted.iter().last().unwrap().rule.as_deref(),
            Some("footing.settings.truncated")
        );
    }

    #[cfg(feature = "postgres")]
    #[test]
    fn postgres_settings_are_tier_loadable_without_serializing_runtime_secrets() {
        use ::tier::{ConfigLoader, TierMetadata};

        assert_tier_metadata::<crate::db::PostgresPoolSettings>();
        assert_tier_metadata::<crate::db::PostgresStartupRetrySettings>();
        assert_tier_metadata::<PostgresBootstrapInput>();

        let metadata = PostgresBootstrapInput::metadata();
        assert_eq!(metadata.secret_paths(), ["database_url"]);
        assert!(
            metadata
                .field("pool.max_connections")
                .and_then(::tier::FieldMetadata::documentation)
                .is_some()
        );

        let input = PostgresBootstrapInput::from_secret(::tier::Secret::new(
            "postgres://app:secret@localhost/app".to_owned(),
        ));
        let debug = format!("{input:?}");
        assert!(!debug.contains("postgres://"));

        let loaded = ConfigLoader::new(input)
            .derive_metadata()
            .validator("postgres", |settings| {
                settings.validate().map_err(Into::into)
            })
            .load()
            .unwrap();

        loaded.into_inner().into_runtime().build().unwrap();
    }

    #[cfg(feature = "http")]
    #[test]
    fn http_settings_expose_complete_tier_metadata() {
        use crate::http::{
            CorsMode, CorsSettings, ForwardedHeadersMode, ForwardedHeadersSettings,
            HttpFoundationSettings, HttpIdempotencySettings, HttpRateLimitSettings,
            HttpRequestPolicySettings, HttpRouteRuleSettings, IdempotencyRequestPolicySettings,
            RateLimitKeySourceSettings, RateLimitRequestPolicySettings, RequestBodyLimitSettings,
            RouteMatcherSettings, SecurityHeadersSettings, StrictTransportSecuritySettings,
        };
        use ::tier::TierMetadata;

        assert_tier_metadata::<CorsMode>();
        assert_tier_metadata::<CorsSettings>();
        assert_tier_metadata::<ForwardedHeadersMode>();
        assert_tier_metadata::<ForwardedHeadersSettings>();
        assert_tier_metadata::<HttpFoundationSettings>();
        assert_tier_metadata::<HttpIdempotencySettings>();
        assert_tier_metadata::<HttpRateLimitSettings>();
        assert_tier_metadata::<HttpRequestPolicySettings>();
        assert_tier_metadata::<HttpRouteRuleSettings>();
        assert_tier_metadata::<IdempotencyRequestPolicySettings>();
        assert_tier_metadata::<RateLimitKeySourceSettings>();
        assert_tier_metadata::<RateLimitRequestPolicySettings>();
        assert_tier_metadata::<RequestBodyLimitSettings>();
        assert_tier_metadata::<RouteMatcherSettings>();
        assert_tier_metadata::<SecurityHeadersSettings>();
        assert_tier_metadata::<StrictTransportSecuritySettings>();
        assert!(
            HttpRateLimitSettings::secret_paths()
                .iter()
                .any(|path| path == "key_source")
        );
    }

    #[cfg(feature = "worker")]
    #[test]
    fn worker_settings_expose_complete_tier_metadata() {
        use crate::worker::{
            BackoffSettings, OutboxWorkerSettings, WorkerLeaseSettings, WorkerSettings,
        };

        assert_tier_metadata::<BackoffSettings>();
        assert_tier_metadata::<OutboxWorkerSettings>();
        assert_tier_metadata::<WorkerLeaseSettings>();
        assert_tier_metadata::<WorkerSettings>();
    }

    #[cfg(feature = "tls")]
    #[test]
    fn tls_settings_expose_tier_metadata() {
        assert_tier_metadata::<crate::tls::TlsTrustSettings>();
    }

    #[cfg(feature = "postgres-admin")]
    #[test]
    fn postgres_reset_settings_are_tier_loadable() {
        use ::tier::TierMetadata;

        assert_tier_metadata::<PostgresResetInput>();
        assert_eq!(PostgresResetInput::secret_paths(), ["database_url"]);

        PostgresResetInput::from_secret(::tier::Secret::new(
            "postgres://app:secret@localhost/app".to_owned(),
        ))
        .into_runtime()
        .build()
        .unwrap();
    }
}