Skip to content
Learni
View all tutorials
Backend

Comment maîtriser Fastify avec TypeScript en 2026

18 minEXPERT
TypeScriptAPIFastify

Introduction

Fastify est le framework Node.js le plus rapide du marché grâce à son architecture basée sur les hooks et les plugins. En 2026, il s'impose pour les APIs critiques nécessitant une faible latence et un typage strict. Ce tutoriel vous guide de l'installation à l'optimisation avancée avec TypeScript, en couvrant la validation, la sérialisation et le monitoring. Vous obtiendrez une base de code production-ready.

Prérequis

  • Node.js 20+
  • TypeScript 5.4+
  • Connaissances solides en Node.js et APIs REST
  • npm ou pnpm

Initialisation du projet

terminal
mkdir fastify-api && cd fastify-api
npm init -y
npm install fastify @fastify/type-provider-typebox
npm install -D typescript @types/node tsx
npx tsc --init

On installe Fastify avec son provider TypeBox pour un typage natif. tsx permet d'exécuter le code TypeScript directement pendant le développement.

Configuration TypeScript avancée

tsconfig.json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "Bundler",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "outDir": "./dist",
    "rootDir": "./src"
  },
  "include": ["src/**/*"]
}

Configuration optimisée pour Fastify 2026 : moduleResolution Bundler et target ES2022 pour supporter les dernières fonctionnalités async.

Serveur de base avec plugins

src/server.ts
import Fastify from 'fastify';
import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox';

const fastify = Fastify({
  logger: true
}).withTypeProvider<TypeBoxTypeProvider>();

fastify.get('/', async () => {
  return { message: 'Fastify 2026' };
});

const start = async () => {
  try {
    await fastify.listen({ port: 3000, host: '0.0.0.0' });
  } catch (err) {
    fastify.log.error(err);
    process.exit(1);
  }
};
start();

Création du serveur avec TypeBox pour un typage automatique des schémas. Le logger intégré facilite le debugging en production.

Plugin de validation avancé

src/plugins/validation.ts
import fp from 'fastify-plugin';
import { Type } from '@sinclair/typebox';

export default fp(async (fastify) => {
  fastify.addSchema({
    $id: 'User',
    type: 'object',
    properties: {
      id: { type: 'string', format: 'uuid' },
      email: { type: 'string', format: 'email' }
    },
    required: ['id', 'email']
  });
});

Utilisation de schémas réutilisables avec TypeBox. Cela garantit une validation stricte et une documentation OpenAPI automatique.

Hooks et cycle de vie

src/hooks/auth.ts
import fp from 'fastify-plugin';

export default fp(async (fastify) => {
  fastify.addHook('onRequest', async (request, reply) => {
    const token = request.headers.authorization;
    if (!token) {
      reply.code(401).send({ error: 'Unauthorized' });
    }
  });

  fastify.addHook('onResponse', async (request, reply) => {
    fastify.log.info(`Request to ${request.url} took ${reply.elapsedTime}ms`);
  });
});

Les hooks permettent d'injecter de la logique transverse (auth, logging) sans polluer les routes. onResponse est idéal pour le monitoring.

Route typée et sérialisation

src/routes/users.ts
import { FastifyInstance } from 'fastify';
import { Type } from '@sinclair/typebox';

export default async function userRoutes(fastify: FastifyInstance) {
  fastify.get('/users/:id', {
    schema: {
      params: Type.Object({ id: Type.String({ format: 'uuid' }) }),
      response: { 200: { $ref: 'User' } }
    }
  }, async (request) => {
    return { id: request.params.id, email: 'user@example.com' };
  });
}

Les routes sont entièrement typées. Fastify sérialise automatiquement la réponse selon le schéma, offrant des performances optimales.

Bonnes pratiques

  • Toujours encapsuler la logique dans des plugins réutilisables
  • Utiliser TypeBox pour la validation et la génération de types
  • Configurer un logger structuré (pino) dès le début
  • Activer la compression et le rate-limiting en production
  • Écrire des tests d'intégration avec fastify.inject

Erreurs courantes à éviter

  • Oublier d'appeler .withTypeProvider()
  • Définir des schémas inline au lieu de les centraliser
  • Ignorer la gestion des erreurs async dans les hooks
  • Ne pas configurer les limites de payload et de timeout

Pour aller plus loin

Approfondissez vos compétences avec nos formations Fastify avancées.