rustauth-plugins 0.2.0

Official RustAuth plugin modules.
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

//! Options for the Have I Been Pwned plugin.

use std::sync::Arc;

use super::checker::{HaveIBeenPwnedChecker, ReqwestHaveIBeenPwnedChecker};

#[derive(Clone)]
pub struct HaveIBeenPwnedOptions {
    pub custom_password_compromised_message: Option<String>,
    pub paths: Vec<String>,
    pub enabled: bool,
    pub checker: Option<Arc<dyn HaveIBeenPwnedChecker>>,
}

impl std::fmt::Debug for HaveIBeenPwnedOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("HaveIBeenPwnedOptions")
            .field(
                "custom_password_compromised_message",
                &self.custom_password_compromised_message,
            )
            .field("paths", &self.paths)
            .field("enabled", &self.enabled)
            .field("checker", &self.checker.as_ref().map(|_| "<checker>"))
            .finish()
    }
}

impl Default for HaveIBeenPwnedOptions {
    fn default() -> Self {
        Self {
            custom_password_compromised_message: None,
            paths: vec![
                "/sign-up/email".to_owned(),
                "/change-password".to_owned(),
                "/reset-password".to_owned(),
            ],
            enabled: false,
            checker: None,
        }
    }
}

impl HaveIBeenPwnedOptions {
    #[must_use]
    pub fn builder() -> HaveIBeenPwnedOptionsBuilder {
        HaveIBeenPwnedOptionsBuilder::default()
    }

    #[must_use]
    pub fn checker(mut self, checker: Arc<dyn HaveIBeenPwnedChecker>) -> Self {
        self.checker = Some(checker);
        self
    }

    pub(crate) fn resolved_checker(&self) -> Arc<dyn HaveIBeenPwnedChecker> {
        self.checker
            .clone()
            .unwrap_or_else(|| Arc::new(ReqwestHaveIBeenPwnedChecker::new()))
    }
}

#[derive(Clone, Default)]
pub struct HaveIBeenPwnedOptionsBuilder {
    custom_password_compromised_message: Option<Option<String>>,
    paths: Option<Vec<String>>,
    enabled: Option<bool>,
    checker: Option<Arc<dyn HaveIBeenPwnedChecker>>,
}

impl HaveIBeenPwnedOptionsBuilder {
    #[must_use]
    pub fn custom_password_compromised_message(mut self, message: impl Into<String>) -> Self {
        self.custom_password_compromised_message = Some(Some(message.into()));
        self
    }

    #[must_use]
    pub fn paths(mut self, paths: Vec<String>) -> Self {
        self.paths = Some(paths);
        self
    }

    #[must_use]
    pub fn path(mut self, path: impl Into<String>) -> Self {
        self.paths
            .get_or_insert_with(|| HaveIBeenPwnedOptions::default().paths)
            .push(path.into());
        self
    }

    #[must_use]
    pub fn enabled(mut self, enabled: bool) -> Self {
        self.enabled = Some(enabled);
        self
    }

    #[must_use]
    pub fn checker(mut self, checker: Arc<dyn HaveIBeenPwnedChecker>) -> Self {
        self.checker = Some(checker);
        self
    }

    #[must_use]
    pub fn build(self) -> HaveIBeenPwnedOptions {
        let defaults = HaveIBeenPwnedOptions::default();
        HaveIBeenPwnedOptions {
            custom_password_compromised_message: self
                .custom_password_compromised_message
                .unwrap_or(defaults.custom_password_compromised_message),
            paths: self.paths.unwrap_or(defaults.paths),
            enabled: self.enabled.unwrap_or(defaults.enabled),
            checker: self.checker.or(defaults.checker),
        }
    }
}