footing 0.4.1

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()
    }
}

#[cfg(feature = "secrets")]
impl From<::tier::Secret<String>> for crate::secret::SecretString {
    fn from(secret: ::tier::Secret<String>) -> Self {
        Self::new(secret.into_inner())
    }
}

/// Tier-loadable PostgreSQL bootstrap settings.
///
/// Build Footing's validated, non-serializable runtime configuration directly
/// with [`crate::db::postgres::PostgresBootstrapSettings::build`].
#[cfg(feature = "postgres")]
pub type PostgresBootstrapInput =
    crate::db::postgres::PostgresBootstrapSettings<::tier::Secret<String>>;

/// Tier-loadable PostgreSQL reset settings.
///
/// Build Footing's validated, non-serializable reset request directly
/// with [`crate::db::postgres::admin::PostgresResetSettings::build`].
#[cfg(feature = "postgres-admin")]
pub type PostgresResetInput =
    crate::db::postgres::admin::PostgresResetSettings<::tier::Secret<String>>;

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;

    #[cfg(any(
        feature = "http",
        feature = "postgres",
        feature = "sqlite",
        feature = "tls",
        feature = "worker"
    ))]
    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::postgres::PostgresPoolSettings>();
        assert_tier_metadata::<crate::db::postgres::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 defaults = serde_json::json!({
            "database_url": "postgres://app:secret@localhost/app"
        });
        let loaded = ConfigLoader::<PostgresBootstrapInput>::from_value(defaults)
            .derive_metadata()
            .validator("postgres", |settings| {
                settings.validate().map_err(Into::into)
            })
            .load()
            .unwrap();

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

    #[cfg(feature = "sqlite")]
    #[test]
    fn sqlite_settings_are_tier_loadable() {
        use crate::db::sqlite::{
            SqliteBootstrapSettings, SqliteConnectionSettings, SqlitePoolSettings,
        };
        use ::tier::{ConfigLoader, TierMetadata};

        assert_tier_metadata::<SqlitePoolSettings>();
        assert_tier_metadata::<SqliteConnectionSettings>();
        assert_tier_metadata::<SqliteBootstrapSettings>();
        assert!(SqliteBootstrapSettings::secret_paths().is_empty());
        assert!(
            SqliteBootstrapSettings::metadata()
                .field("connection.database_url")
                .is_some()
        );

        let loaded = ConfigLoader::new(SqliteBootstrapSettings::new("sqlite::memory:"))
            .derive_metadata()
            .validator("sqlite", |settings| settings.validate().map_err(Into::into))
            .load()
            .unwrap();

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

    #[cfg(feature = "http")]
    #[test]
    fn http_settings_expose_complete_tier_metadata() {
        use crate::http::{
            CorsMode, CorsSettings, ForwardedHeadersMode, ForwardedHeadersSettings,
            HttpIdempotencySettings, HttpMiddlewareSettings, HttpRateLimitSettings,
            HttpRequestPolicySettings, HttpRouteRuleSettings, IdempotencyRequestPolicy,
            RateLimitKeySourceSettings, RateLimitRequestPolicy, 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::<HttpMiddlewareSettings>();
        assert_tier_metadata::<HttpIdempotencySettings>();
        assert_tier_metadata::<HttpRateLimitSettings>();
        assert_tier_metadata::<HttpRequestPolicySettings>();
        assert_tier_metadata::<HttpRouteRuleSettings>();
        assert_tier_metadata::<IdempotencyRequestPolicy>();
        assert_tier_metadata::<RateLimitKeySourceSettings>();
        assert_tier_metadata::<RateLimitRequestPolicy>();
        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(),
        ))
        .build()
        .unwrap();
    }
}