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

Le pattern Repository : find, findOneBy, save, update, delete

Cette leçon remplace le tableau en mémoire d'un service NestJS par une vraie table MySQL grâce au Repository de TypeORM, injecté avec @InjectRepository. Un CRUD complet est exécuté et le SQL envoyé es...

0 chapitres 0 QCM Accès gratuit
Le pattern Repository : find, findOneBy, save, update, delete

À propos de ce cours

Cette leçon remplace le tableau en mémoire d'un service NestJS par une vraie table MySQL grâce au Repository de TypeORM, injecté avec @InjectRepository. Un CRUD complet est exécuté et le SQL envoyé est affiché pour chaque opération : find avec conditions et tri, findOneBy, create et save, preload pour une modification partielle, update direct, suppression douce avec softDelete, count, countBy et existsBy. La leçon montre aussi comment transformer une violation d'unicité (ER_DUP_ENTRY) en 409 et compare save et update. Activités corrigées.

Objectifs de la leçon

  • Injecter un Repository dans un service.
  • Lire avec find, findBy, findOneBy et leurs options.
  • Créer et modifier avec create, save, preload et update.
  • Supprimer avec delete, remove ou softDelete.
  • Traiter les erreurs de contraintes (doublons).
Le pattern Repository

Le Repository (« dépôt ») est un objet qui regroupe toutes les opérations sur un type d'entité : chercher, enregistrer, supprimer. Le service ne manipule plus de tableau : il demande au repository. TypeORM en fournit un pour chaque entité, prêt à l'emploi : Repository<Stagiaire>.

Les méthodes du Repository TypeORM

Lecture et écriture, et le SQL correspondant.

Le service des stagiaires

📄 src/stagiaires/stagiaire.entity.ts

import { Column, CreateDateColumn, DeleteDateColumn, Entity, PrimaryGeneratedColumn } from 'typeorm';

@Entity('stagiaires')
export class Stagiaire {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ length: 50 })
  nom: string;

  @Column({ length: 50 })
  prenom: string;

  @Column({ length: 120, unique: true })
  email: string;

  @Column({ length: 10 })
  groupe: string;

  @CreateDateColumn({ name: 'cree_le' })
  creeLe: Date;

  @DeleteDateColumn({ name: 'supprime_le' })        // suppression « douce »
  supprimeLe: Date | null;
}

📄 src/stagiaires/stagiaires.service.ts

