API REST avec Express et MySQL en utilisant le modèle MVC 🚀

Les codeurs en herbe ! Aujourd'hui, on va plonger dans le monde d'Express.js et créer une API REST pour gérer une bibliothèque de livres. On va utiliser MySQL comme base de données et suivre le modèle MVC (Modèle-Vue-Contrôleur) pour structurer notre projet. Préparez-vous, car on va coder comme des pros (ou presque) !

---

Étape 1 : Initialisation du projet 🛠️

1.1 Créer un nouveau projet

Ouvrez votre terminal et créez un nouveau dossier pour votre projet :

mkdir ma-bibliotheque
cd ma-bibliotheque

Ensuite, initialisez un nouveau projet Node.js :

npm init -y

Cela va créer un fichier package.json qui contiendra toutes les informations sur votre projet et ses dépendances.

1.2 Installer les dépendances

On a besoin de quelques packages pour notre projet :

• Express : Le framework web pour Node.js.
• MySQL2 : Un client MySQL pour Node.js.
• Nodemon : Pour redémarrer automatiquement le serveur quand on fait des changements.

Installez-les avec la commande suivante :

npm install express mysql2 nodemon

1.3 Configurer package.json

Ouvrez le fichier package.json et ajoutez un script pour démarrer le serveur avec Nodemon :

"scripts": {
  "start": "nodemon index.js"
}

Maintenant, vous pouvez démarrer votre serveur avec :

npm start

---

Étape 2 : Structurer le projet avec le modèle MVC 🏗️

Le modèle MVC (Modèle-Vue-Contrôleur) est une façon de structurer votre application en trois parties :

1. Modèle : Gère les données et la logique métier.
2. Vue : Affiche les données (dans notre cas, on utilise une API, donc pas de vue).
3. Contrôleur : Gère les requêtes et les réponses.

2.1 Créer les dossiers

Créez les dossiers suivants dans votre projet :

