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

Connecter NestJS à MySQL avec TypeORM

Cette leçon connecte une application NestJS à une base MySQL avec @nestjs/typeorm. Elle détaille l'installation, la configuration par TypeOrmModule.forRootAsync et ConfigService (chapitre 10), le rôle...

0 chapitres 0 QCM Accès gratuit
Connecter NestJS à MySQL avec TypeORM

À propos de ce cours

Cette leçon connecte une application NestJS à une base MySQL avec @nestjs/typeorm. Elle détaille l'installation, la configuration par TypeOrmModule.forRootAsync et ConfigService (chapitre 10), le rôle des options autoLoadEntities, synchronize, logging et retryAttempts, et l'enregistrement des entités par module avec forFeature. Une route de santé interroge réellement la base. Les messages d'erreur obtenus avec un mauvais mot de passe et une base inexistante sont montrés et expliqués, ainsi que les risques de synchronize en production. Activités corrigées.

Objectifs de la leçon

  • Installer TypeORM, le pilote MySQL et le module NestJS.
  • Configurer la connexion avec TypeOrmModule.forRootAsync et ConfigService.
  • Comprendre autoLoadEntities, synchronize et forFeature.
  • Diagnostiquer les erreurs de connexion.
Installation
npm install @nestjs/typeorm typeorm mysql2 @nestjs/config
  • typeorm: l'ORM ;
  • mysql2: le pilote qui parle le protocole MySQL (et MariaDB) ;
  • @nestjs/typeorm: l'intégration dans le système de modules et d'injection de NestJS ;
  • @nestjs/config: pour lire les paramètres de connexion dans .env (chapitre 10).

📄 .env

# .env
DB_HOTE=localhost
DB_PORT=3306
DB_UTILISATEUR=apc_dev
DB_MOT_DE_PASSE=secret_dev
DB_NOM=formation_dev

Connexion de NestJS à MySQL avec TypeORM

La connexion est configurée une fois ; chaque module déclare ses entités.

Configurer la connexion

📄 src/app.module.ts

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { SanteController } from './sante.controller';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    TypeOrmModule.forRootAsync({
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        type: 'mysql',
        host: config.get('DB_HOTE'),
        port: Number(config.get('DB_PORT', 3306)),
        username: config.get('DB_UTILISATEUR'),
        password: config.get('DB_MOT_DE_PASSE'),
        database: config.get('DB_NOM'),
        entities: [],
        autoLoadEntities: true,
        synchronize: true,
        retryAttempts: 2,
        retryDelay: 500,
        logging: true,
      }),
    }),
  ],
  controllers: [SanteController],
})
export class AppModule {}
OptionRôle
forRootAsync + inject + useFactoryconstruit la configuration avec ConfigService (leçon 10.2) ; forRoot({ … }) existe aussi, mais avec des valeurs fixes
type: 'mysql'pilote ; aussi valable pour MariaDB ('mariadb' existe aussi)
autoLoadEntitiesenregistre automatiquement les entités déclarées avec forFeature() dans les modules
synchronizecrée et modifie les tables d'après les entités à chaque démarrage (développement uniquement, voir plus bas)
loggingaffiche les requêtes SQL (true, ou ['error', 'warn'], ['query']…)
retryAttempts, retryDelaynombre de nouvelles tentatives si la base ne répond pas (9 par défaut, toutes les 3 s)

Avec la configuration validée du chapitre 10 (registerAs('database', …)), la fabrique devient encore plus simple : useFactory: (config: ConfigService) => ({ type: 'mysql', ...config.getOrThrow('database'), autoLoadEntities: true }), à condition que les noms des propriétés correspondent (host, port, username…).

Vérifier la connexion

Le DataSource de TypeORM (la connexion, avec son groupe de connexions réutilisables) est injectable avec @InjectDataSource(). Une route de santé l'utilise pour interroger la base :

📄 src/sante.controller.ts

import { Controller, Get } from '@nestjs/common';
import { InjectDataSource } from '@nestjs/typeorm';
import { DataSource } from 'typeorm';

@Controller('sante')
export class SanteController {
  constructor(@InjectDataSource() private readonly source: DataSource) {}

  @Get()
  async sante() {
    const [infos] = await this.source.query('SELECT VERSION() AS version, DATABASE() AS base, NOW() AS heure');
    return {
      baseDeDonnees: this.source.isInitialized ? 'connectée' : 'déconnectée',
      pilote: this.source.options.type,
      version: infos.version,
      base: infos.base,
    };
  }
}

Résultat réellement obtenu :

$ node dist/main.js
GET /api/sante → 200 {"baseDeDonnees":"connectée","pilote":"mysql","version":"10.11.14-MariaDB-0ubuntu0.24.04.1","base":"ch11_s112"}

