Générateur API Node.js/Express CRUD

Qu'est-ce qu'une API REST CRUD ?

Une API REST CRUD expose quatre opérations fondamentales sur une ressource via HTTP : Create, Read, Update, Delete. Express.js est le framework Node.js le plus utilisé pour construire ce type d'API, grâce à sa légèreté et sa flexibilité.

Structure du projet

Une bonne organisation est la clé d'une API maintenable. Voici la structure recommandée :

my-api/
├── server.js          # Point d'entrée Express
├── routes/
│   └── users.js       # Routes CRUD du modèle
├── models/
│   └── User.js        # Schéma Mongoose (si MongoDB)
├── middleware/
│   └── auth.js        # Middleware JWT
├── .env               # Variables d'environnement
└── package.json

Les routes CRUD expliquées

Voici le détail de chaque route avec les bonnes pratiques :

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

// GET /api/users — liste paginée
router.get('/', async (req, res) => {
    const page  = parseInt(req.query.page)  || 1;
    const limit = parseInt(req.query.limit) || 10;
    // ...
});

// GET /api/users/:id — un utilisateur
router.get('/:id', async (req, res) => {
    // Valider que req.params.id est un ObjectId valide
    // Retourner 404 si non trouvé
});

// POST /api/users — créer
router.post('/', async (req, res) => {
    // Valider req.body avant insertion
    // Retourner 201 Created avec la ressource créée
});

// PUT /api/users/:id — modifier
router.put('/:id', async (req, res) => {
    // Retourner 404 si non trouvé, 200 avec la ressource modifiée
});

// DELETE /api/users/:id — supprimer
router.delete('/:id', async (req, res) => {
    // Retourner 404 si non trouvé, 200 ou 204
});

Intégration base de données

Le générateur supporte plusieurs ORM et drivers. Voici la connexion MongoDB avec Mongoose :

// server.js
const mongoose = require('mongoose');

mongoose.connect(process.env.MONGODB_URI)
    .then(() => console.log('✅ MongoDB connecté'))
    .catch(err => {
        console.error('❌ Erreur MongoDB:', err.message);
        process.exit(1);
    });

// models/User.js
const userSchema = new mongoose.Schema({
    name:  { type: String, required: true, trim: true },
    email: { type: String, required: true, unique: true, lowercase: true },
    age:   { type: Number, min: 0 }
}, { timestamps: true }); // createdAt + updatedAt auto

module.exports = mongoose.model('User', userSchema);

Authentification JWT

Le middleware JWT vérifie le token dans l'en-tête Authorization: Bearer <token> :

// middleware/auth.js
const jwt = require('jsonwebtoken');

module.exports = function authMiddleware(req, res, next) {
    const header = req.headers['authorization'];
    if (!header || !header.startsWith('Bearer ')) {
        return res.status(401).json({ success: false, message: 'Token manquant' });
    }
    const token = header.split(' ')[1];
    try {
        req.user = jwt.verify(token, process.env.JWT_SECRET);
        next();
    } catch (err) {
        res.status(403).json({ success: false, message: 'Token invalide' });
    }
};

Bonnes pratiques

• ✅ Toujours valider les entrées avec Joi ou Zod avant de toucher la base de données
• ✅ Utiliser des codes HTTP sémantiques : 201 pour CREATE, 404 pour NOT FOUND, 422 pour validation
• ✅ Ne jamais exposer les stack traces en production — logger l'erreur serveur, retourner un message générique
• ✅ Paginer toutes les listes — une requête sans limite peut renvoyer des millions de lignes
• ✅ Versionner l'API : /api/v1/users pour évoluer sans casser les clients
• ✅ Activer CORS de manière restrictive : n'autoriser que les origines connues
• ✅ Stocker les secrets dans .env — jamais dans le code source