À propos de ce cours
Objectifs de la leçon
- Définir une transaction et ses propriétés (ACID).
- Utiliser dataSource.transaction et l'EntityManager.
- Gérer une transaction manuellement avec un QueryRunner.
- Comprendre les problèmes d'accès concurrents et utiliser un verrou pessimiste.
Le problème
Inscrire un stagiaire dans un groupe demande deux écritures: augmenter le compteur inscrits du groupe, et créer la ligne d'inscription. Si la seconde échoue (donnée invalide, panne, contrainte), la première a déjà été enregistrée : la base devient incohérente.
Une transaction regroupe plusieurs opérations en une unité indivisible. Ses propriétés, résumées par l'acronyme ACID:
- Atomicité: tout est appliqué, ou rien (
COMMITouROLLBACK) ; - Cohérence: la base passe d'un état valide à un autre état valide ;
- Isolation: les transactions simultanées ne se perturbent pas (selon le niveau d'isolation) ;
- Durabilité: une fois validées, les modifications survivent à une panne.
Avec MySQL, les transactions nécessitent le moteur InnoDB, celui que TypeORM utilise par défaut.
Sans transaction, une erreur laisse la base incohérente ; sans verrou, deux demandes simultanées aussi.
Les entités et le service
📄 src/inscriptions/inscription.entity.ts
import { Column, Entity, JoinColumn, ManyToOne, OneToMany, PrimaryGeneratedColumn, Unique } from 'typeorm';
@Entity('groupes')
export class Groupe {
@PrimaryGeneratedColumn()
id: number;
@Column({ length: 10, unique: true })
code: string;
@Column({ type: 'smallint' })
capacite: number;
@Column({ type: 'smallint', default: 0 })
inscrits: number; // compteur dénormalisé : doit rester égal au nombre d'inscriptions
@OneToMany(() => Inscription, (i) => i.groupe)
inscriptions: Inscription[];
}
@Entity('inscriptions')
@Unique(['stagiaire', 'groupe'])
export class Inscription {
@PrimaryGeneratedColumn()
id: number;
@Column({ length: 30 })
stagiaire: string;
@ManyToOne(() => Groupe, (g) => g.inscriptions)
@JoinColumn({ name: 'groupe_id' })
groupe: Groupe;
}
📄 src/inscriptions/inscriptions.service.ts
import { ConflictException, Injectable, NotFoundException } from '@nestjs/common';
import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
import { DataSource, EntityManager, Repository } from 'typeorm';
import { Groupe, Inscription } from './inscription.entity';
const pause = (ms: number) => new Promise((r) => setTimeout(r, ms));
@Injectable()
export class InscriptionsService {
constructor(
@InjectDataSource() private readonly source: DataSource,
@InjectRepository(Groupe) private readonly groupes: Repository<Groupe>,
@InjectRepository(Inscription) private readonly inscriptions: Repository<Inscription>,
) {}
// ✗ SANS transaction : deux écritures indépendantes
async inscrireSansTransaction(stagiaire: string, code: string) {
const groupe = await this.groupes.findOneByOrFail({ code });
await this.groupes.increment({ id: groupe.id }, 'inscrits', 1); // 1re écriture : réussit
await this.inscriptions.insert({ stagiaire, groupe }); // 2e écriture : peut échouer
}
// ✓ AVEC transaction : tout ou rien
async inscrire(stagiaire: string, code: string) {
return this.source.transaction(async (manager: EntityManager) => {
const groupe = await manager.findOneBy(Groupe, { code });
if (!groupe) throw new NotFoundException(`Groupe ${code} introuvable`);
await manager.increment(Groupe, { id: groupe.id }, 'inscrits', 1);
await manager.insert(Inscription, { stagiaire, groupe });
return `${stagiaire} inscrit(e) en ${code}`;
});
}
// Version avec QueryRunner : contrôle manuel du début, de la validation et de l'annulation
async transferer(stagiaire: string, de: string, vers: string) {
const runner = this.source.createQueryRunner();
await runner.connect();
await runner.startTransaction();
try {
const source = await runner.manager.findOneByOrFail(Groupe, { code: de });
const cible = await runner.manager.findOneByOrFail(Groupe, { code: vers });
await runner.manager.delete(Inscription, { stagiaire, groupe: { id: source.id } });
await runner.manager.decrement(Groupe, { id: source.id }, 'inscrits', 1);
if (cible.inscrits >= cible.capacite) {
throw new ConflictException(`Le groupe ${vers} est complet`); // ← après 2 écritures déjà faites
}
await runner.manager.increment(Groupe, { id: cible.id }, 'inscrits', 1);
await runner.manager.insert(Inscription, { stagiaire, groupe: cible });
await runner.commitTransaction();
return `${stagiaire} transféré(e) de ${de} vers ${vers}`;
} catch (e) {
await runner.rollbackTransaction();
throw e;
} finally {
await runner.release(); // ✓ toujours libérer la connexion
}
}
// Concurrence : deux inscriptions simultanées sur la dernière place
async inscrireSiPlace(stagiaire: string, code: string, verrou: boolean) {
return this.source.transaction(async (manager) => {
const groupe = await manager.findOne(Groupe, {
where: { code },
...(verrou ? { lock: { mode: 'pessimistic_write' as const } } : {}), // SELECT … FOR UPDATE
});
if (!groupe) throw new NotFoundException();
await pause(200); // traitement « long »
if (groupe.inscrits >= groupe.capacite) throw new ConflictException(`${code} est complet`);
await manager.update(Groupe, { id: groupe.id }, { inscrits: groupe.inscrits + 1 });
await manager.insert(Inscription, { stagiaire, groupe });
return `${stagiaire} : inscrit(e)`;
});
}
async etat(code: string) {
const g = await this.groupes.findOneByOrFail({ code });
const reel = await this.inscriptions.countBy({ groupe: { id: g.id } });
return `${code} : compteur inscrits = ${g.inscrits}, inscriptions réelles = ${reel}, capacité = ${g.capacite}`;
}
}
Résultat réellement obtenu :
── 1. Sans transaction
inscrire Ben Ali → ok
inscrire (nom trop long) → ÉCHEC : Data too long for column 'stagiaire' at row 1
DEV101 : compteur inscrits = 2, inscriptions réelles = 1, capacité = 20
── 2. Avec transaction
SQL> START TRANSACTION
SQL> SELECT `Groupe`.`id` AS `Groupe_id`, `Groupe`.`code` AS `Groupe_code`, `Groupe`.`capacite` AS `Groupe_capacite`, `Groupe`.`inscrits` AS `Groupe_inscrits` FROM `groupes` `Groupe` WHERE ((`Groupe`.`code` = ?)) LIMIT 1 -- ["DEV102"]
SQL> UPDATE `groupes` SET `inscrits` = `inscrits` + 1 WHERE `id` = ? -- [2]
SQL> INSERT INTO `inscriptions`(`id`, `stagiaire`, `groupe_id`) VALUES (DEFAULT, ?, ?) -- ["Un nom beaucoup trop long pour la colonne",2]
SQL ERREUR> Data too long for column 'stagiaire' at row 1
SQL> ROLLBACK
inscrire (nom trop long) → ÉCHEC : Data too long for column 'stagiaire' at row 1
inscrire Trabelsi → Trabelsi inscrit(e) en DEV102
inscrire Gharbi → Gharbi inscrit(e) en DEV102
DEV102 : compteur inscrits = 2, inscriptions réelles = 2, capacité = 2
── 3. QueryRunner : transfert vers un groupe complet
inscrire Mansouri en RES201 → Mansouri inscrit(e) en RES201
transférer Trabelsi de DEV102 vers RES201 → ÉCHEC : Le groupe RES201 est complet
DEV102 : compteur inscrits = 2, inscriptions réelles = 2, capacité = 2
RES201 : compteur inscrits = 1, inscriptions réelles = 1, capacité = 1
── 4. Deux demandes simultanées pour la dernière place, SANS verrou
Dridi : inscrit(e)
Karoui : inscrit(e)
ATE401 : compteur inscrits = 1, inscriptions réelles = 2, capacité = 1
── 5. Même situation AVEC verrou pessimiste (SELECT … FOR UPDATE)
Chaabane : inscrit(e)
refusé : MUL301 est complet
MUL301 : compteur inscrits = 1, inscriptions réelles = 1, capacité = 1
Les lignes SQL> sont les requêtes réellement envoyées par TypeORM (option logging). Pour la lisibilité, elles ne sont affichées que pour certaines opérations.
Lecture des résultats
- Sans transaction: l'inscription avec un nom trop long a échoué, mais le compteur a quand même été augmenté. DEV101 affiche 2 inscrits pour 1 inscription réelle.
- Avec
dataSource.transaction(): le SQL montreSTART TRANSACTION, l'UPDATE, l'INSERTen erreur, puisROLLBACK: l'UPDATEest annulé. DEV102 reste cohérent (2 et 2). - Avec un QueryRunner: le transfert a supprimé l'inscription et décrémenté le compteur de DEV102, puis s'est aperçu que RES201 était complet. Le
rollbackTransaction()a tout annulé : les deux groupes sont intacts. - Concurrence sans verrou: deux demandes simultanées lisent toutes les deux « 0 inscrit sur 1 », attendent, puis s'inscrivent. Résultat : 2 inscriptions pour 1 place, et un compteur à 1 (la seconde écriture a écrasé la première : mise à jour perdue). La transaction seule ne suffit pas !
- Avec
lock: { mode: 'pessimistic_write' }: la lecture devientSELECT … FOR UPDATE. La seconde demande attend que la première ait validé, lit alors « 1 sur 1 » et est refusée.
Les règles à respecter
- Dans une transaction, toutes les opérations doivent passer par le
managerreçu en paramètre (ourunner.manager). Utiliser un repository injecté (this.groupes.save(…)) exécuterait la requête hors de la transaction. - Toute exception levée dans la fonction de
transaction()provoque leROLLBACK, y compris uneConflictExceptionmétier. Le résultat renvoyé par la fonction est renvoyé après leCOMMIT. - Avec un QueryRunner,
release()dans unfinallyest obligatoire: sinon la connexion n'est jamais rendue au groupe, et l'application finit par se bloquer. - Une transaction doit être courte: pas d'appel à un service externe (e-mail, API) à l'intérieur, car les verrous seraient conservés pendant ce temps.
Verrou pessimiste ou optimiste ? Le verrou pessimiste bloque la ligne pendant la transaction : sûr, mais les demandes attendent. Le verrou optimiste ne bloque rien : une colonne @VersionColumn() est incrémentée à chaque modification, et une mise à jour échoue si la version a changé entre la lecture et l'écriture (le client doit alors réessayer). Le pessimiste convient aux ressources très demandées (dernières places, stock) ; l'optimiste aux modifications rares d'un même objet (formulaire d'édition).
Opérations atomiques simples
Pour un simple compteur, une seule requête SQL suffit souvent : UPDATE groupes SET inscrits = inscrits + 1 WHERE id = ? AND inscrits < capacite. MySQL l'exécute de façon atomique ; si affected vaut 0, le groupe était complet. C'est ce que fait increment(), la condition en moins.
Activités
Activité 1 Saisie d'un lot de notes
Écrivez ajouterLot(stagiaireId, notes[]) qui enregistre plusieurs notes et met à jour la colonne moyenne du stagiaire, le tout dans une transaction. Si une seule note est invalide (hors de 0 à 20), aucune ne doit être enregistrée.
Voir le corrigé
ajouterLot(stagiaireId: number, notes: { matiere: string; valeur: number }[]) {
return this.source.transaction(async (m) => {
const stagiaire = await m.findOneBy(Stagiaire, { id: stagiaireId });
if (!stagiaire) throw new NotFoundException();
for (const n of notes) {
if (n.valeur < 0 || n.valeur > 20) throw new BadRequestException(`Note invalide : ${n.valeur}`);
await m.insert(Note, { ...n, stagiaire });
}
const { moyenne } = await m
.createQueryBuilder(Note, 'n')
.select('AVG(n.valeur)', 'moyenne')
.where('n.stagiaire_id = :id', { id: stagiaireId })
.getRawOne();
await m.update(Stagiaire, { id: stagiaireId }, { moyenne: Number(moyenne) });
return { ajoutees: notes.length, moyenne: Number(moyenne) };
});
}
La moyenne est calculée par le manager: elle voit donc les notes insérées dans la même transaction, avant le COMMIT.
Activité 2 Trouver l'erreur
Pourquoi ce code n'annule-t-il pas la création du groupe quand l'ajout des stagiaires échoue ?
return this.source.transaction(async (manager) => {
const groupe = await this.groupes.save({ code: 'DEV103', intitule: 'Nouveau' });
await manager.save(Stagiaire, stagiaires.map((s) => ({ ...s, groupe })));
});
Voir le corrigé
this.groupes est le repository injecté : il utilise sa propre connexion, hors de la transaction. Le groupe est validé immédiatement. Il faut écrire manager.save(Groupe, { … }) ou manager.getRepository(Groupe).save(…).
Activité 3 Verrou optimiste
Ajoutez @VersionColumn() version: number à Groupe. Simulez deux modifications concurrentes : lisez deux fois le même groupe, modifiez et enregistrez la première copie, puis la seconde avec update({ id, version: copie2.version }, …). Que vaut affected?
Voir le corrigé
La première sauvegarde fait passer la version de 1 à 2. La seconde demande « mettre à jour si version = 1 » : aucune ligne ne correspond, affected vaut 0. Le service lève alors une ConflictException (« le groupe a été modifié entre-temps, rechargez-le »).
Activité 4 Inscription atomique sans transaction
Réécrivez inscrireSiPlace pour les demandes simultanées en une seule requête de mise à jour conditionnelle, puis insérez l'inscription. Une transaction reste-t-elle utile ?
Voir le corrigé
return this.source.transaction(async (m) => {
const groupe = await m.findOneBy(Groupe, { code });
if (!groupe) throw new NotFoundException();
const r = await m
.createQueryBuilder()
.update(Groupe)
.set({ inscrits: () => 'inscrits + 1' })
.where('id = :id AND inscrits < capacite', { id: groupe.id })
.execute();
if (!r.affected) throw new ConflictException(`${code} est complet`);
await m.insert(Inscription, { stagiaire, groupe });
});
La mise à jour conditionnelle règle la concurrence (MySQL verrouille la ligne pendant l'UPDATE). La transaction reste nécessaire pour que l'UPDATE soit annulé si l'insertion échoue.
À retenir
- Une transaction applique tout ou rien (COMMIT / ROLLBACK).
- dataSource.transaction(async (manager) => …) : une exception déclenche le ROLLBACK.
- Toujours utiliser le manager de la transaction, jamais un repository injecté.
- QueryRunner : startTransaction, commitTransaction, rollbackTransaction, et release() dans finally.
- Concurrence : verrou pessimiste (SELECT … FOR UPDATE), verrou optimiste (@VersionColumn) ou UPDATE conditionnel.
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 !