import { ConflictException, Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { QueryFailedError, Repository } from 'typeorm';
import { CreerStagiaireDto, ModifierStagiaireDto } from './stagiaire.dto';
import { Stagiaire } from './stagiaire.entity';

@Injectable()
export class StagiairesService {
  constructor(
    @InjectRepository(Stagiaire)
    private readonly depot: Repository<Stagiaire>,
  ) {}

  findAll(groupe?: string): Promise<Stagiaire[]> {
    return this.depot.find({
      where: groupe ? { groupe } : {},
      order: { nom: 'ASC', prenom: 'ASC' },
    });
  }

  async findOne(id: number): Promise<Stagiaire> {
    const stagiaire = await this.depot.findOneBy({ id });
    if (!stagiaire) throw new NotFoundException(`Stagiaire ${id} introuvable`);
    return stagiaire;
  }

  async create(dto: CreerStagiaireDto): Promise<Stagiaire> {
    const stagiaire = this.depot.create(dto);          // instance, pas encore en base
    try {
      return await this.depot.save(stagiaire);           // INSERT, puis renvoie l'entité avec son id
    } catch (e) {
      if (e instanceof QueryFailedError && (e as any).code === 'ER_DUP_ENTRY') {
        throw new ConflictException(`L'e-mail ${dto.email} est déjà utilisé`);
      }
      throw e;
    }
  }

  async update(id: number, dto: ModifierStagiaireDto): Promise<Stagiaire> {
    const stagiaire = await this.depot.preload({ id, ...dto });   // charge et fusionne
    if (!stagiaire) throw new NotFoundException(`Stagiaire ${id} introuvable`);
    return this.depot.save(stagiaire);                             // UPDATE des seules colonnes modifiées
  }

  async changerGroupe(id: number, groupe: string): Promise<void> {
    const resultat = await this.depot.update({ id }, { groupe });   // UPDATE direct, sans lecture
    if (resultat.affected === 0) throw new NotFoundException(`Stagiaire ${id} introuvable`);
  }

  async remove(id: number): Promise<void> {
    const resultat = await this.depot.softDelete({ id });         // UPDATE supprime_le = NOW()
    if (resultat.affected === 0) throw new NotFoundException(`Stagiaire ${id} introuvable`);
  }

  statistiques() {
    return Promise.all([
      this.depot.count(),
      this.depot.countBy({ groupe: 'DEV101' }),
      this.depot.existsBy({ email: 'sami@exemple.tn' }),
      this.depot.count({ withDeleted: true }),
    ]).then(([total, dev101, samiExiste, avecSupprimes]) => ({ total, dev101, samiExiste, avecSupprimes }));
  }
}

Le contrôleur ne change pas par rapport aux chapitres précédents, sauf que toutes les méthodes du service sont maintenant asynchrones: elles renvoient des promesses, que NestJS attend automatiquement.

📄 src/stagiaires/stagiaires.controller.ts

import {
  Body, Controller, Delete, Get, HttpCode, Param, ParseIntPipe, Patch, Post, Query,
} from '@nestjs/common';
import { CreerStagiaireDto, ModifierStagiaireDto } from './stagiaire.dto';
import { StagiairesService } from './stagiaires.service';

@Controller('stagiaires')
export class StagiairesController {
  constructor(private readonly stagiairesService: StagiairesService) {}

  @Get('statistiques')
  statistiques() {
    return this.stagiairesService.statistiques();
  }

  @Get()
  findAll(@Query('groupe') groupe?: string) {
    return this.stagiairesService.findAll(groupe);
  }

  @Get(':id')
  findOne(@Param('id', ParseIntPipe) id: number) {
    return this.stagiairesService.findOne(id);
  }

  @Post()
  create(@Body() dto: CreerStagiaireDto) {
    return this.stagiairesService.create(dto);
  }

  @Patch(':id')
  update(@Param('id', ParseIntPipe) id: number, @Body() dto: ModifierStagiaireDto) {
    return this.stagiairesService.update(id, dto);
  }

  @Patch(':id/groupe/:groupe')
  @HttpCode(204)
  changerGroupe(@Param('id', ParseIntPipe) id: number, @Param('groupe') groupe: string) {
    return this.stagiairesService.changerGroupe(id, groupe);
  }

  @Delete(':id')
  @HttpCode(204)
  remove(@Param('id', ParseIntPipe) id: number) {
    return this.stagiairesService.remove(id);
  }
}

📄 src/stagiaires/stagiaires.module.ts

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Stagiaire } from './stagiaire.entity';
import { StagiairesController } from './stagiaires.controller';
import { StagiairesService } from './stagiaires.service';

@Module({
  imports: [TypeOrmModule.forFeature([Stagiaire])],     // rend Repository<Stagiaire> injectable ici
  controllers: [StagiairesController],
  providers: [StagiairesService],
})
export class StagiairesModule {}
  const b = '/api/stagiaires';
  await appel('POST', b, { corps: { nom: 'Ben Ali', prenom: 'Sami', email: 'sami@exemple.tn', groupe: 'DEV101' } });
  await appel('POST', b, { corps: { nom: 'Trabelsi', prenom: 'Ines', email: 'ines@exemple.tn', groupe: 'DEV101' } });
  await appel('POST', b, { corps: { nom: 'Gharbi', prenom: 'Yassine', email: 'yassine@exemple.tn', groupe: 'DEV102' } });
  await appel('POST', b, { corps: { nom: 'Autre', prenom: 'Sami', email: 'sami@exemple.tn', groupe: 'DEV102' } });
  await appel('GET', `${b}?groupe=DEV101`);
  await appel('GET', `${b}/2`);
  await appel('PATCH', `${b}/2`, { corps: { groupe: 'RES201' } });
  await appel('PATCH', `${b}/3/groupe/DEV101`);
  await appel('DELETE', `${b}/1`);
  await appel('GET', `${b}/1`);
  await appel('GET', `${b}/statistiques`);
  await appel('DELETE', `${b}/99`);
  await appel('PATCH', `${b}/99`, { corps: { nom: 'Fantôme' } });

Résultat réellement obtenu :

