👤 Authentification - Profil utilisateur

L'endpoint de profil permet de récupérer les informations de l'utilisateur actuellement authentifié avec un système de cache intelligent pour des performances optimales.

Endpoint

GET /auth/profile

Description

Récupère le profil complet de l'utilisateur authentifié, incluant ses informations personnelles et les détails du token d'authentification. Cet endpoint utilise l'AuthGuard optimisé avec cache Redis pour des performances exceptionnelles.

Authentification requise

Authorization: Bearer <access_token>

Paramètres de requête

Aucun paramètre requis. L'utilisateur est automatiquement identifié via le token JWT.

Réponses

✅ Succès (200 OK)

{
  "success": true,
  "message": "Profil utilisateur récupéré avec succès",
  "result": {
    "user": {
      "id": 1,
      "publicId": "user-123",
      "username": "john.doe",
      "email": "john.doe@example.com",
      "firstName": "John",
      "lastName": "Doe",
      "phone": "+237123456789",
      "status": "ACTIVE",
      "isActive": true,
      "emailVerified": true,
      "phoneVerified": false,
      "lastConnectedAt": "2024-01-01T10:00:00Z",
      "createdAt": "2024-01-01T00:00:00Z",
      "updatedAt": "2024-01-01T10:00:00Z",
      "role": {
        "id": 2,
        "name": "Admin",
        "description": "Administrateur système"
      }
    },
    "token_info": {
      "token": "eyJhbGciOi...",
      "authenticated": true,
      "expires_at": "2024-01-01T12:00:00Z",
      "issued_at": "2024-01-01T08:00:00Z"
    },
    "permissions": {
      "users": ["read", "write", "delete"],
      "organizations": ["read", "write"],
      "complaints": ["read", "write", "moderate"],
      "transports": ["read", "write"],
      "forum": ["read", "write", "moderate"]
    },
    "actor": {
      "id": 1,
      "type": "ADMIN",
      "accessType": "SUPER_ADMIN",
      "country": {
        "id": 1,
        "name": "Cameroun",
        "code": "CM"
      },
      "state": {
        "id": 1,
        "name": "Centre",
        "code": "CE"
      }
    }
  },
  "errors": null,
  "except": null
}

❌ Erreurs possibles

400 Bad Request - Token manquant

{
  "success": false,
  "message": "Token d'authentification manquant",
  "result": null,
  "errors": ["MISSING_TOKEN"],
  "except": null
}

401 Unauthorized - Token invalide ou expiré

{
  "success": false,
  "message": "Token invalide ou expiré",
  "result": null,
  "errors": ["INVALID_TOKEN"],
  "except": null
}

403 Forbidden - Compte bloqué

{
  "success": false,
  "message": "Compte bloqué ou suspendu",
  "result": null,
  "errors": ["ACCOUNT_BLOCKED"],
  "except": null
}

404 Not Found - Utilisateur introuvable

{
  "success": false,
  "message": "Utilisateur non trouvé",
  "result": null,
  "errors": ["USER_NOT_FOUND"],
  "except": null
}

500 Internal Server Error

{
  "success": false,
  "message": "Erreur interne du serveur",
  "result": null,
  "errors": ["INTERNAL_ERROR"],
  "except": "Détails techniques de l'erreur"
}

Exemples d'utilisation

cURL

# Avec token en header (recommandé)
curl -H "Authorization: Bearer $TOKEN" \
  http://localhost:3004/auth/profile

# Avec token en query parameter (fallback)
curl "http://localhost:3004/auth/profile?token=$TOKEN"

JavaScript/Fetch

const token = localStorage.getItem('access_token');

const response = await fetch('http://localhost:3004/auth/profile', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json'
  }
});

const data = await response.json();

if (data.success) {
  const user = data.result.user;
  console.log(`Bienvenue ${user.firstName} ${user.lastName}!`);
  
  // Vérifier les permissions
  const permissions = data.result.permissions;
  if (permissions.users.includes('write')) {
    console.log('Vous pouvez modifier les utilisateurs');
  }
} else {
  console.error('Erreur:', data.errors);
  // Rediriger vers la page de connexion si token invalide
  if (data.errors.includes('INVALID_TOKEN')) {
    window.location.href = '/login';
  }
}

