NeahNew/INVESTIGATION_502_ERROR.md

Investigation Erreur 502 - Redirection depuis Keycloak

🔍 Problème Identifié

Symptôme : Erreur 502 après redirection depuis Keycloak après authentification

Logs observés :

Keycloak profile callback: {
  rawProfile: { ... },
  rawRoles: undefined,
  realmAccess: undefined,  // ⚠️ PROBLÈME ICI
  groups: [ ... ]  // ✅ Groups présents
}
Profile callback raw roles: []
Profile callback cleaned roles: []

🎯 Cause Racine

Le profil Keycloak (ID token) ne contient pas realm_access.roles, mais contient groups. Les rôles sont probablement dans le token d'accès, pas dans le token ID.

✅ Correction Appliquée

Fichier : app/api/auth/options.ts - Callback JWT

Changements :

1. ✅ Extraction des rôles depuis le token d'accès (pas seulement le profil)
2. ✅ Fallback sur groups si pas de rôles
3. ✅ Logs améliorés pour debugging

Code modifié :

// Avant : Seulement depuis profile
const roles = keycloakProfile.realm_access?.roles || [];

// Après : Multi-sources
1. Essayer depuis profile (ID token)
2. Si vide, décoder access token
3. Si toujours vide, utiliser groups comme fallback

🔍 Points d'Investigation pour l'Erreur 502

1. Vérifier les logs serveur Next.js complets

Où chercher :

• Terminal Next.js (erreurs complètes)
• Logs de production (si déployé)
• Console navigateur (erreurs client)

Commandes utiles :

# Voir tous les logs
npm run dev 2>&1 | tee logs.txt

# Filtrer les erreurs
npm run dev 2>&1 | grep -i "error\|502\|exception"

2. Vérifier le callback NextAuth

Fichier : app/api/auth/callback/keycloak (géré par NextAuth)

Points à vérifier :

• ✅ Le callback reçoit bien le code OAuth
• ✅ L'échange code → tokens fonctionne
• ✅ Le callback JWT s'exécute sans erreur
• ✅ Le callback session s'exécute sans erreur

Ajouter des logs :

// Dans options.ts, callback jwt
console.log('JWT callback - account:', !!account, 'profile:', !!profile);
console.log('JWT callback - accessToken length:', account?.access_token?.length);
console.log('JWT callback - roles extracted:', cleanRoles);

3. Vérifier l'initialisation storage

Fichier : app/api/storage/init/route.ts

Problème potentiel :

• Si createUserFolderStructure() échoue, ça peut causer une 502
• Si la session n'est pas encore complètement créée

Vérifications :

// Vérifier si l'erreur vient de là
console.log('Storage init - session:', session);
console.log('Storage init - user id:', session?.user?.id);

4. Vérifier la configuration Keycloak

Problème potentiel :

• Les rôles ne sont pas mappés correctement dans Keycloak
• Le scope "roles" n'est pas configuré correctement
• Les mappers de token ne sont pas configurés

À vérifier dans Keycloak :

1. Client Configuration :

   • Scope "roles" est-il activé ?
   • Mapper "realm roles" est-il configuré ?

2. Token Mappers :

   • realm_access.roles mapper existe-t-il ?
   • Est-il ajouté au token d'accès ?

3. User Roles :

   • L'utilisateur a-t-il des rôles assignés dans le realm ?

5. Vérifier les erreurs dans le callback session

Fichier : app/api/auth/options.ts - Callback session

Problème potentiel :

• Si token.role est undefined et qu'un code s'attend à un array
• Si session.user est mal formé

Vérifications :

// Dans callback session
console.log('Session callback - token.role:', token.role);
console.log('Session callback - token.error:', token.error);
console.log('Session callback - hasAccessToken:', !!token.accessToken);

6. Vérifier les timeouts

Problème potentiel :

• Timeout lors de l'appel à Keycloak pour échanger le code
• Timeout lors de l'initialisation storage
• Timeout lors de la création de la session

Solutions :

• Augmenter les timeouts si nécessaire
• Vérifier la latence réseau vers Keycloak

🛠️ Actions Immédiates

Action 1 : Ajouter plus de logs

Fichier : app/api/auth/options.ts

// Dans callback jwt, après extraction des rôles
console.log('=== JWT CALLBACK DEBUG ===');
console.log('Has account:', !!account);
console.log('Has profile:', !!profile);
console.log('Access token present:', !!account?.access_token);
console.log('Roles from profile:', keycloakProfile.realm_access?.roles);
console.log('Roles from access token:', roles);
console.log('Final roles:', cleanRoles);
console.log('==========================');

Action 2 : Vérifier l'erreur exacte

Dans le terminal Next.js, chercher :

• Stack trace complète
• Message d'erreur exact
• Ligne de code qui cause l'erreur

Action 3 : Tester avec un utilisateur simple

Tester avec :

• Un utilisateur avec des rôles
• Un utilisateur sans rôles
• Vérifier si l'erreur est liée aux rôles

Action 4 : Vérifier la configuration Keycloak

Dans Keycloak Admin Console :

1. Client → Mappers :

   • Vérifier qu'il y a un mapper "realm roles"
   • Vérifier qu'il est ajouté au token d'accès
   • Vérifier qu'il ajoute realm_access.roles

2. Client → Settings :

   • Vérifier que "Full Scope Allowed" est activé
   • Vérifier les "Default Client Scopes" incluent "roles"

3. Realm → Roles :

   • Vérifier que l'utilisateur a des rôles assignés

📊 Checklist de Debugging

• Logs serveur Next.js complets vérifiés
• Erreur exacte identifiée (stack trace)
• Callback JWT s'exécute sans erreur
• Callback session s'exécute sans erreur
• Rôles extraits correctement (depuis access token)
• Storage init fonctionne
• Configuration Keycloak vérifiée
• Mappers Keycloak vérifiés
• Timeouts vérifiés

🔧 Solution Temporaire (si nécessaire)

Si l'erreur persiste, on peut temporairement utiliser les groups comme rôles :

// Dans profile callback
const roles = keycloakProfile.realm_access?.roles || 
              keycloakProfile.groups || 
              [];

Note : Ce n'est qu'une solution temporaire. Il faut corriger la configuration Keycloak pour avoir les rôles correctement mappés.

📝 Prochaines Étapes

1. ✅ Correction appliquée : Extraction rôles depuis access token
2. ⏳ À faire : Vérifier les logs serveur pour l'erreur exacte
3. ⏳ À faire : Vérifier configuration Keycloak
4. ⏳ À faire : Tester après correction

---

Document créé le : $(date) Statut : Correction appliquée, investigation en cours