Fastify Flashcards

Question 1

Q

Qu’est-ce que Fastify ?

Answer

A

Fastify est un framework web pour Node.js ultra-rapide et léger, conçu pour créer des serveurs HTTP et des APIs performantes.

Caractéristiques principales :
- 2-3x plus rapide qu’Express
- Validation automatique via JSON Schema
- Sérialisation optimisée
- Architecture modulaire avec plugins
- Support natif d’async/await

Analogie : C’est comme Express, mais avec un moteur de course et des assistances automatiques (validation, sérialisation).

Question 2

Q

Quel est le mnémotechnique pour retenir les concepts clés de Fastify ?

Answer

A

Mnémotechnique SHAPES

Schema : Validation et sérialisation automatiques
Hooks : Cycle de vie des requêtes
Async : Conçu pour async/await natif
Plugins : Architecture modulaire encapsulée
Extremely fast : Performance exceptionnelle
Safe : Sécurité par défaut

Phrase : “Si Henri Arrive Promptement, Espérons du Succès”

Question 3

Q

Comment fonctionne le routing de Fastify et pourquoi est-il plus rapide ?

Answer

A

Radix Tree vs Routing Linéaire

Fastify utilise un radix tree (find-my-way) au lieu d’un parcours linéaire.

Différence :

Résultat : Avec 100 routes, Fastify peut être 10x plus rapide pour trouver la bonne route.

Question 4

Q

Comment valider automatiquement une requête POST avec Fastify ?

Answer

A

Validation via JSON Schema

fastify.post('/user', {
  schema: {
    body: {
      type: 'object',
      required: ['username', 'email'],
      properties: {
        username: { type: 'string', minLength: 3 },
        email: { type: 'string', format: 'email' },
        age: { type: 'integer', minimum: 18 }
      }
    }
  }
}, async (request, reply) => {
  // request.body est DÉJÀ validé ici !
  return { success: true }
})

Avantages :
- Validation automatique avant le handler
- Erreur 400 si données invalides
- Pas besoin de bibliothèque externe
- Documentation auto-générée

Question 5

Q

Dans quel ordre s’exécutent les hooks Fastify lors d’une requête ?

Answer

A

Ordre d’exécution des hooks :

Requête HTTP
    ↓
1. onRequest (logging, tracking)
    ↓
2. preParsing (décompression)
    ↓
3. Parsing du body
    ↓
4. preValidation (auth préliminaire)
    ↓
5. Validation (automatique)
    ↓
6. preHandler (checks finaux)
    ↓
7. Handler (votre code)
    ↓
8. preSerialization (modif réponse)
    ↓
9. Sérialisation (automatique)
    ↓
10. onSend (compression)
    ↓
Réponse HTTP
    ↓
11. onResponse (logging final)

Mnémo : On Peut Parfaitement Valider Puis Hacker, Puis Sérialiser, Ou Répondre

Question 6

Q

Quelle est la différence entre ‘return’ et ‘reply.send()’ dans Fastify ?

Answer

A

Return vs Reply.send()

Ce sont deux façons de faire LA MÊME CHOSE.

✅ Option 1 : return (recommandé)

fastify.get('/user', async (request, reply) => {
  return { name: 'Alice' }
})

✅ Option 2 : reply.send()

fastify.get('/user', async (request, reply) => {
  reply.send({ name: 'Alice' })
})

❌ INTERDIT : les deux ensemble

fastify.get('/user', async (request, reply) => {
  reply.send({ name: 'Alice' })
  return { name: 'Bob' } // ERREUR : double envoi !
})

Règle : Choisissez l’un OU l’autre, JAMAIS les deux.

Question 7

Q

Comment créer un plugin Fastify simple ?

Answer

A

Structure d’un plugin Fastify

// plugins/logger.js
async function loggerPlugin(fastify, options) {
  // Hook personnalisé
  fastify.addHook('onRequest', async (request) => {
    console.log(`${request.method} ${request.url}`)
  })

  // Décorateur optionnel
  fastify.decorate('customLog', (msg) => {
    console.log(`[LOG] ${msg}`)
  })
}

module.exports = loggerPlugin

Utilisation :

const fastify = require('fastify')()
fastify.register(require('./plugins/logger'))

Points clés :
- Fonction async avec (fastify, options)
- Peut ajouter hooks, décorateurs, routes
- Encapsulé par défaut

Question 8

Q

Quels sont les 3 types de décorateurs Fastify et à quoi servent-ils ?

Answer

A

Les 3 types de décorateurs

1. fastify.decorate()
Ajoute une propriété à l’instance Fastify

fastify.decorate('config', { apiKey: '123' })
// Usage : fastify.config.apiKey

2. fastify.decorateRequest()
Ajoute une propriété à l’objet request

fastify.decorateRequest('startTime', null)
// Usage : request.startTime

3. fastify.decorateReply()
Ajoute une propriété/méthode à l’objet reply

fastify.decorateReply('success', function(data) {
  this.send({ success: true, data })
})
// Usage : reply.success({ user: 'Alice' })

Objectif : Étendre l’API de Fastify de manière typée et cohérente.