SQL> START TRANSACTION
  SQL> INSERT INTO `stagiaires`(`id`, `nom`, `prenom`, `email`, `groupe`, `cree_le`, `supprime_le`) VALUES (DEFAULT, ?, ?, ?, ?, DEFAULT, DEFAULT) -- ["Ben Ali","Sami","sami@exemple.tn","DEV101"]
  SQL> SELECT `Stagiaire`.`id` AS `Stagiaire_id`, `Stagiaire`.`cree_le` AS `Stagiaire_cree_le`, `Stagiaire`.`supprime_le` AS `Stagiaire_supprime_le` FROM `stagiaires` `Stagiaire` WHERE ( `Stagiaire`.`id` = ? ) AND ( `Stagiaire`.`supprime_le` IS NULL ) -- [1]
  SQL> COMMIT
POST /api/stagiaires → 201 {"id":1,"nom":"Ben Ali","prenom":"Sami","email":"sami@exemple.tn","groupe":"DEV101","creeLe":"…","supprimeLe":null}
POST /api/stagiaires → 201 {"id":2,"nom":"Trabelsi","prenom":"Ines","email":"ines@exemple.tn","groupe":"DEV101","creeLe":"…","supprimeLe":null}
POST /api/stagiaires → 201 {"id":3,"nom":"Gharbi","prenom":"Yassine","email":"yassine@exemple.tn","groupe":"DEV102","creeLe":"…","supprimeLe":null}
POST /api/stagiaires → 409 {"message":"L'e-mail sami@exemple.tn est déjà utilisé","error":"Conflict","statusCode":409}
  SQL> SELECT `Stagiaire`.`id` AS `Stagiaire_id`, `Stagiaire`.`nom` AS `Stagiaire_nom`, `Stagiaire`.`prenom` AS `Stagiaire_prenom`, `Stagiaire`.`email` AS `Stagiaire_email`, `Stagiaire`.`groupe` AS `Stagiaire_groupe`, `Stagiaire`.`cree_le` AS `Stagiaire_cree_le`, `Stagiaire`.`supprime_le` AS `Stagiaire_supprime_le` FROM `stagiaires` `Stagiaire` WHERE ( ((`Stagiaire`.`groupe` = ?)) ) AND ( `Stagiaire`.`supprime_le` IS NULL ) ORDER BY `Stagiaire`.`nom` ASC, `Stagiaire`.`prenom` ASC -- ["DEV101"]
GET /api/stagiaires?groupe=DEV101 → 200 [{"id":1,"nom":"Ben Ali","prenom":"Sami","email":"sami@exemple.tn","groupe":"DEV101","creeLe":"…","supprimeLe":null},{"id":2,"nom":"Trabelsi","prenom":"Ines","email":"ines@exemple.tn","groupe":"DEV101","creeLe":"…","supprimeLe":null}]
  SQL> SELECT `Stagiaire`.`id` AS `Stagiaire_id`, `Stagiaire`.`nom` AS `Stagiaire_nom`, `Stagiaire`.`prenom` AS `Stagiaire_prenom`, `Stagiaire`.`email` AS `Stagiaire_email`, `Stagiaire`.`groupe` AS `Stagiaire_groupe`, `Stagiaire`.`cree_le` AS `Stagiaire_cree_le`, `Stagiaire`.`supprime_le` AS `Stagiaire_supprime_le` FROM `stagiaires` `Stagiaire` WHERE ( ((`Stagiaire`.`id` = ?)) ) AND ( `Stagiaire`.`supprime_le` IS NULL ) LIMIT 1 -- [2]
