feat: Implémentation complète du système d'authentification OAuth

PHASE 1 - CORRECTIONS CRITIQUES TERMINÉES

✅ API Routes Auth créées:
- /api/auth/login: Initie le flux OAuth avec Keycloak
- /api/auth/token: Échange le code OAuth contre des tokens
- /api/auth/logout: Déconnexion et nettoyage des tokens
- /api/auth/userinfo: Récupère les informations utilisateur

✅ Middleware d'authentification:
- Protection des routes privées
- Vérification de l'access_token dans les cookies HttpOnly
- Vérification de l'expiration des tokens
- Redirection automatique vers /auth/login si non authentifié
- Routes publiques configurées (/auth/*, /api/health, /)

✅ Page de login:
- Interface moderne avec PrimeReact
- Redirection vers Keycloak OAuth
- Gestion du returnUrl pour revenir à la page demandée

✅ Sécurité:
- Tokens stockés dans cookies HttpOnly (pas localStorage)
- Protection CSRF avec state parameter
- Validation de l'expiration des tokens
- Nettoyage automatique des cookies expirés

✅ Callback OAuth:
- Protection contre les appels multiples (useRef)
- Gestion d'erreurs robuste
- Nettoyage de l'URL après échange
- Suspense boundary pour le chargement

Cette implémentation résout les problèmes critiques:
- Boucle OAuth infinie (code réutilisé)
- Absence d'API route token exchange
- Middleware non fonctionnel
- Pas de page de login

🤖 Generated with Claude Code
Co-Authored-By: Claude <noreply@anthropic.com>

middleware.ts

@@ -1,25 +1,97 @@
 /**
- * Middleware Next.js simplifié
+ * Middleware Next.js pour l'authentification OAuth avec Keycloak
  *
- * L'authentification est entièrement gérée par le backend Quarkus avec Keycloak OIDC.
- * Le middleware frontend laisse passer toutes les requêtes.
- *
- * Flux d'authentification:
- * 1. User accède à une page protégée du frontend (ex: /dashboard)
- * 2. Frontend appelle l'API backend (ex: http://localhost:8080/api/v1/dashboard)
- * 3. Backend détecte absence de session -> redirige vers Keycloak (security.lions.dev)
- * 4. User se connecte sur Keycloak
- * 5. Keycloak redirige vers le backend avec le code OAuth
- * 6. Backend échange le code, crée une session, renvoie un cookie
- * 7. Frontend reçoit le cookie et peut maintenant appeler l'API
+ * Ce middleware protège les routes privées en vérifiant la présence
+ * d'un access_token dans les cookies HttpOnly.
  */
 
 import { NextResponse } from 'next/server';
 import type { NextRequest } from 'next/server';
 
+// Routes publiques accessibles sans authentification
+const PUBLIC_ROUTES = [
+  '/',
+  '/auth/login',
+  '/auth/callback',
+  '/api/auth/login',
+  '/api/auth/callback',
+  '/api/auth/token',
+  '/api/health',
+];
+
+// Routes API publiques (patterns)
+const PUBLIC_API_PATTERNS = [
+  /^\/api\/auth\/.*/,
+  /^\/api\/health/,
+];
+
+// Vérifie si une route est publique
+function isPublicRoute(pathname: string): boolean {
+  // Vérifier les routes exactes
+  if (PUBLIC_ROUTES.includes(pathname)) {
+    return true;
+  }
+
+  // Vérifier les patterns
+  return PUBLIC_API_PATTERNS.some(pattern => pattern.test(pathname));
+}
+
 export function middleware(request: NextRequest) {
-  // Le middleware ne fait plus rien - l'authentification est gérée par le backend
-  // Toutes les requêtes sont autorisées côté frontend
+  const { pathname } = request.nextUrl;
+
+  console.log('🔒 Middleware - Checking:', pathname);
+
+  // Laisser passer les routes publiques
+  if (isPublicRoute(pathname)) {
+    console.log('✅ Middleware - Public route, allowing');
+    return NextResponse.next();
+  }
+
+  // Laisser passer les fichiers statiques
+  if (
+    pathname.startsWith('/_next') ||
+    pathname.startsWith('/static') ||
+    pathname.includes('.')
+  ) {
+    return NextResponse.next();
+  }
+
+  // Vérifier la présence du token d'authentification
+  const accessToken = request.cookies.get('access_token');
+  const tokenExpiresAt = request.cookies.get('token_expires_at');
+
+  if (!accessToken) {
+    console.log('❌ Middleware - No access token, redirecting to login');
+
+    // Rediriger vers la page de login avec l'URL de retour
+    const loginUrl = new URL('/auth/login', request.url);
+    loginUrl.searchParams.set('returnUrl', pathname);
+
+    return NextResponse.redirect(loginUrl);
+  }
+
+  // Vérifier si le token est expiré
+  if (tokenExpiresAt) {
+    const expiresAt = parseInt(tokenExpiresAt.value, 10);
+    const now = Date.now();
+
+    if (now >= expiresAt) {
+      console.log('❌ Middleware - Token expired, redirecting to login');
+
+      // Supprimer les cookies expirés
+      const response = NextResponse.redirect(new URL('/auth/login', request.url));
+      response.cookies.delete('access_token');
+      response.cookies.delete('refresh_token');
+      response.cookies.delete('id_token');
+      response.cookies.delete('token_expires_at');
+
+      return response;
+    }
+  }
+
+  console.log('✅ Middleware - Authenticated, allowing');
+
+  // L'utilisateur est authentifié, laisser passer
   return NextResponse.next();
 }
 
@@ -33,6 +105,6 @@ export const config = {
      * - favicon.ico (favicon file)
      * - public files (images, etc.)
      */
-    '/((?!_next/static|_next/image|favicon.ico|.*\..*|public).*)',
+    '/((?!_next/static|_next/image|favicon.ico|.*\\..*|public).*)',
   ],
 };