rapina 0.8.0

A fast, type-safe web framework for Rust inspired by FastAPI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! Type-safe configuration loading from environment variables
//!
//! This module provides utilities for loading configuration from
//! environment variables and `.env` files

use std::env;
use std::str::FromStr;

/// Load environment variables from `.env` files if it exists.
///
/// Call this at the start of your application before accessing config.
pub fn load_dotenv() {
    let _ = dotenvy::dotenv();
}

/// Get a required environment variable.
///
/// Returns an error if the variable is not set.
pub fn get_env(key: &str) -> Result<String, ConfigError> {
    env::var(key).map_err(|_| ConfigError::Missing(key.to_string()))
}

/// Get an optional environment with a default value
pub fn get_env_or(key: &str, default: &str) -> String {
    env::var(key).unwrap_or_else(|_| default.to_string())
}

/// Get and parse an environment variable.
pub fn get_env_parsed<T: FromStr>(key: &str) -> Result<T, ConfigError> {
    let value = get_env(key)?;
    value.parse().map_err(|_| ConfigError::Invalid {
        key: key.to_string(),
        value,
    })
}

/// Get and parse an environment variable with a default.
pub fn get_env_parsed_or<T: FromStr>(key: &str, default: T) -> T {
    env::var(key)
        .ok()
        .and_then(|v| v.parse().ok())
        .unwrap_or(default)
}

/// Configuration loading errors.
#[derive(Debug)]
pub enum ConfigError {
    /// Environment variable is not set.
    Missing(String),
    /// Multiple environment variables are not set.
    MissingMultiple(Vec<String>),
    /// Environment variable value is invalid.
    Invalid { key: String, value: String },
}
impl std::fmt::Display for ConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ConfigError::Missing(key) => {
                write!(f, "Missing required environment variable '{}'", key)
            }
            ConfigError::MissingMultiple(keys) => {
                writeln!(f, "Missing required environment variables:")?;
                for key in keys {
                    writeln!(f, "  - {}", key)?;
                }
                Ok(())
            }
            ConfigError::Invalid { key, value } => {
                write!(
                    f,
                    "Invalid value '{}' for environment variable '{}' (failed to parse as expected type)",
                    value, key
                )
            }
        }
    }
}

impl std::error::Error for ConfigError {}

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

    #[test]
    fn test_get_env_missing() {
        let result = get_env("RAPINA_TEST_MISSING_VAR_12345");
        assert!(result.is_err());
    }

    #[test]
    fn test_get_env_or_default() {
        let value = get_env_or("RAPINA_TEST_MISSING_VAR_12345", "default");
        assert_eq!(value, "default");
    }

    #[test]
    fn test_get_env_parsed_or_default() {
        let value: u16 = get_env_parsed_or("RAPINA_TEST_MISSING_VAR_12345", 3000);
        assert_eq!(value, 3000);
    }

    #[test]
    fn test_config_error_display() {
        let err = ConfigError::Missing("DATABASE_URL".to_string());
        assert_eq!(
            err.to_string(),
            "Missing required environment variable 'DATABASE_URL'"
        );

        let err = ConfigError::Invalid {
            key: "PORT".to_string(),
            value: "abc".to_string(),
        };
        assert_eq!(
            err.to_string(),
            "Invalid value 'abc' for environment variable 'PORT' (failed to parse as expected type)"
        );
    }
}