Autorisation et authentification en TypeScript

Autorisation et authentification en TypeScript : de la théorie à la pratique

Lors du développement d'applications web modernes en TypeScript, la sécurité des données des utilisateurs est une priorité. Deux processus clés — l'authentification (vérification de l'identité) et l'autorisation (vérification des droits d'accès) — constituent le fondement de tout système sécurisé. Dans ce guide, nous allons parcourir le cycle complet d'implémentation de l'authentification et de l'autorisation en TypeScript en utilisant des bibliothèques populaires et les meilleures pratiques.

1. Concepts de base et différences

Authentification — processus de vérification que l'utilisateur est bien celui qu'il prétend être (identifiant + mot de passe, biométrie, OAuth).
Autorisation — processus déterminant les ressources et actions accessibles à un utilisateur authentifié (rôles, droits d'accès).

Par exemple : un utilisateur a saisi un mot de passe correct (authentification), mais il n'est pas autorisé à supprimer les publications des autres (autorisation).

2. Outils et bibliothèques nécessaires

Pour l'implémentation, nous utiliserons :

bcrypt — pour le hachage des mots de passe
jsonwebtoken (JWT) — pour la création et la vérification des tokens
express + @types/express — partie serveur
zod — validation des données d'entrée

3. Inscription de l'utilisateur (authentification)

Lors de l'inscription, le mot de passe n'est jamais stocké en clair. Nous utilisons bcrypt pour créer un hachage :

import bcrypt from 'bcrypt';import { z } from 'zod';

const registerSchema = z.object({    email: z.string().email(),    password: z.string().min(8)});

async function registerUser(email: string, password: string) {    const validated = registerSchema.parse({ email, password });    const saltRounds = 10;    const hashedPassword = await bcrypt.hash(validated.password, saltRounds);        // Sauvegarder email + hashedPassword dans la base de données    // await db.user.create({ data: { email, password: hashedPassword } });    return { success: true };}

4. Connexion et génération de JWT

Après vérification réussie du mot de passe, nous générons un token d'accès :

import jwt from 'jsonwebtoken';

const JWT_SECRET = process.env.JWT_SECRET!; // obligatoire dans .env

async function loginUser(email: string, password: string) {    // 1. Trouver l'utilisateur dans la base de données par email    // const user = await db.user.findUnique({ where: { email } });    // if (!user) throw new Error('User not found');        // 2. Comparer le mot de passe    const isMatch = await bcrypt.compare(password, user.password);    if (!isMatch) throw new Error('Invalid password');        // 3. Créer un JWT    const token = jwt.sign(        { userId: user.id, role: user.role },        JWT_SECRET,        { expiresIn: '1h' }    );        return { token, user: { id: user.id, email: user.email } };}

5. Middleware pour la vérification JWT (authentification)

Nous créons un middleware qui vérifiera le token pour chaque requête protégée :

import { Request, Response, NextFunction } from 'express';

interface AuthRequest extends Request {    user?: { userId: string; role: string };}

export function authMiddleware(req: AuthRequest, res: Response, next: NextFunction) {    const authHeader = req.headers.authorization;    if (!authHeader?.startsWith('Bearer ')) {        return res.status(401).json({ error: 'No token provided' });    }        const token = authHeader.split(' ')[1];    try {        const decoded = jwt.verify(token, JWT_SECRET) as { userId: string; role: string };        req.user = decoded;        next();    } catch (err) {        return res.status(403).json({ error: 'Invalid or expired token' });    }}