Comenzando con Fastify: Construyendo una API sencilla

Introducción;

Fastify es un framework web para Node.js que se centra en proporcionar una solución de alto rendimiento y bajo overhead para la construcción de aplicaciones web y APIs. Está diseñado para ser simple de usar a la vez que ofrece características potentes que lo hacen ideal para una amplia gama de casos de uso. Fastify presume de impresionantes benchmarks de velocidad y es conocido por su capacidad para manejar altas cargas de manera eficiente.

Ventajas de Fastify:

Performance: Fastify está construido con un enfoque en la velocidad, lo que lo convierte en uno de los frameworks web más rápidos disponibles para Node.js. Su bajo overhead y su arquitectura eficiente contribuyen a reducir los tiempos de respuesta y a mejorar el rendimiento general.
Schema-based Validation: Fastify proporciona soporte integrado para la validación basada en esquemas de las cargas útiles de las peticiones y respuestas. Esto permite a los desarrolladores definir expectativas claras para los datos entrantes, lo que conduce a una mayor fiabilidad y seguridad.
Extensibility: Fastify es altamente extensible, lo que permite a los desarrolladores añadir fácilmente plugins y middleware personalizados para mejorar la funcionalidad de sus aplicaciones. Esto lo hace adaptable a una amplia gama de requisitos del proyecto.
Asynchronous Support: Fastify adopta plenamente los patrones de programación asíncrona, lo que lo hace muy adecuado para manejar operaciones de E/S de manera eficiente. Aprovecha las características modernas de JavaScript como async/await para simplificar el código asíncrono.
Developer-Friendly: Con su API intuitiva y su completa documentación, Fastify pretende proporcionar una experiencia amigable para el desarrollador. Ofrece una sintaxis clara y concisa, lo que facilita su comprensión y uso tanto para principiantes como para desarrolladores experimentados.

Qué se cubrirá en este tutorial:

En este tutorial, cubriremos los conceptos básicos del uso de Fastify para construir una API simple. Comenzando con la configuración de un proyecto Fastify, exploraremos gradualmente sus características clave, incluyendo el manejo de rutas, la validación de peticiones, el middleware, el manejo de errores, las pruebas y el despliegue. Al final del tutorial, tendrás una sólida comprensión de cómo usar Fastify para crear aplicaciones web robustas y eficientes.

Prerrequisitos

Antes de empezar, asegúrate de tener instalados los siguientes prerrequisitos:

Node.js y npm: Fastify requiere que Node.js y npm estén instalados en tu sistema. Puedes descargarlos e instalarlos desde el sitio web oficial de Node.js .
Conocimientos básicos de JavaScript y Node.js: Este tutorial asume que tienes una comprensión básica de JavaScript y de cómo trabajar con Node.js. La familiaridad con conceptos como callbacks, promesas y módulos será beneficiosa a medida que exploremos las características de Fastify.

Con estos prerrequisitos en su lugar, ¡estás listo para sumergirte en la construcción con Fastify! Empecemos.

Configurando Fastify

Instalando Fastify vía npm

Para empezar con Fastify, primero tendrás que instalarlo vía npm, que es el gestor de paquetes para Node.js. Si eres fan de Yarn o Bun, también puedes intentar usarlos. Para esta guía, usaré NPM.

Y en caso de que no sepas, o entiendas completamente cómo usar NPM, puedes echar un vistazo a este tutorial sobre cómo ensuciarte las manos con él.

Para empezar, crea una nueva carpeta, digamos, en tu Escritorio o en tu directorio de trabajo donde te gustaría configurar el proyecto de Fastify.

Para hacer esto, simplemente ejecuta el siguiente código en tu terminal, paso a paso siguiéndose uno al otro

mkdir mi-proyecto-fastify
cd mi-proyecto-fastify

Ahora, has creado una carpeta y te has movido a esa carpeta desde tu terminal. ¡Buen trabajo!

A continuación, inicializa npm para ese proyecto, e instala el framework Fastify.

npm init -y
npm install fastify

En este punto, tu proyecto consiste sólo en los archivos package.json, package-lock.json, & node_moudles, que contienen metadatos sobre tu proyecto y sus dependencias. A medida que continuemos construyendo nuestra aplicación Fastify, añadiremos más archivos y directorios a esta estructura.

Creando un Servidor Simple

Configurando un servidor Fastify básico

Ahora que tenemos nuestro proyecto configurado, vamos a crear un servidor Fastify simple. Crea un nuevo archivo llamado index.js en el directorio de tu proyecto y añade el siguiente código:

// Importa el módulo Fastify
const fastify = require('fastify')();

// Define un manejador de ruta para la URL raíz
fastify.get('/', async (request, reply) => {
  return { hello: 'world' };
});

// Inicia el servidor
const start = async () => {
  try {
    await fastify.listen({ port: 3000 });
    console.log('El servidor está corriendo en http://localhost:3000');
  } catch (error) {
    console.error('Error al iniciar el servidor:', error);
    process.exit(1);
  }
};

start();

