1use 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#[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, enable_tracing: true,
41 }
42 }
43}
44
45pub struct ApiServer {
47 config: ApiServerConfig,
48 auth_framework: Arc<AuthFramework>,
49}
50
51impl ApiServer {
52 pub fn new(auth_framework: Arc<AuthFramework>) -> Self {
54 Self {
55 config: ApiServerConfig::default(),
56 auth_framework,
57 }
58 }
59
60 pub fn with_config(auth_framework: Arc<AuthFramework>, config: ApiServerConfig) -> Self {
62 Self {
63 config,
64 auth_framework,
65 }
66 }
67
68 pub async fn build_router(&self) -> crate::errors::Result<Router> {
70 let state = ApiState::new(self.auth_framework.clone()).await?;
71
72 let router = Router::new()
74 .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 .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 .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 .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 .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 .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 .with_state(state.clone());
125
126 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 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 pub fn config(&self) -> &ApiServerConfig {
183 &self.config
184 }
185
186 pub fn address(&self) -> String {
188 format!("{}:{}", self.config.host, self.config.port)
189 }
190}
191
192pub async fn create_api_server(auth_framework: Arc<AuthFramework>) -> ApiServer {
194 ApiServer::new(auth_framework)
195}
196
197pub 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 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 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 assert!(
264 response
265 .headers()
266 .contains_key("access-control-allow-origin")
267 );
268 }
269}