Cours Nodejs INP-HB - 2024

autDocs.js

/**
 * @swagger
 * /auth/login:
 *   post:
 *     summary: Authentification de l'utilisateur
 *     description: Authentifie l'utilisateur avec les informations de connexion fournies.
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *     responses:
 *       '200':
 *         description: Succès, utilisateur authentifié avec succès.
 *       '400':
 *         description: Requête invalide, vérifiez les données fournies.
 *       '401':
 *         description: Échec de l'authentification, e-mail ou mot de passe incorrect.
 *       '500':
 *         description: Erreur interne du serveur.
 */

/**
 * @swagger
 * /auth/register:
 *   post:
 *     summary: Inscription d'un nouvel utilisateur
 *     description: Inscrit un nouvel utilisateur avec les informations fournies.
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *     responses:
 *       '201':
 *         description: Utilisateur inscrit avec succès.
 *       '400':
 *         description: Requête invalide, vérifiez les données fournies.
 *       '500':
 *         description: Erreur interne du serveur.
 */

authMiddleware.js

const jwt = require("jsonwebtoken");
require("dotenv").config();

// Middleware pour vérifier si l'utilisateur est authentifié
function authMiddleware(req, res, next) {
  const token = req.headers.authorization?.split(" ")[1];

  if (!token) {
    return res.status(401).json({ error: true, message: "Non authentifié." });
  }

  jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
    if (err) {
      return res.status(401).json({ error: true, message: "Token invalide." });
    }

    req.user = decoded.user;
    delete req.user?.password;

    next();
  });
}

module.exports = authMiddleware;

cmd.md

npm i express bcrypt body-parser dotenv jsonwebtoken swagger-jsdoc swagger-ui-express

contact.sql

CREATE TABLE contact (
 id INT AUTO_INCREMENT PRIMARY KEY,
 number VARCHAR(255),
 user_id INT NOT NULL,
 FOREIGN KEY (user_id) REFERENCES user(id) ON DELETE CASCADE
);

contactController.js

const connection = require("../config/db");

/**
 * Route pour récupérer tous les contacts d'un utilisateur
 * @param {Request} req
 * @param {Response} res
 */
const getUserContacts = (req, res) => {
  connection.query(
    "SELECT * FROM contact WHERE user_id = ?",
    [+req.params.id],
    (err, rows) => {
      if (err) throw err;

      res.json(rows);
    }
  );
};

/**
 * Route pour récupérer un contact spécifique d'un utilisateur
 * @param {Request} req
 * @param {Response} res
 */
const getUserContactById = (req, res) => {
  connection.query(
    "SELECT * FROM contact WHERE id = ? AND user_id = ?",
    [+req.params.contactId, +req.params.id],
    (err, rows) => {
      if (err) throw err;

      res.json(rows[0]);
    }
  );
};

/**
 * Route pour ajouter un nouveau contact pour un utilisateur
 * @param {Request} req
 * @param {Response} res
 */
const createContact = (req, res) => {
  const { number } = req.body;

  connection.query(
    "INSERT INTO contact (number, user_id) VALUES (?, ?)",
    [number, +req.params.id],
    (err, result) => {
      if (err) throw err;

      res
        .status(201)
        .json({ message: `Contact ajouté avec l'ID : ${result.insertId}` });
    }
  );
};

/**
 * Route pour mettre à jour un contact existant pour un utilisateur
 * @param {Request} req
 * @param {Response} res
 */
const updateContact = (req, res) => {
  const { number } = req.body;

  connection.query(
    "UPDATE contact SET number = ? WHERE id = ? AND user_id = ?",
    [number, +req.params.contactId, +req.params.id],
    (err, result) => {
      if (err) throw err;

      res.json({ message: "Contact mis à jour avec succès." });
    }
  );
};

/**
 * Route pour supprimer un contact existant pour un utilisateur
 * @param {Request} req
 * @param {Response} res
 */
const deleteContact = (req, res) => {
  connection.query(
    "DELETE FROM contact WHERE id = ? AND user_id = ?",
    [req.params.contactId, req.params.id],
    (err, result) => {
      if (err) throw err;

      res.json({ message: "Contact supprimé avec succès." });
    }
  );
};

module.exports = {
  getUserContactById,
  getUserContacts,
  deleteContact,
  updateContact,
  createContact,
};