Este código configura un servidor Fastify básico que escucha las peticiones HTTP entrantes en el puerto 3000. Cuando se hace una petición a la URL raíz (/), responde con un objeto JSON que contiene el mensaje "hello": "world".

Para que el siguiente código funcione, necesitamos decirle que se ejecute. ¿Cómo podemos hacerlo? Bueno, podemos ejecutar node index.js en nuestra terminal en la carpeta raíz del proyecto y funcionará.

Pero eso significaría que tendríamos que ejecutar ese comando cada vez que hagamos una actualización del archivo. No queremos ese estrés. Deberíamos ser capaces de guardar el archivo, y automáticamente disparar la reconstrucción. ¿Cómo podemos hacer eso?
Bueno, ahí viene Nodemon.

Para instalar Nodemon, simplemente ejecuta el siguiente código en la terminal;
npm install nodemon --save-dev.
Eso instalará Nodemon y podremos centrarnos en nuestro código y no pedirle manualmente que se reconstruya.

Pero aún no hemos terminado con Nodemon. Prometo que esta es la última pieza de código que configuraremos para Nodemon. ¿Qué necesitamos hacer? Necesitamos decirle que se dispare automáticamente cada vez que guardemos un archivo. ¿Cómo hacemos esto?

Abre tu archivo package.json, y reemplaza la sección script con el siguiente código:

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

¡Y ahí lo tenemos! Hemos terminado con la configuración de Nodemon, ¡lo prometo!

Ahora para iniciar nuestro servidor, necesitamos ejecutar npm run dev en el directorio raíz de nuestro proyecto. Una vez que hayas hecho eso, navega a tu navegador y escribe http://localhost:3000/ - verás nuestra respuesta de ejemplo hello world como definimos en nuestro archivo index.js arriba.

Una página mostrando el texto "Hello World" de la salida del servidor.

Añadiendo rutas para manejar diferentes métodos HTTP (GET, POST, etc.)

Fastify facilita la construcción de APIs REST / definir rutas para manejar diferentes métodos HTTP como GET, POST, PUT, DELETE, etc. Vamos a añadir una ruta para manejar una petición POST. Actualiza tu archivo index.js con el siguiente código:

// Define un manejador de ruta para manejar peticiones POST a '/data'
fastify.post('/data', async (request, reply) => {
  const payload = request.body;
  // Procesa los datos entrantes
  // Por ahora, vamos a devolver los datos recibidos
  return { receivedData: payload };
});

Ahora, nuestro servidor Fastify puede manejar tanto peticiones GET a la URL raíz (/) como peticiones POST al endpoint /data.

Respondiendo con datos JSON

En ambos manejadores de ruta que hemos definido ('/' y '/data'), estamos respondiendo con datos JSON usando los métodos de respuesta incorporados de Fastify. Fastify serializa automáticamente los objetos JavaScript a JSON, lo que facilita el envío de datos estructurados como respuestas.

Con estas adiciones, nuestro servidor Fastify es ahora capaz de manejar peticiones HTTP básicas y responder con datos JSON.

Pero, ¿cómo probamos la petición POST? No podemos probar una petición POST desde el navegador, ¿verdad?
Para ayudarnos, usaremos Apidog.

💡

Apidog es una herramienta de gestión de APIs que podemos usar para Diseñar, Depurar, Probar, Documentar, Mock, y Construir APIs más Rápido & Juntos.

button

Puedes registrarte para obtener una cuenta gratuita, probar la interfaz web o descargar la aplicación de escritorio para probar tus APIs recién creadas.

Para ayudarte a entender cómo usar Apidog, aquí tienes una guía bien escrita. Para saltarte la larga charla y la lectura, puedes escanear esta sección - esta es la más importante para nosotros ahora.

Si has seguido la guía anterior, deberías estar familiarizado con Apidog en gran medida.

Página de Apidog para iniciar una Petición

Pulsa en la petición desde la página del proyecto, y podrás probar la API que creamos desde el servidor de Fastify.

Como puedes ver en la captura de pantalla de arriba, necesitarás establecer el método HTTP a POST, introducir la URL correcta (asegúrate de que tu servidor sigue funcionando), e introducir tu carga útil del cuerpo.

Siguiendo los pasos anteriores correctamente te dará entonces un código de respuesta 200, y podrás ver la respuesta.

Si todo te sale bien, deberías obtener la misma respuesta que yo.

Middleware y Plugins

Introducción al Middleware en Fastify

Las funciones de Middleware en Fastify son funciones que tienen acceso a los objetos de petición y respuesta y pueden realizar tareas como el registro, la autenticación, el análisis de datos, etc., antes de pasar el control a la siguiente función de middleware o manejador de ruta. Las funciones de Middleware se ejecutan en el orden en que se añaden a la pipeline de la aplicación.

Creando Funciones de Middleware Personalizadas

Puedes crear funciones de middleware personalizadas en Fastify definiendo funciones que acepten los parámetros request, reply, y next. Aquí tienes un ejemplo de un middleware de registro personalizado:

// Middleware de registro personalizado
const loggerMiddleware = async (request, reply, next) => {
  console.log(`[${new Date().toISOString()}] ${request.method} ${request.url}`);
  next();
};

// Registra el middleware con Fastify
fastify.use(loggerMiddleware);

En este ejemplo, la función loggerMiddleware registra la marca de tiempo, el método HTTP, y la URL de cada petición entrante. Luego llama a la función next() para pasar el control a la siguiente función de middleware o manejador de ruta.

Así es como funciona el Middleware completamente en Node.js y su otro framework como Express.js.

Instalando y Usando Plugins de Fastify

Fastify proporciona un rico ecosistema de plugins que extienden su funcionalidad para varios propósitos como la autenticación, la integración de bases de datos, la validación, etc. Puedes instalar y usar plugins de Fastify vía npm. Aquí tienes cómo instalar un plugin y registrarlo con Fastify:

npm install fastify-auth fastify-cors

// Importa los plugins requeridos
const fastifyAuth = require('fastify-auth');
const fastifyCors = require('fastify-cors');

// Registra los plugins con Fastify
fastify.register(fastifyAuth);
fastify.register(fastifyCors);

En este ejemplo, hemos instalado y registrado dos plugins: fastify-auth para la autenticación y fastify-cors para el soporte de Cross-Origin Resource Sharing (CORS).

Pero espera. No vamos a probar esto. Esos son sólo ejemplos que muestran cómo instalar y ejecutar middleware y plugins en Fastify.

Aquí tienes un artículo para aprender más sobre middleware y plugins. Puedes hacer tu propia investigación y hallazgos. Sólo no lo confundas. El middleware en Node.js y Fastify es un tema amplio.

Manejo de Errores

Manejando Errores en Rutas de Fastify

En Fastify, puedes manejar errores en los manejadores de ruta lanzando errores o devolviéndolos desde funciones asíncronas. Fastify automáticamente captura estos errores y envía una respuesta de error apropiada al cliente. Aquí tienes un ejemplo:

// Manejador de ruta con manejo de errores
fastify.get('/error', async (request, reply) => {
  // Simula un error
  throw new Error('¡Oops! Algo salió mal.');
});

De ese ejemplo, digamos que un usuario navega a un /error que no existe o algo más, podemos lanzar un error y hacerle saber al usuario lo que está pasando.

Si tienes curiosidad (deberías tenerla), aquí tienes un artículo para aprender más sobre Errores.

Aprovechando el middleware, los plugins y las características de manejo de errores en Fastify, puedes mejorar la funcionalidad y la fiabilidad de tus aplicaciones web y APIs. Estas características te permiten modularizar tu código, añadir componentes reutilizables y manejar los errores con elegancia, lo que conduce a aplicaciones más mantenibles y robustas.

Conclusión

En este tutorial, hemos cubierto una introducción completa a Fastify, un framework web rápido y de bajo overhead para Node.js. Aquí tienes un resumen de los temas clave que hemos explorado:

Introducción a Fastify: Comenzamos discutiendo Fastify y sus ventajas sobre otros frameworks de Node.js, incluyendo sus beneficios de rendimiento, su API fácil de usar y su rico ecosistema de plugins.
Configurando Fastify: Recorrimos el proceso de instalación de Fastify usando npm, inicializando un nuevo proyecto Fastify, y explorando la estructura del proyecto. Esto sentó las bases para la construcción de aplicaciones Fastify.
Creando un Servidor Simple: Demostramos cómo configurar un servidor Fastify básico, añadir rutas para manejar diferentes métodos HTTP, y responder con datos JSON. Esto ilustró la simplicidad y la flexibilidad de la definición de rutas y el manejo de peticiones en Fastify.
Middleware y Plugins: Introdujimos el concepto de middleware en Fastify y mostramos cómo crear funciones de middleware personalizadas. Además, discutimos cómo extender la funcionalidad de Fastify con plugins, instalándolos y usándolos para añadir características como la autenticación y el soporte de CORS.
Manejo de Errores: Cubrimos el manejo de errores en Fastify, incluyendo cómo manejar errores en las rutas, usar las características de manejo de errores incorporadas de Fastify, e implementar lógica de manejo de errores personalizada para gestionar excepciones y proporcionar respuestas de error significativas a los clientes.

A través de este tutorial, has adquirido el conocimiento para empezar a construir aplicaciones web y APIs con Fastify. Has aprendido sobre las características principales de Fastify, cómo manejar peticiones y respuestas, extender el framework con plugins, y gestionar los errores de manera efectiva. Con estas habilidades, estás bien equipado para explorar características más avanzadas de Fastify y crear aplicaciones web eficientes y escalables.

A medida que continúes trabajando con Fastify, recuerda explorar la extensa documentación y el ecosistema de plugins disponible. La comunidad de Fastify es activa y de apoyo, ofreciendo una gran cantidad de recursos para ayudarte a avanzar en tus habilidades y construir aplicaciones robustas.

Gracias por seguir este tutorial sobre Fastify. ¡Feliz codificación!