À propos de ce cours
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>.
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éthode | SQL observé | À retenir |
|---|---|---|
create(dto) + save() | INSERT puis SELECT des colonnes générées, dans une transaction | l'objet renvoyé contient l'id et les dates |
find({ where, order }) | SELECT … WHERE groupe = ? … ORDER BY nom, prenom | where: {} = pas de filtre |
findOneBy({ id }) | … LIMIT 1 | renvoie 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 lecture | rapide ; affected indique le nombre de lignes modifiées |
softDelete() | UPDATE … SET supprime_le = CURRENT_TIMESTAMP | la 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êtes | lecture + écriture | une seule écriture |
| Renvoie | l'entité complète | { affected } |
Relations, cascades, @UpdateDateColumn | gérées | non gérées (@UpdateDateColumn l'est par MySQL) |
| Usage | créer, ou modifier puis renvoyer l'objet | modifications 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é ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !