À propos de ce cours
Objectifs de la leçon
- Exposer un CRUD en JSON avec les bonnes méthodes HTTP.
- Réutiliser dépôt et validation dans un contrôleur d'API.
- Afficher et mettre à jour une table en JavaScript.
- Gérer les erreurs de validation 422 dans une modale.
- Appliquer une mise à jour optimiste et la sécurité CSRF.
1. Mise en situation
La coordinatrice gère une quarantaine de modules (code, intitulé, coefficient, heures). Avec le CRUD classique du chapitre 29, chaque modification provoque deux rechargements de page. Elle souhaite une interface de type application : modifier dans une fenêtre, voir la ligne changer immédiatement.
Nous allons réutiliser les classes existantes (Module, ModuleRepository) derrière un petit contrôleur JSON, et écrire côté navigateur une classe qui pilote la table. Créez la branche Git crud-ajax avant de commencer.
2. Les méthodes HTTP
Le CRUD en AJAX : méthodes et réponses
| Action | Méthode | URL | Succès | Erreurs |
|---|---|---|---|---|
| Lister | GET | /api/modules | 200 | — |
| Créer | POST | /api/modules | 201 + module | 422 validation |
| Modifier | PATCH | /api/modules/{id} | 200 + module | 404, 422 |
| Supprimer | DELETE | /api/modules/{id} | 204 | 404, 409 (notes liées) |
Utiliser la bonne méthode et le bon code de réponse rend l'API prévisible : le JavaScript n'a qu'à tester le statut pour savoir quoi faire. C'est la base des API REST du chapitre 38.
3. La page HTML
<meta name="csrf" content="<?= $csrf->valeur() ?>">
<button class="btn btn-success mb-3" id="ajouter">+ Nouveau module</button>
<table class="table table-hover"><thead><tr><th>Code</th><th>Intitulé</th><th>Coef.</th><th>Heures</th><th></th></tr></thead>
<tbody id="modules"></tbody></table>
<div class="modal fade" id="modale" tabindex="-1"><div class="modal-dialog"><form class="modal-content" id="form-module">
<div class="modal-header"><h5 class="modal-title">Module</h5></div>
<div class="modal-body">
<input type="hidden" name="id">
<div class="mb-2"><label class="form-label">Code</label><input class="form-control" name="code"><div class="invalid-feedback"></div></div>
<div class="mb-2"><label class="form-label">Intitulé</label><input class="form-control" name="intitule"><div class="invalid-feedback"></div></div>
<div class="mb-2"><label class="form-label">Coefficient</label><input class="form-control" name="coefficient" type="number" step="0.5"><div class="invalid-feedback"></div></div>
<div class="mb-2"><label class="form-label">Heures</label><input class="form-control" name="heures" type="number"><div class="invalid-feedback"></div></div>
</div>
<div class="modal-footer"><button class="btn btn-primary">Enregistrer</button></div>
</form></div></div>
4. La classe JavaScript
class TableModules {
#api = new ClientApi('/api');
#corps = document.querySelector('#modules');
#form = document.querySelector('#form-module');
#modale = new bootstrap.Modal('#modale');
async demarrer() {
document.querySelector('#ajouter').addEventListener('click', () => this.#ouvrir());
this.#form.addEventListener('submit', (e) => { e.preventDefault(); this.#enregistrer(); });
const modules = await this.#api.get('/modules');
this.#corps.replaceChildren(...modules.map((m) => this.#ligne(m)));
}
#ligne(m) {
const tr = document.createElement('tr');
tr.dataset.id = m.id;
for (const valeur of [m.code, m.intitule, m.coefficient, m.heures]) {
tr.insertCell().textContent = valeur;
}
const actions = tr.insertCell();
actions.append(this.#bouton('Modifier', 'outline-primary', () => this.#ouvrir(m)),
this.#bouton('Supprimer', 'outline-danger', () => this.#supprimer(m, tr)));
return tr;
}
#bouton(texte, style, action) {
const b = Object.assign(document.createElement('button'), { textContent: texte, className: `btn btn-sm btn-${style} me-1` });
b.addEventListener('click', action);
return b;
}
#ouvrir(m = {}) {
this.#form.reset();
this.#form.querySelectorAll('.is-invalid').forEach((c) => c.classList.remove('is-invalid'));
for (const [cle, valeur] of Object.entries(m)) { if (this.#form.elements[cle]) this.#form.elements[cle].value = valeur; }
this.#modale.show();
}
async #enregistrer() {
const donnees = Object.fromEntries(new FormData(this.#form));
try {
const m = donnees.id ? await this.#api.patch(`/modules/${donnees.id}`, donnees) : await this.#api.post('/modules', donnees);
const nouvelle = this.#ligne(m);
const ancienne = this.#corps.querySelector(`tr[data-id="${m.id}"]`);
ancienne ? ancienne.replaceWith(nouvelle) : this.#corps.prepend(nouvelle);
this.#modale.hide();
} catch (e) {
if (e.statut !== 422) throw e;
for (const [champ, message] of Object.entries(e.details)) {
const c = this.#form.elements[champ];
c.classList.add('is-invalid');
c.nextElementSibling.textContent = message;
}
}
}
async #supprimer(m, tr) {
if (!confirm(`Supprimer le module ${m.code} ?`)) return;
tr.classList.add('opacity-50'); // mise à jour optimiste
try { await this.#api.delete(`/modules/${m.id}`); tr.remove(); }
catch (e) { tr.classList.remove('opacity-50'); alert(e.message); } // 409 : module utilisé par des notes
}
}
new TableModules().demarrer();
5. Mise en pratique : le contrôleur d’API ModuleApiController
<?php
declare(strict_types=1);
final class ModuleApiController
{
public function __construct(private ModuleRepository $modules, private Autorisation $autorisation) {}
public function lister(): ReponseJson
{
return ReponseJson::ok($this->modules->tous()); // Module implémente JsonSerializable
}
public function creer(array $donnees): ReponseJson
{
$this->autorisation->exigerRole(Role::Responsable);
$module = Module::depuisFormulaire($donnees); // lève ValidationException
$this->modules->enregistrer($module);
return ReponseJson::cree($module);
}
public function modifier(int $id, array $donnees): ReponseJson
{
$this->autorisation->exigerRole(Role::Responsable);
$module = $this->modules->trouver($id) ?? throw NonTrouveException::entite('Module', $id);
$module->modifier($donnees);
$this->modules->enregistrer($module);
return ReponseJson::ok($module);
}
public function supprimer(int $id): ReponseJson
{
$this->autorisation->exigerRole(Role::Responsable);
$module = $this->modules->trouver($id) ?? throw NonTrouveException::entite('Module', $id);
$this->modules->supprimer($module); // lève ModuleUtiliseException (409)
return ReponseJson::vide();
}
}
// public/api.php : aiguillage minimal (un vrai routeur arrive au chapitre 34)
$verificateur->verifier($_SERVER['REQUEST_METHOD'], $_POST, getallheaders()); // CSRF
$corps = json_decode(file_get_contents('php://input') ?: '[]', true, flags: JSON_THROW_ON_ERROR);
preg_match('#^/api/modules(?:/(\d+))?$#', parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH), $m) || ReponseJson::erreur('Introuvable', 404)->envoyer();
$id = isset($m[1]) ? (int) $m[1] : null;
try {
$reponse = match ([$_SERVER['REQUEST_METHOD'], $id === null]) {
['GET', true] => $c->lister(),
['POST', true] => $c->creer($corps),
['PATCH', false] => $c->modifier($id, $corps),
['DELETE', false] => $c->supprimer($id),
default => ReponseJson::erreur('Méthode non autorisée', 405),
};
} catch (ValidationException $e) {
$reponse = ReponseJson::erreur('Données invalides', 422, $e->erreurs());
}
$reponse->envoyer();
Diagramme de classe UML de ModuleApiController
Le contrôleur ne contient ni SQL ni HTML : il orchestre des objets existants et renvoie des objets ReponseJson. Les exceptions non capturées ici (404, 409, 403) sont traduites par le gestionnaire global du chapitre 26.
Exercice Activités
- Quel code HTTP renvoyer après une création réussie ? Après une suppression ?
- Pourquoi PATCH plutôt que POST pour une modification ?
- Qu'est-ce qu'une mise à jour optimiste ?
- Pourquoi les contrôles de rôle sont-ils dans le contrôleur PHP et pas seulement dans le JavaScript ?
- Ajoutez un tri par colonne côté client en cliquant sur les en-têtes.
- Pourquoi
TableModulesconstruit-il les cellules avectextContent?
Correction
- 201 Created (avec l'objet créé) ; 204 No Content.
- PATCH exprime une modification partielle d'une ressource existante ; l'API devient prévisible et conforme aux conventions REST.
- Mettre à jour l'interface avant la réponse du serveur (ici, griser la ligne), puis annuler visuellement si le serveur renvoie une erreur.
- Le JavaScript s'exécute chez le client et peut être contourné ; seule la vérification côté serveur protège réellement.
- Garder la liste des modules dans un tableau, trier avec
modules.sort((a, b) => String(a[col]).localeCompare(String(b[col]), 'fr', { numeric: true })), puis réafficher les lignes. - Pour qu'un intitulé contenant du HTML ne soit jamais interprété : protection contre les XSS.
Résumé
- Une API JSON : GET, POST, PATCH, DELETE avec des codes 200, 201, 204, 404, 409, 422.
- Le contrôleur d'API réutilise dépôt, objets métier et autorisation.
- Une classe JavaScript pilote la table et la modale Bootstrap.
- Erreurs 422 affichées sous chaque champ ; mise à jour optimiste.
- Sécurité côté serveur : session, rôle, jeton CSRF.
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !