Démarrer avec Fastify : Créer une API simple

```html

Introduction;

Fastify est un framework web pour Node.js qui se concentre sur la fourniture d'une solution très performante et à faible surcharge pour la création d'applications web et d'API. Il est conçu pour être simple à utiliser tout en offrant des fonctionnalités puissantes qui le rendent idéal pour un large éventail de cas d'utilisation. Fastify affiche des benchmarks de vitesse impressionnants et est connu pour sa capacité à gérer efficacement des charges élevées.

Avantages de Fastify :

Performance : Fastify est conçu en mettant l'accent sur la vitesse, ce qui en fait l'un des frameworks web les plus rapides disponibles pour Node.js. Sa faible surcharge et son architecture efficace contribuent à réduire les temps de réponse et à améliorer les performances globales.
Validation basée sur le schéma : Fastify offre une prise en charge intégrée de la validation basée sur le schéma des charges utiles des requêtes et des réponses. Cela permet aux développeurs de définir des attentes claires pour les données entrantes, ce qui améliore la fiabilité et la sécurité.
Extensibilité : Fastify est hautement extensible, ce qui permet aux développeurs d'ajouter facilement des plugins et des middlewares personnalisés pour améliorer les fonctionnalités de leurs applications. Cela le rend adaptable à un large éventail d'exigences de projet.
Prise en charge asynchrone : Fastify adopte pleinement les modèles de programmation asynchrones, ce qui le rend bien adapté à la gestion efficace des opérations liées aux E/S. Il exploite les fonctionnalités modernes de JavaScript comme async/await pour simplifier le code asynchrone.
Convivialité pour les développeurs : Avec son API intuitive et sa documentation complète, Fastify vise à offrir une expérience conviviale pour les développeurs. Il offre une syntaxe claire et concise, ce qui le rend facile à comprendre et à utiliser pour les débutants comme pour les développateurs expérimentés.

Ce qui sera couvert dans ce tutoriel :

Dans ce tutoriel, nous allons aborder les bases de l'utilisation de Fastify pour créer une API simple. En commençant par la configuration d'un projet Fastify, nous explorerons progressivement ses principales fonctionnalités, notamment la gestion des routes, la validation des requêtes, les middlewares, la gestion des erreurs, les tests et le déploiement. À la fin du tutoriel, vous aurez une solide compréhension de la façon d'utiliser Fastify pour créer des applications web robustes et efficaces.

Prérequis

Avant de commencer, assurez-vous d'avoir installé les prérequis suivants :

Node.js et npm : Fastify nécessite que Node.js et npm soient installés sur votre système. Vous pouvez les télécharger et les installer à partir du site web officiel de Node.js .
Connaissances de base de JavaScript et Node.js : Ce tutoriel suppose que vous avez une compréhension de base de JavaScript et de la façon de travailler avec Node.js. La familiarité avec des concepts tels que les rappels, les promesses et les modules sera bénéfique lorsque nous explorerons les fonctionnalités de Fastify.

Avec ces prérequis en place, vous êtes prêt à vous lancer dans la construction avec Fastify ! Commençons.

Configuration de Fastify

Installation de Fastify via npm

Pour commencer avec Fastify, vous devrez d'abord l'installer via npm, qui est le gestionnaire de paquets pour Node.js. Si vous êtes fan de Yarn ou Bun, vous pouvez également essayer de les utiliser. Pour ce guide, j'utiliserai NPM.

Et au cas où vous ne le sauriez pas, ou ne comprendriez pas pleinement comment utiliser NPM, vous pouvez consulter ce tutoriel pour vous familiariser avec lui.

Pour commencer, créez un nouveau dossier, par exemple sur votre bureau ou dans votre répertoire de travail, où vous souhaitez configurer le projet de Fastify.

Pour ce faire, exécutez simplement le code suivant sur votre terminal, étape par étape, en vous suivant les uns les autres

mkdir my-fastify-project
cd my-fastify-project

Maintenant, vous avez créé un dossier et vous vous êtes déplacé dans ce dossier à partir de votre terminal. Bon travail !

Ensuite, initialisez npm pour ce projet et installez le framework Fastify.

npm init -y
npm install fastify

À ce stade, votre projet ne se compose que du fichier package.json, package-lock.json, & node_moudles, qui contient des métadonnées sur votre projet et ses dépendances. Au fur et à mesure que nous continuons à construire notre application Fastify, nous ajouterons d'autres fichiers et répertoires à cette structure.

Création d'un serveur simple

Configuration d'un serveur Fastify de base

Maintenant que notre projet est configuré, créons un serveur Fastify simple. Créez un nouveau fichier appelé index.js dans le répertoire de votre projet et ajoutez le code suivant :

// Import the Fastify module
const fastify = require('fastify')();

// Define a route handler for the root URL
fastify.get('/', async (request, reply) => {
  return { hello: 'world' };
});

// Start the server
const start = async () => {
  try {
    await fastify.listen({ port: 3000 });
    console.log('Server is running on http://localhost:3000');
  } catch (error) {
    console.error('Error starting server:', error);
    process.exit(1);
  }
};

start();

Ce code configure un serveur Fastify de base qui écoute les requêtes HTTP entrantes sur le port 3000. Lorsqu'une requête est faite à l'URL racine (/), elle répond avec un objet JSON contenant le message "hello": "world".

Pour que le code suivant fonctionne, nous devons lui dire de s'exécuter. Comment pouvons-nous le faire ? Eh bien, nous pouvons exécuter node index.js sur notre terminal dans le dossier racine du projet et cela fonctionnera.

Mais cela signifierait que nous devrons exécuter cette commande chaque fois que nous effectuons une mise à jour de fichier. Nous ne voulons pas de ce stress. Nous devrions être en mesure d'enregistrer le fichier et de déclencher automatiquement la reconstruction. Comment pouvons-nous faire cela ?
Eh bien, voici Nodemon.

Pour installer Nodemon, exécutez simplement le code suivant dans le terminal ;
npm install nodemon --save-dev.
Cela installera Nodemon et nous pourrons nous concentrer sur notre code et ne pas lui demander manuellement de se reconstruire.

Mais nous n'avons pas encore terminé avec Nodemon. Je vous promets que c'est la dernière partie du code que nous allons configurer pour Nodemon. Que devons-nous faire ? Nous devons lui dire de se déclencher automatiquement chaque fois que nous enregistrons un fichier. Comment faisons-nous cela ?

Ouvrez votre fichier package.json et remplacez la section script par le code suivant :

 "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },

Et voilà ! Nous avons terminé avec la configuration de Nodemon, je vous le promets !

Maintenant, pour démarrer notre serveur, nous devons exécuter npm run dev dans le répertoire racine de notre projet. Une fois que vous avez terminé, accédez à votre navigateur et tapez http://localhost:3000/ - vous verrez notre exemple de réponse hello world comme nous l'avons défini dans notre fichier index.js ci-dessus.

A page showing "Hello World" text from server output.

Ajout de routes pour gérer différentes méthodes HTTP (GET, POST, etc.)

Fastify facilite la création d'API REST / la définition de routes pour gérer différentes méthodes HTTP telles que GET, POST, PUT, DELETE, etc. Ajoutons une route pour gérer une requête POST. Mettez à jour votre fichier index.js avec le code suivant :

// Define a route handler for handling POST requests to '/data'
fastify.post('/data', async (request, reply) => {
  const payload = request.body;
  // Process the incoming data
  // For now, let's just echo back the received data
  return { receivedData: payload };
});

Maintenant, notre serveur Fastify peut gérer à la fois les requêtes GET vers l'URL racine (/) et les requêtes POST vers le point de terminaison /data.

Répondre avec des données JSON

Dans les deux gestionnaires de routes que nous avons définis ('/' et '/data'), nous répondons avec des données JSON en utilisant les méthodes de réponse intégrées de Fastify. Fastify sérialise automatiquement les objets JavaScript en JSON, ce qui facilite l'envoi de données structurées en tant que réponses.

Avec ces ajouts, notre serveur Fastify est désormais capable de gérer les requêtes HTTP de base et de répondre avec des données JSON.

Mais comment tester la requête POST ? Nous ne pouvons pas tester une requête POST à partir du navigateur, n'est-ce pas ?
Pour nous aider, nous utiliserons Apidog.

💡

Apidog est un outil de gestion d'API que nous pouvons utiliser pour Concevoir, Déboguer, Tester, Documenter, Simuler, et Construire des API plus rapidement et ensemble.

button

Vous pouvez vous inscrire pour un compte gratuit, essayer l'interface web ou télécharger l'application de bureau pour tester vos API nouvellement créées.

Pour vous aider à comprendre comment utiliser Apidog, voici un guide bien écrit. Pour sauter la longue discussion et la lecture, vous pouvez parcourir cette section - c'est la plus importante pour nous maintenant.

Si vous avez suivi le guide ci-dessus, vous devriez être familier avec Apidog dans une large mesure.

Appuyez sur la requête depuis la page du projet, et vous pourrez tester l'API que nous avons créée à partir du serveur de Fastify.

Comme vous pouvez le voir sur la capture d'écran ci-dessus, vous devrez définir la méthode HTTP sur POST, entrer la bonne URL (assurez-vous que votre serveur est toujours en cours d'exécution) et entrer votre charge utile du corps.

Suivre correctement les étapes ci-dessus vous donnera alors un code de réponse 200, et vous pourrez voir la réponse.

Si tout se passe bien pour vous, vous devriez obtenir la même réponse que moi.

Middleware et plugins

Introduction au middleware dans Fastify

Les fonctions de middleware dans Fastify sont des fonctions qui ont accès aux objets de requête et de réponse et peuvent effectuer des tâches telles que la journalisation, l'authentification, l'analyse des données, etc., avant de passer le contrôle à la fonction de middleware suivante ou au gestionnaire de route. Les fonctions de middleware sont exécutées dans l'ordre dans lequel elles sont ajoutées au pipeline de l'application.

Création de fonctions de middleware personnalisées

Vous pouvez créer des fonctions de middleware personnalisées dans Fastify en définissant des fonctions qui acceptent les paramètres request, reply et next. Voici un exemple de middleware de journalisation personnalisé :

// Custom logging middleware
const loggerMiddleware = async (request, reply, next) => {
  console.log(`[${new Date().toISOString()}] ${request.method} ${request.url}`);
  next();
};

// Register middleware with Fastify
fastify.use(loggerMiddleware);

Dans cet exemple, la fonction loggerMiddleware enregistre l'horodatage, la méthode HTTP et l'URL de chaque requête entrante. Elle appelle ensuite la fonction next() pour passer le contrôle à la fonction de middleware suivante ou au gestionnaire de route.

C'est exactement ainsi que fonctionne le middleware dans Node.js et ses autres frameworks tels que Express.js.

Installation et utilisation des plugins Fastify

Fastify fournit un riche écosystème de plugins qui étendent ses fonctionnalités à diverses fins telles que l'authentification, l'intégration de bases de données, la validation, etc. Vous pouvez installer et utiliser les plugins Fastify via npm. Voici comment installer un plugin et l'enregistrer avec Fastify :

npm install fastify-auth fastify-cors

// Import required plugins
const fastifyAuth = require('fastify-auth');
const fastifyCors = require('fastify-cors');

// Register plugins with Fastify
fastify.register(fastifyAuth);
fastify.register(fastifyCors);

Dans cet exemple, nous avons installé et enregistré deux plugins : fastify-auth pour l'authentification et fastify-cors pour la prise en charge du partage de ressources multi-origines (CORS).

Mais attendez. Nous n'allons pas tester cela. Ce ne sont que des exemples montrant comment installer et exécuter des middlewares et des plugins dans Fastify.

Voici un article pour en savoir plus sur les middlewares et les plugins. Vous pouvez faire vos propres recherches et découvertes. Ne vous y trompez pas. Le middleware dans Node.js et Fastify est un sujet vaste.

Gestion des erreurs

Gestion des erreurs dans les routes Fastify

Dans Fastify, vous pouvez gérer les erreurs dans les gestionnaires de routes en lançant des erreurs ou en les renvoyant à partir de fonctions asynchrones. Fastify intercepte automatiquement ces erreurs et envoie une réponse d'erreur appropriée au client. Voici un exemple :

// Route handler with error handling
fastify.get('/error', async (request, reply) => {
  // Simulate an error
  throw new Error('Oops! Something went wrong.');
});

À partir de cet exemple, disons qu'un utilisateur navigue vers une /erreur qui n'existe pas ou autre chose, nous pouvons lancer une erreur et informer l'utilisateur de ce qui se passe.

Si vous êtes curieux (vous devriez l'être), voici un article pour en savoir plus sur les erreurs.

En tirant parti des middlewares, des plugins et des fonctionnalités de gestion des erreurs dans Fastify, vous pouvez améliorer les fonctionnalités et la fiabilité de vos applications web et de vos API. Ces fonctionnalités vous permettent de modulariser votre code, d'ajouter des composants réutilisables et de gérer les erreurs avec élégance, ce qui conduit à des applications plus maintenables et robustes.

Conclusion

Dans ce tutoriel, nous avons couvert une introduction complète à Fastify, un framework web rapide et à faible surcharge pour Node.js. Voici un récapitulatif des principaux sujets que nous avons explorés :

Introduction à Fastify : Nous avons commencé par discuter de Fastify et de ses avantages par rapport aux autres frameworks Node.js, notamment ses avantages en termes de performances, son API facile à utiliser et son riche écosystème de plugins.
Configuration de Fastify : Nous avons parcouru le processus d'installation de Fastify à l'aide de npm, d'initialisation d'un nouveau projet Fastify et d'exploration de la structure du projet. Cela a jeté les bases de la création d'applications Fastify.
Création d'un serveur simple : Nous avons démontré comment configurer un serveur Fastify de base, ajouter des routes pour gérer différentes méthodes HTTP et répondre avec des données JSON. Cela a illustré la simplicité et la flexibilité de la définition des routes et de la gestion des requêtes dans Fastify.
Middleware et plugins : Nous avons introduit le concept de middleware dans Fastify et montré comment créer des fonctions de middleware personnalisées. De plus, nous avons discuté de la façon d'étendre les fonctionnalités de Fastify avec des plugins, en les installant et en les utilisant pour ajouter des fonctionnalités telles que l'authentification et la prise en charge de CORS.
Gestion des erreurs : Nous avons abordé la gestion des erreurs dans Fastify, y compris la façon de gérer les erreurs dans les routes, d'utiliser les fonctionnalités de gestion des erreurs intégrées de Fastify et de mettre en œuvre une logique de gestion des erreurs personnalisée pour gérer les exceptions et fournir des réponses d'erreur significatives aux clients.

Grâce à ce tutoriel, vous avez acquis les connaissances nécessaires pour commencer à créer des applications web et des API avec Fastify. Vous avez appris les principales fonctionnalités de Fastify, comment gérer les requêtes et les réponses, étendre le framework avec des plugins et gérer efficacement les erreurs. Avec ces compétences, vous êtes bien équipé pour explorer les fonctionnalités plus avancées de Fastify et créer des applications web efficaces et évolutives.

Lorsque vous continuerez à travailler avec Fastify, n'oubliez pas d'explorer la vaste documentation et l'écosystème de plugins disponibles. La communauté Fastify est active et solidaire, offrant une multitude de ressources pour vous aider à améliorer vos compétences et à créer des applications robustes.

Merci d'avoir suivi ce tutoriel sur Fastify. Bon codage !

```