systemprompt_models/auth/
enums.rs

1use serde::{Deserialize, Serialize};
2use std::fmt;
3use std::str::FromStr;
4
5use crate::errors::ParseEnumError;
6
7#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
8#[serde(rename_all = "lowercase")]
9pub enum JwtAudience {
10    Web,
11    Api,
12    A2a,
13    Mcp,
14    Internal,
15    Cowork,
16    #[serde(untagged)]
17    Resource(String),
18}
19
20impl JwtAudience {
21    pub fn as_str(&self) -> &str {
22        match self {
23            Self::Web => "web",
24            Self::Api => "api",
25            Self::A2a => "a2a",
26            Self::Mcp => "mcp",
27            Self::Internal => "internal",
28            Self::Cowork => "cowork",
29            Self::Resource(s) => s.as_str(),
30        }
31    }
32
33    pub fn standard() -> Vec<Self> {
34        vec![Self::Web, Self::Api, Self::A2a, Self::Mcp]
35    }
36
37    pub fn service() -> Vec<Self> {
38        vec![Self::Api, Self::Mcp, Self::A2a, Self::Internal]
39    }
40}
41
42impl fmt::Display for JwtAudience {
43    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
44        write!(f, "{}", self.as_str())
45    }
46}
47
48impl FromStr for JwtAudience {
49    type Err = ParseEnumError;
50    fn from_str(s: &str) -> Result<Self, Self::Err> {
51        match s {
52            "web" => Ok(Self::Web),
53            "api" => Ok(Self::Api),
54            "a2a" => Ok(Self::A2a),
55            "mcp" => Ok(Self::Mcp),
56            "internal" => Ok(Self::Internal),
57            "cowork" => Ok(Self::Cowork),
58            _ => Ok(Self::Resource(s.to_string())),
59        }
60    }
61}
62
63#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
64#[serde(rename_all = "lowercase")]
65pub enum UserType {
66    Admin,
67    User,
68    A2a,
69    Mcp,
70    Service,
71    Anon,
72    Unknown,
73}
74
75impl UserType {
76    pub const fn as_str(&self) -> &'static str {
77        match self {
78            Self::Admin => "admin",
79            Self::User => "user",
80            Self::A2a => "a2a",
81            Self::Mcp => "mcp",
82            Self::Service => "service",
83            Self::Anon => "anon",
84            Self::Unknown => "unknown",
85        }
86    }
87
88    pub const fn rate_tier(&self) -> RateLimitTier {
89        match self {
90            Self::Admin => RateLimitTier::Admin,
91            Self::User => RateLimitTier::User,
92            Self::A2a => RateLimitTier::A2a,
93            Self::Mcp => RateLimitTier::Mcp,
94            Self::Service => RateLimitTier::Service,
95            Self::Anon | Self::Unknown => RateLimitTier::Anon,
96        }
97    }
98}
99
100impl fmt::Display for UserType {
101    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
102        write!(f, "{}", self.as_str())
103    }
104}
105
106impl FromStr for UserType {
107    type Err = ParseEnumError;
108    fn from_str(s: &str) -> Result<Self, Self::Err> {
109        match s {
110            "admin" => Ok(Self::Admin),
111            "user" => Ok(Self::User),
112            "a2a" => Ok(Self::A2a),
113            "mcp" => Ok(Self::Mcp),
114            "service" => Ok(Self::Service),
115            "anon" => Ok(Self::Anon),
116            "unknown" => Ok(Self::Unknown),
117            _ => Err(ParseEnumError::new("user_type", s)),
118        }
119    }
120}
121
122#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
123pub enum TokenType {
124    #[default]
125    Bearer,
126}
127
128impl TokenType {
129    pub const fn as_str(self) -> &'static str {
130        match self {
131            Self::Bearer => "Bearer",
132        }
133    }
134}
135
136impl fmt::Display for TokenType {
137    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
138        write!(f, "Bearer")
139    }
140}
141
142#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
143#[serde(rename_all = "lowercase")]
144pub enum RateLimitTier {
145    Admin,
146    User,
147    A2a,
148    Mcp,
149    Service,
150    Anon,
151}
152
153impl RateLimitTier {
154    pub const fn as_str(&self) -> &'static str {
155        match self {
156            Self::Admin => "admin",
157            Self::User => "user",
158            Self::A2a => "a2a",
159            Self::Mcp => "mcp",
160            Self::Service => "service",
161            Self::Anon => "anon",
162        }
163    }
164}
165
166impl fmt::Display for RateLimitTier {
167    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
168        write!(f, "{}", self.as_str())
169    }
170}
171
172impl FromStr for RateLimitTier {
173    type Err = ParseEnumError;
174    fn from_str(s: &str) -> Result<Self, Self::Err> {
175        match s {
176            "admin" => Ok(Self::Admin),
177            "user" => Ok(Self::User),
178            "a2a" => Ok(Self::A2a),
179            "mcp" => Ok(Self::Mcp),
180            "service" => Ok(Self::Service),
181            "anon" => Ok(Self::Anon),
182            _ => Err(ParseEnumError::new("rate_limit_tier", s)),
183        }
184    }
185}
186
187#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
188#[serde(rename_all = "lowercase")]
189pub enum UserRole {
190    Admin,
191    User,
192    Anonymous,
193}
194
195impl UserRole {
196    pub const fn as_str(&self) -> &'static str {
197        match self {
198            Self::Admin => "admin",
199            Self::User => "user",
200            Self::Anonymous => "anonymous",
201        }
202    }
203}
204
205impl fmt::Display for UserRole {
206    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
207        write!(f, "{}", self.as_str())
208    }
209}
210
211impl FromStr for UserRole {
212    type Err = ParseEnumError;
213    fn from_str(s: &str) -> Result<Self, Self::Err> {
214        match s {
215            "admin" => Ok(Self::Admin),
216            "user" => Ok(Self::User),
217            "anonymous" => Ok(Self::Anonymous),
218            _ => Err(ParseEnumError::new("user_role", s)),
219        }
220    }
221}
222
223#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
224#[serde(rename_all = "lowercase")]
225pub enum UserStatus {
226    Active,
227    Inactive,
228    Suspended,
229    Pending,
230    Deleted,
231    Temporary,
232}
233
234impl UserStatus {
235    pub const fn as_str(&self) -> &'static str {
236        match self {
237            Self::Active => "active",
238            Self::Inactive => "inactive",
239            Self::Suspended => "suspended",
240            Self::Pending => "pending",
241            Self::Deleted => "deleted",
242            Self::Temporary => "temporary",
243        }
244    }
245
246    pub const fn is_active(&self) -> bool {
247        matches!(self, Self::Active)
248    }
249}
250
251impl fmt::Display for UserStatus {
252    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
253        write!(f, "{}", self.as_str())
254    }
255}
256
257impl FromStr for UserStatus {
258    type Err = ParseEnumError;
259    fn from_str(s: &str) -> Result<Self, Self::Err> {
260        match s {
261            "active" => Ok(Self::Active),
262            "inactive" => Ok(Self::Inactive),
263            "suspended" => Ok(Self::Suspended),
264            "pending" => Ok(Self::Pending),
265            "deleted" => Ok(Self::Deleted),
266            "temporary" => Ok(Self::Temporary),
267            _ => Err(ParseEnumError::new("user_status", s)),
268        }
269    }
270}
systemprompt_models/auth/enums.rs

systemprompt_models/auth/
enums.rs
