Skip to main content

auth_framework/api/
auth.rs

1//! Authentication API Endpoints
2//!
3//! Handles login, logout, token refresh, and related authentication operations
4
5use crate::api::{ApiResponse, ApiState, extract_bearer_token};
6use axum::{Json, extract::State, http::HeaderMap};
7use serde::{Deserialize, Serialize};
8
9/// Login request payload
10#[derive(Debug, Deserialize)]
11pub struct LoginRequest {
12    pub username: String,
13    pub password: String,
14    #[serde(default)]
15    pub mfa_code: Option<String>,
16    #[serde(default)]
17    pub remember_me: bool,
18}
19
20/// Login response data
21#[derive(Debug, Serialize)]
22pub struct LoginResponse {
23    pub access_token: String,
24    pub refresh_token: String,
25    pub token_type: String,
26    pub expires_in: u64,
27    pub user: UserInfo,
28}
29
30/// User information in login response
31#[derive(Debug, Serialize)]
32pub struct UserInfo {
33    pub id: String,
34    pub username: String,
35    pub roles: Vec<String>,
36    pub permissions: Vec<String>,
37}
38
39/// Token refresh request
40#[derive(Debug, Deserialize)]
41pub struct RefreshRequest {
42    pub refresh_token: String,
43}
44
45/// Token refresh response
46#[derive(Debug, Serialize)]
47pub struct RefreshResponse {
48    pub access_token: String,
49    pub token_type: String,
50    pub expires_in: u64,
51}
52
53/// Logout request
54#[derive(Debug, Deserialize)]
55pub struct LogoutRequest {
56    #[serde(default)]
57    pub refresh_token: Option<String>,
58}
59
60/// POST /auth/login
61pub async fn login(
62    State(state): State<ApiState>,
63    Json(req): Json<LoginRequest>,
64) -> ApiResponse<LoginResponse> {
65    // Validate required fields
66    if req.username.is_empty() || req.password.is_empty() {
67        return ApiResponse::validation_error_typed("Username and password are required");
68    }
69
70    // Create credential for authentication
71    let credential = crate::authentication::credentials::Credential::Password {
72        username: req.username.clone(),
73        password: req.password.clone(),
74    };
75
76    // Attempt authentication
77    match state
78        .auth_framework
79        .authenticate("password", credential)
80        .await
81    {
82        Ok(auth_result) => match auth_result {
83            crate::auth::AuthResult::Success(token) => {
84                // Create response with token information
85                let user_info = UserInfo {
86                    id: token.user_id.clone(),
87                    username: req.username,
88                    roles: token.roles.clone(),
89                    permissions: token.permissions.clone(),
90                };
91
92                // Generate actual JWT access token
93                let token_lifetime = std::time::Duration::from_secs(3600); // 1 hour
94                let access_token = match state.auth_framework.token_manager().create_jwt_token(
95                    &token.user_id,
96                    token.permissions.clone(),
97                    Some(token_lifetime),
98                ) {
99                    Ok(jwt) => jwt,
100                    Err(e) => {
101                        tracing::error!("Failed to create JWT token: {}", e);
102                        return ApiResponse::error_typed(
103                            "TOKEN_CREATION_FAILED",
104                            "Failed to create access token",
105                        );
106                    }
107                };
108
109                // Generate refresh token with longer lifetime
110                let refresh_token_lifetime = std::time::Duration::from_secs(86400 * 7); // 7 days
111                let refresh_token = match state
112                    .auth_framework
113                    .token_manager()
114                    .create_refresh_jwt_token(&token.user_id, Some(refresh_token_lifetime))
115                {
116                    Ok(jwt) => jwt,
117                    Err(e) => {
118                        tracing::error!("Failed to create refresh token: {}", e);
119                        return ApiResponse::error_typed(
120                            "TOKEN_CREATION_FAILED",
121                            "Failed to create refresh token",
122                        );
123                    }
124                };
125
126                let response = LoginResponse {
127                    access_token,
128                    refresh_token,
129                    token_type: "Bearer".to_string(),
130                    expires_in: 3600, // 1 hour
131                    user: user_info,
132                };
133
134                ApiResponse::success(response)
135            }
136            crate::auth::AuthResult::MfaRequired(_challenge) => {
137                // In real implementation, return MFA challenge info
138                ApiResponse::error_typed("MFA_REQUIRED", "Multi-factor authentication required")
139            }
140            crate::auth::AuthResult::Failure(reason) => {
141                ApiResponse::error_typed("AUTHENTICATION_FAILED", reason)
142            }
143        },
144        Err(e) => {
145            // Convert auth error to API error
146            if matches!(e, crate::errors::AuthError::AuthMethod { .. }) {
147                ApiResponse::error_typed("INVALID_CREDENTIALS", "Invalid username or password")
148            } else {
149                ApiResponse::error_typed("AUTH_ERROR", "Authentication failed")
150            }
151        }
152    }
153}
154
155/// POST /auth/refresh
156pub async fn refresh_token(
157    State(state): State<ApiState>,
158    Json(req): Json<RefreshRequest>,
159) -> ApiResponse<RefreshResponse> {
160    if req.refresh_token.is_empty() {
161        return ApiResponse::validation_error_typed("Refresh token is required");
162    }
163
164    // Validate the refresh token
165    match state
166        .auth_framework
167        .token_manager()
168        .validate_jwt_token(&req.refresh_token)
169    {
170        Ok(claims) => {
171            // Only a token minted as a refresh token qualifies. The scope string is not
172            // consulted: it is permission data, and an access token's can contain the word.
173            if !claims.is_refresh_token() {
174                return ApiResponse::error_typed("INVALID_TOKEN", "Token is not a refresh token");
175            }
176
177            // Create new access token
178            let token_lifetime = std::time::Duration::from_secs(3600); // 1 hour
179            let new_access_token = match state.auth_framework.token_manager().create_jwt_token(
180                &claims.sub,
181                vec!["read".to_string(), "write".to_string()], // Default permissions
182                Some(token_lifetime),
183            ) {
184                Ok(jwt) => jwt,
185                Err(e) => {
186                    tracing::error!("Failed to create new access token: {}", e);
187                    return ApiResponse::error_typed(
188                        "TOKEN_CREATION_FAILED",
189                        "Failed to create new access token",
190                    );
191                }
192            };
193
194            let response = RefreshResponse {
195                access_token: new_access_token,
196                token_type: "Bearer".to_string(),
197                expires_in: 3600,
198            };
199
200            ApiResponse::success(response)
201        }
202        Err(e) => {
203            tracing::warn!("Invalid refresh token: {}", e);
204            ApiResponse::error_typed("INVALID_TOKEN", "Invalid or expired refresh token")
205        }
206    }
207}
208
209/// POST /auth/logout
210pub async fn logout(
211    State(_state): State<ApiState>,
212    headers: HeaderMap,
213    Json(req): Json<LogoutRequest>,
214) -> ApiResponse<()> {
215    // Extract token from Authorization header
216    if let Some(token) = extract_bearer_token(&headers) {
217        // In a real implementation, invalidate the token
218        tracing::info!("Logging out user with token: {}", &token[..10]);
219    }
220
221    // If refresh token provided, invalidate it too
222    if let Some(ref refresh_token) = req.refresh_token {
223        tracing::info!("Invalidating refresh token: {}", &refresh_token[..10]);
224    }
225
226    ApiResponse::<()>::ok_with_message("Successfully logged out")
227}
228
229/// GET /auth/validate
230/// Validate current token and return user information
231pub async fn validate_token(
232    State(state): State<ApiState>,
233    headers: HeaderMap,
234) -> ApiResponse<UserInfo> {
235    match extract_bearer_token(&headers) {
236        Some(token) => {
237            match crate::api::validate_api_token(&state.auth_framework, &token).await {
238                Ok(auth_token) => {
239                    // Fetch actual user information from storage
240                    let username = match state
241                        .auth_framework
242                        .get_user_profile(&auth_token.user_id)
243                        .await
244                    {
245                        Ok(profile) => profile
246                            .username
247                            .unwrap_or_else(|| format!("user_{}", auth_token.user_id)),
248                        Err(_) => format!("user_{}", auth_token.user_id), // Fallback if profile fetch fails
249                    };
250
251                    let user_info = UserInfo {
252                        id: auth_token.user_id,
253                        username,
254                        roles: auth_token.roles,
255                        permissions: auth_token.permissions,
256                    };
257                    ApiResponse::success(user_info)
258                }
259                Err(_e) => ApiResponse::error_typed("AUTH_ERROR", "Token validation failed"),
260            }
261        }
262        None => ApiResponse::unauthorized_typed(),
263    }
264}
265
266/// GET /auth/providers
267/// List available OAuth providers
268pub async fn list_providers(State(_state): State<ApiState>) -> ApiResponse<Vec<ProviderInfo>> {
269    let providers = vec![
270        ProviderInfo {
271            name: "google".to_string(),
272            display_name: "Google".to_string(),
273            auth_url: "/oauth/google".to_string(),
274        },
275        ProviderInfo {
276            name: "github".to_string(),
277            display_name: "GitHub".to_string(),
278            auth_url: "/oauth/github".to_string(),
279        },
280        ProviderInfo {
281            name: "microsoft".to_string(),
282            display_name: "Microsoft".to_string(),
283            auth_url: "/oauth/microsoft".to_string(),
284        },
285    ];
286
287    ApiResponse::success(providers)
288}
289
290/// Provider information
291#[derive(Debug, Serialize)]
292pub struct ProviderInfo {
293    pub name: String,
294    pub display_name: String,
295    pub auth_url: String,
296}
297
298