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