openauth-core 0.0.6

Core types and primitives for OpenAuth.
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
124
125
126
127
128

use std::fmt;
use std::sync::Arc;

use http::Request;

use crate::db::User;
use crate::error::OpenAuthError;

/// Payload passed when an existing user attempts email/password sign-up.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ExistingUserSignUpPayload {
    pub user: User,
}

/// Hook invoked for protected duplicate sign-up attempts.
pub trait OnExistingUserSignUp: Send + Sync + 'static {
    fn on_existing_user_sign_up(
        &self,
        payload: ExistingUserSignUpPayload,
        request: Option<&Request<Vec<u8>>>,
    ) -> Result<(), OpenAuthError>;
}

impl<F> OnExistingUserSignUp for F
where
    F: for<'a> Fn(
            ExistingUserSignUpPayload,
            Option<&'a Request<Vec<u8>>>,
        ) -> Result<(), OpenAuthError>
        + Send
        + Sync
        + 'static,
{
    fn on_existing_user_sign_up(
        &self,
        payload: ExistingUserSignUpPayload,
        request: Option<&Request<Vec<u8>>>,
    ) -> Result<(), OpenAuthError> {
        self(payload, request)
    }
}

/// Email/password authentication configuration.
#[derive(Clone)]
pub struct EmailPasswordOptions {
    pub enabled: bool,
    pub disable_sign_up: bool,
    pub auto_sign_in: bool,
    pub require_email_verification: bool,
    pub on_existing_user_sign_up: Option<Arc<dyn OnExistingUserSignUp>>,
}

impl Default for EmailPasswordOptions {
    fn default() -> Self {
        Self {
            enabled: true,
            disable_sign_up: false,
            auto_sign_in: true,
            require_email_verification: false,
            on_existing_user_sign_up: None,
        }
    }
}

impl EmailPasswordOptions {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn builder() -> Self {
        Self::new()
    }

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

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

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

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

    #[must_use]
    pub fn on_existing_user_sign_up<H>(mut self, handler: H) -> Self
    where
        H: OnExistingUserSignUp,
    {
        self.on_existing_user_sign_up = Some(Arc::new(handler));
        self
    }
}

impl fmt::Debug for EmailPasswordOptions {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("EmailPasswordOptions")
            .field("enabled", &self.enabled)
            .field("disable_sign_up", &self.disable_sign_up)
            .field("auto_sign_in", &self.auto_sign_in)
            .field(
                "require_email_verification",
                &self.require_email_verification,
            )
            .field(
                "on_existing_user_sign_up",
                &self
                    .on_existing_user_sign_up
                    .as_ref()
                    .map(|_| "<on-existing-user-sign-up>"),
            )
            .finish()
    }
}