Architecture en couches : présentation, métier, données

// src/erreurs.js
// Une règle de gestion non respectée. Le service la lève, le contrôleur n'a rien à faire :
// le gestionnaire d'erreurs la traduit en réponse HTTP.
export class ErreurMetier extends Error {
  constructor(message, statut = 422) {
    super(message);
    this.name = 'ErreurMetier';
    this.statut = statut;
  }
}

// src/services/reservation.service.js
import { ErreurMetier } from '../erreurs.js';

const DUREE_MAX_MINUTES = 240;

// La couche service : les règles de gestion des réservations. Ni req, ni res, ni SQL.
export function creerReservationService({ salleRepository, reservationRepository, maintenant = () => new Date() }) {
  return {
    async reserver({ salleId, employeId, debut, fin, objet, participants }) {
      const salle = await salleRepository.trouverParId(salleId);
      if (!salle) throw new ErreurMetier('Salle introuvable', 404);
      if (fin <= debut) throw new ErreurMetier('La fin doit être après le début');
      if (debut < maintenant()) throw new ErreurMetier('Impossible de réserver dans le passé');
      if ((fin - debut) / 60_000 > DUREE_MAX_MINUTES) {
        throw new ErreurMetier('Une réservation dure 4 heures au plus');
      }
      if (!Number.isInteger(participants) || participants < 1) {
        throw new ErreurMetier('Indique au moins 1 participant');
      }
      if (participants > salle.capacite) {
        throw new ErreurMetier(`La salle ${salle.nom} accueille ${salle.capacite} personnes au plus`);
      }
      if (await reservationRepository.existeChevauchement(salleId, debut, fin)) {
        throw new ErreurMetier('La salle est déjà réservée sur ce créneau', 409);
      }
      return reservationRepository.ajouter({ salleId, employeId, debut, fin, objet, participants });
    },
  };
}

// src/repositories/reservation.repository.js
export function creerReservationRepository(pool) {
  return {
    async existeChevauchement(salleId, debut, fin) {
      const [lignes] = await pool.execute(
        'SELECT COUNT(*) AS nb FROM reservation WHERE salle_id = ? AND debut < ? AND fin > ?',
        [salleId, fin, debut],
      );
      return lignes[0].nb > 0;
    },

    async ajouter(reservation) {
      const { salleId, employeId, debut, fin, objet, participants } = reservation;
      const [resultat] = await pool.execute(
        `INSERT INTO reservation (salle_id, employe_id, debut, fin, objet, participants)
         VALUES (?, ?, ?, ?, ?, ?)`,
        [salleId, employeId, debut, fin, objet, participants],
      );
      return { id: resultat.insertId, ...reservation };
    },
  };
}

// src/controllers/reservation.controller.js
// Le contrôleur traduit HTTP vers le métier, et le résultat vers HTTP. Il reste mince.
export function creerReservationController(reservationService) {
  return {
    async creer(req, res) {
      const { salleId, debut, fin, objet, participants } = req.body ?? {};
      const dateDebut = new Date(debut);
      const dateFin = new Date(fin);
      if (Number.isNaN(dateDebut.getTime()) || Number.isNaN(dateFin.getTime()) || !objet) {
        return res.status(400).json({ erreur: 'Requête incomplète ou dates invalides' });
      }
      const reservation = await reservationService.reserver({
        salleId: Number(salleId),
        employeId: req.utilisateur.id,
        debut: dateDebut,
        fin: dateFin,
        objet,
        participants: Number(participants),
      });
      res.status(201).json(reservation);
    },
  };
}

// Extrait de src/app.js : le gestionnaire d'erreurs, à la fin
app.use((err, req, res, next) => {
  if (err instanceof ErreurMetier) {
    return res.status(err.statut).json({ erreur: err.message });
  }
  console.error(err);
  res.status(500).json({ erreur: 'Erreur interne' });
});

// Services/ReservationService.cs
using ResaSalles.Data;
using ResaSalles.Models;

namespace ResaSalles.Services;

public class ErreurMetierException : Exception
{
    public ErreurMetierException(string message) : base(message) { }
}

// La couche service : les règles de gestion, et elles seules.
// Elle reçoit ses dépendances par son constructeur : c'est l'injection de dépendances.
public class ReservationService
{
    private const int DureeMaxMinutes = 240;

    private readonly ISalleRepository _salles;
    private readonly IReservationRepository _reservations;
    private readonly TimeProvider _horloge;

    public ReservationService(ISalleRepository salles, IReservationRepository reservations, TimeProvider horloge)
    {
        _salles = salles;
        _reservations = reservations;
        _horloge = horloge;
    }

