API REST Node.js et MongoDB : CRUD, validation Zod et erreurs

applifrais-api/
├── .env                      # MONGODB_URI, JWT_SECRET, PORT (jamais versionné)
├── .env.example
├── .env.test                 # la configuration des tests (jamais versionnée)
├── package.json
├── src/
│   ├── server.js             # connexion à MongoDB, puis démarrage du serveur HTTP
│   ├── app.js                # l'application Express (cours Node.js, inchangé)
│   ├── config.js             # lit et vérifie les variables d'environnement
│   ├── db.js                 # la connexion Mongoose
│   ├── erreurs.js            # ErreurApi et gestionnaireErreurs (cours Node.js, une branche en plus)
│   ├── models/               # Visiteur.js, Fiche.js (chapitre 10)
│   ├── schemas/              # fiches.schemas.js : les schémas Zod des requêtes
│   ├── middlewares/          # authentifier.js, autoriser.js, valider.js (cours Node.js)
│   ├── controllers/          # fiches.controller.js
│   └── routes/               # fiches.routes.js
└── test/
    └── fiches.test.js

npm uninstall mysql2
npm install mongoose
npm install --save-dev mongodb-memory-server

// src/config.js (version MongoDB)
const obligatoires = ['MONGODB_URI', 'JWT_SECRET'];
const manquantes = obligatoires.filter((nom) => !process.env[nom]);
if (manquantes.length > 0) {
  throw new Error(`Variables d'environnement manquantes : ${manquantes.join(', ')}`);
}
if (process.env.JWT_SECRET.length < 32) {
  throw new Error('JWT_SECRET doit contenir au moins 32 caractères');
}

export const config = {
  env: process.env.NODE_ENV ?? 'development',
  port: Number(process.env.PORT ?? 3000),
  mongoUri: process.env.MONGODB_URI,
  jwtSecret: process.env.JWT_SECRET,
  // … les autres clés du cours Node.js (origineFront, dossierJustificatifs), inchangées
};

// src/db.js (remplace le pool MySQL)
import mongoose from 'mongoose';

export async function connecterBase(uri) {
  mongoose.set('sanitizeFilter', true);       // défense contre l'injection NoSQL (chapitre 13)
  mongoose.connection.on('disconnected', () => console.warn('MongoDB : connexion perdue'));
  await mongoose.connect(uri, { serverSelectionTimeoutMS: 5000 });
  console.log(`MongoDB : connecté à la base ${mongoose.connection.name}`);
}

// src/server.js
import mongoose from 'mongoose';
import { app } from './app.js';
import { config } from './config.js';
import { connecterBase } from './db.js';

try {
  await connecterBase(config.mongoUri);
} catch (err) {
  console.error('Impossible de joindre MongoDB :', err.message);
  process.exit(1);
}

const serveur = app.listen(config.port, (erreur) => {
  if (erreur) throw erreur;
  console.log(`API AppliFrais à l'écoute sur http://localhost:${config.port}`);
});

// Arrêt propre (Ctrl+C, docker stop) : on termine les requêtes en cours, puis on ferme la connexion
for (const signal of ['SIGINT', 'SIGTERM']) {
  process.on(signal, () => {
    serveur.close(async () => {
      await mongoose.disconnect();
      process.exit(0);
    });
  });
}

// src/schemas/fiches.schemas.js : ce qui change pour MongoDB
import { ETATS } from '../models/Fiche.js';

// Un ObjectId écrit en chaîne : 24 caractères hexadécimaux, minuscules ou majuscules
const objectId = z.string().regex(/^[0-9a-fA-F]{24}$/, 'Identifiant invalide');

export const schemaId = z.object({ id: objectId });

export const schemaFiltresFiches = z.object({
  mois: mois.optional(),
  etat: z.enum(ETATS).optional(),        // les états du modèle Fiche, RB compris
  visiteur: objectId.optional(),
  page: z.coerce.number().int().min(1).default(1),
  limite: z.coerce.number().int().min(1).max(100).default(20),
});

export const schemaStatistiques = z.object({ mois });

// src/routes/fiches.routes.js
import { Router } from 'express';
import { authentifier } from '../middlewares/authentifier.js';
import { exigerRole } from '../middlewares/autoriser.js';
import { valider } from '../middlewares/valider.js';
import {
  schemaId, schemaFiltresFiches, schemaStatistiques, schemaCreationFiche, schemaLignesForfait,
} from '../schemas/fiches.schemas.js';
import * as fiches from '../controllers/fiches.controller.js';

export const routeurFiches = Router();
routeurFiches.use(authentifier); // toutes les routes exigent un jeton : req.utilisateur = { id, role }

