Les bases de HTTP & REST
Avant de coder, comprendre les règles de communication. Une API REST expose des ressources (étudiants, produits…) via des URL, et on interagit avec elles en utilisant les verbes HTTP.
{"# Lire tous les étudiants"} GET /api/etudiants {"# Lire un étudiant par son id"} GET /api/etudiants/:id {"# Créer un étudiant"} POST /api/etudiants {"← body: { nom, email, note }"} {"# Remplacer complètement un étudiant"} PUT /api/etudiants/:id {"← body: { nom, email, note }"} {"# Modifier partiellement un étudiant"} PATCH /api/etudiants/:id {"← body: { note: 18 } (partiel)"} {"# Supprimer un étudiant"} DELETE /api/etudiants/:id
| Code | Signification | Quand |
|---|---|---|
200 | OK | GET réussi, PUT/PATCH réussi |
201 | Created | POST réussi — ressource créée |
204 | No Content | DELETE réussi — pas de corps |
400 | Bad Request | Données invalides envoyées |
401 | Unauthorized | Non authentifié — token manquant |
403 | Forbidden | Authentifié mais pas autorisé |
404 | Not Found | Ressource introuvable |
500 | Server Error | Bug côté serveur |
L'API fetch en détail
fetch() est l'outil natif du navigateur pour faire des requêtes HTTP. Il retourne une Promise et s'utilise avec async/await. Deux pièges à connaître absolument.
async function exempleComplet() { try { {"// 1. Envoyer la requête → retourne la réponse HTTP"} const reponse = await fetch('/api/etudiants'); {"// 2. PIÈGE 1 — fetch ne throw pas sur les erreurs HTTP !"} {"// Un 404 ou 500 n'est pas une exception — il faut le vérifier"} if (!reponse.ok) { throw new Error(`Erreur HTTP : ${reponse.status}`); } {"// 3. PIÈGE 2 — .json() est aussi asynchrone → await obligatoire"} const data = await reponse.json(); return data; } catch (erreur) { {"// Ici : erreur réseau (hors ligne) OU erreur HTTP (throw ci-dessus)"} console.error('Erreur fetch :', erreur.message); throw erreur; {"← re-throw pour que l'appelant gère l'erreur"} } }
{"// Toutes les options possibles"} const reponse = await fetch('/api/etudiants', { method: 'POST', {"← GET | POST | PUT | PATCH | DELETE"} headers: { 'Content-Type': 'application/json', {"← obligatoire pour envoyer du JSON"} 'Authorization': `Bearer ${token}`, {"← authentification JWT"} 'Accept': 'application/json', }, body: JSON.stringify({ {"← convertir l'objet JS en JSON"} nom: 'Fatou Diallo', email: 'fatou@example.com', filiere: 'info', note: 17, }), signal: controller.signal, {"← AbortController pour le cleanup"} });
Lire des données avec GET
Le GET est la requête la plus courante. On l'utilise pour lister des ressources, ou en lire une seule par son identifiant. Toujours dans un useEffect.
{"// ─── PATTERN 1 : Lire la liste ───"} function ListeEtudiants() { const [etudiants, setEtudiants] = useState([]); const [chargement, setChargement] = useState(true); const [erreur, setErreur] = useState(null); useEffect(() => { const ctrl = new AbortController(); (async () => { try { setChargement(true); setErreur(null); const res = await fetch('/api/etudiants', { signal: ctrl.signal }); if (!res.ok) throw new Error(`${res.status}`); setEtudiants(await res.json()); } catch (e) { if (e.name !== 'AbortError') setErreur(e.message); } finally { setChargement(false); } })(); return () => ctrl.abort(); }, []); if (chargement) return <p>Chargement...</p>; if (erreur) return <p>Erreur : {erreur}</p>; return etudiants.map(e => <div key={e.id}>{e.nom}</div>); } {"// ─── PATTERN 2 : Lire un seul par id ───"} function DetailEtudiant({ id }) { const [etudiant, setEtudiant] = useState(null); useEffect(() => { const ctrl = new AbortController(); (async () => { const res = await fetch(`/api/etudiants/${id}`, { signal: ctrl.signal }); if (res.ok) setEtudiant(await res.json()); })(); return () => ctrl.abort(); }, [id]); {"← re-fetch quand l'id change"} if (!etudiant) return <p>Chargement...</p>; return <div>{etudiant.nom} — {etudiant.note}/20</div>; }
Créer des données avec POST
POST envoie des données au serveur pour créer une nouvelle ressource. Contrairement à GET, le POST ne va pas dans useEffect — il se déclenche à la soumission d'un formulaire ou au clic d'un bouton.
function FormulaireAjout({ onAjoute }) { const [form, setForm] = useState({ nom: '', email: '', note: '' }); const [chargement, setChargement] = useState(false); const [erreur, setErreur] = useState(null); async function handleSubmit(e) { e.preventDefault(); setChargement(true); setErreur(null); try { const res = await fetch('/api/etudiants', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ ...form, note: Number(form.note), }), }); if (!res.ok) { const data = await res.json(); throw new Error(data.message || 'Erreur lors de la création'); } const nouvelEtudiant = await res.json(); {"← le serveur retourne l'objet créé"} onAjoute(nouvelEtudiant); {"← mettre à jour la liste parente"} setForm({ nom: '', email: '', note: '' }); {"← reset le formulaire"} } catch (err) { setErreur(err.message); } finally { setChargement(false); } } return ( <form onSubmit={handleSubmit}> <input value={form.nom} onChange={e => setForm(p => ({...p, nom: e.target.value}))} placeholder="Nom" /> <input value={form.email} onChange={e => setForm(p => ({...p, email: e.target.value}))} placeholder="Email" /> <input value={form.note} onChange={e => setForm(p => ({...p, note: e.target.value}))} placeholder="Note" type="number" /> {erreur && <p style={{color:'red'}}>{erreur}</p>} <button type="submit" disabled={chargement}> {chargement ? 'Envoi...' : 'Ajouter'} </button> </form> ); }
Modifier et supprimer avec PUT & DELETE
PUT modifie une ressource existante, DELETE la supprime. Les deux se déclenchent sur une action utilisateur (clic), pas dans useEffect.
async function modifierEtudiant(id, donnees, onModifie) { try { const res = await fetch(`/api/etudiants/${id}`, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(donnees), }); if (!res.ok) throw new Error(`Erreur ${res.status}`); const majEtudiant = await res.json(); {"// Mettre à jour dans la liste locale via .map()"} onModifie(majEtudiant); } catch (err) { console.error('Erreur modification :', err.message); } } {"// Côté parent — mettre à jour la liste locale"} function handleModifie(etudiantMaj) { setEtudiants(prev => prev.map(e => e.id === etudiantMaj.id ? etudiantMaj : e) ); }
async function supprimerEtudiant(id, onSupprime) { {"// Confirmation avant suppression — bonne pratique UX"} if (!window.confirm('Supprimer cet étudiant ?')) return; try { const res = await fetch(`/api/etudiants/${id}`, { method: 'DELETE', }); if (!res.ok) throw new Error(`Erreur ${res.status}`); {"// 204 No Content → pas de body → supprimer localement"} onSupprime(id); } catch (err) { console.error('Erreur suppression :', err.message); } } {"// Côté parent — retirer de la liste locale"} function handleSupprime(id) { setEtudiants(prev => prev.filter(e => e.id !== id)); }
Organiser les appels avec un service layer
Éparpiller les fetch() dans chaque composant est difficile à maintenir. Le service layer regroupe tous les appels API dans des fichiers dédiés — les composants ne font qu'appeler des fonctions.
const BASE_URL = '/api/etudiants'; {"// Récupère les headers communs (auth token inclus)"} function getHeaders() { const token = localStorage.getItem('token'); return { 'Content-Type': 'application/json', ...(token ? { 'Authorization': `Bearer ${token}` } : {}), }; } {"// Gestion d'erreur centralisée"} async function parseReponse(res) { if (!res.ok) { const err = await res.json().catch(() => ({})); throw new Error(err.message || `Erreur HTTP ${res.status}`); } if (res.status === 204) return null; {"← DELETE : pas de body"} return res.json(); } {"// ─── CRUD complet ───"} export async function listerEtudiants(signal) { const res = await fetch(BASE_URL, { headers: getHeaders(), signal }); return parseReponse(res); } export async function lireEtudiant(id, signal) { const res = await fetch(`${BASE_URL}/${id}`, { headers: getHeaders(), signal }); return parseReponse(res); } export async function creerEtudiant(donnees) { const res = await fetch(BASE_URL, { method: 'POST', headers: getHeaders(), body: JSON.stringify(donnees), }); return parseReponse(res); } export async function modifierEtudiant(id, donnees) { const res = await fetch(`${BASE_URL}/${id}`, { method: 'PUT', headers: getHeaders(), body: JSON.stringify(donnees), }); return parseReponse(res); } export async function supprimerEtudiant(id) { const res = await fetch(`${BASE_URL}/${id}`, { method: 'DELETE', headers: getHeaders(), }); return parseReponse(res); }
import { useState, useEffect, useCallback } from 'react'; import * as etudiantService from '../services/etudiants.service'; export function useEtudiants() { const [etudiants, setEtudiants] = useState([]); const [chargement, setChargement] = useState(true); const [erreur, setErreur] = useState(null); useEffect(() => { const ctrl = new AbortController(); (async () => { try { setChargement(true); const data = await etudiantService.listerEtudiants(ctrl.signal); setEtudiants(data); } catch (e) { if (e.name !== 'AbortError') setErreur(e.message); } finally { setChargement(false); } })(); return () => ctrl.abort(); }, []); async function creer(donnees) { const nouvel = await etudiantService.creerEtudiant(donnees); setEtudiants(prev => [...prev, nouvel]); return nouvel; } async function modifier(id, donnees) { const maj = await etudiantService.modifierEtudiant(id, donnees); setEtudiants(prev => prev.map(e => e.id === id ? maj : e)); return maj; } async function supprimer(id) { await etudiantService.supprimerEtudiant(id); setEtudiants(prev => prev.filter(e => e.id !== id)); } return { etudiants, chargement, erreur, creer, modifier, supprimer }; } {"// Utilisation dans un composant — simple et lisible :"} {"// const { etudiants, chargement, creer, supprimer } = useEtudiants();"}
Sécuriser les requêtes avec JWT
La plupart des APIs protègent leurs routes avec un token JWT. L'utilisateur se connecte, reçoit un token, et l'envoie dans chaque requête via le header Authorization.
{"// ─── 1. Se connecter → recevoir le token ───"} export async function connexion(email, motDePasse) { const res = await fetch('/api/auth/connexion', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ email, motDePasse }), }); if (!res.ok) { const err = await res.json(); throw new Error(err.message || 'Identifiants incorrects'); } const { token, user } = await res.json(); {"// ─── 2. Stocker le token ───"} localStorage.setItem('token', token); localStorage.setItem('user', JSON.stringify(user)); return { token, user }; } {"// ─── 3. Se déconnecter ───"} export function deconnexion() { localStorage.removeItem('token'); localStorage.removeItem('user'); } {"// ─── 4. Récupérer le token pour les requêtes ───"} export function getToken() { return localStorage.getItem('token'); } {"// ─── 5. Envoyer le token dans chaque requête ───"} {"// Dans le service : { Authorization: `Bearer ${getToken()}` }"}
import { getToken, deconnexion } from './auth.service'; {"// Wrapper fetch avec gestion globale des erreurs"} export async function apiFetch(url, options = {}) { const token = getToken(); const res = await fetch(url, { ...options, headers: { 'Content-Type': 'application/json', ...(token && { 'Authorization': `Bearer ${token}` }), ...options.headers, }, }); {"// Token expiré ou invalide → déconnecter et rediriger"} if (res.status === 401) { deconnexion(); window.location.href = '/connexion?expire=1'; return; } if (!res.ok) { const err = await res.json().catch(() => ({})); throw new Error(err.message || `Erreur ${res.status}`); } if (res.status === 204) return null; return res.json(); } {"// Utiliser apiFetch au lieu de fetch partout dans les services :"} {"// const data = await apiFetch('/api/etudiants');"}
L'architecture complète d'une application
Voici comment toutes les briques du cours s'assemblent dans une vraie application React connectée à une API.
src/ │ ├── contexts/ {"← S10 — état global"} │ ├── AuthContext.jsx {"← utilisateur connecté"} │ └── ThemeContext.jsx {"← thème clair/sombre"} │ ├── services/ {"← S11 — couche API"} │ ├── api.js {"← wrapper fetch + token + 401"} │ ├── auth.service.js {"← connexion, token"} │ └── etudiants.service.js {"← CRUD étudiants"} │ ├── hooks/ {"← hooks personnalisés"} │ ├── useEtudiants.js {"← état + CRUD + loading"} │ └── useEtudiant.js {"← détail d'un étudiant"} │ ├── pages/ {"← vues de l'application"} │ ├── Connexion.jsx {"← S7+S8 formulaire"} │ ├── ListeEtudiants.jsx {"← S4+S6+hooks"} │ └── DetailEtudiant.jsx {"← S9 fetch par id"} │ ├── components/ {"← composants réutilisables"} │ ├── CarteEtudiant.jsx {"← S2 props"} │ ├── FormulaireEtudiant.jsx {"← S8 RHF+Zod+MUI"} │ └── RouteProtegee.jsx {"← S10 useAuth"} │ └── main.jsx {"← Providers + Router"}
import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom'; import { AuthProvider, useAuth } from './contexts/AuthContext'; import { ThemeProvider } from './contexts/ThemeContext'; import { ThemeProvider as MuiTheme } from '@mui/material'; import Connexion from './pages/Connexion'; import ListeEtudiants from './pages/ListeEtudiants'; import DetailEtudiant from './pages/DetailEtudiant'; function RouteProtegee({ children }) { const { connecte } = useAuth(); return connecte ? children : <Navigate to="/connexion" />; } ReactDOM.createRoot(document.getElementById('root')).render( <MuiTheme theme={muiTheme}> <AuthProvider> {"← S10 auth"} <ThemeProvider> {"← S10 thème"} <BrowserRouter> {"← routing"} <Routes> <Route path="/connexion" element={<Connexion />} /> <Route path="/" element={ <RouteProtegee> <ListeEtudiants /> </RouteProtegee> } /> <Route path="/etudiants/:id" element={<RouteProtegee><DetailEtudiant /></RouteProtegee>} /> </Routes> </BrowserRouter> </ThemeProvider> </AuthProvider> </MuiTheme> );
Quiz & Projet final
4 questions de validation, puis le projet final du cours — une application CRUD complète connectée à une vraie API.
fetch() ne lève-t-il pas d'exception sur une réponse 404 ou 500 ?full-stack connecté
email + motDePasse). AuthContext avec token stocké dans localStorage. RouteProtegee qui redirige vers /connexion si non connecté. Header avec nom de l'utilisateur et bouton déconnexion.useEtudiants(). Affichage en grille avec CarteEtudiant. Barre de recherche (filtre local sur le nom). Onglets : Tous / Admis (note ≥ 10) / Ajournés. Tri par note (asc/desc) via bouton toggle. Compteur de résultats. Skeleton de chargement. Message d'erreur avec bouton "Réessayer".reset(etudiant). Détection des champs modifiés (affichage des différences). Fetch PUT à la soumission. Mise à jour dans la liste via .map(). Gestion des erreurs serveur via setError('root', ...)..filter(). État loading sur le bouton pendant la requête. Message d'erreur si l'API refuse (ex: étudiant avec des cours associés).ThemeContext persisté en localStorage. Pagination ou infinite scroll. Page de détail /etudiants/:id avec fetch par id. Exportation CSV de la liste filtrée. Notifications toast globales via NotifContext. Service worker pour mode hors-ligne.