    public Reservation Reserver(Reservation demande)
    {
        Salle salle = _salles.TrouverParId(demande.SalleId)
            ?? throw new ErreurMetierException("Salle introuvable.");
        if (string.IsNullOrWhiteSpace(demande.Objet))
            throw new ErreurMetierException("L'objet est obligatoire.");
        if (demande.Fin <= demande.Debut)
            throw new ErreurMetierException("La fin doit être après le début.");
        if (demande.Debut < _horloge.GetLocalNow().DateTime)
            throw new ErreurMetierException("Impossible de réserver dans le passé.");
        if ((demande.Fin - demande.Debut).TotalMinutes > DureeMaxMinutes)
            throw new ErreurMetierException("Une réservation dure 4 heures au plus.");
        if (demande.Participants < 1)
            throw new ErreurMetierException("Indique au moins 1 participant.");
        if (demande.Participants > salle.Capacite)
            throw new ErreurMetierException($"La salle {salle.Nom} accueille {salle.Capacite} personnes au plus.");
        if (_reservations.ExisteChevauchement(salle.Id, demande.Debut, demande.Fin))
            throw new ErreurMetierException("La salle est déjà réservée sur ce créneau.");

        demande.Id = _reservations.Ajouter(demande);
        return demande;
    }
}

// Controllers/ReservationController.cs (version en couches)
public string? Reserver(Reservation demande)
{
    try
    {
        _service.Reserver(demande);
        return null;
    }
    catch (ErreurMetierException ex)
    {
        return ex.Message;
    }
}

<?php
// src/Service/ReservationService.php
declare(strict_types=1);

final class ErreurMetier extends RuntimeException {}

final class ReservationService
{
    private const DUREE_MAX_SECONDES = 4 * 3600;

    public function __construct(
        private SalleModel $salles,
        private ReservationModel $reservations,
    ) {}

    public function reserver(int $salleId, int $employeId, DateTimeImmutable $debut,
                             DateTimeImmutable $fin, string $objet, int $participants): int
    {
        $salle = $this->salles->trouverParId($salleId) ?? throw new ErreurMetier('Salle introuvable.');
        if ($fin <= $debut) {
            throw new ErreurMetier('La fin doit être après le début.');
        }
        if ($debut < new DateTimeImmutable()) {
            throw new ErreurMetier('Impossible de réserver dans le passé.');
        }
        if ($fin->getTimestamp() - $debut->getTimestamp() > self::DUREE_MAX_SECONDES) {
            throw new ErreurMetier('Une réservation dure 4 heures au plus.');
        }
        if ($participants < 1) {
            throw new ErreurMetier('Indique au moins 1 participant.');
        }
        if ($participants > $salle['capacite']) {
            throw new ErreurMetier("La salle {$salle['nom']} accueille {$salle['capacite']} personnes au plus.");
        }
        $d = $debut->format('Y-m-d H:i:s');
        $f = $fin->format('Y-m-d H:i:s');
        if ($this->reservations->existeChevauchement($salleId, $d, $f)) {
            throw new ErreurMetier('La salle est déjà réservée sur ce créneau.');
        }
        return $this->reservations->ajouter($salleId, $employeId, $d, $f, $objet, $participants);
    }
}

public function reserver(int $salleId): void
{
    $employeId = $_SESSION['employe_id'] ?? null;
    if ($employeId === null) {
        http_response_code(401);
        $this->afficher('erreur', ['titre' => 'Connexion requise', 'message' => 'Connecte-toi pour réserver.']);
        return;
    }
    $debut = DateTimeImmutable::createFromFormat('!Y-m-d\TH:i', $_POST['debut'] ?? '');
    $fin = DateTimeImmutable::createFromFormat('!Y-m-d\TH:i', $_POST['fin'] ?? '');
    $objet = trim($_POST['objet'] ?? '');
    if ($debut === false || $fin === false || $objet === '') {
        http_response_code(400);
        $this->detail($salleId, ['Remplis toutes les zones.']);
        return;
    }
    try {
        $this->service->reserver($salleId, (int) $employeId, $debut, $fin, $objet, (int) ($_POST['participants'] ?? 0));
    } catch (ErreurMetier $e) {
        http_response_code(422);
        $this->detail($salleId, [$e->getMessage()]);
        return;
    }
    header('Location: /salles/' . $salleId, true, 303);
}

Par couche (technique)              Par fonctionnalité (métier)
src/                                src/
├── controllers/                    ├── salles/
│   ├── salle.controller.js         │   ├── salle.controller.js
│   └── reservation.controller.js   │   ├── salle.service.js
├── services/                       │   └── salle.repository.js
│   └── reservation.service.js      └── reservations/
└── repositories/                       ├── reservation.controller.js
    ├── salle.repository.js             ├── reservation.service.js
    └── reservation.repository.js       └── reservation.repository.js