À propos de ce cours
Objectifs de la leçon
- Expliquer pourquoi une API a besoin d'une base de données.
- Définir un ORM et le comparer au SQL écrit à la main.
- Reconnaître et éviter l'injection SQL.
- Comparer TypeORM, Prisma et Sequelize.
De la mémoire à la base de données
Toutes nos API stockaient jusqu'ici leurs données dans des tableaux en mémoire : à chaque redémarrage, tout disparaît, et deux instances de l'API ne partagent pas les mêmes données. Une vraie application enregistre ses données dans un système de gestion de bases de données (SGBD). Dans ce chapitre : MySQL (ou MariaDB, son équivalent libre, totalement compatible pour ce que nous faisons), la base relationnelle la plus utilisée dans l'hébergement web.
Il faut alors faire dialoguer deux mondes différents :
| Dans le code TypeScript | Dans la base relationnelle |
|---|---|
classes et objets (Stagiaire) | tables et lignes (stagiaires) |
propriétés (dateNaissance) | colonnes (date_naissance) |
références entre objets (stagiaire.groupe) | clés étrangères (groupe_id) et jointures |
types TypeScript (number, Date, boolean) | types SQL (INT, DATETIME, TINYINT) |
Un ORM (Object-Relational Mapping, correspondance objet-relationnel) est une bibliothèque qui fait cette traduction : vous manipulez des objets, il écrit le SQL et convertit les lignes reçues en objets.
L'ORM traduit les appels de méthodes en SQL paramétré.
Même besoin, deux approches
Une table stagiaire contient quatre stagiaires dans trois groupes. On veut les stagiaires d'un groupe, dont le code est envoyé par le client. D'abord avec le pilote mysql2 seul :
📄 src/brut.ts
import mysql from 'mysql2/promise';
async function main() {
const cnx = await mysql.createConnection({
host: 'localhost', user: 'apc_dev', password: 'secret_dev', database: 'ch11_s111',
});
// Valeur reçue d'un client (query string, formulaire…)
const groupe = "DEV101' OR '1'='1";
// ✗ Concaténation : injection SQL
const sqlDangereux = `SELECT nom FROM stagiaire WHERE groupe = '${groupe}'`;
console.log('SQL envoyé :', sqlDangereux);
const [lignes1] = await cnx.query(sqlDangereux);
console.log('Concaténation :', lignes1);
// ✓ Requête paramétrée : la valeur est transmise à part, jamais interprétée comme du SQL
const [lignes2] = await cnx.execute('SELECT nom FROM stagiaire WHERE groupe = ?', [groupe]);
console.log('Paramétrée :', lignes2);
const [lignes3] = await cnx.execute('SELECT nom FROM stagiaire WHERE groupe = ?', ['DEV101']);
console.log('Paramétrée (DEV101) :', lignes3);
await cnx.end();
}
main();
Puis avec TypeORM :
📄 src/orm.ts
import 'reflect-metadata';
import { Column, DataSource, Entity, PrimaryGeneratedColumn } from 'typeorm';
// La table décrite par une CLASSE
@Entity('stagiaire')
class Stagiaire {
@PrimaryGeneratedColumn()
id: number;
@Column({ length: 50 })
nom: string;
@Column({ length: 10 })
groupe: string;
}
async function main() {
const source = new DataSource({
type: 'mysql', host: 'localhost', username: 'apc_dev', password: 'secret_dev', database: 'ch11_s111',
});
await source.initialize();
const depot = source.getRepository(Stagiaire);
(globalThis as any).SQL = true;
const groupe = "DEV101' OR '1'='1";
console.log('ORM (valeur piégée) :', await depot.findBy({ groupe }));
const dev101 = await depot.find({ where: { groupe: 'DEV101' }, order: { nom: 'ASC' } });
console.log('ORM (DEV101) :', dev101);
console.log('Instance de Stagiaire ?', dev101[0] instanceof Stagiaire);
await source.destroy();
}
main();
Résultat réellement obtenu :
$ node dist/brut.js (mysql2 seul)
SQL envoyé : SELECT nom FROM stagiaire WHERE groupe = 'DEV101' OR '1'='1'
Concaténation : [
{ nom: 'Ben Ali' },
{ nom: 'Trabelsi' },
{ nom: 'Gharbi' },
{ nom: 'Mansouri' }
]
Paramétrée : []
Paramétrée (DEV101) : [ { nom: 'Ben Ali' }, { nom: 'Trabelsi' } ]
$ node dist/orm.js (TypeORM)
SQL> SELECT `Stagiaire`.`id` AS `Stagiaire_id`, `Stagiaire`.`nom` AS `Stagiaire_nom`, `Stagiaire`.`groupe` AS `Stagiaire_groupe` FROM `stagiaire` `Stagiaire` WHERE ((`Stagiaire`.`groupe` = ?)) -- ["DEV101' OR '1'='1"]
ORM (valeur piégée) : []
SQL> SELECT `Stagiaire`.`id` AS `Stagiaire_id`, `Stagiaire`.`nom` AS `Stagiaire_nom`, `Stagiaire`.`groupe` AS `Stagiaire_groupe` FROM `stagiaire` `Stagiaire` WHERE ((`Stagiaire`.`groupe` = ?)) ORDER BY `Stagiaire`.`nom` ASC -- ["DEV101"]
ORM (DEV101) : [
Stagiaire { id: 1, nom: 'Ben Ali', groupe: 'DEV101' },
Stagiaire { id: 2, nom: 'Trabelsi', groupe: 'DEV101' }
]
Instance de Stagiaire ? true
L'injection SQL
Le client a envoyé DEV101' OR '1'='1. Insérée telle quelle dans le texte de la requête, cette valeur a modifié la requête elle-même: la condition devient « groupe = DEV101 ou 1 = 1 », toujours vraie, et les quatre stagiaires sont renvoyés. Avec une requête plus dangereuse, un attaquant pourrait lire d'autres tables ou supprimer des données. C'est l'injection SQL, l'une des failles les plus graves et les plus fréquentes du web.
La correction : la requête paramétrée. Le SQL contient un ?, et la valeur est envoyée séparément au serveur MySQL, qui la traite toujours comme une donnée. Résultat : aucun stagiaire ne s'appelle DEV101' OR '1'='1, donc 0 ligne.
Observez le SQL généré par TypeORM : il utilise systématiquement des paramètres (WHERE groupe = ? suivi de -- ["…"]). En utilisant l'ORM correctement, vous êtes protégés. Et vous recevez des instances de votre classe Stagiaire, pas de simples objets.
Règle absolue: ne jamais construire une requête SQL en concaténant une valeur venant de l'extérieur, que ce soit avec mysql2, dans query() de TypeORM ou dans le QueryBuilder (leçon 11.6). Toujours utiliser des paramètres.
Les principaux outils pour Node.js
| TypeORM | Prisma | Sequelize | SQL brut (mysql2) | |
|---|---|---|---|---|
| Modèle décrit par | classes + décorateurs | fichier schema.prisma | modèles JavaScript | — |
| Style | Repository, QueryBuilder | client généré et typé | Active Record | requêtes écrites à la main |
| Migrations | générées depuis les entités | générées depuis le schéma | écrites à la main (CLI) | à gérer soi-même |
| Intégration NestJS | officielle : @nestjs/typeorm | un service à écrire (chapitre 12) | officielle : @nestjs/sequelize | un provider useFactory |
| Bases | MySQL, PostgreSQL, SQLite, SQL Server, Oracle… | idem + MongoDB | MySQL, PostgreSQL, SQLite… | une seule (le pilote choisi) |
Nous utilisons TypeORM: il est écrit en TypeScript, utilise des décorateurs comme NestJS, a une intégration officielle et reste le plus présent dans les projets NestJS existants. Le chapitre 12 présentera Prisma, très apprécié pour son typage.
Version utilisée: TypeORM est sorti en version 1.0 après de longues années en 0.3. Les exemples de ce chapitre ont été exécutés avec TypeORM 1.1, @nestjs/typeorm 12 et le pilote mysql2 3. L'essentiel de l'API (Repository, QueryBuilder, migrations) est inchangé depuis la 0.3 ; quelques méthodes anciennes (comme findByIds) ont disparu.
Activités
Activité 1 Repérer l'injection
Parmi ces lignes, lesquelles sont vulnérables à l'injection SQL ?
// (a)
cnx.query(`SELECT * FROM notes WHERE stagiaire_id = ${req.params.id}`);
// (b)
cnx.execute('SELECT * FROM notes WHERE stagiaire_id = ?', [req.params.id]);
// (c)
depot.findBy({ matiere: req.query.matiere });
// (d)
depot.query(`DELETE FROM notes WHERE matiere = '${matiere}'`);
// (e)
depot.query('DELETE FROM notes WHERE matiere = ?', [matiere]);
Voir le corrigé
(a) et (d) sont vulnérables : la valeur est insérée dans le texte SQL. Avec (a), id = "1 OR 1=1" renvoie toutes les notes ; avec (d), ' OR '1'='1 supprimerait toutes les notes. (b), (c) et (e) utilisent des paramètres.
Activité 2 Choisir un outil
Pour chaque situation, quel outil conseilleriez-vous ? (a) Un rapport statistique complexe avec des fonctions SQL avancées. (b) Une nouvelle API NestJS avec une équipe qui connaît bien TypeScript. (c) Une reprise d'une application Express existante qui utilise déjà Sequelize.
Voir le corrigé
(a) Le SQL écrit à la main (paramétré) ou le QueryBuilder : l'ORM peut aussi exécuter du SQL brut pour les cas particuliers. (b) TypeORM ou Prisma ; les deux conviennent. (c) Garder Sequelize avec @nestjs/sequelize: migrer d'ORM coûte cher et n'apporte rien de certain.
Activité 3 Installer MySQL ou MariaDB
Installez un serveur MySQL ou MariaDB sur votre poste (XAMPP, Laragon, WAMP, ou un conteneur Docker : docker run -d --name mysql -e MYSQL_ROOT_PASSWORD=root -p 3306:3306 mysql:8). Créez une base formation_dev et un utilisateur dédié qui n'a des droits que sur cette base.
Voir le corrigé
CREATE DATABASE formation_dev CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'apc_dev'@'localhost' IDENTIFIED BY 'secret_dev';
GRANT ALL PRIVILEGES ON formation_dev.* TO 'apc_dev'@'localhost';
FLUSH PRIVILEGES;
Ne pas utiliser root dans l'application : si elle était compromise, l'attaquant aurait accès à toutes les bases du serveur. utf8mb4 permet de stocker tous les caractères (arabe, émojis).
Activité 4 Lire le SQL généré
Dans la sortie de TypeORM, la colonne id est renvoyée sous l'alias Stagiaire_id. Pourquoi TypeORM utilise-t-il de tels alias ?
Voir le corrigé
Quand une requête joint plusieurs tables (leçon 11.5), plusieurs colonnes portent le même nom (id dans stagiaires et dans groupes). Les alias Table_colonne évitent toute ambiguïté et permettent à TypeORM de reconstruire chaque objet à partir de la ligne reçue.
À retenir
- Un ORM traduit les objets en lignes et les appels de méthodes en SQL.
- Concaténer une valeur externe dans du SQL = injection SQL ; toujours utiliser des paramètres.
- TypeORM génère des requêtes paramétrées et renvoie des instances des classes.
- TypeORM (classes + décorateurs), Prisma (schéma + client typé), Sequelize, SQL brut : des compromis différents.
- Ce chapitre : TypeORM 1.x avec MySQL ou MariaDB.
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 !