routeurFiches.get('/', valider({ query: schemaFiltresFiches }), fiches.lister);
routeurFiches.get('/statistiques', exigerRole('comptable'), valider({ query: schemaStatistiques }), fiches.statistiques);
routeurFiches.get('/:id', valider({ params: schemaId }), fiches.lire);
routeurFiches.post('/', exigerRole('visiteur'), valider({ body: schemaCreationFiche }), fiches.creer);
routeurFiches.put('/:id/lignes-forfait', exigerRole('visiteur'),
  valider({ params: schemaId, body: schemaLignesForfait }), fiches.remplacerLignes);
routeurFiches.delete('/:id', exigerRole('visiteur'), valider({ params: schemaId }), fiches.supprimer);

// src/controllers/fiches.controller.js
import { Fiche, FORFAITS } from '../models/Fiche.js';
import { ErreurApi } from '../erreurs.js';

const introuvable = (id) => new ErreurApi(404, 'fiche-introuvable', 'Fiche introuvable', `La fiche ${id} n'existe pas.`);

// Le filtre du propriétaire : un visiteur ne voit que ses fiches, le comptable les voit toutes
const filtreProprietaire = (utilisateur) =>
  utilisateur.role === 'comptable' ? {} : { visiteur: utilisateur.id };

export async function lister(req, res) {
  const { mois, etat, visiteur, page, limite } = req.valide.query;
  const filtre = {};
  if (mois) filtre.mois = mois;
  if (etat) filtre.etat = etat;
  if (visiteur) filtre.visiteur = visiteur;
  Object.assign(filtre, filtreProprietaire(req.utilisateur)); // en dernier : il écrase le visiteur demandé

  const [donnees, total] = await Promise.all([
    Fiche.find(filtre)
      .sort({ mois: -1, _id: 1 })
      .skip((page - 1) * limite)
      .limit(limite)
      .select('mois etat montantValide visiteur')
      .populate('visiteur', 'nom prenom')
      .lean(),
    Fiche.countDocuments(filtre),
  ]);
  res.json({ donnees, pagination: { page, limite, total, pages: Math.ceil(total / limite) } });
}

export async function lire(req, res) {
  const { id } = req.valide.params;
  const fiche = await Fiche.findOne({ _id: id, ...filtreProprietaire(req.utilisateur) })
    .populate('visiteur', 'nom prenom')
    .lean();
  if (!fiche) throw introuvable(id);
  res.json(fiche);
}

export async function creer(req, res) {
  const { mois } = req.valide.body;
  try {
    const fiche = await Fiche.create({ visiteur: req.utilisateur.id, mois });
    res.status(201).location(`/v1/fiches/${fiche._id}`).json(fiche);
  } catch (err) {
    if (err.code === 11000) { // l'index unique { visiteur, mois }
      throw new ErreurApi(409, 'fiche-existante', 'Fiche déjà créée', `Une fiche existe déjà pour le mois ${mois}.`);
    }
    throw err;
  }
}

export async function remplacerLignes(req, res) {
  const { id } = req.valide.params;
  // Le corps est { ETP, KM, NUI, REP } ; le document range un tableau de lignes.
  // Le prix unitaire vient du serveur, jamais du client.
  const lignesForfait = Object.entries(req.valide.body)
    .filter(([, quantite]) => quantite > 0)
    .map(([code, quantite]) => ({ code, quantite, montantUnitaire: FORFAITS[code] }));

  const fiche = await Fiche.findOneAndUpdate(
    { _id: id, visiteur: req.utilisateur.id, etat: 'CR' },
    { $set: { lignesForfait } },
    { returnDocument: 'after', runValidators: true },
  );
  if (!fiche) {
    const existe = await Fiche.exists({ _id: id, visiteur: req.utilisateur.id });
    if (!existe) throw introuvable(id);
    throw new ErreurApi(409, 'fiche-cloturee', 'Fiche non modifiable', 'Seule une fiche en cours (CR) se modifie.');
  }
  res.json(fiche);
}

export async function supprimer(req, res) {
  const { id } = req.valide.params;
  const { deletedCount } = await Fiche.deleteOne({ _id: id, visiteur: req.utilisateur.id, etat: 'CR' });
  if (deletedCount === 0) {
    const existe = await Fiche.exists({ _id: id, visiteur: req.utilisateur.id });
    if (!existe) throw introuvable(id);
    throw new ErreurApi(409, 'fiche-cloturee', 'Fiche non modifiable', 'Seule une fiche en cours se supprime.');
  }
  res.status(204).end();
}

export async function statistiques(req, res) {
  const stats = await Fiche.aggregate([
    { $match: { mois: req.valide.query.mois } },
    { $group: { _id: '$etat', nb: { $sum: 1 }, montantValide: { $sum: '$montantValide' } } },
    { $sort: { _id: 1 } },
    { $project: { _id: 0, etat: '$_id', nb: 1, montantValide: 1 } },
  ]);
  res.json(stats);
}