GET /api/stagiaires/2 → 200 {"id":2,"nom":"Trabelsi","prenom":"Ines","email":"ines@exemple.tn","groupe":"DEV101","creeLe":"…","supprimeLe":null}
  SQL> SELECT `Stagiaire`.`id` AS `Stagiaire_id`, `Stagiaire`.`nom` AS `Stagiaire_nom`, `Stagiaire`.`prenom` AS `Stagiaire_prenom`, `Stagiaire`.`email` AS `Stagiaire_email`, `Stagiaire`.`groupe` AS `Stagiaire_groupe`, `Stagiaire`.`cree_le` AS `Stagiaire_cree_le`, `Stagiaire`.`supprime_le` AS `Stagiaire_supprime_le` FROM `stagiaires` `Stagiaire` WHERE ( `Stagiaire`.`id` = ? ) AND ( `Stagiaire`.`supprime_le` IS NULL ) -- [2]
  SQL> SELECT `Stagiaire`.`id` AS `Stagiaire_id`, `Stagiaire`.`nom` AS `Stagiaire_nom`, `Stagiaire`.`prenom` AS `Stagiaire_prenom`, `Stagiaire`.`email` AS `Stagiaire_email`, `Stagiaire`.`groupe` AS `Stagiaire_groupe`, `Stagiaire`.`cree_le` AS `Stagiaire_cree_le`, `Stagiaire`.`supprime_le` AS `Stagiaire_supprime_le` FROM `stagiaires` `Stagiaire` WHERE `Stagiaire`.`id` = ? -- [2]
  SQL> START TRANSACTION
  SQL> UPDATE `stagiaires` SET `groupe` = ? WHERE `id` = ? -- ["RES201",2]
  SQL> COMMIT
PATCH /api/stagiaires/2 → 200 {"id":2,"nom":"Trabelsi","prenom":"Ines","email":"ines@exemple.tn","groupe":"RES201","creeLe":"…","supprimeLe":null}
  SQL> UPDATE `stagiaires` SET `groupe` = ? WHERE `id` = ? -- ["DEV101",3]
PATCH /api/stagiaires/3/groupe/DEV101 → 204
  SQL> UPDATE `stagiaires` SET `supprime_le` = CURRENT_TIMESTAMP WHERE `id` = ? AND `supprime_le` IS NULL -- [1]
DELETE /api/stagiaires/1 → 204
GET /api/stagiaires/1 → 404 {"message":"Stagiaire 1 introuvable","error":"Not Found","statusCode":404}
GET /api/stagiaires/statistiques → 200 {"total":2,"dev101":1,"samiExiste":false,"avecSupprimes":3}
DELETE /api/stagiaires/99 → 404 {"message":"Stagiaire 99 introuvable","error":"Not Found","statusCode":404}
PATCH /api/stagiaires/99 → 404 {"message":"Stagiaire 99 introuvable","error":"Not Found","statusCode":404}

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 du SQL, opération par opération
MéthodeSQL observéÀ retenir
create(dto) + save()INSERT puis SELECT des colonnes générées, dans une transactionl'objet renvoyé contient l'id et les dates
find({ where, order })SELECT … WHERE groupe = ? … ORDER BY nom, prenomwhere: {} = pas de filtre
findOneBy({ id })… LIMIT 1renvoie null si rien n'est trouvé : à nous de lever le 404
preload() + save()deux SELECT, puis UPDATE … SET groupe = ?seules les colonnes modifiées sont mises à jour
update(critère, valeurs)un seul UPDATE, sans lecturerapide ; affected indique le nombre de lignes modifiées
softDelete()UPDATE … SET supprime_le = CURRENT_TIMESTAMPla ligne reste, mais find l'ignore (supprime_le IS NULL ajouté partout)

Les statistiques le confirment : total vaut 2 (le stagiaire supprimé est ignoré), samiExiste est faux, mais avecSupprimes (option withDeleted: true) en compte 3. restore({ id }) annulerait la suppression.

