Semaine 11 · Chapitre Final

Connecter React
à une API REST

Le chapitre qui assemble tout le cours. Fetch, CRUD complet, service layer, gestion des erreurs, token JWT — tout ce qu'il faut pour construire une vraie application connectée.

HTTP & REST
CRUD complet
Service layer
Authentification JWT
Projet final
Prérequis : S6 useState · S9 useEffect · S10 Context · S8 Formulaires
01 — HTTP & REST

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.

GET
Lire
POST
Créer
PUT
Remplacer
PATCH
Modifier
DELETE
Supprimer
Les routes REST d'une ressource "étudiants"
routes-api.txtConvention REST
{"# 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
Codes de réponse HTTP essentiels
CodeSignificationQuand
200OKGET réussi, PUT/PATCH réussi
201CreatedPOST réussi — ressource créée
204No ContentDELETE réussi — pas de corps
400Bad RequestDonnées invalides envoyées
401UnauthorizedNon authentifié — token manquant
403ForbiddenAuthentifié mais pas autorisé
404Not FoundRessource introuvable
500Server ErrorBug côté serveur
02 — fetch & async/await

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.

1
Anatomie d'un fetch correct
Les deux pièges — response.ok et double await
fetch-anatomie.jsfetch
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"}
  }
}
fetch() ne rejette sa Promise que sur les erreurs réseau (coupure internet, DNS). Les erreurs HTTP (404, 500) sont des réponses "réussies" pour fetch — response.ok est false mais pas d'exception. Toujours vérifier response.ok.
2
Options de fetch — headers, body, method
Toutes les options pour les requêtes POST/PUT/DELETE
fetch-options.jsOptions
{"// 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"}
});
Content-Type: application/json est obligatoire pour que le serveur sache comment décoder le body. Sans ce header, le serveur reçoit du texte brut et ne peut pas parser le JSON.
03 — GET — Lire

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.

→
GET — liste + détail
Les deux patterns les plus courants
useEtudiants.jsxGET
{"// ─── 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>;
}
L'IIFE async (() => { ... })() permet d'utiliser async/await sans déclarer une fonction nommée. C'est un raccourci courant pour les effets simples.
04 — POST — Créer

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.

→
POST depuis un formulaire
onSubmit → fetch POST → mettre à jour l'état local
FormulaireAjout.jsxPOST
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>
  );
}
onAjoute est une callback que le parent passe pour mettre à jour sa liste locale après création — au lieu de re-fetcher toute la liste. Le serveur retourne l'objet créé (avec son id généré), qu'on ajoute directement à la liste locale.
05 — PUT & DELETE

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.

PUT
Modifier un étudiant
Même structure que POST, avec l'id dans l'URL et method PUT
modifierEtudiant.jsPUT
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)
  );
}
DEL
Supprimer un étudiant
DELETE + mettre à jour la liste avec .filter()
supprimerEtudiant.jsDELETE
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));
}
Après un DELETE réussi (204), le serveur ne renvoie pas de corps. On retire l'élément de la liste locale avec .filter() — pas besoin de re-fetcher toute la liste.
06 — Service layer

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.

Composant React
→
Appelle les fonctions du service — ne connaît pas fetch
Hook custom (useEtudiants)
→
Gère useState + useEffect + appels service
Service (etudiants.service.js)
→
Contient les fetch() — une fonction par opération CRUD
API REST
→
Le serveur — renvoie du JSON
1
Le fichier service — toutes les opérations au même endroit
Un fichier par ressource : etudiants.service.js, auth.service.js…
services/etudiants.service.jsService
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);
}
Si l'URL de base change (/api → /v2/api), on ne modifie qu'une seule ligne dans le service. Si le format d'erreur change côté serveur, on ne modifie que parseReponse(). C'est toute la valeur de centraliser les appels.
2
Hook personnalisé — useEtudiants
Le composant ne voit que le hook, jamais le service directement
hooks/useEtudiants.jsHook
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();"}
07 — Authentification JWT

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
Le flux d'authentification JWT
Connexion → token → stockage → envoi dans chaque requête
services/auth.service.jsAuth
{"// ─── 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()}` }"}
2
Gérer les 401 — token expiré
Intercepter les erreurs d'authentification globalement
services/api.jsIntercepteur
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');"}
Ce wrapper apiFetch remplace tous les fetch() directs dans les services. Il injecte automatiquement le token et redirige vers la page de connexion si le token expire. C'est le pattern "intercepteur" en React natif.
08 — Tout assembler

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.

Architecture finale — structure de fichiers
structure-projet.txtArchitecture
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"}
→
main.jsx — point d'entrée complet
Tous les Providers imbriqués dans le bon ordre
main.jsxAssemblage
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>
);
🎉
Félicitations — vous venez de voir toute la stack React moderne. JSX → Props → Conditionnel → Listes → Événements → useState → Formulaires → useEffect → Context → API. Chaque chapitre était une brique. Ce fichier main.jsx les utilise toutes ensemble.
09 — Validation & Projet final

Quiz & Projet final

4 questions de validation, puis le projet final du cours — une application CRUD complète connectée à une vraie API.

1. Pourquoi fetch() ne lève-t-il pas d'exception sur une réponse 404 ou 500 ?
2. Quelle est la bonne façon de mettre à jour la liste locale après un DELETE réussi (sans re-fetcher toute la liste) ?
3. Pourquoi créer un "service layer" (fichier séparé pour les fetch) plutôt de mettre les fetch directement dans les composants ?
4. Comment envoyer le token JWT dans chaque requête API ?

Projet Final · S11 — Toutes les semaines assemblées
Gestionnaire d'étudiants
full-stack connecté
Utilisez jsonplaceholder.typicode.com comme API ou créez votre propre backend Express/Node.js
🔐
Authentification simulée
Page de connexion avec formulaire RHF + Zod (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.
📋
Liste des étudiants — GET + filtres
Fetch GET au montage via 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".
➕
Créer un étudiant — POST
Bouton "Ajouter" ouvre une modal. Formulaire MUI + RHF + Zod (nom, email, filière select, note 0-20, boursier checkbox). Validation complète. Feedback loading sur le bouton submit. Après création : ajout immédiat dans la liste sans re-fetch. Toast de succès. Reset du formulaire et fermeture de la modal.
✏️
Modifier un étudiant — PUT
Bouton "Modifier" sur chaque carte. Même formulaire qu'à la création, pré-rempli avec 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', ...).
🗑️
Supprimer un étudiant — DELETE
Bouton "Supprimer" avec confirmation (dialog MUI ou window.confirm). Fetch DELETE avec gestion du 204. Retrait immédiat via .filter(). État loading sur le bouton pendant la requête. Message d'erreur si l'API refuse (ex: étudiant avec des cours associés).
🎨
Bonus — UX & finitions
Toggle thème clair/sombre avec 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.