Python

import requests

token = "your_access_token_here"
headers = {
    "Authorization": f"Bearer {token}",
    "Content-Type": "application/json"
}

response = requests.get("http://localhost:3004/auth/profile", headers=headers)
data = response.json()

if data['success']:
    user = data['result']['user']
    print(f"Utilisateur: {user['firstName']} {user['lastName']}")
    print(f"Email: {user['email']}")
    print(f"Rôle: {user['role']['name']}")
else:
    print(f"Erreur: {data['errors']}")

Fonctionnalités avancées

🚀 Cache intelligent

• TTL : 5 minutes pour les tokens valides
• Performance : Réduction de 80% des appels microservices
• Invalidation automatique : Tokens inactifs non mis en cache
• Sécurité : Validation en temps réel pour tokens suspects

🔍 AuthGuard optimisé

• Protection automatique : Appliqué automatiquement sur cet endpoint
• Enrichissement de requête : Ajoute automatiquement user et token à l'objet request
• Extraction flexible : Support Bearer token et query parameters
• Gestion granulaire des erreurs avec codes HTTP appropriés

📝 Logging sécurisé

Chaque accès au profil génère un log avec :

• User ID et timestamp
• Adresse IP et User-Agent
• Statut de la requête (succès/échec)
• Tokens masqués pour la sécurité

Utilisation dans les contrôleurs

Si vous développez des endpoints personnalisés, voici comment utiliser les données enrichies par l'AuthGuard :

@UseGuards(AuthGuard)
@Get('protected-endpoint')
async getProtectedData(@Req() request: any) {
  // Données utilisateur automatiquement extraites par l'AuthGuard
  const user = request.user;
  const token = request.token;
  
  console.log(`Utilisateur ${user.id} accède à l'endpoint protégé`);
  
  // Utiliser les données utilisateur
  return {
    message: `Bonjour ${user.firstName}!`,
    permissions: user.permissions
  };
}

Gestion des sessions

Informations de session

Le profil inclut des informations détaillées sur la session :

• Durée de vie du token : Timestamp d'expiration
• Dernière connexion : Horodatage de la dernière activité
• Statut d'authentification : Validation en temps réel

Renouvellement automatique

// Vérifier l'expiration du token
function isTokenExpired(tokenInfo) {
  const expiresAt = new Date(tokenInfo.expires_at);
  const now = new Date();
  const timeUntilExpiry = expiresAt.getTime() - now.getTime();
  
  // Renouveler si expire dans moins de 5 minutes
  return timeUntilExpiry < 5 * 60 * 1000;
}

// Renouveler automatiquement si nécessaire
async function checkAndRenewToken() {
  const profile = await getProfile();
  if (isTokenExpired(profile.token_info)) {
    // Implémenter la logique de renouvellement
    await renewToken();
  }
}

Cas d'usage courants

Vérification des permissions

function hasPermission(profile, resource, action) {
  const permissions = profile.permissions;
  return permissions[resource] && permissions[resource].includes(action);
}

// Exemple d'utilisation
if (hasPermission(profile, 'users', 'write')) {
  // Afficher le bouton "Créer utilisateur"
}

Personnalisation de l'interface

function customizeUI(profile) {
  const user = profile.user;
  const actor = profile.actor;
  
  // Personnaliser selon le type d'acteur
  switch (actor.type) {
    case 'ADMIN':
      showAdminPanel();
      break;
    case 'AGENT':
      showAgentDashboard();
      break;
    case 'CUSTOMER':
      showCustomerInterface();
      break;
  }
  
  // Afficher le nom de l'utilisateur
  document.getElementById('username').textContent = 
    `${user.firstName} ${user.lastName}`;
}

---

Prochaine étape : Sécurité et authentification