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

Présentation des ORM Node.js : TypeORM, Prisma, Sequelize

Cette leçon introduit la persistance des données dans une API NestJS. Elle explique le rôle d'un ORM (correspondance objet-relationnel) et le compare au SQL écrit à la main. Un même besoin est exécuté...

0 chapitres 0 QCM Accès gratuit
Présentation des ORM Node.js : TypeORM, Prisma, Sequelize

À propos de ce cours

Cette leçon introduit la persistance des données dans une API NestJS. Elle explique le rôle d'un ORM (correspondance objet-relationnel) et le compare au SQL écrit à la main. Un même besoin est exécuté avec le pilote mysql2 seul puis avec TypeORM : la version par concaténation subit une injection SQL réelle, corrigée par les requêtes paramétrées que l'ORM génère automatiquement. La leçon compare ensuite TypeORM, Prisma, Sequelize et le SQL brut, et justifie le choix de TypeORM pour ce chapitre et de Prisma pour le chapitre 12. Activités corrigées.

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 TypeScriptDans 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.

Rôle d'un ORM et comparaison des outils

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
TypeORMPrismaSequelizeSQL brut (mysql2)
Modèle décrit parclasses + décorateursfichier schema.prismamodèles JavaScript—
StyleRepository, QueryBuilderclient généré et typéActive Recordrequêtes écrites à la main
Migrationsgénérées depuis les entitésgénérées depuis le schémaécrites à la main (CLI)à gérer soi-même
Intégration NestJSofficielle : @nestjs/typeormun service à écrire (chapitre 12)officielle : @nestjs/sequelizeun provider useFactory
BasesMySQL, PostgreSQL, SQLite, SQL Server, Oracle…idem + MongoDBMySQL, 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é ?