// src/erreurs.js : ajout pour MongoDB (ErreurApi et routeInconnue ne changent pas)
import mongoose from 'mongoose';

// Traduit une erreur de Mongoose ou de MongoDB en ErreurApi ; null si ce n'en est pas une.
export function erreurMongo(err) {
  if (err instanceof mongoose.Error.ValidationError) {
    const erreurs = Object.entries(err.errors).map(([champ, e]) => ({ champ, message: e.message }));
    return new ErreurApi(422, 'validation', 'Données invalides', 'Un ou plusieurs champs sont invalides.', { erreurs });
  }
  if (err instanceof mongoose.Error.CastError) {
    return new ErreurApi(400, 'parametre-invalide', 'Paramètre invalide', `Valeur invalide pour le champ ${err.path}.`);
  }
  if (err.code === 11000) {
    return new ErreurApi(409, 'doublon', 'Doublon', 'Cette ressource existe déjà.');
  }
  return null;
}

// src/erreurs.js, dans gestionnaireErreurs
  } else if (!(err instanceof ErreurApi)) {
    erreur = erreurMongo(err);   // nouveau : ValidationError → 422, CastError → 400, E11000 → 409
    if (!erreur) {
      console.error(err);        // le détail pour toi, jamais pour le client
      erreur = new ErreurApi(500, 'erreur-interne', 'Erreur interne', 'Une erreur inattendue est survenue.');
    }
  }

curl -s "http://localhost:3000/v1/fiches?limite=2" -H "Authorization: Bearer $JETON_LUCAS"

{"donnees":[
  {"_id":"6ae8b983eb52ec336df67e95","visiteur":{"_id":"6a0000000000000000000001","nom":"Martin","prenom":"Lucas"},"mois":"2026-10","etat":"CR","montantValide":null},
  {"_id":"6ae8b983eb52ec336df67e94","visiteur":{"_id":"6a0000000000000000000001","nom":"Martin","prenom":"Lucas"},"mois":"2026-09","etat":"VA","montantValide":898.9}],
 "pagination":{"page":1,"limite":2,"total":3,"pages":2}}

{"type":"https://api.gsb.example/problemes/fiche-introuvable","title":"Fiche introuvable","status":404,"detail":"La fiche 6ae8b983eb52ec336df67e97 n'existe pas.","instance":"/v1/fiches/6ae8b983eb52ec336df67e97"}

// test/fiches.test.js
import { test, before, after, beforeEach } from 'node:test';
import assert from 'node:assert/strict';
import mongoose from 'mongoose';
import { MongoMemoryServer } from 'mongodb-memory-server';
import jwt from 'jsonwebtoken';
import { app } from '../src/app.js';
import { Fiche } from '../src/models/Fiche.js';

let mongo, serveur, base;
const LUCAS = '6a0000000000000000000001';

// Un jeton signé comme ceux de la route de connexion : même clé, identifiant dans sub, rôle
const jetonDeTest = (role) =>
  jwt.sign({ role }, process.env.JWT_SECRET, { subject: LUCAS, expiresIn: '5m', algorithm: 'HS256' });

before(async () => {
  mongo = await MongoMemoryServer.create();          // un mongod jetable, en mémoire
  await mongoose.connect(mongo.getUri());
  await Fiche.init();                                 // crée les index, dont l'index unique
  serveur = app.listen(0);                            // un port libre, choisi par le système
  base = `http://localhost:${serveur.address().port}/v1/fiches`;
});

after(async () => {
  serveur.close();
  await mongoose.disconnect();
  await mongo.stop();
});

beforeEach(() => Fiche.deleteMany({}));               // chaque test part d'une collection vide

const requete = (methode, chemin, corps) =>
  fetch(base + chemin, {
    method: methode,
    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${jetonDeTest('visiteur')}` },
    body: corps && JSON.stringify(corps),
  });

test('crée une fiche, puis refuse un doublon pour le même mois', async () => {
  assert.equal((await requete('POST', '', { mois: '2026-11' })).status, 201);
  assert.equal((await requete('POST', '', { mois: '2026-11' })).status, 409);
});

test('refuse un champ non prévu (affectation de masse)', async () => {
  const r = await requete('POST', '', { mois: '2026-11', etat: 'VA' });
  assert.equal(r.status, 422);
  assert.equal(await Fiche.countDocuments(), 0);
});

test('le tarif vient du serveur, pas du client', async () => {
  const { _id } = await (await requete('POST', '', { mois: '2026-11' })).json();
  const r = await requete('PUT', `/${_id}/lignes-forfait`, { ETP: 0, KM: 0, NUI: 0, REP: 2 });
  assert.equal(r.status, 200);
  assert.deepEqual((await r.json()).lignesForfait, [{ code: 'REP', quantite: 2, montantUnitaire: 25 }]);
});