Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
Node.js

Projet de synthèse : application SPA Full Stack JS de réservation (Express, MongoDB Atlas, Mongoose, JWT, client SPA, déploiement)

Projet de synthèse du cours Node.js : réaliser une application SPA Full Stack JS de réservation de salles pour un centre de formation. L'API Express 5 avec Mongoose et MongoDB Atlas gère l'authentific...

0 chapitres 0 QCM Accès gratuit
Projet de synthèse : application SPA Full Stack JS de réservation (Express, MongoDB Atlas, Mongoose, JWT, client SPA, déploiement)

À propos de ce cours

Projet de synthèse du cours Node.js : réaliser une application SPA Full Stack JS de réservation de salles pour un centre de formation. L'API Express 5 avec Mongoose et MongoDB Atlas gère l'authentification JWT, les rôles, les salles et les réservations avec de vraies règles de gestion (horaires d'ouverture, durée, capacité, chevauchements, annulation). Le client SPA en JavaScript sans framework affiche les plannings. Le projet est testé avec node:test et Supertest, mis à jour en temps réel avec Socket.IO, versionné sur GitHub dès le départ et déployé. Énoncé en 9 parties, correction complète, grille sur 20.

Objectifs du projet

  • Concevoir et réaliser seul ou en binôme une application complète : API, base de données, client, tests, déploiement.
  • Traduire des règles de gestion réelles en code, et les vérifier par des tests automatisés.
  • Sécuriser l'application : authentification, rôles, validation, données privées.
  • Travailler comme en entreprise : GitHub dès le premier jour, commits réguliers, README, mise en production.

Durée: 24 à 30 h (4 à 5 séances et du travail personnel)  |  Travail: seul ou en binôme  |  Prérequis: tout le cours, en particulier les TP 8, 9 et 10 et le chapitre 16  |  Livrables: le dépôt GitHub (étiquette v1.0.0), l'adresse de l'application en ligne, une soutenance de 15 minutes.

Planning d'une salle

Le résultat attendu : le planning d'une salle, ses réservations et le formulaire de réservation (capture réelle de la correction).

Le contexte

Un centre de formation dispose de plusieurs salles : salles de cours, laboratoire informatique, petites salles de réunion. Aujourd'hui, les formateurs réservent sur un tableau papier à l'accueil : doubles réservations, salles trop petites, réservations oubliées jamais annulées. La direction vous demande une application web de réservation de salles, utilisable depuis un ordinateur ou un téléphone.

Architecture du projet

L'architecture attendue : un client SPA, une API Express, MongoDB Atlas, des tests et un déploiement.

Cahier des charges

Les utilisateurs

Profil Peut…
Visiteur créer un compte, se connecter (rien d'autre n'est visible sans connexion)
Utilisateur (formateur, personnel) consulter les salles (filtres capacité et équipement), voir le planning d'une salle pour un jour, réserver, consulter et annuler ses réservations
Administrateur tout ce que fait un utilisateur, plus : ajouter une salle, désactiver ou réactiver une salle, voir toutes les réservations à venir, annuler n'importe quelle réservation

Les règles de gestion

N° Règle Réponse de l'API si non respectée
R1 Une salle ne peut pas être réservée deux fois sur des créneaux qui se chevauchent. Deux créneaux qui se touchent (l'un finit à 11 h, l'autre commence à 11 h) sont acceptés. 409, avec le créneau en conflit
R2 Le centre est ouvert de 8 h à 19 h (heure de Tunis) ; une réservation tient dans une seule journée. 400
R3 Durée : de 30 minutes à 4 heures ; la fin est après le début. 400
R4 On ne réserve pas dans le passé. 400
R5 Le nombre de participants ne dépasse pas la capacité de la salle. 400
R6 Une salle désactivée ne peut plus être réservée (ses réservations existantes restent). 409
R7 Un utilisateur a au plus 5 réservations à venir. 409
R8 Seul l'auteur ou un administrateur annule une réservation, et seulement avant son début. Une réservation annulée libère le créneau ; elle n'est pas supprimée. 404 (réservation d'un autre), 409
R9 Dans le planning d'une salle, l'objet des réservations des autres est masqué (« Réservé »). —

Les exigences techniques

  • API REST Express 5 en modules ES, organisée en routes, contrôleurs, services (séparation des couches) ; erreurs en JSON homogènes.
  • MongoDB Atlas avec Mongoose ; mots de passe hachés avec bcrypt ; authentification JWT ; validation des entrées avec express-validator ; helmet et limite des tentatives de connexion.
  • Client SPA en JavaScript sans framework, servi par Express (une seule origine), routes en #/…, aucune insertion de données avec innerHTML.
  • Tests automatisés avec node:test et Supertest couvrant toutes les règles R1 à R9 ; workflow GitHub Actions.
  • Dépôt GitHub dès la première séance ; aucun secret dans le dépôt.
  • Application en ligne, en HTTPS : VPS avec PM2 et nginx, ou plateforme cloud avec MongoDB Atlas (déployer une application Node.js).
  • Bonus : planning mis à jour en temps réel avec Socket.IO (le temps réel avec Socket.IO).
L'API à réaliser
Méthode Route Accès Rôle
POST /api/auth/inscription public créer un compte (rôle utilisateur imposé)
POST /api/auth/connexion public renvoie { jeton, utilisateur }
GET /api/auth/moi connecté profil de l'utilisateur connecté
GET /api/salles?capaciteMin=&equipement= connecté salles actives (toutes avec ?toutes=oui pour l'administrateur)
GET /api/salles/:id/planning?date=AAAA-MM-JJ connecté créneaux occupés de la journée (R9)
POST / PATCH /api/salles, /api/salles/:id admin ajouter, modifier, désactiver une salle
POST /api/reservations connecté réserver (R1 à R7)
GET /api/reservations/miennes connecté ses réservations
PATCH /api/reservations/:id/annuler auteur ou admin annuler (R8)
GET /api/reservations admin toutes les réservations à venir

Modèle de données

Les trois collections et la condition de chevauchement (R1).

Déroulement

Le projet est découpé en neuf parties. À la fin de chacune, poussez votre travail sur GitHub avec un message de commit clair : votre enseignant suit l'avancement par l'historique du dépôt.

Partie 1 Initialiser le projet et le dépôt GitHub
  1. Créez un dépôt privé reservation-salles sur GitHub (avec un README), invitez votre enseignant (et votre binôme), puis clonez-le.
  2. npm init -y, "type": "module", "engines": { "node": ">=24" }. Installez express mongoose jsonwebtoken bcrypt express-validator helmet express-rate-limit cors morgan et, en développement, supertest.
  3. Créez l'arborescence src/ (config, models, services, controllers, routes, middlewares, utils), public/, test/, scripts/.
  4. Fichiers .gitignore (node_modules/, .env), .env.example (documenté, sans secret), .env (vos valeurs).
  5. Sur MongoDB Atlas, créez un cluster gratuit, un utilisateur de base et autorisez votre adresse IP (MongoDB Atlas).
  6. Scripts dev (node --watch --env-file-if-exists=.env src/server.js), start, test. Séparez src/app.js (création de l'application) et src/server.js (connexion à la base et écoute).

Point de contrôle: GET /api/sante répond { "statut": "ok" }. Commit : chore: initialisation du projet.

Partie 2 Modèles Mongoose et données de démonstration
  1. Écrivez les modèles Utilisateur, Salle et Reservation (schéma ci-dessus) avec leurs validations ; le mot de passe a select: false.
  2. Ajoutez un index { salle: 1, debut: 1, fin: 1 } sur les réservations : la recherche de chevauchement l'utilisera à chaque réservation.
  3. Écrivez scripts/seed.js (npm run seed) : 3 comptes (un administrateur), 5 salles dont une désactivée, quelques réservations pour demain. Le script refuse de s'exécuter en production.

Point de contrôle: les trois collections apparaissent dans Compass ou Atlas. Commit : feat: modèles et données de démonstration.

Partie 3 Authentification et rôles
  1. Service d'authentification : inscription (409 si l'e-mail existe, rôle toujours utilisateur), connexion (même message 401 pour un e-mail inconnu ou un mauvais mot de passe), profil.
  2. Middlewares authentifier (jeton Bearer) et autoriser(...roles) (middleware d'authentification).
  3. Validation : e-mail valide, mot de passe d'au moins 8 caractères avec majuscule, minuscule et chiffre ; 10 tentatives de connexion par quart d'heure.
  4. Middleware d'erreurs centralisé : toutes les erreurs en JSON { erreur, details? }, jamais de pile d'appels envoyée au client.

Point de contrôle: avec un fichier .http, inscription, connexion et GET /api/auth/moi avec le jeton. Commit : feat: authentification JWT et rôles.

Partie 4 Les salles et leur planning
  1. Routes des salles, toutes protégées par authentifier; création et modification réservées à l'administrateur ; filtres capaciteMin et equipement.
  2. Route du planning : les réservations confirmées de la salle qui recoupent la journée demandée, triées par heure. Appliquez R9.
  3. Attention aux fuseaux horaires : MongoDB stocke les dates en UTC. La « journée du 20 novembre » à Tunis va de 2026-11-19T23:00:00Z à 2026-11-20T23:00:00Z. Écrivez dans src/utils/dates.js des fonctions qui font ces conversions avec Intl.DateTimeFormat et le fuseau Africa/Tunis, sans dépendre du fuseau du serveur (souvent UTC en production).

Point de contrôle: le planning de demain d'une salle du seed renvoie ses créneaux. Commit : feat: salles et planning.

Partie 5 Les réservations : le cœur du projet
  1. Dans src/services/reservations.service.js, la fonction creer() applique R2 à R7, puis R1. Pour R1, une seule requête suffit : chercher une réservation confirmée de la même salle avec debut < nouvelleFin et fin > nouveauDebut.
  2. En cas de conflit, renvoyez 409 et le créneau en conflit dans details, pour que le client puisse l'afficher.
  3. Annulation (R8) : on passe le statut à annulee (on garde l'historique). Pour la réservation d'un autre, répondez 404 et non 403, pour ne pas révéler son existence.
  4. Routes /miennes (utilisateur) et / (administrateur), avec populate pour afficher le nom de la salle et de l'auteur.

Point de contrôle: deux réservations qui se chevauchent avec deux comptes : la seconde reçoit 409. Commit : feat: réservations et règles de gestion.

Partie 6 Les tests automatisés
  1. Fichier .env.test (base séparée, versionné) et script "test": "node --env-file=.env.test --test \"test/**/*.test.js\"" (tester une API avec node:test).
  2. Un fichier d'outils test/aide.js: une base par fichier de test, création d'un compte et de son jeton, et une fonction creneau(dansJours, heureDebut, heureFin) qui fabrique des dates futures en heure de Tunis.
  3. Au moins un test par règle R1 à R9, plus les cas 401, 403 et 404. Une boucle for évite de répéter les tests des règles R2 et R3.
  4. Workflow GitHub Actions avec un service mongo:8.0; la coche verte doit apparaître sur chaque Pull Request.

Point de contrôle: npm test passe entièrement, en local et dans GitHub Actions. Commit : test: règles de gestion R1 à R9.

Partie 7 Le client SPA
  1. public/index.html: une barre de navigation, un <main id="vue">, un script type="module". Le style dans public/css/style.css. Aucun script dans la page : la CSP de helmet l'interdit.
  2. public/js/api.js: une fonction api(chemin, options) qui ajoute le jeton, envoie et décode le JSON, transforme les réponses d'erreur en exceptions, et renvoie vers la connexion en cas de 401 (l'authentification côté client).
  3. public/js/app.js: un routeur sur l'événement hashchange; une table des routes, avec les routes publiques et la route réservée à l'administrateur.
  4. Les vues : connexion, inscription, liste des salles avec filtres, planning d'une salle (grille de 8 h à 19 h, formulaire de réservation, message d'erreur de l'API), mes réservations (bouton Annuler), administration.
  5. Créez les éléments avec document.createElement et textContent: un objet de réservation comme <img src=x onerror=alert(1)> doit s'afficher comme du texte.

Point de contrôle: le parcours complet dans le navigateur, avec deux comptes. Commit : feat: client SPA.

Partie 8 Bonus : le temps réel
  1. Les services émettent reservation:modifiee (salle et date) sur un EventEmitter à chaque réservation ou annulation.
  2. Le serveur Socket.IO, qui accepte uniquement les clients avec un jeton valide, diffuse planning:modifie.
  3. La vue planning se connecte en arrivant, recharge le planning si l'événement concerne la salle et le jour affichés, et ferme la connexion en quittant la vue.

Point de contrôle: deux navigateurs sur le même planning ; une réservation dans l'un apparaît dans l'autre sans rechargement. Commit : feat: planning en temps réel.

Partie 9 Mise en production
  1. Préparez la production : HOTE, TRUST_PROXY, arrêt propre sur SIGTERM, script admin:creer (le seed est interdit en production).
  2. Option A, VPS: utilisateur deploy, Node.js 24, PM2 (ecosystem.config.cjs), nginx avec HTTPS et le bloc /socket.io/ pour les WebSockets, script deploiement/deployer.sh.
  3. Option B, cloud: Render (Web Service relié au dépôt) + MongoDB Atlas, variables d'environnement saisies dans l'interface, TRUST_PROXY=1.
  4. Complétez le README : présentation, installation, comptes de démonstration, règles, tableau de l'API, adresse en ligne, badge de la CI. Créez l'étiquette v1.0.0.

Point de contrôle: l'application répond en HTTPS ; le premier administrateur a été créé par le script. Commit : chore: déploiement, puis git tag v1.0.0 && git push --tags.

Soutenance (15 minutes)
  1. Démonstration (5 min) : inscription, réservation, conflit refusé, annulation, administration, sur l'application en ligne.
  2. Code (5 min) : la fonction qui applique les règles de réservation, un test, la gestion des dates.
  3. Questions (5 min) : par exemple « que se passe-t-il si deux personnes réservent le même créneau à la même milliseconde ? » (voir « Pour aller plus loin »).
Grille d'évaluation
Critère Points
Organisation du code (couches, configuration, erreurs JSON homogènes) 2
Authentification, rôles, validation, sécurité (bcrypt, JWT, helmet, limite de connexion, R9, 404 sur la réservation d'un autre) 3
Salles et planning (filtres, fuseau horaire correct) 2
Règles de réservation R1 à R8 toutes respectées 4
Tests automatisés couvrant les règles, CI GitHub Actions verte 3
Client SPA complet, ergonomique, sans innerHTML pour les données 3
Application en ligne en HTTPS, secrets hors du dépôt, README 2
Historique Git (commits réguliers et clairs), soutenance 1
Bonus : temps réel avec Socket.IO +1
Total 20
Pour aller plus loin
  • Réservations simultanées: entre la recherche d'un conflit et l'enregistrement, une autre requête peut enregistrer le même créneau. Avec une seule instance, le risque est faible mais réel. Solutions : une transaction MongoDB (Atlas fonctionne en replica set, ce qui les rend possibles) avec un document « verrou » par salle et par jour, ou une file d'attente qui traite les réservations d'une salle une par une.
  • Réservations récurrentes (« tous les mardis de 9 h à 11 h jusqu'en juin »), avec le rapport des conflits.
  • E-mail de confirmation et de rappel la veille.
  • Export du planning de la semaine en PDF ou au format iCalendar (.ics) pour l'importer dans un agenda.

Correction

Correction réellement construite, testée et déployée: Node.js 24, Express 5, Mongoose 9, MongoDB 8.0, Socket.IO 4.8. Les 33 tests passent ; la couverture est de 96 % des lignes. Le déploiement a été fait sur un serveur de test Ubuntu 24.04 (adresse 192.0.2.2, domaine fictif reservations.exemple.tn, certificat de test à la place de Let's Encrypt). MongoDB était installé sur ce serveur, Atlas n'étant pas joignable depuis l'environnement de test : avec Atlas, seule la valeur de MONGODB_URI change. Le dépôt a été cloné depuis une copie locale du dépôt GitHub.

Arborescence
reservation-salles/
├── .github/
│   └── workflows/
│       └── tests.yml
├── deploiement/
│   ├── deployer.sh
│   └── nginx-reservation-salles.conf
├── public/
│   ├── css/
│   │   └── style.css
│   ├── js/
│   │   ├── vues/
│   │   │   ├── admin.js
│   │   │   ├── connexion.js
│   │   │   ├── planning.js
│   │   │   ├── reservations.js
│   │   │   └── salles.js
│   │   ├── api.js
│   │   ├── app.js
│   │   └── dom.js
│   └── index.html
├── scripts/
│   ├── creer-admin.js
│   └── seed.js
├── src/
│   ├── config/
│   │   ├── db.js
│   │   └── index.js
│   ├── controllers/
│   │   ├── auth.controller.js
│   │   ├── reservations.controller.js
│   │   └── salles.controller.js
│   ├── middlewares/
│   │   ├── auth.js
│   │   ├── erreurs.js
│   │   └── valider.js
│   ├── models/
│   │   ├── reservation.js
│   │   ├── salle.js
│   │   └── utilisateur.js
│   ├── routes/
│   │   ├── auth.routes.js
│   │   ├── reservations.routes.js
│   │   └── salles.routes.js
│   ├── services/
│   │   ├── auth.service.js
│   │   ├── reservations.service.js
│   │   └── salles.service.js
│   ├── utils/
│   │   ├── dates.js
│   │   └── erreur-api.js
│   ├── app.js
│   ├── evenements.js
│   ├── server.js
│   └── temps-reel.js
├── test/
│   ├── aide.js
│   ├── auth.test.js
│   ├── dates.test.js
│   ├── reservations.test.js
│   └── salles.test.js
├── .env.example
├── .env.test
├── .gitignore
├── README.md
├── ecosystem.config.cjs
├── package-lock.json
└── package.json
Les captures de la correction

Connexion

Connexion : seule page accessible sans compte.

Liste des salles

Liste des salles actives, avec filtres ; la salle désactivée n'apparaît pas.

Conflit de réservation

R1 : le créneau 10 h – 11 h 30 chevauche la réservation de 9 h à 11 h ; l'API répond 409 et le client affiche le créneau en conflit.

Planning vu par un autre utilisateur

Le même planning vu par Lina : les réservations des autres sont masquées (R9) ; celle de 11 h à 12 h 30 est apparue en temps réel, sans rechargement.

Mes réservations

Mes réservations, avec le bouton Annuler (R8).

Administration

Administration : salles (dont une désactivée), ajout d'une salle, réservations à venir de tous les utilisateurs.

Configuration et dates

📄 package.json

{
  "name": "reservation-salles",
  "version": "1.0.0",
  "description": "Application SPA Full Stack JS de réservation de salles (Express, MongoDB, Mongoose, JWT)",
  "type": "module",
  "main": "src/server.js",
  "engines": {
    "node": ">=24"
  },
  "scripts": {
    "dev": "node --watch --env-file-if-exists=.env src/server.js",
    "start": "node --env-file-if-exists=.env src/server.js",
    "test": "node --env-file=.env.test --test \"test/**/*.test.js\"",
    "test:watch": "node --env-file=.env.test --test --watch \"test/**/*.test.js\"",
    "test:couverture": "node --env-file=.env.test --test --experimental-test-coverage --test-coverage-include=\"src/**\" \"test/**/*.test.js\"",
    "seed": "node --env-file-if-exists=.env scripts/seed.js",
    "admin:creer": "node --env-file-if-exists=.env scripts/creer-admin.js"
  },
  "dependencies": {
    "bcrypt": "^6.0.0",
    "cors": "^2.8.6",
    "express": "^5.3.0",
    "express-rate-limit": "^8.7.4",
    "express-validator": "^7.3.2",
    "helmet": "^8.3.0",
    "jsonwebtoken": "^9.0.3",
    "mongoose": "^9.12.1",
    "morgan": "^1.12.1",
    "socket.io": "^4.8.4"
  },
  "devDependencies": {
    "socket.io-client": "^4.8.4",
    "supertest": "^7.3.2"
  }
}

📄 .env.example

NODE_ENV=development
PORT=3000
HOTE=0.0.0.0
# local : mongodb://127.0.0.1:27017/reservations
# Atlas : mongodb+srv://UTILISATEUR:MOT_DE_PASSE@cluster0.xxxxx.mongodb.net/reservations
MONGODB_URI=mongodb://127.0.0.1:27017/reservations
JWT_SECRET=remplacer-par-une-longue-chaine-aleatoire
JWT_DUREE=2h
# vide : client servi par la même origine (public/)
CORS_ORIGINES=
# fuseau horaire du centre (horaires d'ouverture)
FUSEAU=Africa/Tunis
# derrière nginx : loopback ; sur Render : 1
TRUST_PROXY=

📄 src/config/index.js

// Configuration lue une seule fois depuis les variables d'environnement
const obligatoire = (nom) => {
  const valeur = process.env[nom];
  if (!valeur) throw new Error(`Variable d'environnement manquante : ${nom}`);
  return valeur;
};

export const config = {
  env: process.env.NODE_ENV ?? 'development',
  port: Number(process.env.PORT ?? 3000),
  hote: process.env.HOTE ?? '0.0.0.0',
  mongoUri: obligatoire('MONGODB_URI'),
  jwtSecret: obligatoire('JWT_SECRET'),
  jwtDuree: process.env.JWT_DUREE ?? '2h',
  coutBcrypt: process.env.NODE_ENV === 'test' ? 4 : 12, // bcrypt est volontairement lent : moins en test
  fuseau: process.env.FUSEAU ?? 'Africa/Tunis',
  corsOrigines: (process.env.CORS_ORIGINES ?? '').split(',').filter(Boolean),
  trustProxy: process.env.TRUST_PROXY ?? '',
};

📄 src/utils/dates.js

// Calculs de dates dans le fuseau du centre (Africa/Tunis par défaut), quel que soit le fuseau du serveur
import { config } from '../config/index.js';

function parties(date, fuseau = config.fuseau) {
  const p = Object.fromEntries(new Intl.DateTimeFormat('en-GB', {
    timeZone: fuseau, hourCycle: 'h23', year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit',
  }).formatToParts(date).map(({ type, value }) => [type, value]));
  return { annee: +p.year, mois: +p.month, jour: +p.day, heure: +p.hour, minute: +p.minute, seconde: +p.second };
}

// écart (ms) entre l'heure locale du fuseau et UTC à un instant donné
function decalage(date, fuseau) {
  const p = parties(date, fuseau);
  return Date.UTC(p.annee, p.mois - 1, p.jour, p.heure, p.minute, p.seconde) - Math.floor(date.getTime() / 1000) * 1000;
}

// « 2026-11-20 » → instants UTC du début et de la fin de cette journée locale
export function journeeLocale(texte, fuseau = config.fuseau) {
  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(texte ?? '');
  if (!m) return null;
  const minuitUtc = Date.UTC(+m[1], +m[2] - 1, +m[3]);
  const debut = new Date(minuitUtc - decalage(new Date(minuitUtc), fuseau));
  return { debut, fin: new Date(debut.getTime() + 24 * 3600 * 1000) };
}

// heure locale décimale (8.5 pour 8 h 30) et date locale « AAAA-MM-JJ »
export function heureLocale(date, fuseau = config.fuseau) {
  const p = parties(date, fuseau);
  return p.heure + p.minute / 60;
}
export function dateLocale(date, fuseau = config.fuseau) {
  const p = parties(date, fuseau);
  return `${p.annee}-${String(p.mois).padStart(2, '0')}-${String(p.jour).padStart(2, '0')}`;
}
Les modèles
src/models/ (3 fichiers)

📄 src/models/utilisateur.js

import mongoose from 'mongoose';

const utilisateurSchema = new mongoose.Schema(
  {
    nom: { type: String, required: true, trim: true, maxlength: 80 },
    email: { type: String, required: true, unique: true, lowercase: true, trim: true },
    motDePasse: { type: String, required: true, select: false },
    role: { type: String, enum: ['utilisateur', 'admin'], default: 'utilisateur' },
  },
  { timestamps: true, versionKey: false },
);

export const Utilisateur = mongoose.model('Utilisateur', utilisateurSchema);

📄 src/models/salle.js

import mongoose from 'mongoose';

const salleSchema = new mongoose.Schema(
  {
    nom: { type: String, required: [true, 'Le nom est obligatoire'], unique: true, trim: true, maxlength: 60 },
    capacite: { type: Number, required: true, min: [1, 'Capacité minimale : 1'], max: [500, 'Capacité maximale : 500'] },
    equipements: { type: [String], default: [] }, // ex. ['vidéoprojecteur', 'tableau blanc']
    etage: { type: Number, default: 0 },
    active: { type: Boolean, default: true }, // une salle désactivée ne peut plus être réservée
  },
  { timestamps: true, versionKey: false },
);

export const Salle = mongoose.model('Salle', salleSchema);

📄 src/models/reservation.js

import mongoose from 'mongoose';

const reservationSchema = new mongoose.Schema(
  {
    salle: { type: mongoose.Schema.Types.ObjectId, ref: 'Salle', required: true },
    utilisateur: { type: mongoose.Schema.Types.ObjectId, ref: 'Utilisateur', required: true },
    debut: { type: Date, required: true },
    fin: { type: Date, required: true },
    objet: { type: String, required: true, trim: true, maxlength: 120 },
    participants: { type: Number, min: 1, default: 1 },
    statut: { type: String, enum: ['confirmee', 'annulee'], default: 'confirmee' },
  },
  { timestamps: true, versionKey: false },
);

// recherche rapide des réservations d'une salle sur une période (contrôle des chevauchements)
reservationSchema.index({ salle: 1, debut: 1, fin: 1 });
reservationSchema.index({ utilisateur: 1, debut: -1 });

export const Reservation = mongoose.model('Reservation', reservationSchema);
Les règles de réservation

📄 src/services/reservations.service.js

import { Reservation } from '../models/reservation.js';
import { Salle } from '../models/salle.js';
import { ErreurApi } from '../utils/erreur-api.js';
import { heureLocale, dateLocale } from '../utils/dates.js';
import { verifierId } from './salles.service.js';
import { bus } from '../evenements.js';

// Règles de gestion du centre de formation
export const REGLES = { ouverture: 8, fermeture: 19, dureeMinMinutes: 30, dureeMaxHeures: 4, maxAVenir: 5 };

export async function creer({ salle: salleId, debut, fin, objet, participants = 1 }, moi) {
  verifierId(salleId, 'Salle');
  const d = new Date(debut);
  const f = new Date(fin);
  if (Number.isNaN(d.getTime()) || Number.isNaN(f.getTime())) throw new ErreurApi(400, 'Dates invalides');

  // 1) règles sur le créneau
  const minutes = (f - d) / 60000;
  if (minutes <= 0) throw new ErreurApi(400, 'La fin doit être après le début');
  if (minutes < REGLES.dureeMinMinutes) throw new ErreurApi(400, `Durée minimale : ${REGLES.dureeMinMinutes} minutes`);
  if (minutes > REGLES.dureeMaxHeures * 60) throw new ErreurApi(400, `Durée maximale : ${REGLES.dureeMaxHeures} heures`);
  if (d <= new Date()) throw new ErreurApi(400, 'Impossible de réserver dans le passé');
  if (dateLocale(d) !== dateLocale(f) || heureLocale(d) < REGLES.ouverture || heureLocale(f) > REGLES.fermeture) {
    throw new ErreurApi(400, `Le centre est ouvert de ${REGLES.ouverture} h à ${REGLES.fermeture} h`);
  }

  // 2) règles sur la salle
  const salle = await Salle.findById(salleId).lean();
  if (!salle) throw new ErreurApi(404, 'Salle introuvable');
  if (!salle.active) throw new ErreurApi(409, "Cette salle n'est pas disponible à la réservation");
  if (participants > salle.capacite) throw new ErreurApi(400, `Capacité de la salle dépassée (${salle.capacite} places)`);

  // 3) règles sur l'utilisateur
  const aVenir = await Reservation.countDocuments({ utilisateur: moi.id, statut: 'confirmee', debut: { $gt: new Date() } });
  if (aVenir >= REGLES.maxAVenir) throw new ErreurApi(409, `Vous avez déjà ${REGLES.maxAVenir} réservations à venir`);

  // 4) pas de chevauchement : une réservation existante commence avant notre fin ET finit après notre début
  const conflit = await Reservation.findOne({ salle: salleId, statut: 'confirmee', debut: { $lt: f }, fin: { $gt: d } }).lean();
  if (conflit) {
    throw new ErreurApi(409, 'Créneau déjà réservé', { conflit: { debut: conflit.debut, fin: conflit.fin } });
  }

  const reservation = await Reservation.create({ salle: salleId, utilisateur: moi.id, debut: d, fin: f, objet, participants });
  const resultat = await reservation.populate('salle', 'nom');
  bus.emit('reservation:modifiee', { salle: salleId, date: dateLocale(d) });
  return resultat.toObject();
}

export async function mesReservations(moi, { aVenir }) {
  const filtre = { utilisateur: moi.id };
  if (aVenir) Object.assign(filtre, { statut: 'confirmee', fin: { $gt: new Date() } });
  return Reservation.find(filtre).sort({ debut: aVenir ? 1 : -1 }).limit(100).populate('salle', 'nom etage').lean();
}

export async function toutes({ date, salle }) {
  const filtre = {};
  if (salle) { verifierId(salle, 'Salle'); filtre.salle = salle; }
  if (date) filtre.debut = { $gte: new Date(date) };
  return Reservation.find(filtre).sort({ debut: 1 }).limit(200)
    .populate('salle', 'nom').populate('utilisateur', 'nom email').lean();
}

export async function annuler(id, moi) {
  verifierId(id);
  const r = await Reservation.findById(id);
  // 404 aussi si elle appartient à un autre : on ne révèle pas son existence
  if (!r || (!r.utilisateur.equals(moi.id) && moi.role !== 'admin')) throw new ErreurApi(404, 'Réservation introuvable');
  if (r.statut === 'annulee') throw new ErreurApi(409, 'Réservation déjà annulée');
  if (r.debut <= new Date()) throw new ErreurApi(409, 'Une réservation commencée ou passée ne peut plus être annulée');
  r.statut = 'annulee';
  await r.save();
  bus.emit('reservation:modifiee', { salle: r.salle.toString(), date: dateLocale(r.debut) });
  return r.toObject();
}

L'ordre des contrôles est volontaire : d'abord les règles qui ne demandent aucune requête (dates, durée, horaires), puis celles qui lisent la base. Une requête mal formée est ainsi refusée sans solliciter MongoDB.

src/services/salles.service.js et auth.service.js

📄 src/services/salles.service.js

import mongoose from 'mongoose';
import { Salle } from '../models/salle.js';
import { Reservation } from '../models/reservation.js';
import { ErreurApi } from '../utils/erreur-api.js';
import { journeeLocale } from '../utils/dates.js';

export function verifierId(id, quoi = 'Identifiant') {
  if (!mongoose.isValidObjectId(id)) throw new ErreurApi(400, `${quoi} invalide`);
}

export async function lister({ capaciteMin, equipement, toutes }) {
  const filtre = toutes ? {} : { active: true };
  if (capaciteMin) filtre.capacite = { $gte: Number(capaciteMin) };
  if (equipement) filtre.equipements = equipement;
  return Salle.find(filtre).sort({ etage: 1, nom: 1 }).lean();
}

export async function trouver(id) {
  verifierId(id);
  const salle = await Salle.findById(id).lean();
  if (!salle) throw new ErreurApi(404, 'Salle introuvable');
  return salle;
}

export async function creer(donnees) {
  if (await Salle.exists({ nom: donnees.nom })) throw new ErreurApi(409, 'Une salle porte déjà ce nom');
  return (await Salle.create(donnees)).toObject();
}

export async function modifier(id, donnees) {
  verifierId(id);
  const champs = ['nom', 'capacite', 'equipements', 'etage', 'active'];
  const modifs = Object.fromEntries(Object.entries(donnees).filter(([k]) => champs.includes(k)));
  const salle = await Salle.findByIdAndUpdate(id, modifs, { returnDocument: 'after', runValidators: true }).lean();
  if (!salle) throw new ErreurApi(404, 'Salle introuvable');
  return salle;
}

// Planning d'une salle pour une journée : créneaux occupés, sans révéler qui a réservé (sauf ses propres réservations)
export async function planning(id, date, moi) {
  const salle = await trouver(id);
  const jour = journeeLocale(date);
  if (!jour) throw new ErreurApi(400, 'Date attendue au format AAAA-MM-JJ');
  const reservations = await Reservation.find({ salle: id, statut: 'confirmee', debut: { $lt: jour.fin }, fin: { $gt: jour.debut } })
    .sort({ debut: 1 }).lean();
  return {
    salle, date,
    creneaux: reservations.map((r) => ({
      id: r._id, debut: r.debut, fin: r.fin,
      objet: r.utilisateur.equals(moi.id) || moi.role === 'admin' ? r.objet : 'Réservé',
      aMoi: r.utilisateur.equals(moi.id),
    })),
  };
}

📄 src/services/auth.service.js

import bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';
import { Utilisateur } from '../models/utilisateur.js';
import { ErreurApi } from '../utils/erreur-api.js';
import { config } from '../config/index.js';

const profil = (u) => ({ id: u.id, nom: u.nom, email: u.email, role: u.role });

export async function inscrire({ nom, email, motDePasse }) {
  if (await Utilisateur.exists({ email: email.toLowerCase() })) throw new ErreurApi(409, 'Cet e-mail est déjà utilisé');
  const u = await Utilisateur.create({ nom, email, motDePasse: await bcrypt.hash(motDePasse, config.coutBcrypt) });
  return profil(u);
}

export async function connecter({ email, motDePasse }) {
  const u = await Utilisateur.findOne({ email: email.toLowerCase() }).select('+motDePasse');
  if (!u || !(await bcrypt.compare(motDePasse, u.motDePasse))) throw new ErreurApi(401, 'Identifiants incorrects');
  const jeton = jwt.sign({ sub: u.id, role: u.role, nom: u.nom }, config.jwtSecret, { expiresIn: config.jwtDuree });
  return { jeton, utilisateur: profil(u) };
}

export async function moi(id) {
  const u = await Utilisateur.findById(id);
  if (!u) throw new ErreurApi(401, 'Compte introuvable');
  return profil(u);
}

export function verifierJeton(jeton) {
  return jwt.verify(jeton, config.jwtSecret);
}
Routes, contrôleurs et middlewares

📄 src/app.js

import express from 'express';
import helmet from 'helmet';
import cors from 'cors';
import morgan from 'morgan';
import { routesSalles } from './routes/salles.routes.js';
import { routesReservations } from './routes/reservations.routes.js';
import { routesAuth } from './routes/auth.routes.js';
import { routeIntrouvable, gererErreurs } from './middlewares/erreurs.js';
import { config } from './config/index.js';
import pkg from '../package.json' with { type: 'json' };

// Crée l'application SANS la démarrer : server.js l'écoute, les tests l'utilisent directement
export function creerApp() {
  const app = express();
  if (config.trustProxy) app.set('trust proxy', config.trustProxy);
  app.use(helmet());
  app.use(cors({ origin: config.corsOrigines }));
  if (config.env === 'development') app.use(morgan('dev'));
  if (config.env === 'production') app.use(morgan('combined'));
  app.use(express.json({ limit: '10kb' }));
  app.use(express.static('public'));

  app.get('/api/sante', (req, res) => res.json({ statut: 'ok', version: pkg.version, uptime: Math.round(process.uptime()) }));
  app.use('/api/auth', routesAuth);
  app.use('/api/salles', routesSalles);
  app.use('/api/reservations', routesReservations);

  // la SPA utilise des adresses en #/… : la partie après # n'est jamais envoyée au serveur
  app.use(routeIntrouvable);
  app.use(gererErreurs);
  return app;
}

📄 src/routes/reservations.routes.js

import { Router } from 'express';
import { body } from 'express-validator';
import * as ctrl from '../controllers/reservations.controller.js';
import { authentifier, autoriser } from '../middlewares/auth.js';
import { valider } from '../middlewares/valider.js';

export const routesReservations = Router();
routesReservations.use(authentifier);
routesReservations.post('/',
  body('salle').notEmpty().withMessage('La salle est obligatoire'),
  body('debut').isISO8601().withMessage('Début : date ISO 8601'),
  body('fin').isISO8601().withMessage('Fin : date ISO 8601'),
  body('objet').trim().isLength({ min: 3, max: 120 }).withMessage('Objet : 3 à 120 caractères'),
  body('participants').optional().isInt({ min: 1 }).toInt(),
  valider, ctrl.creer);
routesReservations.get('/miennes', ctrl.miennes);
routesReservations.get('/', autoriser('admin'), ctrl.toutes);
routesReservations.patch('/:id/annuler', ctrl.annuler);

📄 src/routes/salles.routes.js

import { Router } from 'express';
import { body } from 'express-validator';
import * as ctrl from '../controllers/salles.controller.js';
import { authentifier, autoriser } from '../middlewares/auth.js';
import { valider } from '../middlewares/valider.js';

const regles = [
  body('nom').trim().notEmpty().withMessage('Le nom est obligatoire'),
  body('capacite').isInt({ min: 1, max: 500 }).withMessage('Capacité : entier de 1 à 500'),
  body('equipements').optional().isArray().withMessage('Équipements : tableau de textes'),
  body('etage').optional().isInt({ min: -2, max: 20 }),
];

export const routesSalles = Router();
routesSalles.use(authentifier); // toutes les routes des salles exigent une connexion
routesSalles.get('/', ctrl.lister);
routesSalles.get('/:id', ctrl.trouver);
routesSalles.get('/:id/planning', ctrl.planning);
routesSalles.post('/', autoriser('admin'), regles, valider, ctrl.creer);
routesSalles.patch('/:id', autoriser('admin'), ctrl.modifier);

📄 src/routes/auth.routes.js

import { Router } from 'express';
import { body } from 'express-validator';
import rateLimit from 'express-rate-limit';
import * as ctrl from '../controllers/auth.controller.js';
import { valider } from '../middlewares/valider.js';
import { authentifier } from '../middlewares/auth.js';

const limiteConnexion = rateLimit({ windowMs: 15 * 60 * 1000, limit: 10, standardHeaders: 'draft-8', legacyHeaders: false,
  message: { erreur: 'Trop de tentatives, réessayez dans 15 minutes' } });

export const routesAuth = Router();
routesAuth.post('/inscription',
  body('nom').trim().isLength({ min: 2, max: 80 }).withMessage('Nom : 2 à 80 caractères'),
  body('email').isEmail().withMessage('E-mail invalide'),
  body('motDePasse').isStrongPassword({ minLength: 8, minSymbols: 0 }).withMessage('8 caractères minimum, avec majuscule, minuscule et chiffre'),
  valider, ctrl.inscription);
routesAuth.post('/connexion', limiteConnexion, body('email').isEmail(), body('motDePasse').notEmpty(), valider, ctrl.connexion);
routesAuth.get('/moi', authentifier, ctrl.moi);

📄 src/controllers/reservations.controller.js

import * as service from '../services/reservations.service.js';

export const creer = async (req, res) => res.status(201).json(await service.creer(req.body, req.utilisateur));
export const miennes = async (req, res) => res.json(await service.mesReservations(req.utilisateur, { aVenir: req.query.aVenir === 'oui' }));
export const toutes = async (req, res) => res.json(await service.toutes(req.query));
export const annuler = async (req, res) => res.json(await service.annuler(req.params.id, req.utilisateur));

📄 src/controllers/salles.controller.js

import * as service from '../services/salles.service.js';

export const lister = async (req, res) =>
  res.json(await service.lister({ ...req.query, toutes: req.utilisateur.role === 'admin' && req.query.toutes === 'oui' }));
export const trouver = async (req, res) => res.json(await service.trouver(req.params.id));
export const creer = async (req, res) => res.status(201).json(await service.creer(req.body));
export const modifier = async (req, res) => res.json(await service.modifier(req.params.id, req.body));
export const planning = async (req, res) => res.json(await service.planning(req.params.id, req.query.date, req.utilisateur));

📄 src/controllers/auth.controller.js

import * as service from '../services/auth.service.js';

export const inscription = async (req, res) => res.status(201).json(await service.inscrire(req.body));
export const connexion = async (req, res) => res.json(await service.connecter(req.body));
export const moi = async (req, res) => res.json(await service.moi(req.utilisateur.id));

📄 src/middlewares/auth.js

import { verifierJeton } from '../services/auth.service.js';
import { ErreurApi } from '../utils/erreur-api.js';

export function authentifier(req, res, next) {
  const [type, jeton] = (req.headers.authorization ?? '').split(' ');
  if (type !== 'Bearer' || !jeton) return next(new ErreurApi(401, 'Authentification requise'));
  try {
    const charge = verifierJeton(jeton);
    req.utilisateur = { id: charge.sub, role: charge.role, nom: charge.nom };
    next();
  } catch {
    next(new ErreurApi(401, 'Jeton invalide ou expiré'));
  }
}

export const autoriser = (...roles) => (req, res, next) =>
  roles.includes(req.utilisateur?.role) ? next() : next(new ErreurApi(403, 'Accès refusé'));

📄 src/middlewares/valider.js

import { validationResult } from 'express-validator';
import { ErreurApi } from '../utils/erreur-api.js';

// À placer après les règles express-validator d'une route
export function valider(req, res, next) {
  const erreurs = validationResult(req);
  if (!erreurs.isEmpty()) {
    return next(new ErreurApi(400, 'Données invalides', erreurs.array().map((e) => ({ champ: e.path, message: e.msg }))));
  }
  next();
}

📄 src/middlewares/erreurs.js

import mongoose from 'mongoose';
import { ErreurApi } from '../utils/erreur-api.js';

export function routeIntrouvable(req, res, next) {
  next(new ErreurApi(404, `Route introuvable : ${req.method} ${req.originalUrl}`));
}

// Middleware d'erreurs : 4 paramètres, déclaré en dernier
// eslint-disable-next-line no-unused-vars
export function gererErreurs(err, req, res, next) {
  if (err instanceof mongoose.Error.ValidationError) {
    const details = Object.values(err.errors).map((e) => ({ champ: e.path, message: e.message }));
    return res.status(400).json({ erreur: 'Données invalides', details });
  }
  if (err.type === 'entity.parse.failed') return res.status(400).json({ erreur: 'JSON mal formé' });
  if (err instanceof ErreurApi) {
    return res.status(err.statut).json({ erreur: err.message, ...(err.details && { details: err.details }) });
  }
  console.error(err);
  res.status(500).json({ erreur: 'Erreur interne du serveur' });
}

📄 src/utils/erreur-api.js

// Erreur « attendue » : un code HTTP et un message pour le client
export class ErreurApi extends Error {
  constructor(statut, message, details) {
    super(message);
    this.statut = statut;
    this.details = details;
  }
}
server.js, temps réel et scripts

📄 src/server.js

import { createServer } from 'node:http';
import { creerApp } from './app.js';
import { config } from './config/index.js';
import { connecterBase, deconnecterBase } from './config/db.js';
import { brancherTempsReel } from './temps-reel.js';

await connecterBase(config.mongoUri);

const app = creerApp();
const serveur = createServer(app); // un serveur HTTP partagé par Express et Socket.IO
const io = brancherTempsReel(serveur);

serveur.listen(config.port, config.hote, () => {
  console.log(`API démarrée sur http://${config.hote}:${config.port} (${config.env})`);
});

// Arrêt propre (Ctrl+C, PM2, Docker) : on ferme les connexions avant de quitter
for (const signal of ['SIGINT', 'SIGTERM']) {
  process.on(signal, async () => {
    console.log(`${signal} reçu : arrêt en cours…`);
    io.close();
    serveur.close(async () => {
      await deconnecterBase();
      process.exit(0);
    });
  });
}

📄 src/evenements.js

import { EventEmitter } from 'node:events';

// Bus d'événements de l'application : les services annoncent, d'autres parties écoutent (ex. Socket.IO)
export const bus = new EventEmitter();

📄 src/temps-reel.js

import { Server } from 'socket.io';
import { bus } from './evenements.js';
import { verifierJeton } from './services/auth.service.js';
import { config } from './config/index.js';

// Bonus : le planning affiché se met à jour quand quelqu'un réserve ou annule
export function brancherTempsReel(serveurHttp) {
  const io = new Server(serveurHttp, { cors: { origin: config.corsOrigines } });
  io.use((socket, next) => {
    try {
      socket.data.utilisateur = verifierJeton(socket.handshake.auth?.jeton ?? '');
      next();
    } catch {
      next(new Error('Authentification requise'));
    }
  });
  bus.on('reservation:modifiee', (donnees) => io.emit('planning:modifie', donnees));
  return io;
}

📄 scripts/seed.js

// Données de démonstration (développement uniquement) : npm run seed
import bcrypt from 'bcrypt';
import { connecterBase, deconnecterBase } from '../src/config/db.js';
import { config } from '../src/config/index.js';
import { Salle } from '../src/models/salle.js';
import { Reservation } from '../src/models/reservation.js';
import { Utilisateur } from '../src/models/utilisateur.js';
import { journeeLocale, dateLocale } from '../src/utils/dates.js';

if (config.env === 'production') throw new Error('Le seed est interdit en production');
await connecterBase(config.mongoUri);
await Promise.all([Salle.deleteMany({}), Reservation.deleteMany({}), Utilisateur.deleteMany({})]);

const hash = (mdp) => bcrypt.hash(mdp, config.coutBcrypt);
const [admin, sami, lina] = await Utilisateur.create([
  { nom: 'Administration', email: 'admin@exemple.tn', role: 'admin', motDePasse: await hash('Admin2026!') },
  { nom: 'Sami Ben Ali', email: 'sami@exemple.tn', motDePasse: await hash('Sami2026!') },
  { nom: 'Lina Trabelsi', email: 'lina@exemple.tn', motDePasse: await hash('Lina2026!') },
]);
const salles = await Salle.create([
  { nom: 'Carthage', capacite: 30, etage: 0, equipements: ['vidéoprojecteur', 'tableau blanc', 'sonorisation'] },
  { nom: 'Dougga', capacite: 16, etage: 1, equipements: ['vidéoprojecteur', 'tableau blanc'] },
  { nom: 'Kerkouane', capacite: 8, etage: 1, equipements: ['écran tactile', 'visioconférence'] },
  { nom: 'Laboratoire Web', capacite: 20, etage: 2, equipements: ['20 postes', 'vidéoprojecteur'] },
  { nom: 'Utique', capacite: 12, etage: 2, equipements: ['tableau blanc'], active: false },
]);

// réservations sur les deux prochains jours ouvrés, à heures locales fixes
const demain = new Date(Date.now() + 24 * 3600 * 1000);
const j1 = journeeLocale(dateLocale(demain)).debut;
const h = (jour, heure) => new Date(jour.getTime() + heure * 3600 * 1000);
await Reservation.create([
  { salle: salles[0]._id, utilisateur: sami._id, debut: h(j1, 9), fin: h(j1, 11), objet: 'Cours Node.js — groupe DEV201', participants: 24 },
  { salle: salles[0]._id, utilisateur: lina._id, debut: h(j1, 14), fin: h(j1, 16), objet: 'Jury de soutenance', participants: 6 },
  { salle: salles[1]._id, utilisateur: lina._id, debut: h(j1, 10), fin: h(j1, 12), objet: 'Atelier Git et GitHub', participants: 12 },
  { salle: salles[2]._id, utilisateur: admin._id, debut: h(j1, 8.5), fin: h(j1, 9.5), objet: 'Réunion pédagogique', participants: 5 },
]);
console.log(`${await Utilisateur.countDocuments()} utilisateurs, ${await Salle.countDocuments()} salles, ${await Reservation.countDocuments()} réservations`);
await deconnecterBase();

📄 scripts/creer-admin.js

// Premier administrateur en production :
//   ADMIN_NOM=... ADMIN_EMAIL=... ADMIN_MOT_DE_PASSE=... npm run admin:creer
import bcrypt from 'bcrypt';
import { connecterBase, deconnecterBase } from '../src/config/db.js';
import { config } from '../src/config/index.js';
import { Utilisateur } from '../src/models/utilisateur.js';

const email = process.env.ADMIN_EMAIL?.toLowerCase();
const motDePasse = process.env.ADMIN_MOT_DE_PASSE ?? '';
if (!email || motDePasse.length < 12) {
  console.error('ADMIN_EMAIL et ADMIN_MOT_DE_PASSE (12 caractères minimum) sont obligatoires');
  process.exit(1);
}
await connecterBase(config.mongoUri);
if (await Utilisateur.exists({ email })) {
  console.log(`Le compte ${email} existe déjà : rien à faire`);
} else {
  await Utilisateur.create({ nom: process.env.ADMIN_NOM ?? 'Administration', email, role: 'admin', motDePasse: await bcrypt.hash(motDePasse, 12) });
  console.log(`Compte administrateur ${email} créé`);
}
await deconnecterBase();
Les tests

📄 test/aide.js

// Outils communs aux tests d'intégration (ce fichier n'est pas un test)
import mongoose from 'mongoose';
import bcrypt from 'bcrypt';
import request from 'supertest';
import { creerApp } from '../src/app.js';
import { Utilisateur } from '../src/models/utilisateur.js';
import { journeeLocale, dateLocale } from '../src/utils/dates.js';

export const app = creerApp();

// une base par fichier de test : node --test exécute les fichiers en parallèle
export async function ouvrirBase(nom) {
  await mongoose.connect(`${process.env.MONGODB_URI}_${nom}`);
  await mongoose.connection.dropDatabase();
}
export async function fermerBase() {
  await mongoose.connection.dropDatabase();
  await mongoose.disconnect();
}

// crée un compte et renvoie son jeton
export async function jetonPour(nom, role = 'utilisateur') {
  const email = `${nom}@test.tn`;
  await Utilisateur.create({ nom, email, role, motDePasse: await bcrypt.hash('MotDePasse1', 4) });
  const res = await request(app).post('/api/auth/connexion').send({ email, motDePasse: 'MotDePasse1' });
  return res.body.jeton;
}

// créneau en heure locale du centre, dans N jours : creneau(2, 9, 11) → après-demain de 9 h à 11 h
export function creneau(dansJours, heureDebut, heureFin) {
  const jour = journeeLocale(dateLocale(new Date(Date.now() + dansJours * 86400000))).debut.getTime();
  return { debut: new Date(jour + heureDebut * 3600000).toISOString(), fin: new Date(jour + heureFin * 3600000).toISOString() };
}

export const avec = (jeton) => ({ Authorization: `Bearer ${jeton}` });

📄 test/reservations.test.js

import { describe, it, before, after, beforeEach } from 'node:test';
import assert from 'node:assert/strict';
import request from 'supertest';
import { app, ouvrirBase, fermerBase, jetonPour, creneau, avec } from './aide.js';
import { Salle } from '../src/models/salle.js';
import { Reservation } from '../src/models/reservation.js';

describe('API /api/reservations', () => {
  let sami, lina, admin, salle;
  const reserver = (jeton, corps) => request(app).post('/api/reservations').set(avec(jeton)).send({ salle: salle.id, objet: 'Cours', ...corps });

  before(async () => {
    await ouvrirBase('reservations');
    [sami, lina, admin] = await Promise.all([jetonPour('sami'), jetonPour('lina'), jetonPour('admin', 'admin')]);
  });
  after(fermerBase);
  beforeEach(async () => {
    await Promise.all([Salle.deleteMany({}), Reservation.deleteMany({})]);
    salle = await Salle.create({ nom: 'Carthage', capacite: 20 });
  });

  describe('création', () => {
    it('201 pour un créneau libre', async () => {
      const res = await reserver(sami, creneau(1, 9, 11)).expect(201);
      assert.equal(res.body.salle.nom, 'Carthage');
      assert.equal(res.body.statut, 'confirmee');
    });

    it('409 si le créneau chevauche une réservation existante', async () => {
      await reserver(sami, creneau(1, 9, 11)).expect(201);
      const res = await reserver(lina, creneau(1, 10, 12)).expect(409);
      assert.equal(res.body.erreur, 'Créneau déjà réservé');
      assert.ok(res.body.details.conflit.debut);
    });

    it('accepte deux créneaux qui se touchent (fin = début)', async () => {
      await reserver(sami, creneau(1, 9, 11)).expect(201);
      await reserver(lina, creneau(1, 11, 12)).expect(201);
    });

    it('400 pour un créneau dans le passé', () => reserver(sami, creneau(-1, 9, 10)).expect(400));

    for (const [cas, c, message] of [
      ['avant l\'ouverture', creneau(1, 7, 9), 'Le centre est ouvert de 8 h à 19 h'],
      ['après la fermeture', creneau(1, 18, 20), 'Le centre est ouvert de 8 h à 19 h'],
      ['plus de 4 heures', creneau(1, 8, 13), 'Durée maximale : 4 heures'],
      ['moins de 30 minutes', creneau(1, 9, 9.25), 'Durée minimale : 30 minutes'],
      ['fin avant le début', creneau(1, 11, 9), 'La fin doit être après le début'],
    ]) {
      it(`400 : ${cas}`, async () => {
        const res = await reserver(sami, c).expect(400);
        assert.equal(res.body.erreur, message);
      });
    }

    it('400 si les participants dépassent la capacité', () => reserver(sami, { ...creneau(1, 9, 10), participants: 21 }).expect(400));

    it('409 pour une salle désactivée', async () => {
      await Salle.updateOne({ _id: salle.id }, { active: false });
      await reserver(sami, creneau(1, 9, 10)).expect(409);
    });

    it('409 au-delà de 5 réservations à venir', async () => {
      for (let h = 8; h < 18; h += 2) await reserver(sami, creneau(2, h, h + 1)).expect(201);
      const res = await reserver(sami, creneau(3, 9, 10)).expect(409);
      assert.match(res.body.erreur, /5 réservations à venir/);
    });

    it('401 sans jeton', () => request(app).post('/api/reservations').send(creneau(1, 9, 10)).expect(401));
  });

  describe('annulation', () => {
    it("l'auteur annule, et le créneau redevient libre", async () => {
      const { body } = await reserver(sami, creneau(1, 9, 11));
      const res = await request(app).patch(`/api/reservations/${body._id}/annuler`).set(avec(sami)).expect(200);
      assert.equal(res.body.statut, 'annulee');
      await reserver(lina, creneau(1, 9, 11)).expect(201);
    });

    it("404 pour la réservation d'un autre utilisateur", async () => {
      const { body } = await reserver(sami, creneau(1, 9, 11));
      await request(app).patch(`/api/reservations/${body._id}/annuler`).set(avec(lina)).expect(404);
    });

    it("l'administration peut annuler n'importe quelle réservation", async () => {
      const { body } = await reserver(sami, creneau(1, 9, 11));
      await request(app).patch(`/api/reservations/${body._id}/annuler`).set(avec(admin)).expect(200);
    });

    it('409 pour une réservation déjà annulée', async () => {
      const { body } = await reserver(sami, creneau(1, 9, 11));
      await request(app).patch(`/api/reservations/${body._id}/annuler`).set(avec(sami)).expect(200);
      await request(app).patch(`/api/reservations/${body._id}/annuler`).set(avec(sami)).expect(409);
    });
  });

  describe('consultation', () => {
    it('GET /miennes ne renvoie que ses propres réservations', async () => {
      await reserver(sami, creneau(1, 9, 10));
      await reserver(lina, creneau(1, 10, 11));
      const res = await request(app).get('/api/reservations/miennes').set(avec(sami)).expect(200);
      assert.equal(res.body.length, 1);
    });

    it("GET / est réservé à l'administration", async () => {
      await request(app).get('/api/reservations').set(avec(sami)).expect(403);
      await request(app).get('/api/reservations').set(avec(admin)).expect(200);
    });
  });
});
test/salles.test.js, auth.test.js et dates.test.js

📄 test/salles.test.js

import { describe, it, before, after } from 'node:test';
import assert from 'node:assert/strict';
import request from 'supertest';
import { app, ouvrirBase, fermerBase, jetonPour, creneau, avec } from './aide.js';
import { Salle } from '../src/models/salle.js';
import { dateLocale } from '../src/utils/dates.js';

describe('API /api/salles', () => {
  let sami, lina, admin, salle;
  before(async () => {
    await ouvrirBase('salles');
    [sami, lina, admin] = await Promise.all([jetonPour('sami'), jetonPour('lina'), jetonPour('admin', 'admin')]);
    salle = await Salle.create({ nom: 'Dougga', capacite: 16, equipements: ['vidéoprojecteur'] });
    await Salle.create({ nom: 'Utique', capacite: 12, active: false });
  });
  after(fermerBase);

  it('401 sans jeton', () => request(app).get('/api/salles').expect(401));

  it('ne liste que les salles actives', async () => {
    const res = await request(app).get('/api/salles').set(avec(sami)).expect(200);
    assert.deepEqual(res.body.map((s) => s.nom), ['Dougga']);
  });

  it("l'administration voit aussi les salles désactivées", async () => {
    const res = await request(app).get('/api/salles?toutes=oui').set(avec(admin)).expect(200);
    assert.equal(res.body.length, 2);
  });

  it('création : 403 pour un utilisateur, 201 pour un administrateur, 409 pour un nom existant', async () => {
    const nouvelle = { nom: 'Carthage', capacite: 30, equipements: ['tableau blanc'] };
    await request(app).post('/api/salles').set(avec(sami)).send(nouvelle).expect(403);
    await request(app).post('/api/salles').set(avec(admin)).send(nouvelle).expect(201);
    await request(app).post('/api/salles').set(avec(admin)).send(nouvelle).expect(409);
  });

  it("le planning masque l'objet des réservations des autres", async () => {
    const c = creneau(1, 9, 11);
    await request(app).post('/api/reservations').set(avec(sami)).send({ salle: salle.id, objet: 'Entretien confidentiel', ...c }).expect(201);
    const date = dateLocale(new Date(c.debut));
    const vuParLina = await request(app).get(`/api/salles/${salle.id}/planning?date=${date}`).set(avec(lina)).expect(200);
    assert.equal(vuParLina.body.creneaux[0].objet, 'Réservé');
    const vuParSami = await request(app).get(`/api/salles/${salle.id}/planning?date=${date}`).set(avec(sami)).expect(200);
    assert.equal(vuParSami.body.creneaux[0].objet, 'Entretien confidentiel');
    assert.equal(vuParSami.body.creneaux[0].aMoi, true);
  });

  it('planning : 400 pour une date mal formée', () =>
    request(app).get(`/api/salles/${salle.id}/planning?date=20-11-2026`).set(avec(sami)).expect(400));
});

📄 test/auth.test.js

import { describe, it, before, after } from 'node:test';
import assert from 'node:assert/strict';
import request from 'supertest';
import { app, ouvrirBase, fermerBase } from './aide.js';

describe('API /api/auth', () => {
  before(() => ouvrirBase('auth'));
  after(fermerBase);
  const nadia = { nom: 'Nadia', email: 'nadia@exemple.tn', motDePasse: 'Nadia2026' };

  it('inscription : 201, rôle utilisateur, pas de mot de passe renvoyé', async () => {
    const res = await request(app).post('/api/auth/inscription').send({ ...nadia, role: 'admin' }).expect(201);
    assert.equal(res.body.role, 'utilisateur'); // le rôle envoyé par le client est ignoré
    assert.equal(res.body.motDePasse, undefined);
  });

  it('mot de passe trop faible : 400', () =>
    request(app).post('/api/auth/inscription').send({ ...nadia, email: 'autre@exemple.tn', motDePasse: 'azerty' }).expect(400));

  it('e-mail déjà utilisé : 409', () => request(app).post('/api/auth/inscription').send(nadia).expect(409));

  it('connexion puis /moi', async () => {
    const { body } = await request(app).post('/api/auth/connexion').send({ email: nadia.email, motDePasse: nadia.motDePasse }).expect(200);
    const res = await request(app).get('/api/auth/moi').set('Authorization', `Bearer ${body.jeton}`).expect(200);
    assert.equal(res.body.email, nadia.email);
  });

  it('mauvais mot de passe : 401', () =>
    request(app).post('/api/auth/connexion').send({ email: nadia.email, motDePasse: 'Faux2026' }).expect(401));
});

📄 test/dates.test.js

import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { journeeLocale, heureLocale, dateLocale } from '../src/utils/dates.js';

describe('dates dans le fuseau du centre (Africa/Tunis, UTC+1)', () => {
  it('une journée locale commence à 23 h UTC la veille', () => {
    const { debut, fin } = journeeLocale('2026-11-20');
    assert.equal(debut.toISOString(), '2026-11-19T23:00:00.000Z');
    assert.equal(fin.toISOString(), '2026-11-20T23:00:00.000Z');
  });

  it('refuse un format de date incorrect', () => {
    for (const texte of ['20/11/2026', '2026-11', '', undefined]) assert.equal(journeeLocale(texte), null);
  });

  it("donne l'heure et la date locales d'un instant UTC", () => {
    const instant = new Date('2026-11-20T23:30:00Z'); // 0 h 30 le 21 à Tunis
    assert.equal(heureLocale(instant), 0.5);
    assert.equal(dateLocale(instant), '2026-11-21');
  });
});

Résultat réellement obtenu :

$ npm test
> reservation-salles@1.0.0 test
> node --env-file=.env.test --test "test/**/*.test.js"

▶ API /api/auth
  ✔ inscription : 201, rôle utilisateur, pas de mot de passe renvoyé (81.471361ms)
  ✔ mot de passe trop faible : 400 (9.156719ms)
  ✔ e-mail déjà utilisé : 409 (7.958212ms)
  ✔ connexion puis /moi (25.310955ms)
  ✔ mauvais mot de passe : 401 (7.876234ms)
✔ API /api/auth (210.408068ms)
▶ dates dans le fuseau du centre (Africa/Tunis, UTC+1)
  ✔ une journée locale commence à 23 h UTC la veille (120.300833ms)
  ✔ refuse un format de date incorrect (0.368708ms)
  ✔ donne l'heure et la date locales d'un instant UTC (0.716132ms)
✔ dates dans le fuseau du centre (Africa/Tunis, UTC+1) (127.114291ms)
▶ API /api/reservations
  ▶ création
    ✔ 201 pour un créneau libre (40.08592ms)
    ✔ 409 si le créneau chevauche une réservation existante (34.748239ms)
    ✔ accepte deux créneaux qui se touchent (fin = début) (27.658358ms)
    ✔ 400 pour un créneau dans le passé (9.716244ms)
    ✔ 400 : avant l'ouverture (7.946105ms)
    ✔ 400 : après la fermeture (7.200153ms)
    ✔ 400 : plus de 4 heures (6.046308ms)
    ✔ 400 : moins de 30 minutes (5.593104ms)
    ✔ 400 : fin avant le début (7.058822ms)
    ✔ 400 si les participants dépassent la capacité (10.248756ms)
    ✔ 409 pour une salle désactivée (10.565517ms)
    ✔ 409 au-delà de 5 réservations à venir (87.006767ms)
    ✔ 401 sans jeton (10.75173ms)
  ✔ création (267.029452ms)
  ▶ annulation
    ✔ l'auteur annule, et le créneau redevient libre (39.660724ms)
    ✔ 404 pour la réservation d'un autre utilisateur (21.22746ms)
    ✔ l'administration peut annuler n'importe quelle réservation (17.935575ms)
    ✔ 409 pour une réservation déjà annulée (21.795667ms)
  ✔ annulation (101.229198ms)
  ▶ consultation
    ✔ GET /miennes ne renvoie que ses propres réservations (30.635969ms)
    ✔ GET / est réservé à l'administration (9.233567ms)
  ✔ consultation (40.247991ms)
✔ API /api/reservations (592.768373ms)
▶ API /api/salles
  ✔ 401 sans jeton (13.522087ms)
  ✔ ne liste que les salles actives (10.499787ms)
  ✔ l'administration voit aussi les salles désactivées (5.332074ms)
  ✔ création : 403 pour un utilisateur, 201 pour un administrateur, 409 pour un nom existant (15.505113ms)
  ✔ le planning masque l'objet des réservations des autres (62.762528ms)
  ✔ planning : 400 pour une date mal formée (4.254317ms)
✔ API /api/salles (300.489962ms)
ℹ tests 33
ℹ pass 33
ℹ fail 0
ℹ duration_ms 2822.988998

📄 .github/workflows/tests.yml

name: Tests

on:
  push:
    branches: [main]
  pull_request:

jobs:
  tests:
    runs-on: ubuntu-24.04
    services:
      mongodb:
        image: mongo:8.0
        ports:
          - 27017:27017
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-node@v7
        with:
          node-version: 24
          cache: npm
      - run: npm ci
      # .env.test est versionné : il ne contient que des valeurs de test
      - run: npm test
Le client SPA

📄 public/js/api.js

// Toutes les requêtes vers l'API passent par ici : jeton, JSON et erreurs au même endroit
const CLE = 'jeton';

export const session = {
  get jeton() { return localStorage.getItem(CLE); },
  get utilisateur() { return JSON.parse(localStorage.getItem('utilisateur') ?? 'null'); },
  ouvrir({ jeton, utilisateur }) {
    localStorage.setItem(CLE, jeton);
    localStorage.setItem('utilisateur', JSON.stringify(utilisateur));
  },
  fermer() {
    localStorage.removeItem(CLE);
    localStorage.removeItem('utilisateur');
  },
};

export class ErreurApi extends Error {
  constructor(statut, corps) {
    super(corps?.erreur ?? `Erreur ${statut}`);
    this.statut = statut;
    this.details = corps?.details;
  }
}

export async function api(chemin, { methode = 'GET', corps } = {}) {
  const entetes = { Accept: 'application/json' };
  if (corps) entetes['Content-Type'] = 'application/json';
  if (session.jeton) entetes.Authorization = `Bearer ${session.jeton}`;
  const reponse = await fetch(`/api${chemin}`, { method: methode, headers: entetes, body: corps && JSON.stringify(corps) });
  const donnees = reponse.status === 204 ? null : await reponse.json().catch(() => null);
  if (reponse.status === 401 && session.jeton) {
    session.fermer(); // jeton expiré : retour à la connexion
    location.hash = '#/connexion';
  }
  if (!reponse.ok) throw new ErreurApi(reponse.status, donnees);
  return donnees;
}

📄 public/js/app.js

// Routeur de la SPA : la partie après # de l'adresse choisit la vue, sans recharger la page
import { session } from './api.js';
import { h } from './dom.js';
import { vueConnexion, vueInscription } from './vues/connexion.js';
import { vueSalles } from './vues/salles.js';
import { vuePlanning } from './vues/planning.js';
import { vueMesReservations } from './vues/reservations.js';
import { vueAdmin } from './vues/admin.js';

const ROUTES = [
  { motif: /^#\/connexion$/, vue: vueConnexion, publique: true },
  { motif: /^#\/inscription$/, vue: vueInscription, publique: true },
  { motif: /^#\/salles$/, vue: vueSalles },
  { motif: /^#\/salles\/([a-f\d]{24})$/, vue: vuePlanning },
  { motif: /^#\/mes-reservations$/, vue: vueMesReservations },
  { motif: /^#\/admin$/, vue: vueAdmin, role: 'admin' },
];

let nettoyer = null; // fonction fournie par la vue précédente (ex. fermer Socket.IO)

async function afficher() {
  const [adresse, requete = ''] = (location.hash || '#/salles').split('?');
  const route = ROUTES.find((r) => r.motif.test(adresse));
  const u = session.utilisateur;
  if (!route) return (location.hash = '#/salles');
  if (!route.publique && !u) return (location.hash = '#/connexion'); // route protégée
  if (route.role && u.role !== route.role) return (location.hash = '#/salles');

  nettoyer?.();
  nettoyer = null;
  dessinerMenu(adresse);
  const conteneur = document.getElementById('vue');
  conteneur.replaceChildren(h('p', { class: 'muet' }, 'Chargement…'));
  const params = adresse.match(route.motif).slice(1);
  nettoyer = await route.vue(conteneur, ...params, new URLSearchParams(requete));
}

function dessinerMenu(adresse) {
  const u = session.utilisateur;
  const lien = (href, texte) => h('a', { href, class: adresse === href ? 'actif' : null }, texte);
  const menu = u
    ? [lien('#/salles', 'Salles'), lien('#/mes-reservations', 'Mes réservations'), u.role === 'admin' && lien('#/admin', 'Administration'),
       h('span', { class: 'muet', style: { color: '#c7d2fe' } }, u.nom),
       h('button', { class: 'secondaire', onclick: () => { session.fermer(); location.hash = '#/connexion'; } }, 'Déconnexion')]
    : [lien('#/connexion', 'Connexion'), lien('#/inscription', 'Inscription')];
  document.getElementById('menu').replaceChildren(...menu.filter(Boolean));
}

window.addEventListener('hashchange', afficher);
afficher();

📄 public/js/vues/planning.js

import { api, session } from '../api.js';
import { h, notifier, heure, jour, aujourdhui, versIso } from '../dom.js';

const OUVERTURE = 8, FERMETURE = 19, HAUTEUR = 40; // 40 px par heure
const horaires = [];
for (let m = OUVERTURE * 60; m <= FERMETURE * 60; m += 30) horaires.push(`${String(Math.floor(m / 60)).padStart(2, '0')}:${String(m % 60).padStart(2, '0')}`);

export async function vuePlanning(conteneur, id, params) {
  const date = params.get('date') ?? aujourdhui();
  const zonePlanning = h('div');
  const titre = h('h1');

  async function charger() {
    const p = await api(`/salles/${id}/planning?date=${date}`);
    titre.textContent = `Salle ${p.salle.nom} — ${jour(`${date}T12:00:00+01:00`)}`;
    const journee = h('div', { class: 'journee', style: { height: `${(FERMETURE - OUVERTURE) * HAUTEUR}px` } },
      ...p.creneaux.map((c) => {
        const debut = (new Date(c.debut) - new Date(`${date}T0${OUVERTURE}:00:00+01:00`)) / 3600000;
        const duree = (new Date(c.fin) - new Date(c.debut)) / 3600000;
        return h('div', { class: c.aMoi ? 'creneau moi' : 'creneau', style: { top: `${debut * HAUTEUR}px`, height: `${duree * HAUTEUR - 2}px` } },
          h('strong', {}, `${heure(c.debut)} – ${heure(c.fin)}`), ' ', c.objet);
      }));
    const heures = h('div', { class: 'heures' }, ...Array.from({ length: FERMETURE - OUVERTURE }, (_, i) => h('div', {}, `${OUVERTURE + i} h`)));
    zonePlanning.replaceChildren(
      h('p', { class: 'muet' }, `${p.salle.capacite} places · ${p.salle.equipements.join(', ') || 'sans équipement'}`),
      h('div', { class: 'planning' }, heures, journee),
      h('p', { class: 'muet' }, '🟩 vos réservations · 🟥 créneaux occupés'));
  }

  const erreur = h('div', { class: 'erreur', hidden: true });
  const select = (nom, defaut) => h('select', { name: nom }, ...horaires.map((t) => h('option', { value: t, selected: t === defaut }, t)));
  const form = h('form', {
    onsubmit: async (e) => {
      e.preventDefault();
      erreur.hidden = true;
      const d = Object.fromEntries(new FormData(form));
      try {
        await api('/reservations', { methode: 'POST', corps: {
          salle: id, debut: versIso(date, d.debut), fin: versIso(date, d.fin), objet: d.objet, participants: Number(d.participants),
        } });
        notifier('Réservation confirmée');
        form.reset();
        await charger();
      } catch (err) {
        const conflit = err.details?.conflit;
        erreur.replaceChildren(err.message + (conflit ? ` (occupé de ${heure(conflit.debut)} à ${heure(conflit.fin)})` : ''),
          ...(Array.isArray(err.details) ? err.details.map((x) => h('div', {}, `• ${x.message}`)) : []));
        erreur.hidden = false;
      }
    },
  },
  h('div', { class: 'ligne' }, h('label', {}, 'Début', select('debut', '09:00')), h('label', {}, 'Fin', select('fin', '10:00'))),
  h('label', {}, 'Objet', h('input', { name: 'objet', required: true, minlength: 3, maxlength: 120, placeholder: 'Ex. : cours, réunion, examen' })),
  h('label', {}, 'Participants', h('input', { name: 'participants', type: 'number', min: 1, value: 1 })),
  erreur, h('button', { type: 'submit' }, 'Réserver ce créneau'));

  const choixDate = h('input', { type: 'date', value: date, min: aujourdhui(),
    onchange: (e) => { location.hash = `#/salles/${id}?date=${e.target.value}`; } });

  conteneur.replaceChildren(
    h('p', {}, h('a', { href: '#/salles' }, '← Toutes les salles')), titre,
    h('div', { class: 'deux-colonnes' },
      h('section', { class: 'carte' }, h('label', {}, 'Jour', choixDate), zonePlanning),
      h('section', { class: 'carte' }, h('h2', {}, 'Nouvelle réservation'), form)));
  await charger();

  // Bonus temps réel : si quelqu'un réserve ou annule dans cette salle ce jour-là, le planning se met à jour
  const socket = window.io?.({ auth: { jeton: session.jeton } });
  socket?.on('planning:modifie', (m) => { if (m.salle === id && m.date === date) charger(); });
  return () => socket?.close(); // appelé par le routeur en quittant la vue
}
index.html, style.css, dom.js et les autres vues

📄 public/index.html

<!doctype html>
<html lang="fr">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Réservation de salles</title>
  <link rel="stylesheet" href="/css/style.css">
</head>
<body>
  <header class="barre">
    <a href="#/salles" class="logo">🏫 Réservation de salles</a>
    <nav id="menu"></nav>
  </header>
  <main id="vue" aria-live="polite"></main>
  <div id="notification" role="status"></div>
  <script src="/socket.io/socket.io.js"></script>
  <script type="module" src="/js/app.js"></script>
</body>
</html>

📄 public/css/style.css

* { box-sizing: border-box; }
body { margin: 0; font-family: system-ui, sans-serif; color: #1e293b; background: #f1f5f9; }
.barre { display: flex; justify-content: space-between; align-items: center; padding: 12px 24px; background: #1e3a8a; color: #fff; }
.barre a { color: #fff; text-decoration: none; }
.logo { font-weight: 700; font-size: 18px; }
#menu { display: flex; gap: 16px; align-items: center; font-size: 15px; }
#menu .actif { border-bottom: 2px solid #fbbf24; }
main { max-width: 1050px; margin: 24px auto; padding: 0 16px; }
h1 { font-size: 24px; margin: 0 0 16px; }
.carte { background: #fff; border-radius: 10px; padding: 18px; box-shadow: 0 1px 3px rgb(0 0 0 / .08); }
.grille { display: grid; grid-template-columns: repeat(auto-fill, minmax(230px, 1fr)); gap: 16px; }
.salle h2 { margin: 0 0 6px; font-size: 18px; }
.muet { color: #64748b; font-size: 14px; }
.etiquettes { display: flex; flex-wrap: wrap; gap: 6px; margin: 10px 0; }
.etiquette { background: #e0e7ff; color: #3730a3; border-radius: 999px; padding: 2px 10px; font-size: 12px; }
form { display: grid; gap: 12px; }
label { display: grid; gap: 4px; font-size: 14px; font-weight: 600; }
input, select { padding: 8px 10px; border: 1px solid #cbd5e1; border-radius: 6px; font: inherit; }
button, .bouton { background: #2563eb; color: #fff; border: 0; border-radius: 6px; padding: 9px 16px; font: inherit; cursor: pointer; text-decoration: none; display: inline-block; text-align: center; }
button.secondaire { background: #e2e8f0; color: #1e293b; }
button.danger { background: #dc2626; }
button:disabled { opacity: .5; cursor: default; }
.ligne { display: flex; gap: 12px; flex-wrap: wrap; align-items: end; }
.ligne > * { flex: 1; min-width: 140px; }
.erreur { background: #fee2e2; color: #991b1b; padding: 10px 12px; border-radius: 6px; font-size: 14px; }
.connexion { max-width: 420px; margin: 40px auto; }
.planning { display: grid; grid-template-columns: 60px 1fr; margin-top: 12px; }
.heures div { height: 40px; font-size: 12px; color: #64748b; transform: translateY(-7px); }
.journee { position: relative; border-left: 1px solid #cbd5e1; background: repeating-linear-gradient(#fff 0 39px, #e2e8f0 39px 40px); }
.creneau { position: absolute; left: 8px; right: 8px; border-radius: 6px; padding: 4px 8px; font-size: 13px; background: #fecaca; border-left: 4px solid #dc2626; overflow: hidden; }
.creneau.moi { background: #bbf7d0; border-left-color: #16a34a; }
.deux-colonnes { display: grid; grid-template-columns: 1.3fr 1fr; gap: 20px; align-items: start; }
table { width: 100%; border-collapse: collapse; font-size: 14px; }
th, td { text-align: left; padding: 8px; border-bottom: 1px solid #e2e8f0; }
.statut-annulee { color: #94a3b8; text-decoration: line-through; }
#notification { position: fixed; bottom: 20px; right: 20px; background: #1e293b; color: #fff; padding: 10px 16px; border-radius: 8px; opacity: 0; transition: opacity .3s; }
#notification.visible { opacity: 1; }
@media (max-width: 760px) { .deux-colonnes { grid-template-columns: 1fr; } }

📄 public/js/dom.js

// Petit utilitaire pour créer des éléments sans innerHTML (pas d'injection de HTML)
export function h(balise, attributs = {}, ...enfants) {
  const el = document.createElement(balise);
  for (const [cle, valeur] of Object.entries(attributs ?? {})) {
    if (valeur === false || valeur == null) continue;
    if (cle.startsWith('on')) el.addEventListener(cle.slice(2), valeur);
    else if (cle === 'class') el.className = valeur;
    else if (cle === 'style') Object.assign(el.style, valeur);
    else el.setAttribute(cle, valeur === true ? '' : valeur);
  }
  el.append(...enfants.flat().filter((e) => e != null && e !== false));
  return el;
}

export function notifier(texte) {
  const n = document.getElementById('notification');
  n.textContent = texte;
  n.classList.add('visible');
  setTimeout(() => n.classList.remove('visible'), 2500);
}

const FUSEAU = 'Africa/Tunis';
export const heure = (iso) => new Date(iso).toLocaleTimeString('fr-FR', { hour: '2-digit', minute: '2-digit', timeZone: FUSEAU });
export const jour = (iso) => new Date(iso).toLocaleDateString('fr-FR', { weekday: 'long', day: 'numeric', month: 'long', timeZone: FUSEAU });
export const aujourdhui = () => new Date().toLocaleDateString('sv-SE', { timeZone: FUSEAU }); // AAAA-MM-JJ
// « 2026-11-20 » + « 09:30 » (heure de Tunis, UTC+1 toute l'année) → ISO 8601
export const versIso = (date, hhmm) => new Date(`${date}T${hhmm}:00+01:00`).toISOString();

📄 public/js/vues/connexion.js

import { api, session } from '../api.js';
import { h, notifier } from '../dom.js';

function formulaire({ titre, champs, bouton, lien, envoyer }) {
  const erreur = h('div', { class: 'erreur', hidden: true });
  const form = h('form', {
    onsubmit: async (e) => {
      e.preventDefault();
      erreur.hidden = true;
      const valider = form.querySelector('button');
      valider.disabled = true;
      try {
        await envoyer(Object.fromEntries(new FormData(form)));
      } catch (err) {
        erreur.replaceChildren(err.message, ...(err.details?.map?.((d) => h('div', {}, `• ${d.message}`)) ?? []));
        erreur.hidden = false;
      } finally {
        valider.disabled = false;
      }
    },
  }, ...champs.map(([nom, libelle, type, autocomplete]) => h('label', {}, libelle, h('input', { name: nom, type, required: true, autocomplete }))),
  erreur, h('button', { type: 'submit' }, bouton));
  return h('div', { class: 'carte connexion' }, h('h1', {}, titre), form, h('p', { class: 'muet' }, lien));
}

export function vueConnexion(conteneur) {
  conteneur.replaceChildren(formulaire({
    titre: 'Connexion',
    champs: [['email', 'E-mail', 'email', 'username'], ['motDePasse', 'Mot de passe', 'password', 'current-password']],
    bouton: 'Se connecter',
    lien: h('span', {}, 'Pas encore de compte ? ', h('a', { href: '#/inscription' }, 'Créer un compte')),
    envoyer: async (donnees) => {
      session.ouvrir(await api('/auth/connexion', { methode: 'POST', corps: donnees }));
      notifier(`Bienvenue ${session.utilisateur.nom}`);
      location.hash = '#/salles';
    },
  }));
}

export function vueInscription(conteneur) {
  conteneur.replaceChildren(formulaire({
    titre: 'Créer un compte',
    champs: [['nom', 'Nom complet', 'text', 'name'], ['email', 'E-mail', 'email', 'username'], ['motDePasse', 'Mot de passe (8 caractères, majuscule, minuscule, chiffre)', 'password', 'new-password']],
    bouton: "S'inscrire",
    lien: h('span', {}, 'Déjà inscrit ? ', h('a', { href: '#/connexion' }, 'Se connecter')),
    envoyer: async (donnees) => {
      await api('/auth/inscription', { methode: 'POST', corps: donnees });
      session.ouvrir(await api('/auth/connexion', { methode: 'POST', corps: { email: donnees.email, motDePasse: donnees.motDePasse } }));
      location.hash = '#/salles';
    },
  }));
}

📄 public/js/vues/salles.js

import { api } from '../api.js';
import { h } from '../dom.js';

export async function vueSalles(conteneur, params) {
  const filtres = { capaciteMin: params.get('capaciteMin') ?? '', equipement: params.get('equipement') ?? '' };
  const requete = new URLSearchParams(Object.entries(filtres).filter(([, v]) => v)).toString();
  const salles = await api(`/salles${requete ? '?' + requete : ''}`);

  const form = h('form', {
    class: 'carte ligne',
    onsubmit: (e) => {
      e.preventDefault();
      const q = new URLSearchParams([...new FormData(e.target)].filter(([, v]) => v)).toString();
      location.hash = '#/salles' + (q ? '?' + q : '');
    },
  },
  h('label', {}, 'Places minimum', h('input', { name: 'capaciteMin', type: 'number', min: 1, value: filtres.capaciteMin })),
  h('label', {}, 'Équipement', h('select', { name: 'equipement' },
    h('option', { value: '' }, 'Tous'),
    ...['vidéoprojecteur', 'tableau blanc', 'visioconférence', 'écran tactile'].map((e) => h('option', { value: e, selected: e === filtres.equipement }, e)))),
  h('button', { type: 'submit' }, 'Filtrer'));

  conteneur.replaceChildren(
    h('h1', {}, 'Salles disponibles'), form, h('p', { class: 'muet' }, `${salles.length} salle(s)`),
    h('div', { class: 'grille' }, ...salles.map((s) => h('article', { class: 'carte salle' },
      h('h2', {}, s.nom),
      h('div', { class: 'muet' }, `${s.capacite} places · ${s.etage === 0 ? 'rez-de-chaussée' : `étage ${s.etage}`}`),
      h('div', { class: 'etiquettes' }, ...s.equipements.map((e) => h('span', { class: 'etiquette' }, e))),
      h('a', { class: 'bouton', href: `#/salles/${s._id}` }, 'Planning et réservation')))),
  );
}

📄 public/js/vues/reservations.js

import { api } from '../api.js';
import { h, notifier, heure, jour } from '../dom.js';

export async function vueMesReservations(conteneur) {
  const liste = await api('/reservations/miennes');
  const maintenant = new Date();
  const lignes = liste.map((r) => {
    const annulable = r.statut === 'confirmee' && new Date(r.debut) > maintenant;
    return h('tr', { class: r.statut === 'annulee' ? 'statut-annulee' : null },
      h('td', {}, jour(r.debut)), h('td', {}, `${heure(r.debut)} – ${heure(r.fin)}`),
      h('td', {}, r.salle?.nom ?? '—'), h('td', {}, r.objet),
      h('td', {}, r.statut === 'annulee' ? 'annulée' : new Date(r.fin) < maintenant ? 'passée' : 'confirmée'),
      h('td', {}, annulable && h('button', { class: 'danger', onclick: async () => {
        if (!confirm(`Annuler « ${r.objet} » ?`)) return;
        await api(`/reservations/${r._id}/annuler`, { methode: 'PATCH' });
        notifier('Réservation annulée');
        vueMesReservations(conteneur);
      } }, 'Annuler')));
  });
  conteneur.replaceChildren(h('h1', {}, 'Mes réservations'), h('div', { class: 'carte' },
    liste.length === 0 ? h('p', {}, 'Aucune réservation pour le moment. ', h('a', { href: '#/salles' }, 'Réserver une salle'))
      : h('table', {}, h('thead', {}, h('tr', {}, ...['Jour', 'Horaire', 'Salle', 'Objet', 'Statut', ''].map((t) => h('th', {}, t)))), h('tbody', {}, ...lignes))));
}

📄 public/js/vues/admin.js

import { api } from '../api.js';
import { h, notifier, heure, jour } from '../dom.js';

export async function vueAdmin(conteneur) {
  const [salles, reservations] = await Promise.all([api('/salles?toutes=oui'), api(`/reservations?date=${new Date().toISOString()}`)]);

  const erreur = h('div', { class: 'erreur', hidden: true });
  const form = h('form', { class: 'ligne', onsubmit: async (e) => {
    e.preventDefault();
    const d = Object.fromEntries(new FormData(form));
    try {
      await api('/salles', { methode: 'POST', corps: { nom: d.nom, capacite: Number(d.capacite), etage: Number(d.etage),
        equipements: d.equipements.split(',').map((x) => x.trim()).filter(Boolean) } });
      notifier('Salle ajoutée');
      vueAdmin(conteneur);
    } catch (err) {
      erreur.replaceChildren(err.message, ...(Array.isArray(err.details) ? err.details.map((x) => h('div', {}, `• ${x.message}`)) : []));
      erreur.hidden = false;
    }
  } },
  h('label', {}, 'Nom', h('input', { name: 'nom', required: true })),
  h('label', {}, 'Places', h('input', { name: 'capacite', type: 'number', min: 1, required: true })),
  h('label', {}, 'Étage', h('input', { name: 'etage', type: 'number', value: 0 })),
  h('label', {}, 'Équipements (séparés par des virgules)', h('input', { name: 'equipements' })),
  h('button', { type: 'submit' }, 'Ajouter'));

  const basculer = (s) => async () => {
    await api(`/salles/${s._id}`, { methode: 'PATCH', corps: { active: !s.active } });
    notifier(s.active ? `${s.nom} désactivée` : `${s.nom} réactivée`);
    vueAdmin(conteneur);
  };

  conteneur.replaceChildren(
    h('h1', {}, 'Administration'),
    h('section', { class: 'carte' }, h('h2', {}, 'Salles'),
      h('table', {}, h('tbody', {}, ...salles.map((s) => h('tr', {},
        h('td', {}, h('strong', {}, s.nom)), h('td', {}, `${s.capacite} places`), h('td', {}, s.equipements.join(', ')),
        h('td', {}, s.active ? 'active' : 'désactivée'),
        h('td', {}, h('button', { class: s.active ? 'secondaire' : '', onclick: basculer(s) }, s.active ? 'Désactiver' : 'Réactiver')))))),
      h('h3', {}, 'Ajouter une salle'), form, erreur),
    h('section', { class: 'carte', style: { marginTop: '20px' } }, h('h2', {}, `Réservations à venir (${reservations.length})`),
      h('table', {}, h('thead', {}, h('tr', {}, ...['Jour', 'Horaire', 'Salle', 'Objet', 'Réservé par', 'Statut'].map((t) => h('th', {}, t)))),
        h('tbody', {}, ...reservations.map((r) => h('tr', { class: r.statut === 'annulee' ? 'statut-annulee' : null },
          h('td', {}, jour(r.debut)), h('td', {}, `${heure(r.debut)} – ${heure(r.fin)}`), h('td', {}, r.salle?.nom),
          h('td', {}, r.objet), h('td', {}, r.utilisateur?.nom), h('td', {}, r.statut === 'annulee' ? 'annulée' : 'confirmée')))))));
}
La mise en production (option A)

📄 ecosystem.config.cjs

// PM2 : pm2 start ecosystem.config.cjs
module.exports = {
  apps: [
    {
      name: 'reservation-salles',
      cwd: __dirname,
      script: 'src/server.js',
      node_args: '--env-file-if-exists=.env', // .env du serveur, jamais versionné
      instances: 1, // Socket.IO garde ses connexions en mémoire : une seule instance (voir 16.3)
      exec_mode: 'fork',
      max_memory_restart: '300M',
      env: { NODE_ENV: 'production' },
      time: true,
    },
  ],
};

📄 deploiement/nginx-reservation-salles.conf

# /etc/nginx/sites-available/reservation-salles
upstream reservation_salles {
    server 127.0.0.1:3000;
    keepalive 16;
}

server {
    listen 80;
    server_name reservations.exemple.tn;
    server_tokens off;
    return 301 https://$host$request_uri;
}

server {
    # nginx 1.24 (Ubuntu 24.04) ; nginx >= 1.25.1 : « listen 443 ssl; » + « http2 on; »
    listen 443 ssl http2;
    server_name reservations.exemple.tn;

    ssl_certificate     /etc/letsencrypt/live/reservations.exemple.tn/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/reservations.exemple.tn/privkey.pem;

    server_tokens off;
    client_max_body_size 1m;
    access_log /var/log/nginx/reservation-salles.access.log;
    error_log  /var/log/nginx/reservation-salles.error.log;

    # Socket.IO : la connexion HTTP doit pouvoir être « transformée » en WebSocket
    location /socket.io/ {
        proxy_pass http://reservation_salles;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 1h;   # une connexion WebSocket peut rester ouverte longtemps
    }

    # tout le reste (API et client SPA de public/) : Express
    location / {
        proxy_pass http://reservation_salles;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

📄 deploiement/deployer.sh

#!/bin/bash
# Mise à jour sur le serveur (utilisateur deploy) : bash deploiement/deployer.sh
set -euo pipefail
cd /var/www/reservation-salles
git pull --ff-only
npm ci --omit=dev --no-audit --no-fund   # du JavaScript : rien à compiler
pm2 reload ecosystem.config.cjs --update-env
pm2 save
sleep 2
curl -fsS http://127.0.0.1:3000/api/sante && echo

Fichier .env du serveur (secret masqué) :

NODE_ENV=production
PORT=3000
HOTE=127.0.0.1
# MongoDB Atlas : mongodb+srv://reservations:MOT_DE_PASSE@cluster0.xxxxx.mongodb.net/reservations
MONGODB_URI=mongodb://127.0.0.1:27017/reservations_prod
JWT_SECRET=••••••••
JWT_DUREE=2h
CORS_ORIGINES=
FUSEAU=Africa/Tunis
TRUST_PROXY=loopback

Déploiement réellement effectué :

deploy@vps:/var/www/reservation-salles$ git clone https://github.com/VOTRE_COMPTE/reservation-salles.git .
Cloning into '.'...
done.
deploy@vps:/var/www/reservation-salles$ chmod 600 .env && ls -l .env
-rw------- 1 deploy deploy 343 Nov 16 06:14 .env
deploy@vps:/var/www/reservation-salles$ npm ci --omit=dev
added 133 packages, and audited 134 packages in 5s
36 packages are looking for funding
  run `npm fund` for details
found 0 vulnerabilities
deploy@vps:/var/www/reservation-salles$ ADMIN_NOM='Direction des études' ADMIN_EMAIL=direction@exemple.tn ADMIN_MOT_DE_PASSE='Direction-2026-Prod' npm run admin:creer
> reservation-salles@1.0.0 admin:creer
> node --env-file-if-exists=.env scripts/creer-admin.js

MongoDB connecté : 127.0.0.1/reservations_prod
Compte administrateur direction@exemple.tn créé
deploy@vps:/var/www/reservation-salles$ pm2 start ecosystem.config.cjs
[PM2][WARN] Applications reservation-salles not running, starting...
[PM2] App [reservation-salles] launched (1 instances)
┌────┬───────────────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name                  │ namespace   │ version │ mode    │ pid      │ uptime │ ↺    │ status    │ cpu      │ mem      │ user     │ watching │
├────┼───────────────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0  │ reservation-salles    │ default     │ 1.0.0   │ fork    │ 1375     │ 0s     │ 0    │ online    │ 0%       │ 29.4mb   │ deploy   │ disabled │
└────┴───────────────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
deploy@vps:/var/www/reservation-salles$ pm2 ls && pm2 save
┌────┬───────────────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name                  │ namespace   │ version │ mode    │ pid      │ uptime │ ↺    │ status    │ cpu      │ mem      │ user     │ watching │
├────┼───────────────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0  │ reservation-salles    │ default     │ 1.0.0   │ fork    │ 1375     │ 4s     │ 0    │ online    │ 0%       │ 107.4mb  │ deploy   │ disabled │
└────┴───────────────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
[PM2] Saving current process list...
[PM2] Successfully saved in /home/deploy/.pm2/dump.pm2
root@vps:~# cp /var/www/reservation-salles/deploiement/nginx-reservation-salles.conf /etc/nginx/sites-available/reservation-salles
root@vps:~# ln -s /etc/nginx/sites-available/reservation-salles /etc/nginx/sites-enabled/
root@vps:~# nginx -t && nginx -s reload
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
root@vps:~# curl -sI http://reservations.exemple.tn/ | grep -iE "^HTTP|^location"
HTTP/1.1 301 Moved Permanently
Location: https://reservations.exemple.tn/
root@vps:~# curl -s https://reservations.exemple.tn/ | grep -o "<title>.*</title>"
<title>Réservation de salles</title>
root@vps:~# curl -s https://reservations.exemple.tn/api/sante
{"statut":"ok","version":"1.0.0","uptime":6}
root@vps:~# curl -s https://reservations.exemple.tn/api/salles
{"erreur":"Authentification requise"}
root@vps:~# curl -s -m 3 http://192.0.2.2:3000/api/sante || echo "refusé (code $?)"
refusé (code 7)

HTTP redirige vers HTTPS, le client SPA et l'API répondent par nginx, l'API exige un jeton, et le port 3000 est fermé depuis l'extérieur (code 7 de curl). Le journal de nginx confirme la connexion WebSocket du planning (statut 101). L'administratrice a ensuite ajouté les salles depuis l'écran d'administration :

Application en production

L'application en production sur https://reservations.exemple.tn (capture réelle dans Chrome).

📄 README.md

# Réservation de salles — projet de synthèse Node.js

Application SPA Full Stack JS : API REST Express 5 + MongoDB (Mongoose) + JWT, client JavaScript sans framework,
planning mis à jour en temps réel (Socket.IO), tests avec node:test et Supertest.

## Démarrer en local
```bash
npm install
cp .env.example .env      # compléter JWT_SECRET (et MONGODB_URI pour Atlas)
npm run seed              # 3 comptes, 5 salles, 4 réservations
npm run dev               # http://localhost:3000
```
Comptes de démonstration : admin@exemple.tn / Admin2026!, sami@exemple.tn / Sami2026!, lina@exemple.tn / Lina2026!

## Règles de gestion
- Centre ouvert de 8 h à 19 h (fuseau Africa/Tunis) ; réservation de 30 minutes à 4 heures, dans le futur.
- Pas de chevauchement sur une même salle ; participants ≤ capacité ; salle désactivée non réservable.
- 5 réservations à venir au maximum par utilisateur ; annulation par l'auteur ou l'administration, avant le début.

## Tests
```bash
npm test
npm run test:couverture
```

## API
| Méthode | Route | Accès |
|---|---|---|
| POST | /api/auth/inscription, /api/auth/connexion | public |
| GET | /api/auth/moi | connecté |
| GET | /api/salles, /api/salles/:id, /api/salles/:id/planning?date=AAAA-MM-JJ | connecté |
| POST, PATCH | /api/salles, /api/salles/:id | admin |
| POST | /api/reservations | connecté |
| GET | /api/reservations/miennes | connecté |
| PATCH | /api/reservations/:id/annuler | auteur ou admin |
| GET | /api/reservations | admin |

## Déploiement
PM2 (`ecosystem.config.cjs`), nginx (`deploiement/nginx-reservation-salles.conf`), mise à jour (`deploiement/deployer.sh`).

Cet article vous a-t-il aidé ?