Comment créer une API REST en Node.js natif (sans Express)

Aujourd'hui, lorsqu'on démarre un nouveau projet backend avec Node.js, le premier réflexe de tout développeur est d'installer un framework comme Express.js, Fastify, ou d'initialiser une architecture avancée avec NestJS. Bien que ces outils soient indispensables en entreprise pour concevoir des API scalables, cette "magie" des frameworks masque souvent les mécanismes fondamentaux du web.

Le problème ? Sans comprendre ce qui se passe sous le capot, il devient extrêmement difficile de débugger des erreurs complexes liées aux requêtes HTTP, aux flux de données (streams) ou aux en-têtes (headers).

Comment fonctionne réellement un serveur web en JavaScript quand on le dépouille de tous ses frameworks ? Pour illustrer ce retour aux sources vital, nous allons construire Sunu Boutique, une petite API REST autonome gérant un catalogue de produits, en utilisant exclusivement le module natif de Node.js.

Le Cœur du sujet : Le code du serveur HTTP natif

Voici le code complet et autonome de notre API REST "from scratch". Ce script crée un serveur web complet et fonctionnel sans nécessiter le moindre npm install.

const http = require("http");

// Cas pratique : Serveur web Sunu Boutique
const server = http.createServer((req, res) => {
  // On indique que toutes nos réponses seront au format JSON
  res.setHeader("Content-Type", "application/json");
  
  const methode = req.method;
  const url = req.url;

  // Routage basique
  if (url === "/" && methode === "GET") {
    res.statusCode = 200;
    res.end(
      JSON.stringify({
        boutique: "Sunu Boutique",
        description: "Votre boutique en ligne de produits locaux",
        adresse: "Senegal, Dakar",
        telephone: "+221 77 000 00 00",
      })
    );
  } 
  else if (url === "/produits" && methode === "GET") {
    res.statusCode = 200;
    res.end(
      JSON.stringify([
        { id: 1, nom: "Thiof frais", prix: 3500, categorie: "Alimentation", enStock: true },
        { id: 2, nom: "Tissu Wax (6 yards)", prix: 15000, categorie: "Mode", enStock: true },
        { id: 3, nom: "Panier tressé artisanal", prix: 5000, categorie: "Décoration", enStock: true }
      ])
    );
  } 
  else if (url === "/produits" && methode === "POST") {
    res.statusCode = 201; // Code "Created"
    res.end(JSON.stringify({ message: "Nouveau produit ajouté au catalogue avec succès." }));
  } 
  else if (url === "/produits" && methode === "PUT") {
    res.statusCode = 200; // Code "OK"
    res.end(JSON.stringify({ message: "Produit mis à jour avec succès." }));
  } 
  else if (url === "/produits" && methode === "DELETE") {
    res.statusCode = 200;
    res.end(JSON.stringify({ message: "Produit retiré du catalogue." }));
  } 
  else {
    // Gestion des routes inexistantes (404)
    res.statusCode = 404;
    res.end(
      JSON.stringify({
        erreur: "Non trouvé",
        message: "Cette ressource n'existe pas dans notre API."
      })
    );
  }
});

// Démarrage du serveur sur le port 3000
server.listen(3000, () => {
  console.log("🚀 Sunu Boutique API démarrée sur http://localhost:3000/");
});

Le Décryptage : Explication étape par étape

Plongeons sous le capot de Node.js pour comprendre comment traiter des requêtes HTTP brutes.

Étape 1 : Le module HTTP et l'initialisation du serveur

Tout commence avec l'importation require("http"). Il s'agit de l'un des modules fondamentaux (Core Modules) fournis directement par Node.js. La méthode http.createServer() prend en paramètre une fonction de rappel (callback). C'est le cœur du réacteur : cette fonction sera exécutée à chaque fois qu'un client (votre navigateur web, une application React, ou Postman) enverra une requête vers le serveur.

Cette fonction nous donne un accès direct à deux objets essentiels :

req (Request) : Contient toutes les informations envoyées par le client (l'URL demandée, la méthode HTTP, les headers, le corps de la requête).
res (Response) : Permet de construire manuellement la réponse qui sera renvoyée au client.

Étape 2 : Le formatage de la réponse (Headers JSON)

Avant d'envoyer nos données, la ligne res.setHeader("Content-Type", "application/json"); est cruciale. Elle indique formellement au client web qu'il doit interpréter notre réponse comme du JSON (le format standard d'échange de données des API modernes), et non comme du texte brut ou une page HTML.

Étape 3 : Le routage fait maison (Routing)

Dans un framework comme Express, le routage est géré par des méthodes abstraites très simples (app.get('/produits', ...)). En Node.js natif, nous devons le faire "à la main". Pour cela, nous récupérons l'URL ciblée (req.url) et le verbe HTTP utilisé (req.method). Une série de conditions if / else if agit alors comme un aiguilleur du ciel :

Une requête GET sur /produits renvoie notre liste d'articles.
Une requête POST sur /produits simule l'ajout d'une donnée.
Une requête PUT sur /produits permet de mettre à jour un produit existant.
Une requête DELETE sur /produits simule la suppression d'un élément.

Étape 4 : La fin de la requête avec res.end()

Chaque condition de notre routeur se termine obligatoirement par res.end(). Cette fonction native a une double utilité :

Elle sérialise notre objet JavaScript en une chaîne de caractères conforme grâce à JSON.stringify().
Elle indique explicitement au serveur Node.js que la construction de la réponse est terminée et qu'elle peut être transmise au réseau. Tant que res.end() n'est pas appelée, la requête du client restera "en attente" indéfiniment.

Pourquoi maîtriser le Node.js natif ? (Conclusion et Limites)

Ce code est parfaitement fonctionnel et extrêmement rapide pour des micro-services ou de petits utilitaires. Cependant, ses limites apparaissent vite : imaginez devoir maintenir 200 routes différentes, extraire des paramètres dynamiques de l'URL (/produits/:id), gérer l'authentification via JWT, ou parser des fichiers téléversés. La suite infinie de if / else deviendrait très rapidement un cauchemar architectural à maintenir.

C'est exactement pour résoudre ce problème de DX (Developer Experience) que les frameworks existent. Néanmoins, comprendre cette architecture bas niveau en Node.js natif fait de vous un ingénieur backend accompli, capable de comprendre l'essence du protocole HTTP et de débugger n'importe quelle application, quel que soit l'outil utilisé par-dessus.

Besoin d'un expert backend sur vos projets ?

Construire des API REST performantes, sécurisées et scalables (en Node.js ou NestJS) est le cœur de mon expertise logicielle. Si vous avez une application métier ou un projet SaaS à concrétiser :

📩 Discutons-en ! En tant que développeur fullstack et consultant digital basé à Dakar, j'accompagne les entreprises de A à Z dans la conception de leurs architectures. N'hésitez pas à me contacter via mon portfolio.

🎁 Et pour les curieux souhaitant consolider leurs bases de développement, mon guide complet "De zéro à développeur web en 90 jours" arrive très bientôt.