Les plugins Fastify, briques de base d’une API Node.js backend

Pour créer des API Node.js backend, Fastify se distingue par son écosystème de plugins et son architecture, offrant une alternative intéressante au framework Express traditionnel. Ce framework web très efficace et léger se démarque par sa vitesse remarquable et sa simplicité. Au cœur de sa conception se trouve une architecture de plugins robuste qui exploite pleinement les capacités asynchrones de Node.js. Fastify établit ainsi une nouvelle référence en matière de performances parmi les frameworks Node.js, en mettant en avant le rôle essentiel de ses plugins.

Le développement de Fastify est porté par une communauté open source grandissante, ce qui lui permet de rester pertinent et à jour face aux dernières tendances du développement d’applications web. Si vous développez des applications web backend en 2024, Fastify s’est révélé être un framework de choix pour créer des applications web rapides, évolutives et sécurisées.

Pourquoi Fastify et ses plugins sont des atouts pour une API Node.js backend robuste

Pour développer des applications web modernes, Fastify s’est imposé comme un choix intéressant auprès des développeurs. Ce framework web conçu pour Node.js offre un équilibre convaincant entre performances, flexibilité et fonctionnalités pensées pour les développeurs. Cette section présente les avantages de Fastify pour le développement d’applications modernes.

Prise en charge moderne d’ESM

Fastify prend directement en charge les modules ECMAScript (ESM). C’est important, car ESM est le format officiel des modules JavaScript des packages. Avec Fastify, vous pouvez utiliser nativement la syntaxe import et export sans étape de transpilation.

Voici un exemple simple de serveur Fastify utilisant ESM :

import fastify from 'fastify';

const server = fastify();

server.get('/', async (request, reply) => {
  return { hello: 'world' }
});

server.listen({port: 3000}, (err, address) => {
  if (err) throw err
  server.log.info(`Server listening at ${address}`)
});

Définition de routes basée sur les promesses avec async/await

Fastify simplifie la gestion des routes grâce à la syntaxe async/await. Le code obtenu est plus clair et plus lisible qu’avec les modèles traditionnels basés sur des callbacks.

Express ne prend pas nativement en charge async/await dans les définitions de routes, ce qui mène souvent à des callbacks imbriqués ou oblige à entourer les gestionnaires de routes de blocs try/catch pour gérer les erreurs. La prise en charge native d’async/await par Fastify facilite l’écriture et la maintenance de code asynchrone avec des promesses.

Voici un exemple montrant comment Fastify utilise async/await dans la définition d’une route :

server.get('/api/tasks', async (request, reply) => {
  const tasks = await Tasks.findAll();
  return tasks;
});

Performances élevées grâce à la résolution rapide de l’arbre de routage radix

Fastify est conçu pour offrir des performances élevées. Il utilise un algorithme de routage particulièrement efficace, qui résout rapidement l’arbre de routage radix. Fastify peut ainsi gérer de nombreuses routes avec une surcharge minimale et répondre rapidement, même en cas de forte charge.

Une architecture de plugins Fastify riche avec encapsulation

Fastify dispose d’une architecture de plugins riche qui prend en charge l’encapsulation. Vous pouvez ainsi facilement diviser votre application en composants isolés, chacun avec ses propres routes, plugins et décorateurs. Cette approche favorise une meilleure organisation du code et réduit le risque de conflits de noms.

Voici un exemple de plugin Fastify qui ajoute une fonction utilitaire au gestionnaire de routes à l’aide d’un décorateur :

import fp from 'fastify-plugin';

export default fp(async function (fastify, opts) {
  fastify.decorate('utility', () => 'This is a utility function');
});

Voici comment utiliser ce plugin :

// import and get a fastify server instance,
// and then:
server.register(import('./utility-plugin.js'));

server.get('/', async (request, reply) => {
  return server.utility();
});

Injection de dépendances légère

Le système de plugins de Fastify fait aussi office de système léger d’injection de dépendances (DI). Il permet de partager facilement des utilitaires et services communs dans toute votre application, sans recourir à des singletons ou à des variables globales.

Dans l’exemple suivant, une connexion à la base de données est partagée entre différentes parties de l’application :

fastify.register(async function (fastify, opts) {
  const db = await someDbConnectionLibrary(opts.connectionString);

  fastify.decorate('db', db);
});

Une API Node.js backend simple avec Fastify

Cet article présente les briques fondamentales pour créer des API Node.js backend avec Fastify et ses plugins recommandés en 2024. Nous examinerons en détail les composants essentiels d’une application Fastify, du routage et des middlewares à la validation et à la sérialisation.

Par ailleurs, compte tenu de l’importance de la cybersécurité dans le monde numérique d’aujourd’hui, nous aborderons brièvement la sécurité web et la manière d’utiliser les plugins Fastify pour la renforcer, un aspect crucial souvent négligé dans la précipitation du développement d’applications.

Pour commencer, vérifiez que la dernière version LTS de Node.js est installée sur votre système (à la date de rédaction, il s’agit de la version 20.11.1). Initialisez ensuite un nouveau projet Node.js et installez Fastify avec npm, comme indiqué ci-dessous :

$ mkdir fastify-app && cd fastify-app
$ npm init -y
$ npm install --save fastify

Modifiez le fichier package.json pour ajouter une définition de clé type: module à la racine et activer la prise en charge d’ESM :

{
  "type": "module",
}

Nous pouvons ensuite créer la structure de base d’une application Fastify dans un fichier server.js situé à la racine du projet :

1// Import Fastify using ESM syntax
2import Fastify from "fastify";
3
4const fastify = Fastify({ logger: true });
5
6// Defining a route
7fastify.get("/", async (request, reply) => {
8  return { hello: "world" };
9});
10
11async function startServer() {
12  try {
13    // Start the server
14    const address = await fastify.listen({
15      port: 3000,
16      host: "localhost",
17    });
18
19    // Log the server start information using the address returned by Fastify
20    // Fastify will already log the server start information by default
21    // But here is an example of how you can log the server start information
22    // fastify.log.info(`Server starting up at ${address}`);
23  } catch (err) {
24    fastify.log.error(err);
25    process.exit(1);
26  }
27}
28
29startServer();

Encapsuler la route d’API dans un plugin Fastify

Fastify encourage l’utilisation de plugins pour organiser votre code et permettre l’encapsulation. Vous pouvez ainsi regrouper le code associé et éviter les conflits entre les différentes parties de votre application.

Refactorisons notre route « Hello World » pour en faire un plugin Fastify :

1const fastify = require('fastify')({ logger: true });
2
3const helloRoute = async (fastify, options) => {
4  fastify.get('/', async (request, reply) => {
5    return { hello: 'world' };
6  });
7};
8
9fastify.register(helloRoute);
10
11const start = async () => {
12  try {
13    await fastify.listen(3000);
14    fastify.log.info(`server listening on ${fastify.server.address().port}`);
15  } catch (err) {
16    fastify.log.error(err);
17    process.exit(1);
18  }
19};
20start();

Utiliser un schéma pour les requêtes et les réponses des routes

Fastify permet de valider les requêtes entrantes et de structurer les réponses sortantes à l’aide de schémas JSON. Vous garantissez ainsi l’intégrité des données de votre application et simplifiez la création de documentation.

Voici comment définir un schéma de requête et de réponse pour la route « Hello World » :

1const helloRoute = async (fastify, options) => {
2  fastify.route({
3    method: 'GET',
4    url: '/',
5    schema: {
6      response: {
7        200: {
8          type: 'object',
9          properties: {
10            hello: { type: 'string' },
11          },
12        },
13      },
14    },
15    handler: async (request, reply) => {
16      return { hello: 'world' };
17    },
18  });
19};
20
21fastify.register(helloRoute);

Fastify validera alors automatiquement la réponse de la route « Hello World » par rapport au schéma fourni. Cela permet de détecter d’éventuels bugs et de garantir le comportement attendu de votre application.

Les plugins Fastify, briques de base des applications Fastify

Dans cette section, nous allons examiner quatre plugins Fastify essentiels : @fastify/pino, @fastify/cors, @fastify/env et @fastify/swagger, ainsi que @fastify/swagger-ui. Ces plugins contribuent à former l’ossature de toute application Fastify destinée à créer une API Node.js backend.

Le logger Pino pour Fastify

Pino est un logger pour Node.js particulièrement performant. Il dispose de ses propres plugins, qui lui permettent notamment de s’intégrer à d’autres systèmes de journalisation comme Sentry.

Fastify utilise Pino comme logger par défaut. Vous utilisez donc déjà Pino en arrière-plan lorsque vous instanciez Fastify avec { logger: true }. Vous pouvez toutefois transmettre un objet de configuration à la propriété logger pour mieux contrôler le niveau de journalisation ou d’autres paramètres propres à Pino.

Pendant le développement, vous préférerez peut-être des journaux plus faciles à lire et plus colorés. Le package pino-pretty permet d’obtenir ce résultat. Commencez par installer pino et pino-pretty :

npm install --save pino pino-pretty

Configurez ensuite pino-pretty comme suit :

1import pino from "pino";
2
3const logger = pino({
4  transport: {
5    target: "pino-pretty",
6    options: {
7      colorize: true,
8    },
9  },
10});
11
12logger.info("Hello from pino-pretty");
13
14const fastify = Fastify({
15  logger: logger,
16});

Ici, nous instancions un logger avec pino et le configurons pour utiliser pino-pretty comme cible de transport, avec l’option colorize pour activer la coloration des journaux. Nous transmettons ensuite notre variable personnalisée logger à l’option logger de Fastify.

Les journaux sont ainsi présentés dans un format plus lisible, plus facile à parcourir et à comprendre :

[12:13:43.499] INFO (95477): hello from pino-pretty
[12:13:43.517] INFO (95477): Server listening at http://[::1]:3000
[12:13:43.518] INFO (95477): Server listening at http://127.0.0.1:3000

Voici les avantages de Pino dans Fastify :

• Journalisation plus rapide : Pino a pour objectif principal d’être le logger le plus rapide pour Node.js.

• Un logger polyvalent : il prend en charge différents niveaux de journalisation et peut formater les journaux en JSON.

Le plugin Fastify @fastify/cors

Le plugin @fastify/cors permet d’utiliser facilement le partage des ressources entre origines (CORS) dans votre application Fastify.

Avantages :

• Sécurité : aide à gérer les échanges de données entre différentes origines.

• Personnalisable : permet de définir une fonction personnalisée pour configurer les options CORS.

Voici un exemple simple montrant comment ajouter le plugin @fastify/cors et l’utiliser :

// after creating the fastify instance
// let's register the fastify cors plugin:
fastify.register(require('@fastify/cors'), { 
  origin: '*',
  methods: ['GET','POST', 'PUT', 'DELETE']
})

Vous pouvez ensuite vérifier que la configuration CORS fonctionne en envoyant une requête cURL au serveur Fastify :

curl -i http://localhost:3000

La réponse doit inclure l’en-tête Access-Control-Allow-Origin, ce qui indique que la configuration CORS fonctionne comme prévu :

HTTP/1.1 200 OK
access-control-allow-origin: *
content-type: application/json; charset=utf-8
content-length: 17
Date: Sun, 18 Feb 2024 10:20:15 GMT
Connection: keep-alive
Keep-Alive: timeout=72

Le plugin Fastify @fastify/env

Les développeurs Node.js utilisent couramment des variables d’environnement pour configurer leurs applications, et notamment le fichier .env pour gérer ces variables.

Le plugin Fastify @fastify/env est très utile dans ce cas. Vous pouvez charger la configuration avec dotenv ou l’option intégrée à Node.js --env-file, mais ce plugin Fastify vous permet d’accéder directement à ces variables d’environnement depuis votre application Fastify, tout en assurant la validation de la configuration et la conversion des types.

Voici un exemple simple montrant comment ajouter et utiliser le plugin @fastify/env. Commencez par installer le plugin et créer un fichier .env :

npm install --save @fastify/env
echo "PORT=3001" > .env

Mettez ensuite à jour le code de server.js pour enregistrer ce nouveau plugin Fastify :

1fastify.register(import('@fastify/env'), {
2  dotenv: true,
3  schema: {
4    type: 'object',
5    required: [ 'PORT' ],
6    properties: {
7      PORT: {
8        type: 'string',
9        default: 3000
10      }
11    }
12  }
13})

L’enregistrement du plugin Fastify @fastify/env permet d’accéder à la configuration définie dans le fichier .env via l’objet fastify.config. Toutefois, nous ne pouvons pas l’utiliser directement. Il faut d’abord introduire un nouveau concept lié à l’architecture des plugins Fastify.

Avec l’architecture asynchrone des plugins Fastify, il faut attendre que Fastify ait initialisé tous les plugins avant qu’ils soient appliqués. Cela garantit qu’ils sont correctement enregistrés et prêts à être utilisés. Si vous aviez omis cette étape, vous auriez rencontré une erreur en tentant d’accéder à l’objet fastify.config.

