chore: separate backend from frontend

src/settings.rs

@@ -0,0 +1,619 @@
+//! Application configuration settings.
+//!
+//! This module provides configuration structures that can be loaded from:
+//! - YAML configuration files (base.yaml and environment-specific files)
+//! - Environment variables (prefixed with APP__)
+//!
+//! Settings include application details, email server configuration, and environment settings.
+
+/// Application configuration settings.
+///
+/// Loads configuration from YAML files and environment variables.
+#[derive(Debug, serde::Deserialize, Clone, Default)]
+pub struct Settings {
+    /// Application-specific settings (name, version, host, port, etc.)
+    pub application: ApplicationSettings,
+    /// Debug mode flag
+    pub debug: bool,
+    /// Email server configuration for contact form
+    pub email: EmailSettings,
+    /// Frontend URL for CORS configuration
+    pub frontend_url: String,
+    /// Rate limiting configuration
+    #[serde(default)]
+    pub rate_limit: RateLimitSettings,
+}
+
+impl Settings {
+    /// Creates a new `Settings` instance by loading configuration from files and environment variables.
+    ///
+    /// # Errors
+    ///
+    /// Returns a `config::ConfigError` if:
+    /// - Configuration files cannot be read or parsed
+    /// - Required configuration values are missing
+    /// - Configuration values cannot be deserialized into the expected types
+    ///
+    /// # Panics
+    ///
+    /// Panics if:
+    /// - The current directory cannot be determined
+    /// - The `APP_ENVIRONMENT` variable contains an invalid value (not "dev", "development", "prod", or "production")
+    pub fn new() -> Result<Self, config::ConfigError> {
+        let base_path = std::env::current_dir().expect("Failed to determine the current directory");
+        let settings_directory = base_path.join("settings");
+        let environment: Environment = std::env::var("APP_ENVIRONMENT")
+            .unwrap_or_else(|_| "dev".into())
+            .try_into()
+            .expect("Failed to parse APP_ENVIRONMENT");
+        let environment_filename = format!("{environment}.yaml");
+        // Lower = takes precedence
+        let settings = config::Config::builder()
+            .add_source(config::File::from(settings_directory.join("base.yaml")))
+            .add_source(config::File::from(
+                settings_directory.join(environment_filename),
+            ))
+            .add_source(
+                config::Environment::with_prefix("APP")
+                    .prefix_separator("__")
+                    .separator("__"),
+            )
+            .build()?;
+        settings.try_deserialize()
+    }
+}
+
+/// Application-specific configuration settings.
+#[derive(Debug, serde::Deserialize, Clone, Default)]
+pub struct ApplicationSettings {
+    /// Application name
+    pub name: String,
+    /// Application version
+    pub version: String,
+    /// Port to bind to
+    pub port: u16,
+    /// Host address to bind to
+    pub host: String,
+    /// Base URL of the application
+    pub base_url: String,
+    /// Protocol (http or https)
+    pub protocol: String,
+}
+
+/// Application environment.
+#[derive(Debug, PartialEq, Eq, Default)]
+pub enum Environment {
+    /// Development environment
+    #[default]
+    Development,
+    /// Production environment
+    Production,
+}
+
+impl std::fmt::Display for Environment {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let self_str = match self {
+            Self::Development => "development",
+            Self::Production => "production",
+        };
+        write!(f, "{self_str}")
+    }
+}
+
+impl TryFrom<String> for Environment {
+    type Error = String;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        Self::try_from(value.as_str())
+    }
+}
+
+impl TryFrom<&str> for Environment {
+    type Error = String;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value.to_lowercase().as_str() {
+            "development" | "dev" => Ok(Self::Development),
+            "production" | "prod" => Ok(Self::Production),
+            other => Err(format!(
+                "{other} is not a supported environment. Use either `development` or `production`"
+            )),
+        }
+    }
+}
+
+/// Email server configuration for the contact form.
+#[derive(serde::Deserialize, Clone, Default)]
+pub struct EmailSettings {
+    /// SMTP server hostname
+    pub host: String,
+    /// SMTP server port
+    pub port: u16,
+    /// SMTP authentication username
+    pub user: String,
+    /// Email address to send from
+    pub from: String,
+    /// SMTP authentication password
+    pub password: String,
+    /// Email address to send contact form submissions to
+    pub recipient: String,
+    /// STARTTLS configuration
+    pub starttls: Starttls,
+    /// Whether to use implicit TLS (SMTPS)
+    pub tls: bool,
+}
+
+impl std::fmt::Debug for EmailSettings {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("EmailSettings")
+            .field("host", &self.host)
+            .field("port", &self.port)
+            .field("user", &self.user)
+            .field("from", &self.from)
+            .field("password", &"[REDACTED]")
+            .field("recipient", &self.recipient)
+            .field("starttls", &self.starttls)
+            .field("tls", &self.tls)
+            .finish()
+    }
+}
+
+/// STARTTLS configuration for SMTP connections.
+#[derive(Debug, PartialEq, Eq, Default, Clone)]
+pub enum Starttls {
+    /// Never use STARTTLS (unencrypted connection)
+    #[default]
+    Never,
+    /// Use STARTTLS if available (opportunistic encryption)
+    Opportunistic,
+    /// Always use STARTTLS (required encryption)
+    Always,
+}
+
+impl TryFrom<&str> for Starttls {
+    type Error = String;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value.to_lowercase().as_str() {
+            "off" | "no" | "never" => Ok(Self::Never),
+            "opportunistic" => Ok(Self::Opportunistic),
+            "yes" | "always" => Ok(Self::Always),
+            other => Err(format!(
+                "{other} is not a supported option. Use either `yes`, `no`, or `opportunistic`"
+            )),
+        }
+    }
+}
+
+impl TryFrom<String> for Starttls {
+    type Error = String;
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        value.as_str().try_into()
+    }
+}
+
+impl From<bool> for Starttls {
+    fn from(value: bool) -> Self {
+        if value { Self::Always } else { Self::Never }
+    }
+}
+
+impl std::fmt::Display for Starttls {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let self_str = match self {
+            Self::Never => "never",
+            Self::Opportunistic => "opportunistic",
+            Self::Always => "always",
+        };
+        write!(f, "{self_str}")
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Starttls {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct StartlsVisitor;
+
+        impl serde::de::Visitor<'_> for StartlsVisitor {
+            type Value = Starttls;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("a string or boolean representing STARTTLS setting (e.g., 'yes', 'no', 'opportunistic', true, false)")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Starttls, E>
+            where
+                E: serde::de::Error,
+            {
+                Starttls::try_from(value).map_err(E::custom)
+            }
+
+            fn visit_string<E>(self, value: String) -> Result<Starttls, E>
+            where
+                E: serde::de::Error,
+            {
+                Starttls::try_from(value.as_str()).map_err(E::custom)
+            }
+
+            fn visit_bool<E>(self, value: bool) -> Result<Starttls, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(Starttls::from(value))
+            }
+        }
+
+        deserializer.deserialize_any(StartlsVisitor)
+    }
+}
+
+/// Rate limiting configuration.
+#[derive(Debug, serde::Deserialize, Clone)]
+pub struct RateLimitSettings {
+    /// Whether rate limiting is enabled
+    #[serde(default = "default_rate_limit_enabled")]
+    pub enabled: bool,
+    /// Maximum number of requests allowed in the time window (burst size)
+    #[serde(default = "default_burst_size")]
+    pub burst_size: u32,
+    /// Time window in seconds for rate limiting
+    #[serde(default = "default_per_seconds")]
+    pub per_seconds: u64,
+}
+
+impl Default for RateLimitSettings {
+    fn default() -> Self {
+        Self {
+            enabled: default_rate_limit_enabled(),
+            burst_size: default_burst_size(),
+            per_seconds: default_per_seconds(),
+        }
+    }
+}
+
+const fn default_rate_limit_enabled() -> bool {
+    true
+}
+
+const fn default_burst_size() -> u32 {
+    100
+}
+
+const fn default_per_seconds() -> u64 {
+    60
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn environment_display_development() {
+        let env = Environment::Development;
+        assert_eq!(env.to_string(), "development");
+    }
+
+    #[test]
+    fn environment_display_production() {
+        let env = Environment::Production;
+        assert_eq!(env.to_string(), "production");
+    }
+
+    #[test]
+    fn environment_from_str_development() {
+        assert_eq!(
+            Environment::try_from("development").unwrap(),
+            Environment::Development
+        );
+        assert_eq!(
+            Environment::try_from("dev").unwrap(),
+            Environment::Development
+        );
+        assert_eq!(
+            Environment::try_from("Development").unwrap(),
+            Environment::Development
+        );
+        assert_eq!(
+            Environment::try_from("DEV").unwrap(),
+            Environment::Development
+        );
+    }
+
+    #[test]
+    fn environment_from_str_production() {
+        assert_eq!(
+            Environment::try_from("production").unwrap(),
+            Environment::Production
+        );
+        assert_eq!(
+            Environment::try_from("prod").unwrap(),
+            Environment::Production
+        );
+        assert_eq!(
+            Environment::try_from("Production").unwrap(),
+            Environment::Production
+        );
+        assert_eq!(
+            Environment::try_from("PROD").unwrap(),
+            Environment::Production
+        );
+    }
+
+    #[test]
+    fn environment_from_str_invalid() {
+        let result = Environment::try_from("invalid");
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("not a supported environment"));
+    }
+
+    #[test]
+    fn environment_from_string_development() {
+        assert_eq!(
+            Environment::try_from("development".to_string()).unwrap(),
+            Environment::Development
+        );
+    }
+
+    #[test]
+    fn environment_from_string_production() {
+        assert_eq!(
+            Environment::try_from("production".to_string()).unwrap(),
+            Environment::Production
+        );
+    }
+
+    #[test]
+    fn environment_from_string_invalid() {
+        let result = Environment::try_from("invalid".to_string());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn environment_default_is_development() {
+        let env = Environment::default();
+        assert_eq!(env, Environment::Development);
+    }
+
+    #[test]
+    fn startls_deserialize_from_string_never() {
+        let json = r#""never""#;
+        let result: Starttls = serde_json::from_str(json).unwrap();
+        assert_eq!(result, Starttls::Never);
+
+        let json = r#""no""#;
+        let result: Starttls = serde_json::from_str(json).unwrap();
+        assert_eq!(result, Starttls::Never);
+
+        let json = r#""off""#;
+        let result: Starttls = serde_json::from_str(json).unwrap();
+        assert_eq!(result, Starttls::Never);
+    }
+
+    #[test]
+    fn startls_deserialize_from_string_always() {
+        let json = r#""always""#;
+        let result: Starttls = serde_json::from_str(json).unwrap();
+        assert_eq!(result, Starttls::Always);
+
+        let json = r#""yes""#;
+        let result: Starttls = serde_json::from_str(json).unwrap();
+        assert_eq!(result, Starttls::Always);
+    }
+
+    #[test]
+    fn startls_deserialize_from_string_opportunistic() {
+        let json = r#""opportunistic""#;
+        let result: Starttls = serde_json::from_str(json).unwrap();
+        assert_eq!(result, Starttls::Opportunistic);
+    }
+
+    #[test]
+    fn startls_deserialize_from_bool() {
+        let json = "true";
+        let result: Starttls = serde_json::from_str(json).unwrap();
+        assert_eq!(result, Starttls::Always);
+
+        let json = "false";
+        let result: Starttls = serde_json::from_str(json).unwrap();
+        assert_eq!(result, Starttls::Never);
+    }
+
+    #[test]
+    fn startls_deserialize_from_string_invalid() {
+        let json = r#""invalid""#;
+        let result: Result<Starttls, _> = serde_json::from_str(json);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn startls_default_is_never() {
+        let startls = Starttls::default();
+        assert_eq!(startls, Starttls::Never);
+    }
+
+    #[test]
+    fn startls_try_from_str_never() {
+        assert_eq!(Starttls::try_from("never").unwrap(), Starttls::Never);
+        assert_eq!(Starttls::try_from("no").unwrap(), Starttls::Never);
+        assert_eq!(Starttls::try_from("off").unwrap(), Starttls::Never);
+        assert_eq!(Starttls::try_from("NEVER").unwrap(), Starttls::Never);
+        assert_eq!(Starttls::try_from("No").unwrap(), Starttls::Never);
+    }
+
+    #[test]
+    fn startls_try_from_str_always() {
+        assert_eq!(Starttls::try_from("always").unwrap(), Starttls::Always);
+        assert_eq!(Starttls::try_from("yes").unwrap(), Starttls::Always);
+        assert_eq!(Starttls::try_from("ALWAYS").unwrap(), Starttls::Always);
+        assert_eq!(Starttls::try_from("Yes").unwrap(), Starttls::Always);
+    }
+
+    #[test]
+    fn startls_try_from_str_opportunistic() {
+        assert_eq!(
+            Starttls::try_from("opportunistic").unwrap(),
+            Starttls::Opportunistic
+        );
+        assert_eq!(
+            Starttls::try_from("OPPORTUNISTIC").unwrap(),
+            Starttls::Opportunistic
+        );
+    }
+
+    #[test]
+    fn startls_try_from_str_invalid() {
+        let result = Starttls::try_from("invalid");
+        assert!(result.is_err());
+        assert!(result
+            .unwrap_err()
+            .contains("not a supported option"));
+    }
+
+    #[test]
+    fn startls_try_from_string_never() {
+        assert_eq!(
+            Starttls::try_from("never".to_string()).unwrap(),
+            Starttls::Never
+        );
+    }
+
+    #[test]
+    fn startls_try_from_string_always() {
+        assert_eq!(
+            Starttls::try_from("yes".to_string()).unwrap(),
+            Starttls::Always
+        );
+    }
+
+    #[test]
+    fn startls_try_from_string_opportunistic() {
+        assert_eq!(
+            Starttls::try_from("opportunistic".to_string()).unwrap(),
+            Starttls::Opportunistic
+        );
+    }
+
+    #[test]
+    fn startls_try_from_string_invalid() {
+        let result = Starttls::try_from("invalid".to_string());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn startls_from_bool_true() {
+        assert_eq!(Starttls::from(true), Starttls::Always);
+    }
+
+    #[test]
+    fn startls_from_bool_false() {
+        assert_eq!(Starttls::from(false), Starttls::Never);
+    }
+
+    #[test]
+    fn startls_display_never() {
+        let startls = Starttls::Never;
+        assert_eq!(startls.to_string(), "never");
+    }
+
+    #[test]
+    fn startls_display_always() {
+        let startls = Starttls::Always;
+        assert_eq!(startls.to_string(), "always");
+    }
+
+    #[test]
+    fn startls_display_opportunistic() {
+        let startls = Starttls::Opportunistic;
+        assert_eq!(startls.to_string(), "opportunistic");
+    }
+
+    #[test]
+    fn rate_limit_settings_default() {
+        let settings = RateLimitSettings::default();
+        assert!(settings.enabled);
+        assert_eq!(settings.burst_size, 100);
+        assert_eq!(settings.per_seconds, 60);
+    }
+
+    #[test]
+    fn rate_limit_settings_deserialize_full() {
+        let json = r#"{"enabled": true, "burst_size": 50, "per_seconds": 30}"#;
+        let settings: RateLimitSettings = serde_json::from_str(json).unwrap();
+        assert!(settings.enabled);
+        assert_eq!(settings.burst_size, 50);
+        assert_eq!(settings.per_seconds, 30);
+    }
+
+    #[test]
+    fn rate_limit_settings_deserialize_partial() {
+        let json = r#"{"enabled": false}"#;
+        let settings: RateLimitSettings = serde_json::from_str(json).unwrap();
+        assert!(!settings.enabled);
+        assert_eq!(settings.burst_size, 100); // default
+        assert_eq!(settings.per_seconds, 60); // default
+    }
+
+    #[test]
+    fn rate_limit_settings_deserialize_empty() {
+        let json = "{}";
+        let settings: RateLimitSettings = serde_json::from_str(json).unwrap();
+        assert!(settings.enabled); // default
+        assert_eq!(settings.burst_size, 100); // default
+        assert_eq!(settings.per_seconds, 60); // default
+    }
+
+    #[test]
+    fn startls_deserialize_from_incompatible_type() {
+        // Test that deserialization from an array fails with expected error message
+        let json = "[1, 2, 3]";
+        let result: Result<Starttls, _> = serde_json::from_str(json);
+        assert!(result.is_err());
+        let error = result.unwrap_err().to_string();
+        // The error should mention what was expected
+        assert!(
+            error.contains("STARTTLS") || error.contains("string") || error.contains("boolean")
+        );
+    }
+
+    #[test]
+    fn startls_deserialize_from_number() {
+        // Test that deserialization from a number fails
+        let json = "42";
+        let result: Result<Starttls, _> = serde_json::from_str(json);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn startls_deserialize_from_object() {
+        // Test that deserialization from an object fails
+        let json = r#"{"foo": "bar"}"#;
+        let result: Result<Starttls, _> = serde_json::from_str(json);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn email_settings_debug_redacts_password() {
+        let settings = EmailSettings {
+            host: "smtp.example.com".to_string(),
+            port: 587,
+            user: "user@example.com".to_string(),
+            from: "noreply@example.com".to_string(),
+            password: "super_secret_password".to_string(),
+            recipient: "admin@example.com".to_string(),
+            starttls: Starttls::Always,
+            tls: false,
+        };
+
+        let debug_output = format!("{settings:?}");
+
+        // Password should be redacted
+        assert!(debug_output.contains("[REDACTED]"));
+        // Password should not appear in output
+        assert!(!debug_output.contains("super_secret_password"));
+        // Other fields should still be present
+        assert!(debug_output.contains("smtp.example.com"));
+        assert!(debug_output.contains("user@example.com"));
+    }
+}