Aller au contenu

MySQL avec Express.js

Installation

Pour nous permettre d'interragir avec une base de données MySQL nous allons installer un nouveau module avec npm.

npm install mysql

Manuel

Documentation du module mysql

Création du pool de connexions

Ensuite nous allons créer le fichier ./src/config/db.js où nous allons déclarer un pool de connexion à notre BD. Notez aussi que j'utilise le module dotenv pour enregistrer les informations de connexion à la base de données

Note

On aurait aussi pu créer une connexion au lieu d'un pool, mais ce dernier est mieux adapté pour gérer de multiples utilisateurs. Pour plus de détail, cet article (anglais) résume bien la situation : Why is Connection Pooling better than Single Connection

.env
MYSQL_HOST="localhost"
MYSQL_USER="root"
MYSQL_PASSWORD="**********"
MYSQL_DATABASE="**********"
MYSQL_CONNECTION_LIMIT = 10
.src/config/db.js
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import mysql from "mysql";
import dotenv from "dotenv";
dotenv.config();

const pool = mysql.createPool({
    connectionLimit: process.env.MYSQL_CONNECTION_LIMIT,
    host: process.env.MYSQL_HOST,
    user: process.env.MYSQL_USER,
    password: process.env.MYSQL_PASSWORD,
    database: process.env.MYSQL_DATABASE
});

export default pool;

Utilisation

Maintenant pour lancer des requêtes à notre base de données MySQL il suffit d'importer le module db qu'on vient de créer et d'utiliser la fonction query()

script.js
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
// À ajuster selon votre structure
import db from '../config/db.js';

...

const requete = `SELECT nom, prenom FROM professeurs WHERE id = ?`;
// Les paramètres doivent toujours être passés sous forme de tableau, 
// même quand il n'y en a qu'un.
const params = [id]

db.query(requete, params, (erreur, resultat) => {
    // fonction à exécuter une fois la requête exécutée
    // erreur : Si une erreur SQL est survenur, objet contentant des informations sur celle-ci
    // resultat : Le résultat de la requète sous forme d'un tableau d'objets.
});

Attention l'objet resultat est toujours un tableau d'objets, même s'il n'y a qu'une ligne de résultat. Si on veut accéder à la valeur d'une colonne de la première ligne de résultat par exemple on peut faire resultat[0].nomColonneDansLaRequête. Dans l'exemple plus haut resultat[0].prenom me retournerait le prénom du professeur de la première ligne de résultat.

Dans l'objet erreur vous pouvez récupérer des informations sur l'erreur comme le code d'erreur SQL (erreur.sqlState) et un message explicatif (erreur.sqlMessage).

script.js
1
console.log(`Erreur SQL (${erreur.sqlState}) : ${erreur.sqlMessage}`);

On va aussi englober notre code dans une promesse (Promise). Pour plus de détail sur les promesses, voir la page sur l'asynchronisme.

Exemple

Voici un exemple complet d'une requête SELECT avec le modèle, la route et le controleur.

professeurs.route.js
1
2
3
4
5
6
7
8
9
// À ajuster selon la structure
import express from 'express';
import { trouverUnProfesseur } from '../controllers/professeurs.controller.js';

const router = express.Router();

router.get('/:id', trouverUnProfesseur);

export default router;
professeurs.controller.js
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// À ajuster selon la structure
import professeursModel from "../models/professeurs.model.js";

const trouverUnProfesseur = async (req, res) => {
    // Teste si le paramètre id est présent et valide
    if(!req.params.id || parseInt(req.params.id) <= 0){
        res.status(400);
        res.send({
            message: "L'id du professeur est obligatoire et doit être supérieur à 0"
        });
        return;
    }

    // Appel à la fonction getProfesseur dans le modèle
    await professeursModel.getProfesseur(req.params.id)
    // Si c'est un succès
    .then((professeur) => {
        // S'il n'y a aucun résultat, on retourne un message d'erreur avec le code 404
        if (!professeur[0]) {
            res.status(404);
            res.send({
                message: `Professeur introuvable avec l'id ${req.params.id}`
            });
            return;
        }
        // Sinon on retourne le premier objet du tableau de résultat car on ne devrait avoir qu'un professeur par id
        res.send(professeur[0]);
    })
    // S'il y a eu une erreur au niveau de la requête, on retourne un erreur 500 car c'est du serveur que provient l'erreur.
    .catch((erreur) => {
        console.log('Erreur : ', erreur);
        res.status(500)
        res.send({
            message: "Erreur lors de la récupération du professeur avec l'id " + req.params.id
        });
    });
};

export {
    trouverUnProfesseur
}
professeurs.model.js
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// À ajuster selon la structure
import db from '../config/db.js';

const getProfesseur = (id) => {
    return new Promise((resolve, reject) => {

        const requete = `SELECT nom, prenom FROM professeurs WHERE id = ?`;
        const params = [id]

        db.query(requete, params, (erreur, resultat) => {
            if (erreur) {
                console.log(`Erreur sqlState ${erreur.sqlState} : ${erreur.sqlMessage}`);
                // S'il y a une erreur, je la retourne avec reject()
                reject(erreur);
            }
            // Sinon je retourne le résultat sans faire de validation, c'est possible que le résultat soit vide
            resolve(resultat);
        });
    });
};

export default {
    getProfesseur
}

Références et autres exemples