confik 0.11.8

A library for reading application configuration split across multiple sources
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
121
122
123

//! Useful configuration types that services will likely otherwise re-implement.

use std::{fmt, str};

use crate::{Configuration, MissingValue};

/// The database type, used to determine the connection string format
#[derive(Debug, Clone, PartialEq, Eq, Configuration)]
#[confik(forward_serde(rename_all = "lowercase"))]
enum DatabaseKind {
    Mysql,
    Postgres,
}

impl str::FromStr for DatabaseKind {
    type Err = MissingValue;

    fn from_str(input: &str) -> Result<Self, Self::Err> {
        match () {
            _ if input.eq_ignore_ascii_case("mysql") => Ok(Self::Mysql),
            _ if input.eq_ignore_ascii_case("postgres") => Ok(Self::Postgres),
            _ => Err(Self::Err::default()),
        }
    }
}

impl fmt::Display for DatabaseKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Mysql => f.write_str("mysql"),
            Self::Postgres => f.write_str("postgres"),
        }
    }
}

/// Database connection configuration, with a secret `password`.
///
/// The [`Display`] impl provides the full connection string, whereas [`Debug`] is as normal, but
/// with the `password` field value replaced by `[redacted]`.
///
/// See [`SecretBuilder`](crate::SecretBuilder) for details on secrets. NOTE: The [`Debug`] hiding
/// of the field is manually implemented for this type, and is not automatically handled by
/// `#[config(secret)]`.
///
/// [`Display`]: #impl-Display-for-DatabaseConnectionConfig
/// [`Debug`]: #impl-Debug-for-DatabaseConnectionConfig
#[derive(Clone, Configuration)]
pub struct DatabaseConnectionConfig {
    database: DatabaseKind,

    username: String,

    #[confik(secret)]
    password: String,

    path: String,
}

impl fmt::Debug for DatabaseConnectionConfig {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("DatabaseConnectionConfig")
            .field("database", &self.database)
            .field("username", &self.username)
            .field("password", &"[redacted]")
            .field("path", &self.path)
            .finish()
    }
}

impl fmt::Display for DatabaseConnectionConfig {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}://{}:{}@{}",
            self.database, self.username, self.password, self.path
        )
    }
}

impl str::FromStr for DatabaseConnectionConfig {
    type Err = MissingValue;

    fn from_str(input: &str) -> Result<Self, Self::Err> {
        let Some((database, input)) = input.split_once("://") else {
            return Err(Self::Err::default().prepend("database"));
        };

        let database = database
            .parse()
            .map_err(|err: MissingValue| err.prepend("database".to_string()))?;

        let Some((username, input)) = input.split_once(':') else {
            return Err(Self::Err::default().prepend("username".to_string()));
        };

        let Some((password, path)) = input.split_once('@') else {
            return Err(Self::Err::default().prepend("path".to_string()));
        };

        Ok(Self {
            database,
            username: username.to_owned(),
            password: password.to_owned(),
            path: path.to_owned(),
        })
    }
}

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

    #[test]
    fn parse_connection_string() {
        let db_config = "mysql://root:foo@localhost:3307"
            .parse::<DatabaseConnectionConfig>()
            .unwrap();
        assert_eq!(db_config.database, DatabaseKind::Mysql);
        assert_eq!(db_config.username, "root");
        assert_eq!(db_config.password, "foo");
        assert_eq!(db_config.path, "localhost:3307");
    }
}