Initialisation du projet

Création du point d’entrée côté back-end

// importation d'express
const express = require('express');
const mongoose = require('mongoose');

const app = express();

mongoose.connect('mongodb://127.0.0.1:27017/shoppinglist')
.then(() => console.log('Connection à MongoDB réussie'))
.catch(() => console.log('Connection à MongoDB échouée'))

app.use(express.json());

app.use((req, res, next) => {
    res.setHeader('Access-Control-Allow-Origin', '*');
    res.setHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content, Accept, Content-Type, Authorization');
    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
    next();
});

app.get("/", (req, res) => {
    res.send("test")
    console.log('test')
})

module.exports = app;

• Initialisation du serveur Express : Il importe et configure Express pour créer une application web et API REST.
• Connexion à MongoDB via Mongoose : Il se connecte à la base MongoDB et affiche un message si la connexion réussit ou échoue.
• Configuration JSON Middleware : L’application peut recevoir et traiter des données JSON dans les requêtes.
• Mise en place des headers CORS : Il autorise les appels d’API provenant d’autres domaines/frontends.
• Route GET basique (“/”) : Il fournit une réponse simple à la racine, servant de test de fonctionnement serveur/API.
• Export du module app : Le fichier prépare l’application Express pour être utilisée ou démarrée ailleurs (généralement dans un fichier server.js qui écoute sur un port).

Ce fichier pose les bases pour développer une API REST sécurisée, connectée à MongoDB, et prête à recevoir des requêtes HTTP

Ajout des dépendances

{
  "dependencies": {
    "bcrypt": "^5.1.1",
    "express": "^4.21.2",
    "mongoose": "^8.9.5",
    "mongoose-unique-validator": "^4.0.1"
  },
  "devDependencies": {
    "nodemon": "^3.1.9"
  }
}

• bcrypt : bibliothèque utilisée pour hasher (chiffrer) les mots de passe.
• express : framework web léger pour Node.js qui facilite la création de serveurs, d’API REST, la gestion des routes et des requêtes HTTP.
• mongoose : bibliothèque qui facilite l’interaction avec MongoDB en fournissant un système de modélisation de données objet (ODM).
• mongoose-unique-validator : plugin Mongoose qui assure que certains champs (par exemple un email ou un nom d’utilisateur) soient uniques dans la base de données, en ajoutant une validation pratique pour éviter les doublons.
• nodemon : outil de développement qui redémarre automatiquement le serveur Node.js dès qu’il y a un changement dans le code. Il améliore l’efficacité du développement en évitant de relancer manuellement l’application à chaque modification.

Création du serveur

const http = require('http');
const app = require('./app');

const normalizePort = val => {
    const port = parseInt(val, 10);

    if(isNaN(port)) { return val; }
    if(port >= 0) { return port }
    return false;
}

const port = normalizePort(process.env.PORT || 3200);
app.set('port', port);

const errorHandler = error => {
    if (error.syscall !== 'listen') {
      throw error;
    }
    const address = server.address();
    const bind = typeof address === 'string' ? 'pipe ' + address : 'port: ' + port;
    switch (error.code) {
      case 'EACCES':
        console.error(bind + ' requires elevated privileges.');
        process.exit(1);
        break;
      case 'EADDRINUSE':
        console.error(bind + ' is already in use.');
        process.exit(1);
        break;
      default:
        throw error;
    }
};

const server = http.createServer(app);

server.on('error', errorHandler);
server.on('listening', () => {
  const address = server.address();
  const bind = typeof address === 'string' ? 'pipe ' + address : 'port ' + port;
  console.log('Listening on ' + bind);
});

server.listen(port);

• Importation du module HTTP native de Node.js et de l’application Express (app) exportée par un autre fichier.
• Normalisation du port : la fonction normalizePort assure que la valeur du port est correcte et numérique, en utilisant soit la variable d’environnement PORT, soit une valeur par défaut (ici 3200).
• Configuration du port dans Express pour que l’application sache sur quel port écouter.
• Gestion des erreurs serveur via errorHandler qui intercepte les erreurs lors du démarrage (ex. port déjà utilisé, permissions insuffisantes) et affiche des messages adaptés avant d’arrêter le processus si nécessaire.
• Création du serveur HTTP en passant l’application Express comme gestionnaire.
• Écoute des événements du serveur :
  • error : utilise errorHandler pour gérer les erreurs.
  • listening : affiche en console que le serveur est bien lancé et écoute sur le port.
• Lancement du serveur avec server.listen(port), ce qui rend l’application accessible à ce port.