Fastify : Définition, Architecture et Sources Officielles | Coderoe

Par Matteo Collina & Tomas Della Vedova · 2016 · Sources officielles vérifiées

1. Définition détaillée & Contexte d'émergence

Fastify est un framework backend open-source faisant partie de l'OpenJS Foundation. Il est réputé pour être l'un des frameworks web les plus rapides sur le runtime Node.js, capable de traiter jusqu'à 2 à 3 fois plus de requêtes par seconde qu'Express. Fastify atteint ces performances grâce à l'utilisation interne de `fast-json-stringify` pour accélérer la sérialisation des réponses et d'`Ajv` pour valider les paramètres et payloads entrants, tout en offrant un système de plugins hiérarchique avec encapsulation complète.

Pourquoi ce concept a été créé : Créé pour surpasser Express en termes de débit de requêtes par seconde et combler le manque de validation de schémas intégrée dans les frameworks backend Node.js existants.

2. Mécanismes d’Optimisation de Fastify

Fastify réduit au minimum absolu le coût d'exécution par requête HTTP.

1. Sérialisation compilée (fast-json-stringify)

Au lieu d'utiliser le classique `JSON.stringify()`, Fastify compile des fonctions JavaScript spécialisées basées sur le schéma de sortie déclaré, générant des chaînes JSON jusqu'à 2x plus rapidement.

2. Validation déclarative (Ajv)

Validation automatique des headers, query params, params d'URL et body selon la norme JSON Schema avant même d'entrer dans la logique de la route.

3. Architecture de Plugins Encapsulée

Modèle de dépendances arborescent où un plugin peut enregistrer des décorateurs et hooks isolés sans polluer le scope global de l'application.

3. Caractéristiques fondamentales

Débit de requêtes exceptionnel (faible latence et consommation CPU réduite).
Cycle de vie de requête hautement configurable via des hooks (`onRequest`, `preHandler`, etc.).
Typage TypeScript de premier ordre avec inférence automatique des types depuis les schémas JSON ou TypeBox.
Logging intégré haute performance via Pino.
Génération automatique de documentation OpenAPI / Swagger avec `@fastify/swagger`.

4. Exemple concret d'implémentation

Serveur Fastify typé avec validation de schéma JSON et logging Pino

server.tstypescript

import Fastify from 'fastify';

const fastify = Fastify({
  logger: true, // Pino logger intégré
});

// Définition de route avec validation JSON Schema stricte
fastify.post('/api/users', {
  schema: {
    body: {
      type: 'object',
      required: ['email', 'name'],
      properties: {
        email: { type: 'string', format: 'email' },
        name: { type: 'string', minLength: 2 },
      },
    },
    response: {
      201: {
        type: 'object',
        properties: {
          id: { type: 'string' },
          email: { type: 'string' },
          status: { type: 'string' },
        },
      },
    },
  },
}, async (request, reply) => {
  const { email, name } = request.body as { email: string; name: string };
  // Logique métier...
  return reply.status(201).send({
    id: "usr_12345",
    email,
    status: "active",
  });
});

await fastify.listen({ port: 3000, host: '0.0.0.0' });

5. Avantages et limites techniques

Points forts

✓Performances brutes exceptionnelles parmi les frameworks Node.js.
✓Validation native des entrées empêchant les failles de données corrompues.
✓Architecture de plugins très propre pour des applications modulaires à grande échelle.
✓Excellente prise en charge native de TypeScript.

Points de vigilance

⚠Écosystème de middlewares historiques plus restreint qu’Express (bien qu’adaptable via `@fastify/express`).
⚠Le système d’encapsulation des plugins peut dérouter les débutants habitués au scope global d’Express.

6. Recommandations : Quand l'utiliser ?

Idéal pour :

Création d’APIs REST ou microservices Node.js à fort trafic nécessitant une latence minimale.
Projets exigeant une validation stricte des données et une génération automatique de spécifications Swagger/OpenAPI.

À éviter pour :

Petits scripts d’apprentissage où Express est imposé par un tutoriel débutant.
Architectures fullstack serverless Next.js où le backend est déjà géré par les Route Handlers.

7. Comparatif : Fastify vs Express.js

Fastify est beaucoup plus rapide et moderne qu’Express, avec validation de schémas intégrée et support TypeScript natif.

Critère	Fastify	Express.js
Débit / Performance	Jusqu’à 2x à 3x plus de requêtes par seconde qu’Express.	Performance modérée, architecture historique datant de 2010.
Validation des données	JSON Schema et Ajv natifs, pré-compilés au démarrage.	Aucune validation intégrée, nécessite des middlewares tiers manuels (Zod, Joi).
Support async/await	Support natif des fonctions asynchrones sans gestion manuelle de try/catch `next(err)`.	Historiquement basé sur des callbacks `next()`, gestion d’erreurs async délicate en v4.

8. Sources officielles vérifiées

Données techniques vérifiées auprès des documentations officielles, des RFCs et des spécifications standards.

Documentation officielle FastifyOpenJS Foundation

Benchmarks officiels FastifyFastify Team

Fastify - Fastify (Framework Web Node.js Haute Performance)