Aller au contenu
Réussir mon BTS SIO

Tape une notion, une commande ou le nom d'une épreuve.

Par exemple

Exercice 3 / 7Difficile

Ajouter une couche Service

À toi

Insère une couche userService entre le controller et le model. Elle porte la logique métier :

  • userService.list() → délègue à userModel.findAll()
  • userService.create(data) → valide que data.prenom est présent et non vide. Si invalide, throw une erreur avec error.statusCode = 400 et error.message = "prenom requis". Si valide, délègue à userModel.create(data).

Le userController.create :

  • Appelle userService.create(req.body) dans un try
  • En cas d'erreur, renvoie le statut error.statusCode avec { error: error.message }
  • En cas de succès, renvoie 201 avec le résultat

La couche Service : où vit la logique métier

Tu as maintenant Routes / Controller / Model. Pour les apps non-triviales, on ajoute souvent une quatrième couche : le Service.

Pourquoi ?

Le Controller a deux responsabilités qui s'opposent :

  1. Plomberie HTTP — lire req, écrire res, statuts, headers, JSON.
  2. Logique métier — règles, validations, orchestration de plusieurs models.

Mélanger les deux rend le code dur à tester et difficile à réutiliser hors HTTP. La séparation :

  • Controller : ne fait que la plomberie HTTP. Reçoit req, appelle un Service, renvoie une res.
  • Service : porte les règles. Validations, orchestrations, calculs. Aucune connaissance de HTTP.
  • Model : accès données pur, comme avant.

Avant — Controller bourré de logique

javascript
const produitController = {
  create(req, res) {
    // validation
    if (!req.body.nom) {
      return res.status(400).json({ error: "nom requis" });
    }
    // règles métier
    const existant = produitModel.findByNom(req.body.nom);
    if (existant) {
      return res.status(409).json({ error: "nom déjà pris" });
    }
    // orchestration
    const produit = produitModel.create(req.body);
    auditLog.write("produit.created", produit.ref);
    notificationService.send(produit);
    // réponse HTTP
    res.status(201).json(produit);
  },
};

C'est lourd. Et rien n'est testable sans Express.

Après — Service centralise

javascript
const express = require("express");
const app = express();
app.use(express.json());

let produits = [];

const produitModel = {
  create(data) {
    const p = { ref: produits.length + 1, ...data };
    produits.push(p);
    return p;
  },
};

// SERVICE — logique métier, throw au lieu de res.status
const produitService = {
  create(data) {
    if (typeof data.prix !== "number" || data.prix <= 0) {
      const erreur = new Error("prix invalide");
      erreur.statusCode = 422; // l'erreur porte son statut HTTP
      throw erreur;
    }
    return produitModel.create(data);
  },
};

// CONTROLLER — fine couche HTTP, traduit les exceptions
const produitController = {
  create(req, res) {
    try {
      const nouveau = produitService.create(req.body);
      res.status(201).json(nouveau);
    } catch (erreur) {
      res.status(erreur.statusCode || 500).json({ error: erreur.message });
    }
  },
};

app.post("/produits", produitController.create);
module.exports = app;

Avantages concrets

  1. Testabilité : produitService.create({ prix: -5 }) jette une erreur, testable en 2 lignes sans Express.
  2. Réutilisation : un job cron, une CLI, un autre endpoint peut appeler produitService.create directement.
  3. Lisibilité : le Controller fait 5 lignes, on voit immédiatement la traduction HTTP.

Quand introduire un Service ?

  • App petite (un domaine, < 5 endpoints) : Controller + Model suffisent.
  • App moyenne / large : Service systématique.
  • Si tu te surprends à dupliquer de la logique entre 2 controllers → c'est le signal pour extraire un Service.

📖 Définition Cette architecture (Controller → Service → Model) s'appelle parfois 3-tier architecture ou « architecture en couches ». C'est la base de tout backend sérieux, en JS comme en Java, Python, Go.

Bonus : middleware d'erreur centralisé

Au lieu de répéter try/catch dans chaque controller, tu peux laisser l'erreur remonter et l'attraper dans un middleware d'erreur (cf module 14) :

javascript
const produitController = {
  async create(req, res, next) {
    try {
      const nouveau = await produitService.create(req.body);
      res.status(201).json(nouveau);
    } catch (erreur) {
      next(erreur); // → middleware d'erreur prend la suite
    }
  },
};

app.use((erreur, req, res, next) => {
  res.status(erreur.statusCode || 500).json({ error: erreur.message });
});

Pour les exos suivants on reste en try/catch dans chaque controller pour la lisibilité.

Ton code

Connecte-toi pour faire cet exercice

C'est gratuit, avec ton compte Google : un clic, et tu reviens ici. Ta progression te suit ensuite sur tous tes appareils.

Le site garde ton nom et ton email, rien d'autre. Tes données