Nous devons donc mettre à jour notre nouvelle fonction startServer() comme suit :

1try {
2    // wait for all plugins to run 
3    await fastify.ready();
4    // Start the server
5    const address = await fastify.listen({
6      // now we can access the fastify.config.PORT configuration
7      port: fastify.config.PORT,
8      host: "localhost",
9    });

Avantages du plugin @fastify/env :

• Validation des variables d’environnement : garantit la présence des variables d’environnement obligatoires.

• Conversion des types : convertit les variables d’environnement dans les types requis.

• Injection de dépendances légère : permet de partager facilement la configuration dans toute votre application, partout où vous avez accès à l’instance de l’application fastify.

Documenter les API Node.js côté serveur avec les plugins Fastify @fastify/swagger et @fastify/swagger-ui

Le plugin @fastify/swagger permet de générer et de fournir une page de documentation Swagger pour votre application Fastify. @fastify/swagger-ui fournit une interface utilisateur intégrée pour cette documentation, accessible dans un navigateur web ; c’est l’application Fastify elle-même qui sert cette page Swagger UI.

Comme précédemment, nous allons commencer par ajouter ces plugins à notre application Fastify :

npm install --save @fastify/swagger @fastify/swagger-ui

Nous allons ensuite enregistrer ces deux plugins dans notre fichier server.js :

1fastify.register(import('@fastify/swagger'), {
2  routePrefix: '/documentation',
3  swagger: {
4    info: {
5      title: 'Test swagger',
6      description: 'testing the fastify swagger api',
7      version: '0.1.0'
8    },
9    host: 'localhost',
10    schemes: ['http'],
11    consumes: ['application/json'],
12    produces: ['application/json']
13  },
14  exposeRoute: true
15})
16
17fastify.register(import('@fastify/swagger-ui'))

Redémarrez le serveur Fastify et ouvrez l’URL http://localhost:3001/documentation dans votre navigateur web pour consulter la page de documentation Swagger UI générée. Et voilà : votre application Fastify dispose d’une page de documentation Swagger pleinement fonctionnelle.

Remarque sur la sécurité : dans un environnement de production, pensez à protéger la page de documentation Swagger UI par une authentification et une autorisation. Évitez également d’utiliser vos serveurs Node.js de production pour la servir.

Avantages :

• Documentation d’API simplifiée : génère automatiquement la documentation de l’API.

• Personnalisable : permet de personnaliser la page de documentation.

Pour conclure

Comme nous l’avons vu, l’écosystème dynamique de Fastify propose une grande variété de plugins qui peuvent considérablement faciliter le développement de vos API Node.js backend. De l’amélioration de la journalisation avec pino et pino-pretty à la sécurisation des échanges CORS dans les navigateurs avec @fastify/cors, en passant par la gestion des variables d’environnement avec @fastify/env et la documentation de votre API avec @fastify/swagger et @fastify/swagger-ui, ces outils sont conçus pour simplifier votre workflow, améliorer les performances et rehausser la qualité de vos applications.

Voici un résumé de ce que nous avons appris sur les plugins Fastify :

Adopter le développement modulaire : l’architecture de plugins de Fastify favorise le développement modulaire et encourage la création d’une base de code claire et facile à maintenir. En intégrant ces plugins, les développeurs peuvent se concentrer sur la logique métier plutôt que sur le code répétitif, ce qui accélère le développement sans compromettre les performances ni l’évolutivité.

Améliorer la productivité et les performances : chaque plugin répond, avec sa spécialité, aux défis courants du développement web et vous permet de créer des API robustes, efficaces et sécurisées. Leur intégration simple à Fastify, associée aux avantages qu’ils offrent — journalisation améliorée, partage des ressources entre origines, configuration de l’environnement et documentation de l’API — contribue directement à accroître la productivité des développeurs et les performances des applications.

Encourager à explorer davantage : nous avons présenté quelques plugins essentiels, mais l’écosystème Fastify en regorge d’autres qui répondent à différents besoins : authentification, intégration aux bases de données, limitation du débit, et bien plus encore. Nous encourageons les développeurs à consulter la page des plugins Fastify et à tester ces outils pour découvrir comment optimiser et améliorer davantage leur processus de développement d’API.

Vous pouvez consulter le code source complet de tous les exemples ci-dessus d’API backend Node.js utilisant les plugins Fastify présentés.