Pourquoi Node.js pour le backend

Node.js permet d’utiliser JavaScript (ou TypeScript) côté serveur. Son modèle événementiel non-bloquant le rend particulièrement adapté aux API web et aux applications temps réel.

Chez Lueur Externe, nous utilisons Node.js pour les API, les fonctions serverless (comme le handler de contact de ce site) et les scripts d’automatisation.

L’architecture événementielle

Event Loop

Node.js traite les requêtes de manière asynchrone grâce à l’event loop :

Requête entrante
    │
    ▼
Event Loop ──► Opération I/O (DB, fichier, réseau)
    │                    │
    │                    ▼
    │              Callback/Promise
    │                    │
    ◄────────────────────┘
    │
    ▼
Réponse envoyée

Ce modèle permet de gérer des milliers de connexions simultanées avec un seul thread.

Quand Node.js excelle

  • API REST et GraphQL
  • Applications temps réel (WebSocket)
  • Microservices
  • Fonctions serverless (AWS Lambda)
  • Scripts CLI et automatisation

Quand éviter Node.js

  • Calculs CPU intensifs (préférez Go, Rust ou Python)
  • Applications nécessitant du multithreading natif

Frameworks backend

Express.js

Le framework le plus populaire, minimaliste et flexible :

import express from "express";

const app = express();
app.use(express.json());

app.get("/api/articles", async (req, res) => {
  const articles = await getArticles();
  res.json({ data: articles });
});

app.listen(3000);

Fastify

Plus performant qu’Express, avec validation de schéma intégrée :

import Fastify from "fastify";

const app = Fastify({ logger: true });

app.get("/api/articles", {
  schema: {
    response: {
      200: {
        type: "object",
        properties: {
          data: { type: "array" }
        }
      }
    }
  }
}, async () => {
  return { data: await getArticles() };
});

await app.listen({ port: 3000 });

Hono

Ultra-léger, conçu pour les edge runtimes :

import { Hono } from "hono";

const app = new Hono();

app.get("/api/articles", async (c) => {
  const articles = await getArticles();
  return c.json({ data: articles });
});

export default app;

Structure de projet

src/
├── routes/          # Définition des routes
│   ├── articles.ts
│   └── auth.ts
├── controllers/     # Logique métier
│   ├── articles.ts
│   └── auth.ts
├── services/        # Couche service
│   └── article.service.ts
├── models/          # Modèles de données
│   └── article.model.ts
├── middleware/       # Middlewares
│   ├── auth.ts
│   └── validation.ts
├── utils/           # Utilitaires
└── index.ts         # Point d'entrée

Bonnes pratiques

Gestion des erreurs

// Middleware de gestion d'erreurs centralisé
app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
  console.error(err.stack);
  res.status(500).json({
    error: {
      code: "INTERNAL_ERROR",
      message: "Une erreur interne est survenue"
    }
  });
});

Validation des entrées

Utilisez Zod pour valider les données entrantes :

import { z } from "zod";

const createArticleSchema = z.object({
  title: z.string().min(10).max(100),
  content: z.string().min(100),
  category: z.string(),
});

Variables d’environnement

Ne jamais hardcoder les secrets :

import { z } from "zod";

const envSchema = z.object({
  DATABASE_URL: z.string().url(),
  JWT_SECRET: z.string().min(32),
  PORT: z.coerce.number().default(3000),
});

export const env = envSchema.parse(process.env);

Tests

Testez vos API avec Vitest et Supertest :

import { describe, it, expect } from "vitest";
import request from "supertest";
import { app } from "../src/app";

describe("GET /api/articles", () => {
  it("returns a list of articles", async () => {
    const res = await request(app).get("/api/articles");
    expect(res.status).toBe(200);
    expect(res.body.data).toBeInstanceOf(Array);
  });
});

C’est l’approche que nous utilisons chez Lueur Externe pour garantir la fiabilité de nos API.

Conclusion

Node.js est une plateforme mature et performante pour le développement backend. Avec TypeScript, un framework adapté et de bonnes pratiques, vous construisez des API robustes et maintenables. Contactez Lueur Externe pour vos projets backend.