arche 3.0.1

An opinionated backend foundation for Axum applications, providing batteries-included integrations for cloud services, databases, authentication, middleware, and logging.
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

use crate::error::AppError;
use std::str::FromStr;

pub fn resolve_required<T>(param: Option<T>, env_var: &str, field: &str) -> Result<T, AppError>
where
    T: FromStr,
    T::Err: std::fmt::Debug,
{
    if let Some(value) = param {
        return Ok(value);
    }

    match std::env::var(env_var) {
        Ok(value) => value.parse::<T>().map_err(|e| {
            AppError::internal_error(
                format!("Config error [{field}/{env_var}]: Failed to parse value: {e:?}"),
                None,
            )
        }),
        Err(_) => Err(AppError::internal_error(
            format!(
                "Config error [{field}/{env_var}]: Value not provided and environment variable not set"
            ),
            None,
        )),
    }
}

pub fn resolve_with_default<T>(param: Option<T>, env_var: &str, default: T) -> T
where
    T: FromStr,
{
    if let Some(value) = param {
        return value;
    }

    std::env::var(env_var)
        .ok()
        .and_then(|v| v.parse::<T>().ok())
        .unwrap_or(default)
}

pub fn resolve_optional<T>(param: Option<T>, env_var: &str) -> Option<T>
where
    T: FromStr,
{
    if param.is_some() {
        return param;
    }

    std::env::var(env_var)
        .ok()
        .and_then(|v| v.parse::<T>().ok())
}

pub fn resolve_required_string(
    param: Option<String>,
    env_var: &str,
    field: &str,
) -> Result<String, AppError> {
    resolve_required(param, env_var, field)
}

pub fn resolve_optional_string(param: Option<String>, env_var: &str) -> Option<String> {
    resolve_optional(param, env_var)
}