authvault 0.1.0

Authentication and authorization vault with multi-provider support
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

//! Domain errors.

/// Authentication errors.
#[derive(Debug, thiserror::Error)]
pub enum AuthError {
    #[error("Invalid credentials")]
    InvalidCredentials,

    #[error("User not found")]
    UserNotFound,

    #[error("User already exists")]
    UserAlreadyExists,

    #[error("Token expired")]
    Expired,

    #[error("Bad token signature")]
    BadSignature,

    #[error("Token audience mismatch")]
    WrongAudience,

    #[error("Malformed token")]
    Malformed,

    #[error("Token has been revoked")]
    Revoked,

    #[error("Refresh token reuse detected — token family revoked")]
    CompromisedTokenFamily,

    #[error("Invalid refresh token")]
    InvalidRefreshToken,

    #[error("Token generation failed: {0}")]
    TokenGeneration(String),

    #[error("Token verification failed: {0}")]
    TokenVerification(String),

    #[error("Session expired")]
    SessionExpired,

    #[error("Session revoked")]
    SessionRevoked,

    #[error("Session not found")]
    SessionNotFound,

    #[error("Insufficient permissions")]
    InsufficientPermissions,

    #[error("Access denied")]
    AccessDenied,

    #[error("Account locked")]
    AccountLocked,

    #[error("Account disabled")]
    AccountDisabled,

    #[error("Email not verified")]
    EmailNotVerified,

    #[error("Password too weak: {0}")]
    PasswordTooWeak(String),

    #[error("Password hash error: {0}")]
    PasswordHashError(String),

    #[error("Storage error: {0}")]
    StorageError(String),

    #[error("Validation error: {0}")]
    ValidationError(String),
}

impl serde::Serialize for AuthError {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(&self.to_string())
    }
}