contactDocs.js

/**
 * @swagger
 * /users/{id}/contacts:
 *   get:
 *     summary: Récupère tous les contacts d'un utilisateur
 *     description: Renvoie la liste complète des contacts de l'utilisateur spécifié par son ID.
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: ID de l'utilisateur dont les contacts doivent être récupérés
 *         schema:
 *           type: string
 *     responses:
 *       '200':
 *         description: Succès, renvoie la liste des contacts de l'utilisateur.
 *       '404':
 *         description: Utilisateur non trouvé, l'ID spécifié n'existe pas.
 *       '500':
 *         description: Erreur interne du serveur.
 *   post:
 *     summary: Crée un nouveau contact pour un utilisateur
 *     description: Crée un nouveau contact pour l'utilisateur spécifié par son ID avec les données fournies.
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: ID de l'utilisateur pour lequel le contact doit être créé
 *         schema:
 *           type: string
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *     responses:
 *       '201':
 *         description: Contact créé avec succès.
 *       '400':
 *         description: Requête invalide, vérifiez les données fournies.
 *       '404':
 *         description: Utilisateur non trouvé, l'ID spécifié n'existe pas.
 *       '500':
 *         description: Erreur interne du serveur.
 */

/**
 * @swagger
 * /users/{id}/contacts/{contactId}:
 *   get:
 *     summary: Récupère un contact par ID pour un utilisateur
 *     description: Renvoie les détails du contact spécifié par son ID pour l'utilisateur spécifié par son ID.
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: ID de l'utilisateur dont le contact doit être récupéré
 *         schema:
 *           type: string
 *       - in: path
 *         name: contactId
 *         required: true
 *         description: ID du contact à récupérer
 *         schema:
 *           type: string
 *     responses:
 *       '200':
 *         description: Succès, renvoie les détails du contact.
 *       '404':
 *         description: Contact non trouvé, l'ID spécifié n'existe pas.
 *       '500':
 *         description: Erreur interne du serveur.
 *   put:
 *     summary: Met à jour un contact pour un utilisateur
 *     description: Met à jour les informations du contact spécifié par son ID pour l'utilisateur spécifié par son ID.
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: ID de l'utilisateur dont le contact doit être mis à jour
 *         schema:
 *           type: string
 *       - in: path
 *         name: contactId
 *         required: true
 *         description: ID du contact à mettre à jour
 *         schema:
 *           type: string
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *     responses:
 *       '200':
 *         description: Contact mis à jour avec succès.
 *       '400':
 *         description: Requête invalide, vérifiez les données fournies.
 *       '404':
 *         description: Contact non trouvé, l'ID spécifié n'existe pas.
 *       '500':
 *         description: Erreur interne du serveur.
 *   delete:
 *     summary: Supprime un contact pour un utilisateur
 *     description: Supprime le contact spécifié par son ID pour l'utilisateur spécifié par son ID.
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: ID de l'utilisateur dont le contact doit être supprimé
 *         schema:
 *           type: string
 *       - in: path
 *         name: contactId
 *         required: true
 *         description: ID du contact à supprimer
 *         schema:
 *           type: string
 *     responses:
 *       '204':
 *         description: Contact supprimé avec succès.
 *       '404':
 *         description: Contact non trouvé, l'ID spécifié n'existe pas.
 *       '500':
 *         description: Erreur interne du serveur.
 */

contactRoutes.js

const express = require("express");
const router = express.Router();
const {
  getUserContactById,
  getUserContacts,
  deleteContact,
  updateContact,
  createContact,
} = require("../controllers/contactController");

router
  .get("/:id/contacts", getUserContacts)
  .post("/:id/contacts", createContact);
router
  .get("/:id/contacts/:contactId", getUserContactById)
  .put("/:id/contacts/:contactId", updateContact)
  .delete("/:id/contacts/:contactId", deleteContact);

module.exports = router;

create-user.js

app.put("/users/:id", (req, res) => {
  const { nom, email, password } = req.body;
  const { id } = req.params;

  if (!nom || !email || !password) {
    res.json({
      error: true,
      message: "Veuillez renseigner l'email, le nom et le mot de passe",
    });
  }

  connection.query(
    "UPDATE user SET nom = ?, email = ?,  password = ? WHERE id = ?",
    [nom, email, password, +id],
    (err, result) => {
      if (err) {
        console.log(err);
        res.status(400).json({
          statusCode: 400,
          message: "Une erreur est survenue",
        });
      }

      res.json({
        message: "Utilisateur modifié avec succès",
      });
    }
  );
});

