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