Skip to main content

auth_framework/api/
server.rs

1//! REST API Server Implementation
2//!
3//! Main server that hosts all API endpoints
4
5use crate::AuthFramework;
6use crate::api::{ApiState, admin, auth, health, mfa, middleware, oauth, users};
7use axum::{
8    Router,
9    extract::DefaultBodyLimit,
10    http::Method,
11    middleware as axum_middleware,
12    routing::{delete, get, post, put},
13};
14use std::net::SocketAddr;
15use std::sync::Arc;
16use tower::ServiceBuilder;
17use tower_http::{
18    cors::{Any, CorsLayer},
19    trace::TraceLayer,
20};
21use tracing::info;
22
23/// API Server configuration
24#[derive(Debug, Clone)]
25pub struct ApiServerConfig {
26    pub host: String,
27    pub port: u16,
28    pub enable_cors: bool,
29    pub max_body_size: usize,
30    pub enable_tracing: bool,
31}
32
33impl Default for ApiServerConfig {
34    fn default() -> Self {
35        Self {
36            host: "127.0.0.1".to_string(),
37            port: 8080,
38            enable_cors: true,
39            max_body_size: 1024 * 1024, // 1MB
40            enable_tracing: true,
41        }
42    }
43}
44
45/// REST API Server
46pub struct ApiServer {
47    config: ApiServerConfig,
48    auth_framework: Arc<AuthFramework>,
49}
50
51impl ApiServer {
52    /// Create new API server
53    pub fn new(auth_framework: Arc<AuthFramework>) -> Self {
54        Self {
55            config: ApiServerConfig::default(),
56            auth_framework,
57        }
58    }
59
60    /// Create new API server with custom configuration
61    pub fn with_config(auth_framework: Arc<AuthFramework>, config: ApiServerConfig) -> Self {
62        Self {
63            config,
64            auth_framework,
65        }
66    }
67
68    /// Build the router with all routes and middleware
69    pub async fn build_router(&self) -> crate::errors::Result<Router> {
70        let state = ApiState::new(self.auth_framework.clone()).await?;
71
72        // Create the main router with all routes
73        let router = Router::new()
74            // Health and monitoring endpoints (public)
75            .route("/health", get(health::health_check))
76            .route("/health/detailed", get(health::detailed_health_check))
77            .route("/metrics", get(health::metrics))
78            .route("/readiness", get(health::readiness_check))
79            .route("/liveness", get(health::liveness_check))
80            // Authentication endpoints (public)
81            .route("/auth/login", post(auth::login))
82            .route("/auth/refresh", post(auth::refresh_token))
83            .route("/auth/logout", post(auth::logout))
84            .route("/auth/validate", get(auth::validate_token))
85            .route("/auth/providers", get(auth::list_providers))
86            // OAuth 2.0 endpoints (mostly public)
87            .route("/oauth/authorize", get(oauth::authorize))
88            .route("/oauth/token", post(oauth::token))
89            .route("/oauth/revoke", post(oauth::revoke_token))
90            .route("/oauth/introspect", post(oauth::introspect_token))
91            .route("/oauth/clients/{client_id}", get(oauth::get_client_info))
92            // User management endpoints (authenticated)
93            .route("/users/profile", get(users::get_profile))
94            .route("/users/profile", put(users::update_profile))
95            .route("/users/change-password", post(users::change_password))
96            .route("/users/sessions", get(users::get_sessions))
97            .route(
98                "/users/sessions/{session_id}",
99                delete(users::revoke_session),
100            )
101            .route("/users/{user_id}/profile", get(users::get_user_profile))
102            // Multi-factor authentication endpoints (authenticated)
103            .route("/mfa/setup", post(mfa::setup_mfa))
104            .route("/mfa/verify", post(mfa::verify_mfa))
105            .route("/mfa/disable", post(mfa::disable_mfa))
106            .route("/mfa/status", get(mfa::get_mfa_status))
107            .route(
108                "/mfa/regenerate-backup-codes",
109                post(mfa::regenerate_backup_codes),
110            )
111            .route("/mfa/verify-backup-code", post(mfa::verify_backup_code))
112            // Administrative endpoints (admin only)
113            .route("/admin/users", get(admin::list_users))
114            .route("/admin/users", post(admin::create_user))
115            .route(
116                "/admin/users/{user_id}/roles",
117                put(admin::update_user_roles),
118            )
119            .route("/admin/users/{user_id}", delete(admin::delete_user))
120            .route("/admin/users/{user_id}/activate", put(admin::activate_user))
121            .route("/admin/stats", get(admin::get_system_stats))
122            .route("/admin/audit-logs", get(admin::get_audit_logs))
123            // Set shared state
124            .with_state(state.clone());
125
126        // Add middleware layers
127        let middleware_stack = ServiceBuilder::new()
128            .layer(axum_middleware::from_fn(middleware::timeout_middleware))
129            .layer(axum_middleware::from_fn(
130                middleware::security_headers_middleware,
131            ))
132            .layer(axum_middleware::from_fn(middleware::rate_limit_middleware))
133            .layer(axum_middleware::from_fn(middleware::logging_middleware));
134
135        let router = if self.config.enable_cors {
136            router.layer(
137                CorsLayer::new()
138                    .allow_origin(Any)
139                    .allow_methods([
140                        Method::GET,
141                        Method::POST,
142                        Method::PUT,
143                        Method::DELETE,
144                        Method::OPTIONS,
145                    ])
146                    .allow_headers(Any)
147                    .max_age(std::time::Duration::from_secs(3600)),
148            )
149        } else {
150            router
151        };
152
153        let router = if self.config.enable_tracing {
154            router.layer(TraceLayer::new_for_http())
155        } else {
156            router
157        };
158
159        Ok(router
160            .layer(middleware_stack)
161            .layer(DefaultBodyLimit::max(self.config.max_body_size)))
162    }
163
164    /// Start the API server
165    pub async fn start(&self) -> Result<(), Box<dyn std::error::Error>> {
166        let app = self.build_router().await?;
167
168        let addr = SocketAddr::new(self.config.host.parse()?, self.config.port);
169
170        info!("🚀 AuthFramework API server starting on http://{}", addr);
171        info!("📖 API documentation available at http://{}/docs", addr);
172        info!("🏥 Health check available at http://{}/health", addr);
173        info!("📊 Metrics available at http://{}/metrics", addr);
174
175        let listener = tokio::net::TcpListener::bind(addr).await?;
176        axum::serve(listener, app).await?;
177
178        Ok(())
179    }
180
181    /// Get server configuration
182    pub fn config(&self) -> &ApiServerConfig {
183        &self.config
184    }
185
186    /// Get server address
187    pub fn address(&self) -> String {
188        format!("{}:{}", self.config.host, self.config.port)
189    }
190}
191
192/// Create a basic API server with default configuration
193pub async fn create_api_server(auth_framework: Arc<AuthFramework>) -> ApiServer {
194    ApiServer::new(auth_framework)
195}
196
197/// Create an API server with custom host and port
198pub async fn create_api_server_with_address(
199    auth_framework: Arc<AuthFramework>,
200    host: impl Into<String>,
201    port: u16,
202) -> ApiServer {
203    let config = ApiServerConfig {
204        host: host.into(),
205        port,
206        ..Default::default()
207    };
208    ApiServer::with_config(auth_framework, config)
209}
210
211#[cfg(test)]
212mod tests {
213    use super::*;
214    use crate::storage::memory::InMemoryStorage;
215    use crate::{AuthConfig, AuthFramework};
216    use axum_test::TestServer;
217
218    #[ignore = "TestServer compatibility issue - axum-test version mismatch"]
219    async fn create_test_server() -> TestServer {
220        let _storage = Arc::new(InMemoryStorage::new());
221        let config = AuthConfig::default();
222        let auth_framework = Arc::new(AuthFramework::new(config));
223
224        let api_server = ApiServer::new(auth_framework);
225        let _app = api_server.build_router().await.unwrap();
226
227        // Note: TestServer compatibility issue with current axum-test version
228        // The Router type doesn't properly implement IntoTransportLayer
229        todo!("TestServer::new needs axum-test compatibility fix")
230    }
231
232    #[tokio::test]
233    #[ignore = "TestServer compatibility issue"]
234    async fn test_health_endpoint() {
235        let server = create_test_server().await;
236
237        let response = server.get("/health").await;
238        response.assert_status_ok();
239
240        let body: serde_json::Value = response.json();
241        assert_eq!(body["status"], "healthy");
242    }
243
244    #[tokio::test]
245    #[ignore = "TestServer compatibility issue"]
246    async fn test_auth_required_endpoints() {
247        let server = create_test_server().await;
248
249        // Try to access protected endpoint without token
250        let response = server.get("/users/profile").await;
251        response.assert_status_unauthorized();
252    }
253
254    #[tokio::test]
255    #[ignore = "TestServer compatibility issue"]
256    async fn test_cors_headers() {
257        let server = create_test_server().await;
258
259        let response = server.get("/health").await;
260        response.assert_status_ok();
261
262        // Check CORS headers are present
263        assert!(
264            response
265                .headers()
266                .contains_key("access-control-allow-origin")
267        );
268    }
269}