ma-bibliotheque/
├── src/
│   ├── controller/
│   ├── model/
│   └── views/ (on n'en aura pas besoin pour une API)
├── index.js
└── package.json

---

Étape 3 : Créer le serveur Express 🌐

3.1 Le fichier index.js

Ouvrez le fichier index.js et ajoutez le code suivant :

const express = require('express');
const app = express();
const port = 3555;

// Middleware pour parser le JSON
app.use(express.json());

// Importer le contrôleur des livres
const BookController = require('./src/controller/BookController');

// Utiliser le contrôleur pour les routes /api/books
app.use('/api/books', BookController);

// Démarrer le serveur
app.listen(port, () => {
  console.log(`Serveur en écoute sur le port ${port}`);
});

Explication :

• express() : Crée une instance d'Express.
• app.use(express.json()) : Ce middleware permet à Express de comprendre le JSON envoyé dans les requêtes.
• app.use('/api/books', BookController) : On utilise le contrôleur pour gérer toutes les routes qui commencent par /api/books.
• app.listen(port) : Le serveur écoute sur le port 3555.

---

Étape 4 : Créer le contrôleur des livres 📚

4.1 Le fichier BookController.js

Dans le dossier src/controller/, créez un fichier BookController.js :

const express = require('express');
const app = express();
const {
  getAllBooks,
  getBookById,
  updateBook,
  createBook,
  deleteBook
} = require('./../model/BookManager');

// Récupérer tous les livres
app.get('/', async (req, res) => {
  const results = await getAllBooks();
  res.json(results);
});

// Récupérer un livre par son ID
app.get('/:id', async (req, res) => {
  const id = req.params.id;
  const results = await getBookById(id);
  res.json(results);
});

// Modifier un livre par son ID
app.put('/:id', async (req, res) => {
  const id = req.params.id;
  const results = await updateBook(id, req.body);
  res.json(results);
});

// Créer un livre
app.post('/', async (req, res) => {
  const results = await createBook(req.body);
  res.json(results);
});

// Supprimer un livre par son ID
app.delete('/:id', async (req, res) => {
  const id = req.params.id;
  const results = await deleteBook(id);
  res.json(results);
});

module.exports = app;

Explication détaillée du code 🧐

On va décortiquer cette partie du code pour bien comprendre ce qui se passe. C'est le cœur de notre contrôleur, où on définit les routes pour gérer les livres. Préparez-vous, car on va rentrer dans les détails !

---

1. Importation des modules et des fonctions

const express = require('express');
const app = express();
const {
  getAllBooks,
  getBookById,
  updateBook,
  createBook,
  deleteBook
} = require('./../model/BookManager');

Explication :

• const express = require('express'); : On importe le module Express. C'est notre framework web qui va nous permettre de créer des routes et de gérer les requêtes HTTP.

• const app = express(); : On crée une instance d'Express. Cette instance (app) va nous permettre de définir des routes et de démarrer le serveur.

• const { getAllBooks, getBookById, updateBook, createBook, deleteBook } = require('./../model/BookManager'); : On importe les fonctions du modèle BookManager. Ces fonctions sont responsables de l'interaction avec la base de données. Elles vont nous permettre de récupérer, créer, mettre à jour et supprimer des livres.

---

2. Définition de la route pour récupérer tous les livres

// Récupérer tous les livres
app.get('/', async (req, res) => {
  const results = await getAllBooks();
  res.json(results);
});

Explication :

• app.get('/', async (req, res) => { ... }); : On définit une route GET pour l'URL racine (/). Quand un client (comme un navigateur ou Postman) fait une requête GET à cette URL, cette fonction sera exécutée.

• app.get : C'est une méthode d'Express pour définir une route qui répond aux requêtes HTTP de type GET.

• '/' : C'est l'URL de la route. Ici, c'est la racine, donc quand on accède à /api/books, cette route sera déclenchée.

• async (req, res) => { ... } : C'est une fonction asynchrone qui prend deux paramètres :

• req (request) : Contient les informations sur la requête HTTP (comme les paramètres, les headers, etc.).

• res (response) : Utilisé pour envoyer une réponse au client.

• const results = await getAllBooks(); : On appelle la fonction getAllBooks() pour récupérer tous les livres de la base de données. Cette fonction est asynchrone, donc on utilise await pour attendre qu'elle termine son travail avant de passer à la ligne suivante.

• getAllBooks() : Cette fonction est définie dans BookManager.js. Elle exécute une requête SQL pour récupérer tous les livres de la table livres.

• res.json(results); : Une fois qu'on a récupéré les livres, on les envoie au client sous forme de JSON.

• res.json() : C'est une méthode d'Express qui envoie une réponse au client au format JSON. C'est parfait pour une API REST, car les clients (comme les applications frontend) peuvent facilement interpréter ce format.

---

3. Pourquoi utiliser async et await ?

Dans ce code, on utilise async et await pour gérer les opérations asynchrones, comme les appels à la base de données.

• async : On déclare la fonction comme asynchrone. Cela signifie qu'elle peut contenir des opérations qui prennent du temps (comme une requête SQL).

• await : On l'utilise pour attendre qu'une opération asynchrone se termine avant de passer à la ligne suivante. Par exemple, await getAllBooks() attend que la fonction getAllBooks() termine son travail (c'est-à-dire qu'elle récupère les livres de la base de données) avant de continuer.

Exemple sans await :

Si on n'utilisait pas await, le code essaierait d'envoyer la réponse (res.json(results)) avant que getAllBooks() ait fini de récupérer les livres. Cela causerait une erreur, car results serait undefined.

• app.get('/') : Route pour récupérer tous les livres.
• app.get('/:id') : Route pour récupérer un livre par son ID.
• app.put('/:id') : Route pour modifier un livre.
• app.post('/') : Route pour créer un nouveau livre.
• app.delete('/:id') : Route pour supprimer un livre.

---

Étape 5 : Créer le modèle pour gérer les livres 📖

5.1 Le fichier BookManager.js

Dans le dossier src/model/, créez un fichier BookManager.js :

const createConnection = require('./../../db');

// Récupérer tous les livres
const getAllBooks = async () => {
  try {
    const mysqlConnection = await createConnection();
    const [results] = await mysqlConnection.query('SELECT * FROM livres');
    await mysqlConnection.end();
    return results;
  } catch (err) {
    console.error(err);
    return 'Error 500';
  }
};

// Récupérer un livre par son ID
const getBookById = async (id) => {
  try {
    const mysqlConnection = await createConnection();
    const [results] = await mysqlConnection.query(
      `SELECT l.*, a.nom as auteur_nom, a.pays as auteur_pays, a.email as auteur_email
       FROM livres l
       LEFT JOIN auteurs a ON auteur_id = a.id
       WHERE l.id = ?`, [id]
    );
    await mysqlConnection.end();
    return results[0] || null;
  } catch (err) {
    console.error(err);
    throw new Error("Erreur serveur");
  }
};

// Modifier un livre
const updateBook = async (id, updateData) => {
  try {
    const mysqlConnection = await createConnection();
    const [result] = await mysqlConnection.query(
      `UPDATE livres SET titre = ?, auteur_id = ?, annee_publication = ?
       WHERE id = ?`, [updateData.titre, updateData.auteur_id, updateData.annee_publication, id]
    );
    await mysqlConnection.end();
    if (result.affectedRows === 0) return null;
    return await getBookById(id);
  } catch (e) {
    console.error(e);
  }
};

// Créer un livre
const createBook = async (bookData) => {
  try {
    const mysqlConnection = await createConnection();
    const [result] = await mysqlConnection.query(
      `INSERT INTO livres (titre, auteur_id, annee_publication) VALUES (?, ?, ?)`,
      [bookData.titre, bookData.auteur_id, bookData.annee_publication]
    );
    await mysqlConnection.end();
    if (result.insertId) return await getBookById(result.insertId);
    return null;
  } catch (e) {
    console.log(e);
  }
};

// Supprimer un livre
const deleteBook = async (id) => {
  try {
    const mysqlConnection = await createConnection();
    const [result] = await mysqlConnection.query(
      'DELETE FROM livres WHERE id = ?', [id]
    );
    await mysqlConnection.end();
    return result.affectedRows > 0;
  } catch (err) {
    console.error(err);
    throw new Error('Erreur serveur');
  }
};

module.exports = {
  getAllBooks,
  getBookById,
  updateBook,
  deleteBook,
  createBook
};

Explication détaillée du code 🧐

On va maintenant décortiquer cette partie du code, qui se trouve dans le fichier BookManager.js. Cette fonction, getAllBooks, est responsable de récupérer tous les livres de la base de données. C'est une fonction asynchrone qui interagit avec MySQL pour exécuter une requête SQL. Préparez-vous, car on va rentrer dans les détails techniques !

---

1. Importation du module de connexion à la base de données

const createConnection = require('./../../db');

Explication :

• const createConnection = require('./../../db'); : On importe une fonction appelée createConnection depuis un fichier db.js. Cette fonction est responsable de créer une connexion à la base de données MySQL.

• ./../../db : Le chemin relatif indique que le fichier db.js se trouve deux niveaux au-dessus du dossier actuel. Ce fichier contient probablement la configuration pour se connecter à la base de données (comme l'hôte, l'utilisateur, le mot de passe, etc.).

---

2. Définition de la fonction getAllBooks

const getAllBooks = async () => {
  try {
    // Connexion MySQL
    const mysqlConnection = await createConnection();
    // Requête MySQL
    const [results, fields] = await mysqlConnection.query(
      'SELECT * FROM `livres`'
    );

    // Fermer la connexion après utilisation
    await mysqlConnection.end();

    return results;
  } catch (err) {
    // Gestion des erreurs
    console.error(err);
    return 'Error 500';
  }
}

Explication :

• const getAllBooks = async () => { ... } : On définit une fonction asynchrone appelée getAllBooks. Cette fonction est asynchrone car elle interagit avec une base de données, ce qui est une opération qui prend du temps.

• async : Cela indique que la fonction contient des opérations asynchrones (comme des appels à une base de données).

• () => { ... } : C'est une fonction fléchée (arrow function), une syntaxe moderne pour définir des fonctions en JavaScript.

---

3. Connexion à la base de données

const mysqlConnection = await createConnection();

Explication :

• const mysqlConnection = await createConnection(); : On utilise la fonction createConnection() pour établir une connexion à la base de données MySQL.

• await : On attend que la connexion soit établie avant de passer à la ligne suivante. C'est nécessaire car la connexion à une base de données est une opération asynchrone.

• mysqlConnection : Une fois la connexion établie, on stocke l'objet de connexion dans cette variable. Cet objet nous permet d'exécuter des requêtes SQL.

---

4. Exécution de la requête SQL

const [results, fields] = await mysqlConnection.query(
  'SELECT * FROM `livres`'
);

Explication :

• **await mysqlConnection.query('SELECT * FROM \livres`');** : On exécute une requête SQL pour récupérer tous les livres de la table livres`.

• **SELECT * FROM \livres`** : C'est la requête SQL. Elle signifie "sélectionne toutes les colonnes de la table livres`".

• await : On attend que la requête soit exécutée et que les résultats soient retournés.

• const [results, fields] : La méthode query() retourne un tableau avec deux éléments :

• results : Contient les résultats de la requête (ici, la liste des livres).

• fields : Contient des métadonnées sur les colonnes de la table (comme les noms des colonnes, les types de données, etc.). Dans ce cas, on ne l'utilise pas, donc on pourrait aussi écrire const [results].

---

5. Fermeture de la connexion

await mysqlConnection.end();

Explication :

• await mysqlConnection.end(); : Une fois que la requête est exécutée et que les résultats sont récupérés, on ferme la connexion à la base de données.

• end() : Cette méthode ferme la connexion. C'est une bonne pratique de toujours fermer la connexion après l'avoir utilisée pour éviter des fuites de ressources.

• await : On attend que la connexion soit fermée avant de continuer.

---

6. Retour des résultats

return results;

Explication :

• return results; : On retourne les résultats de la requête SQL (c'est-à-dire la liste des livres) à la fonction qui a appelé getAllBooks.

• results : Contient les lignes retournées par la requête SQL. Dans ce cas, ce sera un tableau d'objets, où chaque objet représente un livre avec ses propriétés (comme id, titre, auteur_id, etc.).

---

7. Gestion des erreurs

} catch (err) {
  console.error(err);
  return 'Error 500';
}

Explication :

• catch (err) { ... } : Si une erreur se produit dans le bloc try, le code dans le bloc catch sera exécuté.

• err : Contient l'objet d'erreur, qui donne des informations sur ce qui s'est mal passé (par exemple, une erreur de connexion à la base de données ou une requête SQL invalide).

• console.error(err); : On affiche l'erreur dans la console pour le débogage. C'est utile pendant le développement pour comprendre ce qui a échoué.

• return 'Error 500'; : On retourne une chaîne de caractères 'Error 500' pour indiquer qu'une erreur serveur s'est produite. Dans une application réelle, on pourrait retourner un objet d'erreur plus détaillé ou utiliser un mécanisme de gestion d'erreurs plus sophistiqué.

---

8. Résumé de ce que fait cette fonction

• Quand getAllBooks est appelée :

1. Elle établit une connexion à la base de données MySQL.
2. Elle exécute une requête SQL pour récupérer tous les livres de la table livres.
3. Elle ferme la connexion à la base de données.
4. Elle retourne les résultats (la liste des livres) à la fonction appelante.
5. Si une erreur se produit, elle affiche l'erreur dans la console et retourne 'Error 500'.

---

Pourquoi cette fonction est-elle importante ?

Cette fonction est cruciale car elle permet à l'application de récupérer des données de la base de données. Sans elle, notre API ne pourrait pas renvoyer la liste des livres aux clients (comme un navigateur ou une application mobile). C'est un bon exemple de la couche Modèle dans le modèle MVC, où la logique métier et l'accès aux données sont gérés.

---

Étape 6 : Tester l'API 🧪

Maintenant que tout est en place, vous pouvez tester votre API avec des outils comme Postman ou directement avec des requêtes HTTP.

• GET /api/books : Récupère tous les livres.
• GET /api/books/1 : Récupère le livre avec l'ID 1.
• POST /api/books : Crée un nouveau livre.
• PUT /api/books/1 : Met à jour le livre avec l'ID 1.
• DELETE /api/books/1 : Supprime le livre avec l'ID 1.

---

Conclusion 🎉

Félicitations ! Vous avez créé une API REST avec Express et MySQL en utilisant le modèle MVC. Vous êtes maintenant prêt à conquérir le monde du développement web backend. 🚀

N'oubliez pas de garder votre code propre et bien documenté, et surtout, amusez-vous en codant ! 😄

---

Prochaine étape : Ajouter une authentification pour protéger votre API. Mais ça, c'est une autre histoire... 😉