init

src/http/server.rs

@@ -20,7 +20,7 @@ use crate::core::AppState;
 use crate::routes;
 
 use super::metrics::HttpMetrics;
-use super::middleware::context_middleware;
+use super::middleware;
 
 // ── Erreurs ───────────────────────────────────────────────────────────────────
 
@@ -44,8 +44,9 @@ pub enum HttpServerError {
 /// - Injecte [`AppState`] via le middleware (les handlers l'obtiendront via
 ///   `State<AppState>` quand ils seront implémentés ; `.with_state()` sera
 ///   ajouté en conséquence).
-/// - Applique [`context_middleware`] (authentification JWT + contexte de
-///   requête) sur l'ensemble du router.
+/// - Applique [`middleware::request_context_middleware`] (contexte de requête)
+///   et [`middleware::auth_middleware`] (authentification JWT) sur l'ensemble
+///   du router.
 /// - Empile les layers Tower : [`CatchPanicLayer`], [`CorsLayer`] (permissif),
 ///   [`TraceLayer`].
 /// - Collecte des métriques via [`HttpMetrics`] et les reporte périodiquement.
@@ -104,35 +105,35 @@ impl HttpServer {
     /// La future se résout lorsqu'un signal de shutdown est reçu ou qu'une
     /// erreur I/O fatale survient.
     pub async fn run(mut self) -> Result<(), HttpServerError> {
-        let metrics = self.metrics.clone();
         let app_state = self.app_state.clone();
 
         // Construit le router avec state + middleware + layers Tower.
         //
-        // Ordre d'application en axum : chaque `.layer()` enveloppe le service
-        // courant — le dernier appel devient la couche la plus externe.
+        // Ordre d'application en axum (LIFO) : le dernier .layer() ajouté est le premier exécuté.
         //
-        //  CatchPanicLayer  (outermost — intercepte tout panic en dessous)
-        //    └─ CorsLayer   (répond aux preflight avant auth)
-        //         └─ TraceLayer  (span tracing sur la durée totale)
-        //              └─ context_middleware  (JWT + RequestContext + métriques)
-        //                   └─ routes (handlers)
+        // Courant de la requête :
+        // 1. CatchPanicLayer (le plus externe)
+        // 2. CorsLayer
+        // 3. TraceLayer
+        // 4. metrics_middleware (commence le chrono)
+        // 5. request_context_middleware (init ID)
+        // 6. auth_middleware (identifie l'utilisateur)
+        // 7. Routes (handlers)
         let app: Router = routes::router()
             .with_state(app_state.clone())
-            // Innermost : auth JWT, injection contexte, métriques
+            // Identification de l'utilisateur (optionnelle ici)
             .layer(axum_middleware::from_fn_with_state(
                 app_state.clone(),
-                move |state, req, next| {
-                    let metrics = metrics.clone();
-                    async move {
-                        metrics.inc_request();
-                        let started = std::time::Instant::now();
-                        let response = context_middleware(state, req, next).await;
-                        let latency = started.elapsed();
-                        metrics.record_response(response.status().as_u16(), latency);
-                        response
-                    }
-                },
+                middleware::auth_middleware,
+            ))
+            // Initialisation du contexte (ID de requête, etc.)
+            .layer(axum_middleware::from_fn(
+                middleware::request_context_middleware,
+            ))
+            // Métriques (mesure de la durée totale de la requête)
+            .layer(axum_middleware::from_fn_with_state(
+                app_state.metrics.http.clone(),
+                middleware::metrics_middleware,
             ))
             // Spans tracing par requête (method, uri, status, latency)
             .layer(TraceLayer::new_for_http())