save ou update ?
save(entite)update(critère, valeurs)
Requêteslecture + écritureune seule écriture
Renvoiel'entité complète{ affected }
Relations, cascades, @UpdateDateColumngéréesnon gérées (@UpdateDateColumn l'est par MySQL)
Usagecréer, ou modifier puis renvoyer l'objetmodifications en masse ou simples, sans besoin de relire

Remarquez que update ignore la suppression douce : PATCH /3/groupe modifierait aussi un stagiaire supprimé. À vous d'ajouter la condition ({ id, supprimeLe: IsNull() }) si nécessaire.

Les doublons : ER_DUP_ENTRY

La contrainte d'unicité de l'e-mail est vérifiée par MySQL : le second INSERT avec sami@exemple.tn échoue avec une QueryFailedError de code ER_DUP_ENTRY. Sans traitement, le client recevrait un 500. Le service la traduit en 409 Conflict. Le TP 7 généralise cette traduction dans un filtre d'exception (leçon 9.3).

Vérifier avant ou attraper l'erreur ? Faire un existsBy({ email }) avant l'insertion donne un message plus clair, mais ne suffit pas : entre la vérification et l'insertion, une autre requête peut insérer le même e-mail. Seule la contrainte UNIQUE de la base est fiable ; on attrape donc toujours ER_DUP_ENTRY.

Les options de find
import { Between, ILike, In, IsNull, LessThan, Like, MoreThanOrEqual, Not } from 'typeorm';

this.depot.find({
  select: { id: true, nom: true, prenom: true },              // colonnes à lire
  where: [                                                    // tableau = OU entre les objets
    { groupe: In(['DEV101', 'DEV102']), nom: Like('B%') },    // dans un objet = ET
    { supprimeLe: Not(IsNull()) },
  ],
  order: { nom: 'ASC', creeLe: 'DESC' },
  skip: 20,                                                   // pagination (leçon 11.7)
  take: 10,
  withDeleted: true,                                          // inclure les supprimés « doux »
});

// autres opérateurs : MoreThanOrEqual(10), LessThan('2026-01-01'), Between(10, 15), ILike('%ben%')
Activités

Activité 1 Le service des groupes

Écrivez GroupesService avec un Repository<Groupe>: findAll() trié par code, findOne(id) avec 404, create(dto) avec 409 sur code en double, update(id, dto) avec preload, remove(id). N'oubliez pas forFeature.

Voir le corrigé

Même structure que StagiairesService. Points de vigilance : findOne doit lever le 404 (findOneBy renvoie null) ; remove doit vérifier affected; GroupesModule importe TypeOrmModule.forFeature([Groupe]), sans quoi l'erreur « Nest can't resolve dependencies of the GroupesService (?) … GroupeRepository » apparaît.

Activité 2 Recherche multicritère

Ajoutez rechercher(texte) qui renvoie les stagiaires dont le nom ou le prénom contient le texte, sans tenir compte de la casse, triés par nom, avec au plus 20 résultats.

Voir le corrigé
rechercher(texte: string) {
  const motif = ILike(`%${texte}%`);           // valeur paramétrée : pas d'injection possible
  return this.depot.find({
    where: [{ nom: motif }, { prenom: motif }],
    order: { nom: 'ASC' },
    take: 20,
  });
}

Avec MySQL, la collation utf8mb4_unicode_ci rend déjà LIKE insensible à la casse ; ILike rend l'intention explicite et fonctionne aussi avec PostgreSQL.

Activité 3 Restaurer

Ajoutez la route PATCH /api/stagiaires/:id/restaurer qui annule une suppression douce (404 si l'identifiant n'existe pas du tout). Comment lister les stagiaires supprimés ?

Voir le corrigé
async restaurer(id: number) {
  const resultat = await this.depot.restore({ id });      // UPDATE … SET supprime_le = NULL
  if (!resultat.affected) throw new NotFoundException(`Stagiaire ${id} introuvable`);
  return this.findOne(id);
}

corbeille() {
  return this.depot.find({ where: { supprimeLe: Not(IsNull()) }, withDeleted: true });
}

Activité 4 Erreur d'injection

Un étudiant oublie TypeOrmModule.forFeature([Stagiaire]) dans StagiairesModule. Quel message obtient-il ? Et s'il écrit private depot: Repository<Stagiaire> sans @InjectRepository?

Voir le corrigé

Messages réellement obtenus. Premier cas : « Nest can't resolve dependencies of the StagiairesService (?). Please make sure that the argument "StagiaireRepository" at index [0] is available in the StagiairesModule module. » Second cas : « … the argument Repository at index [0] is available in the StagiairesModule module. » NestJS cherche alors un provider pour la classe générique Repository: le paramètre de type <Stagiaire> n'existe pas à l'exécution, d'où la nécessité du jeton StagiaireRepository fourni par @InjectRepository(Stagiaire).

À retenir

  • TypeOrmModule.forFeature([Entite]) + @InjectRepository(Entite) private depot: Repository.
  • Lire : find, findBy, findOneBy (null si absent → 404), findAndCount, count, existsBy.
  • Créer : create(dto) puis save() ; modifier : preload + save, ou update direct.
  • Supprimer : delete / remove, ou softDelete avec @DeleteDateColumn.
  • Doublon : QueryFailedError ER_DUP_ENTRY → 409 ; la contrainte UNIQUE reste la seule garantie.

Cet article vous a-t-il aidé ?