$ DB_MOT_DE_PASSE=mauvais node dist/main.js
ERREUR : Access denied for user 'apc_dev'@'localhost' (using password: YES)

$ DB_NOM=base_inexistante node dist/main.js
ERREUR : Unknown database 'base_inexistante'

Les exemples de ce chapitre ont été exécutés avec MariaDB 10.11, comme l'indique la version. Avec MySQL 8, vous obtiendrez une version de la forme 8.0.x et exactement les mêmes résultats.

Les erreurs de connexion

Les deux dernières exécutions montrent les messages les plus fréquents. NestJS réessaie la connexion (retryAttempts), puis l'application refuse de démarrer.

MessageCause probable
Access denied for user 'apc_dev'@'localhost'mot de passe ou nom d'utilisateur incorrect, ou droits non accordés sur la base
Unknown database '…'la base n'a pas été créée (CREATE DATABASE) ; TypeORM ne crée pas la base, seulement les tables
connect ECONNREFUSED 127.0.0.1:3306serveur MySQL arrêté, ou mauvais port
getaddrinfo ENOTFOUND …nom d'hôte inconnu (faute de frappe dans DB_HOTE)
Data type "Object" … is not supportedproblème dans une entité (leçon 11.3)
Déclarer les entités dans les modules : forFeature

Chaque module de fonctionnalité déclare les entités qu'il utilise. C'est ce qui rend injectable le Repository de l'entité (leçon 11.4) :

📄 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 {}
synchronize : pratique, mais dangereux

Avec synchronize: true, TypeORM compare au démarrage les entités et les tables, et exécute les CREATE TABLE et ALTER TABLE nécessaires. C'est très pratique pendant l'apprentissage et le développement. Mais si vous renommez une propriété, TypeORM peut supprimer la colonne et en créer une nouvelle : toutes les données de cette colonne sont perdues.

En production : synchronize: false, toujours. Le schéma évolue alors par des migrations (leçon 11.8), relues et versionnées. Une bonne pratique : synchronize: config.get('NODE_ENV') === 'development'.

Activités

Activité 1 Connecter api-formation-securisee

Dans votre projet du TP 6 (branche base-de-donnees), installez les paquets, ajoutez les variables DB_* à .env, .env.example et au schéma de validation du chapitre 10, puis configurez TypeOrmModule.forRootAsync. Ajoutez à SanteController l'état de la base.

Voir le corrigé

Points de contrôle : .env.example contient les noms des variables sans le vrai mot de passe ; le schéma Joi ou Zod rend DB_HOTE, DB_UTILISATEUR et DB_NOM obligatoires ; GET /sante renvoie la version du serveur. Avec un mauvais mot de passe, l'application doit refuser de démarrer.

Activité 2 Diagnostiquer

Un étudiant obtient ER_ACCESS_DENIED_ERROR: Access denied for user 'root'@'localhost' (using password: NO), alors que son .env contient DB_MOT_DE_PASSE=root. Que vérifier ?

Voir le corrigé

« using password: NO » : aucun mot de passe n'a été transmis. La variable n'est pas lue : nom différent dans le code (DB_PASSWORD au lieu de DB_MOT_DE_PASSE), ConfigModule non importé avant TypeOrmModule, fichier .env qui n'est pas à la racine du projet, ou forRoot utilisé avec process.env lu avant le chargement du fichier. forRootAsync avec ConfigService évite ce dernier piège.

Activité 3 logging sélectif

Configurez logging pour n'afficher que les requêtes lentes (plus de 500 ms) et les erreurs. Quelle option complémentaire faut-il ?

Voir le corrigé
logging: ['error', 'warn'],
maxQueryExecutionTime: 500,      // les requêtes de plus de 500 ms sont signalées

En production, afficher toutes les requêtes ralentirait l'application et remplirait les journaux, avec des données parfois sensibles.

Activité 4 synchronize selon l'environnement

Modifiez la configuration pour que synchronize et logging ne soient actifs qu'en développement. Vérifiez avec NODE_ENV=production npm run start.

Voir le corrigé
useFactory: (config: ConfigService) => {
  const dev = config.get('NODE_ENV', 'development') === 'development';
  return {
    type: 'mysql',
    host: config.getOrThrow('DB_HOTE'),
    // …
    autoLoadEntities: true,
    synchronize: dev,
    logging: dev ? true : ['error'],
  };
},

À retenir

  • npm install @nestjs/typeorm typeorm mysql2 ; connexion avec TypeOrmModule.forRootAsync et ConfigService.
  • TypeORM crée les tables, pas la base : CREATE DATABASE au préalable, avec un utilisateur dédié.
  • autoLoadEntities + forFeature([Entite]) dans chaque module rendent le Repository injectable.
  • @InjectDataSource() donne accès au DataSource (requêtes, transactions).
  • synchronize: true en développement seulement ; en production : migrations.

Cet article vous a-t-il aidé ?