rustauth-core 0.2.0

Core types and primitives for RustAuth.
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
129
130
131
132

//! API error handling options (parity with Better Auth `onAPIError`).

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

use crate::api::{ApiRequest, ApiResponse};
use crate::error::RustAuthError;

/// Configuration for unhandled API errors.
#[derive(Clone, Default)]
pub struct OnApiErrorOptions {
    /// When true, internal errors propagate instead of returning JSON/redirect responses.
    pub throw: bool,
    /// Default redirect target for OAuth-style error flows.
    pub error_url: Option<String>,
    pub default_error_page: DefaultErrorPage,
    pub on_error: Option<Arc<dyn OnApiErrorHandler>>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DefaultErrorPage {
    pub title: String,
    pub heading: String,
    pub message: String,
}

impl Default for DefaultErrorPage {
    fn default() -> Self {
        Self {
            title: "Error".to_owned(),
            heading: "Something went wrong".to_owned(),
            message: "We encountered an unexpected error.".to_owned(),
        }
    }
}

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

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

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

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

impl fmt::Debug for OnApiErrorOptions {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("OnApiErrorOptions")
            .field("throw", &self.throw)
            .field("error_url", &self.error_url)
            .field("default_error_page", &self.default_error_page)
            .field(
                "on_error",
                &self.on_error.as_ref().map(|_| "<on-api-error>"),
            )
            .finish()
    }
}

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

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

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

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

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

/// Hook invoked when the router surfaces an unhandled error.
pub trait OnApiErrorHandler: Send + Sync + 'static {
    fn on_error(
        &self,
        error: &RustAuthError,
        request: &ApiRequest,
    ) -> Result<Option<ApiResponse>, RustAuthError>;
}

impl<F> OnApiErrorHandler for F
where
    F: Fn(&RustAuthError, &ApiRequest) -> Result<Option<ApiResponse>, RustAuthError>
        + Send
        + Sync
        + 'static,
{
    fn on_error(
        &self,
        error: &RustAuthError,
        request: &ApiRequest,
    ) -> Result<Option<ApiResponse>, RustAuthError> {
        self(error, request)
    }
}