Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
NestJS

Les transactions

Cette leçon explique les transactions, qui garantissent qu'un ensemble d'écritures s'applique entièrement ou pas du tout. Un service d'inscription dans des groupes est exécuté sans transaction, ce qui...

0 chapitres 0 QCM Accès gratuit
Les transactions

À propos de ce cours

Cette leçon explique les transactions, qui garantissent qu'un ensemble d'écritures s'applique entièrement ou pas du tout. Un service d'inscription dans des groupes est exécuté sans transaction, ce qui laisse un compteur faux après une erreur, puis avec dataSource.transaction, dont le SQL montre le ROLLBACK. La version manuelle avec QueryRunner annule un transfert interrompu. Enfin, deux demandes simultanées pour la dernière place d'un groupe produisent une surréservation sans verrou, corrigée par un verrou pessimiste (SELECT … FOR UPDATE). Activités corrigées.

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 (COMMIT ou ROLLBACK) ;
  • 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.

Transactions et verrous

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
  1. 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.
  2. Avec dataSource.transaction(): le SQL montre START TRANSACTION, l'UPDATE, l'INSERT en erreur, puis ROLLBACK: l'UPDATE est annulé. DEV102 reste cohérent (2 et 2).
  3. 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.
  4. 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 !
  5. Avec lock: { mode: 'pessimistic_write' }: la lecture devient SELECT … 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 manager reçu en paramètre (ou runner.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 le ROLLBACK, y compris une ConflictException métier. Le résultat renvoyé par la fonction est renvoyé après le COMMIT.
  • Avec un QueryRunner, release() dans un finally est 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é ?