Question 9

Q

Comparez les performances de Fastify vs Express vs Koa

Answer

A

Benchmarks de Performance

Facteurs de performance Fastify :
- Radix tree routing (vs linéaire)
- Sérialisation optimisée (fast-json-stringify)
- Schémas précompilés
- Moins d’overhead middleware

En pratique : Sur une API avec 1M requêtes/jour, Fastify économise ~60% de ressources serveur par rapport à Express.

Framework | Req/sec | Latency | Throughput |
|———–|———|———|————|
| Fastify | ~65,000 | 1.5ms | 11.6 MB/s |
| Express | ~25,000 | 4ms | 4.5 MB/s |
| Koa | ~50,000 | 2ms | 9 MB/s |

Question 10

Q

Quel est le problème avec ce code Fastify et comment le corriger ?

fastify.get('/user', (request, reply) => {
  const user = getUserFromDB()
  reply.send(user)
})

Answer

A

Problème : Oubli du mot-clé async

❌ Mauvais :

fastify.get('/user', (request, reply) => {
  const user = getUserFromDB() // Retourne Promise
  reply.send(user) // Envoie [object Promise] !
})

✅ Correct :

fastify.get('/user', async (request, reply) => {
  const user = await getUserFromDB()
  return user
})

Pourquoi :
- Sans async, les erreurs asynchrones ne sont pas catchées
- Fastify gère automatiquement les erreurs des fonctions async
- Sans await, vous envoyez une Promise non résolue

Règle : Toujours utiliser async/await pour les opérations asynchrones.

Question 11

Q

Comment partager un décorateur à toute l’application malgré l’encapsulation ?

Answer

A

Problème d’encapsulation

Par défaut, les décorateurs sont encapsulés dans leur plugin.

❌ Ne fonctionnera pas :

async function myPlugin(fastify) {
  fastify.decorate('db', dbConnection)
}
fastify.register(myPlugin)

fastify.get('/users', async (request, reply) => {
  return fastify.db.getUsers() // ERREUR : db n'existe pas
})

✅ Solution : fastify-plugin

const fp = require('fastify-plugin')

async function myPlugin(fastify) {
  fastify.decorate('db', dbConnection)
}

module.exports = fp(myPlugin) // Désactive l'encapsulation

fastify.register(require('./myPlugin'))
fastify.get('/users', async () => {
  return fastify.db.getUsers() // Fonctionne !
})

fastify-plugin permet de partager décorateurs/hooks globalement.

Question 12

Q

Comment activer la conversion automatique de types dans les paramètres ?

Answer

A

Coercition automatique des types

Par défaut, tous les paramètres sont des strings.

Activation de la coercition :

const fastify = require('fastify')({
  ajv: {
    customOptions: {
      coerceTypes: true,      // Conversion auto
      removeAdditional: true, // Supprime propriétés non définies
      useDefaults: true       // Applique valeurs par défaut
    }
  }
})

Exemple :

fastify.get('/user/:id', {
  schema: {
    params: {
      type: 'object',
      properties: {
        id: { type: 'number' } // Sera converti de string → number
      }
    }
  }
}, async (request, reply) => {
  // request.params.id est un NUMBER, pas une string !
  console.log(typeof request.params.id) // 'number'
  return { userId: request.params.id }
})

Conversions supportées : string ↔ number, string ↔ boolean, etc.

Question 13

Q

Quand devriez-vous choisir Fastify plutôt qu’Express ?

Answer

A

Choisissez Fastify si :

✅ Nouveau projet : Pas de code legacy à migrer
✅ Performance critique : APIs haute charge, microservices
✅ Validation stricte : Besoin de valider toutes les entrées
✅ TypeScript : Excellent support natif
✅ Standards modernes : Async/await, JSON Schema
✅ Documentation auto : Swagger/OpenAPI intégré

Choisissez Express si :

❌ Projet existant complexe (migration coûteuse)
❌ Dépendance à des middlewares Express spécifiques
❌ Équipe non familière avec async/await
❌ Besoin d’un écosystème très mature

En résumé : Fastify pour du neuf et de la performance, Express pour du legacy et des besoins spécifiques.

Question 14

Q

Quels sont les plugins Fastify essentiels pour une API production ?

Answer

A

Plugins officiels essentiels

Sécurité & Auth :

@fastify/cors          // CORS
@fastify/jwt           // Authentification JWT
@fastify/helmet        // Headers de sécurité
@fastify/rate-limit    // Protection contre abus

Performance :

@fastify/compress      // Compression gzip/brotli
@fastify/caching       // Cache des réponses
@fastify/static        // Fichiers statiques

Développement :

@fastify/swagger       // Documentation OpenAPI
@fastify/swagger-ui    // Interface Swagger
@fastify/autoload      // Chargement auto plugins/routes

Données :

@fastify/multipart     // Upload fichiers
@fastify/formbody      // Parsing formulaires
@fastify/cookie        // Gestion cookies
@fastify/session       // Sessions utilisateur

Installation typique : npm install @fastify/cors @fastify/jwt @fastify/swagger @fastify/compress

Fastify Flashcards

(14 cards)