db.js

const mysql = require("mysql");

const connection = mysql.createConnection({
  host: "127.0.0.1",
  user: "root",
  password: "",
  database: "cours_node",
});

connection.connect((err) => {
  if (err) {
    console.error("Erreur de connexion à la base de données : " + err.stack);
    return;
  }

  console.log("Connecté à la base de données.");
});

module.exports = connection;

delete-user

const deleteUser = (req, res) => {
  connection.query(
    "DELETE FROM user WHERE id = ?",
    [+req.params.id],
    (err, result) => {
      if (err) throw err;

      res.json({ message: "Utilisateur supprimé avec succès." });
    }
  );
};

swagger.js

const swaggerJsdoc = require("swagger-jsdoc");
const swaggerUi = require("swagger-ui-express");

const options = {
  swaggerDefinition: {
    openapi: "3.0.0",
    info: {
      title: "Documentation de l'API",
      version: "1.0.0",
      description: "Documentation de l'API pour mon application",
    },
  },
  apis: ["./docs/*.js"], // Spécifiez les chemins des fichiers où se trouvent vos routes
};

const specs = swaggerJsdoc(options);

module.exports = (app) => {
  app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(specs));
};

user.sql

 CREATE TABLE user (
   id INT AUTO_INCREMENT PRIMARY KEY,
   nom VARCHAR(255),
   email VARCHAR(255),
   password VARCHAR(255),
 );

userDocs.js

/**
 * @swagger
 * /users:
 *   get:
 *     summary: Récupère tous les utilisateurs
 *     description: Renvoie la liste complète de tous les utilisateurs.
 *     security:
 *       - BearerAuth: []
 *     responses:
 *       '200':
 *         description: Succès, renvoie la liste des utilisateurs.
 *       '401':
 *         description: Non autorisé, jeton d'authentification manquant ou invalide.
 *       '500':
 *         description: Erreur interne du serveur.
 *   post:
 *     summary: Crée un nouvel utilisateur
 *     description: Crée un nouvel utilisateur avec les données fournies.
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *     responses:
 *       '201':
 *         description: Utilisateur créé avec succès.
 *       '400':
 *         description: Requête invalide, vérifiez les données fournies.
 *       '401':
 *         description: Non autorisé, jeton d'authentification manquant ou invalide.
 *       '500':
 *         description: Erreur interne du serveur.
 */

/**
 * @swagger
 * /users/{id}:
 *   get:
 *     summary: Récupère un utilisateur par ID
 *     description: Renvoie les détails de l'utilisateur spécifié par son ID.
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: ID de l'utilisateur à récupérer
 *         schema:
 *           type: string
 *     responses:
 *       '200':
 *         description: Succès, renvoie les détails de l'utilisateur.
 *       '404':
 *         description: Utilisateur non trouvé, l'ID spécifié n'existe pas.
 *       '500':
 *         description: Erreur interne du serveur.
 *   put:
 *     summary: Met à jour un utilisateur
 *     description: Met à jour les informations de l'utilisateur spécifié par son ID.
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: ID de l'utilisateur à mettre à jour
 *         schema:
 *           type: string
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *     responses:
 *       '200':
 *         description: Utilisateur mis à jour avec succès.
 *       '400':
 *         description: Requête invalide, vérifiez les données fournies.
 *       '404':
 *         description: Utilisateur non trouvé, l'ID spécifié n'existe pas.
 *       '500':
 *         description: Erreur interne du serveur.
 *   delete:
 *     summary: Supprime un utilisateur
 *     description: Supprime l'utilisateur spécifié par son ID.
 *     parameters:
 *       - in: path
 *         name: id
 *         required: true
 *         description: ID de l'utilisateur à supprimer
 *         schema:
 *           type: string
 *     responses:
 *       '204':
 *         description: Utilisateur supprimé avec succès.
 *       '404':
 *         description: Utilisateur non trouvé, l'ID spécifié n'existe pas.
 *       '500':
 *         description: Erreur interne du serveur.
 */