Routes et middlewares

// Signature d'un middleware Express
const monMiddleware = (req, res, next) => {
  // 1. Faire quelque chose avec req ou res
  console.log('Requête reçue :', req.method, req.url);

  // 2. Passer au middleware suivant (ou répondre)
  next();
};

// Enregistrer le middleware dans l'application
app.use(monMiddleware);

// Pile de middlewares — exécutés dans l'ordre
app.use(middlewareA);  // 1er exécuté
app.use(middlewareB);  // 2ème
app.use(middlewareC);  // 3ème — peut envoyer la réponse finale

const express = require('express');
const app = express();

// Parse les corps JSON : { "nom": "Alice" }
app.use(express.json());

// Parse les corps de formulaires HTML (application/x-www-form-urlencoded)
app.use(express.urlencoded({ extended: true }));

// Après ces middlewares, req.body est disponible dans toutes les routes
app.post('/utilisateurs', (req, res) => {
  console.log(req.body); // { nom: 'Alice', email: 'alice@ex.com' }
  res.json({ ok: true });
});

npm install cors morgan helmet

const cors    = require('cors');
const morgan  = require('morgan');
const helmet  = require('helmet');

// Ajoute des headers HTTP de sécurité (XSS, clickjacking…)
app.use(helmet());

// Autorise les requêtes cross-origin (depuis un navigateur sur un autre domaine)
app.use(cors());

// Journalise chaque requête dans le terminal (format 'dev' = colorisé)
// Exemple de sortie : GET /utilisateurs 200 4.321 ms
app.use(morgan('dev'));

// Middleware d'application — toutes les routes
app.use(morgan('dev'));

// Middleware de routeur — uniquement les routes /api/*
const apiRouter = express.Router();
apiRouter.use(verifierToken); // s'applique seulement ici
app.use('/api', apiRouter);

// Middleware de gestion d'erreurs — 4 paramètres obligatoires
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ erreur: err.message });
});

const express = require('express');
const router  = express.Router();

// GET /utilisateurs
router.get('/', (req, res) => {
  res.json([{ id: 1, nom: 'Alice' }]);
});

// GET /utilisateurs/:id
router.get('/:id', (req, res) => {
  res.json({ id: req.params.id, nom: 'Alice' });
});

// POST /utilisateurs
router.post('/', (req, res) => {
  const { nom, email } = req.body;
  res.status(201).json({ id: 2, nom, email });
});

module.exports = router;

const utilisateursRouter = require('./routes/utilisateurs');
const articlesRouter     = require('./routes/articles');

// Préfixes de routes — les chemins du routeur s'y ajoutent
app.use('/utilisateurs', utilisateursRouter);
app.use('/articles', articlesRouter);
// Résultat : GET /utilisateurs/, GET /utilisateurs/:id, POST /utilisateurs/
//            GET /articles/, GET /articles/:id, etc.

const TOKEN_SECRET = 'mon-token-secret';

function verifierToken(req, res, next) {
  // Le header attendu : Authorization: Bearer <token>
  const authHeader = req.headers['authorization'];

  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ erreur: 'Token manquant' });
  }

  const token = authHeader.split(' ')[1];

  if (token !== TOKEN_SECRET) {
    return res.status(401).json({ erreur: 'Token invalide' });
  }

  // Token valide — on passe à la suite
  next();
}

module.exports = verifierToken;

const verifierToken = require('./middlewares/auth');

// Protéger une route spécifique
app.get('/profil', verifierToken, (req, res) => {
  res.json({ message: 'Accès autorisé' });
});

// Protéger tout un routeur
apiRouter.use(verifierToken);
app.use('/api', apiRouter);

// Dans une route, propager une erreur avec next(err)
app.get('/donnees', async (req, res, next) => {
  try {
    const data = await recupererDonnees();
    res.json(data);
  } catch (err) {
    next(err); // Express route l'erreur vers le gestionnaire d'erreurs
  }
});

// Gestionnaire d'erreurs global — TOUJOURS en dernier
app.use((err, req, res, next) => {
  console.error('[Erreur]', err.message);

  const status = err.status || 500;
  res.status(status).json({
    erreur: err.message || 'Erreur interne du serveur'
  });
});

const app = express();

// 1. Sécurité et logging — en premier, avant tout
app.use(helmet());
app.use(morgan('dev'));

// 2. Parsing du corps — avant les routes qui lisent req.body
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// 3. CORS — avant les routes
app.use(cors());

// 4. Routes de l'application
app.use('/utilisateurs', utilisateursRouter);
app.use('/articles', articlesRouter);

// 5. Route 404 — après toutes les routes
app.use((req, res) => {
  res.status(404).json({ erreur: 'Route introuvable' });
});

// 6. Gestionnaire d'erreurs — absolument en dernier
app.use((err, req, res, next) => {
  res.status(err.status || 500).json({ erreur: err.message });
});