Vamos a aprender a documentar una API REST creada en Node.js utilizando las herramientas Swagger Autogen y Swagger UI Express. Además, exploraremos las ventajas que estas herramientas ofrecen para facilitar el desarrollo y el consumo de APIs.

¿Qué es Swagger?

Swagger es un conjunto de herramientas para definir y documentar APIs REST bajo el estándar OpenAPI. Es importante destacar que Swagger no está ligado a un lenguaje de programación específico, sino que su objetivo principal es describir de manera clara cómo interactuar con los servicios de una API. Con Swagger, es posible crear documentación interactiva que permite a los desarrolladores explorar y probar los endpoints directamente desde el navegador.

Nota: Aunque Swagger facilita la visualización y uso de la documentación, no genera automáticamente el archivo de especificación de la API. Este trabajo es realizado por herramientas como Swagger Autogen, que automatiza la creación de dicho archivo JSON o YAML.

Ventajas de usar Swagger y Swagger Autogen

1. Automatización del proceso de documentación
   Con Swagger Autogen, puedes generar el archivo de especificación a partir de tu código, reduciendo la carga manual y garantizando que siempre esté actualizado.
2. Interfaz interactiva con Swagger UI Express
   La integración con Swagger UI Express permite visualizar y probar los endpoints de manera fácil y amigable.
3. Estandarización y compatibilidad
   Al seguir el estándar OpenAPI, las APIs documentadas con Swagger son fácilmente entendibles por otros desarrolladores y herramientas.
4. Reducción de Errores y Mejor Colaboración
   La sincronización entre código y documentación minimiza malentendidos y agiliza la colaboración entre equipos.
5. Experiencia mejorada para consumidores
   Los desarrolladores que consumen tu API pueden integrarse más rápido gracias a la claridad y accesibilidad de la documentación.

Cómo documentar tu API REST con Swagger Autogen y Swagger UI Express

1. Preparación del proyecto

Inicia un proyecto Node.js
Si aún no tienes un proyecto, inicialízalo con:

npm init -y

Instala las dependencias necesarias
Usa los siguientes comandos para instalar las herramientas requeridas:

npm install swagger-ui-express npm install --save-dev swagger-autogen

2. Configuración de Swagger Autogen

Crea el Archivo de Configuración
Añade un archivo swagger.js en el directorio raíz con el siguiente contenido:

const swaggerAutogen = require('swagger-autogen')();

const doc = {
    info: {
        title: 'API de Mascotas',
        description: 'Documentación de la API para la gestión de mascotas',
    },
    host: 'localhost:3000',
    schemes: ['http'],
};

const outputFile = './swagger_output.json';
const endpointsFiles = ['./index.js']; // Cambia este archivo según el punto de entrada de tu API

swaggerAutogen(outputFile, endpointsFiles).then(() => {
    require('./index'); // Inicia el servidor automáticamente
});

En el script anterior, importamos el paquete swagger-autogen y definimos las configuraciones necesarias para realizar la construcción del archivo .json necesario para mostrar la documentación.

Ejecuta el script de generación
Ejecuta el siguiente comando para generar el archivo JSON de especificación:bashCopiar códigonode swagger.js

Esto creará un archivo llamado swagger_output.json que contiene la descripción de los endpoints de tu API. Este archivo será usado por el paquete swagger-ui-express.

3. Integración con Swagger UI Express

Configura la ruta de documentación
Modifica el archivo principal de tu API (index.js) para incluir el middleware de Swagger UI Express:

const express = require('express');
const swaggerUi = require('swagger-ui-express');
const swaggerFile = require('./swagger_output.json');

const app = express();

app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerFile));

app.listen(3000, () => {
    console.log('Servidor corriendo en http://localhost:3000');
});

1. Accede a la documentación
   Inicia tu servidor y abre un navegador en http://localhost:3000/api-docs para explorar los endpoints de tu API a través de la interfaz interactiva.

Swagger Autogen, hace una lectura del código, luego lo verifica y a partir del él va a generar todo lo necesario.

Importante cuando uses métodos que requieren o usan el payload (req.body) haz la desestructuración que swagger autogen, va a incluir esta definición en la llamada o uso del endpoint respectivo.

Si deseas personalizar o complementar la documentación, puedes agregar comentarios en el controller de forma que swagger autogen los tome en cuenta.  

Ejemplo de código documentado

El uso de comentarios en tus controladores puede mejorar la documentación generada. Por ejemplo:

/**
 * @route GET /pets
 * @description Obtiene una lista de mascotas
 * @response 200 - Lista de mascotas
 */
app.get('/pets', (req, res) => {
    res.send([{ id: 1, name: 'Fido' }, { id: 2, name: 'Luna' }]);
});

Swagger Autogen extraerá estos comentarios para enriquecer la especificación de tu API.

El uso de Swagger Autogen y Swagger UI Express transforma la documentación de APIs REST en un proceso eficiente y profesional. Estas herramientas no solo automatizan tareas tediosas, sino que también proporcionan una experiencia superior para los consumidores de la API, quienes pueden explorar y probar los servicios de manera intuitiva.

Implementar Swagger en tus proyectos garantiza una documentación clara, estandarizada y accesible, facilitando la colaboración entre equipos y mejorando la percepción de calidad de tu API.

En este contenido, realizamos la implementación de la documentación de una API real, donde hacemos el paso a paso y obtenemos el swagger a partir de la ejecución de lo descrito anteriormente.

React es una librería popular de Front-end que los desarrolladores usan para crear aplicaciones. Si quieres crear aplicaciones listas para poner en producción seguramente vas a necesitar saber integrar APIs a tu aplicación de React en algún momento de tu carrera.

Cada desarrollador que quiera construir aplicaciones web robustas y modernas con React tiene que saber cómo consumir APIs para traer información a su aplicación de React.

En esta guía para principiantes, vamos a aprender como consumir una API RESTful en React trayendo, borrando o agregando información.  También veremos dos formas de consumir APIs RESTful y cómo usarla con React Hooks.

Aquí tienes un scrim interactivo sobre cómo consumir APIs REST en React:

¿Qué es una API REST?

Si alguna vez haz pasado tiempo programando o investigando sobre programación, seguramente te haz cruzado con el término "API".

API significa "Interfaz de Programación de Aplicación", por sus siglas en inglés. Es un medio que permite la comunicación programática entre diferentes aplicaciones y que devuelve una respuesta en tiempo real.

En los 2000, Roy Fielding definió el concepto REST como un estilo de arquitectura y metodología usado frecuentemente en el desarrollo de servicios de internet, como, por ejemplo, los sistemas de hipermedia distribuidos. Es un acrónimo que significa, en inglés, Transferencia de Estado Representacional.

Cuando se hace una petición a través de una API REST, ésta envía, al peticionante o a un endpoint, una representación del estado actual del recurso. Esta representación del estado puede tomar la forma de archivo JSON (JavaScript Object Notation), XML, o HTML.

JSON es el formato de archivo más usado porque no depende de ningún lenguaje de programación y puede ser leído tanto por personas como por computadoras.

Por ejemplo:

[
   {
      "userId": 1,
      "id": 1,
      "title": "sunt excepturi",
      "body": "quia et suscipit\nsuscipit recusandae consequuntur "
   },
   {
      "userId": 1,
      "id": 2,
      "title": "qui est esse",
      "body": "est rerum tempore vitae\nsequi sint nihil"
   }
]

Cómo consumir APIs REST en React

Es posible consumir APIs REST dentro de una aplicación React de distintas maneras, pero en esta guía veremos dos de las formas más populares: Axios (un cliente HTTP basado en promesas) y Fetch API (una API web ya incluida en el navegador).

Nota: Para poder comprender esta guía en su totalidad, deberías saber JavaScript, React y React Hooks, ya que son conocimientos que vamos a usar aquí.

Antes de explicar cómo consumir APIs, es importante entender que consumir APIs en React es muy diferente de como se lo hace en JavaScript. Esto es porque estas peticiones ahora se hacen en un componente de React.

En nuestro caso, vamos a usar componentes funcionales, lo que significa que vamos a necesitar 2 Hooks de React importantes:

• Hook useEffect: En React, las peticiones a las API se hacen dentro del hook useEffect(). El hook muestra la información cuando la aplicación es montada o después de se alcanza un estado específico. Esta es la sintaxis general que vamos a usar:

useEffect(() => {
    // data fetching here
}, []);

• Hook useState: Al pedir información, debemos crear un estado en el cual se va a guardar el resultado de la petición. También lo podemos guardar en un herramienta de administración de estado como Redux o en un objeto de contexto. Para hacerlo más simple, vamos a guardar el resultado de la petición en el estado local de React.

const [posts, setPosts] = useState([]);

Vamos a meternos en la parte jugosa de esta guía, donde aprenderemos como obtener, agregar, y borrar información usando la API JSONPlaceholder. Este conocimiento es aplicable a cualquier tipo de API, ya que esta guía está orientada a principiantes.

Cómo consumir APIs con la Fetch API

La Fetch API es un método JavaScript para obtener recursos de un servidor o de un endpoint de una API. Como ya viene incluida en el navegador, no es necesario instalar dependencias o paquetes.

El método fetch() requiere de un argumento obligatorio que es la URL o dirección al recurso que queremos obtener. Luego, este se convierte en una promesa para que podamos manejar su éxito o error a través de los métodos then() y catch().

Una petición fetch básica es muy simple de escribir y se parece al código de abajo. Lo que estamos haciendo es simplemente obtener información desde una URL que devuelve esa información como un JSON y luego mostrándola en la consola:

fetch('https://jsonplaceholder.typicode.com/posts?_limit=10')
   .then(response => response.json())
   .then(data => console.log(data));

La respuesta por defecto es una respuesta HTTP estándar más que un JSON, pero podemos ver la información como un objeto JSON al usar el método json() incluida en la respuesta.

Cómo realizar una petición GET en React con Fetch API

Es posible usar el método HTTP GET para obtener información desde un endpoint.

Como dijimos antes, Fetch API solo acepta un argumento obligatorio, lo cual es cierto. También acepta un argumento option, el cual es opcional, específicamente cuando se usa el método GET, el cual es el método predeterminado. Pero para los otros métodos como POST y DELETE, es necesario usar el método con un arreglo:

fetch(url, {
    method: "GET" // default, so we can ignore
})

Hasta el momento aprendimos cómo funcionan las cosas, ahora vamos a poner todo lo que aprendimos junto y hacer una petición get para obtener información de nuestra API.

De nuevo, volvemos a usar la API gratuita JSONPlaceholder para obtener una lista de posts dentro de nuestra aplicación:

import React, { useState, useEffect } from 'react';

const App = () => {
   const [posts, setPosts] = useState([]);
   useEffect(() => {
      fetch('https://jsonplaceholder.typicode.com/posts?_limit=10')
         .then((response) => response.json())
         .then((data) => {
            console.log(data);
            setPosts(data);
         })
         .catch((err) => {
            console.log(err.message);
         });
   }, []);

return (
   // ... consume here
);
};

Creamos un estado en el código anterior para guardar la información que obtuvimos de la API así la podemos usar después en nuestra aplicación. También podemos establecer el valor predeterminado a un arreglo vacío.

const [posts, setPosts] = useState([]);

Como la parte más importante de then() ocurrió en el hook useState, la información/los posteos se obtienen apenas carga la aplicación. La petición fetch produce una promesa que puede ser aceptada o rechazada:

useEffect(() => {
   fetch('https://jsonplaceholder.typicode.com/posts?_limit=10').then(
      (response) => console.log(response)
   );
}, []);

Esta respuesta contiene una gran cantidad de información, como el código de estado, texto, y otra información que vamos a necesitar después para manejar los errores.

Hasta ahora, hemos manejado la resolución de una promesa con .then(), pero nos devolvió un objeto como respuesta que no es lo que queremos. Por esos, necesitamos transformar el objeto respuesta al formato JSON con el método .then(). Esto también nos devuelve una promesa para que podamos obtener la información usando el segundo .then().

useEffect(() => {
   fetch('https://jsonplaceholder.typicode.com/posts?_limit=10')
      .then((response) => response.json())
      .then((data) => {
         console.log(data);
         setPosts(data);
      });
}, []);

Si miramos la consola, vamos a ver que obtuvimos 10 posts de nuestra API, lo que también especificamos anteriormente en el estado.

Esto no está completo porque solamente estuvimos manejando la resolución favorable de la promesa pero no su rechazo, lo cual haremos con el método .catch():

useEffect(() => {
   fetch('https://jsonplaceholder.typicode.com/posts?_limit=10')
      .then((response) => response.json())
      .then((data) => {
         console.log(data);
         setPosts(data);
      })
      .catch((err) => {
         console.log(err.message);
      });
}, []);

Hasta ahora vimos como hacer una petición GET. Esta puede ser consumida dentro de nuestra aplicación, a través de un bucle que recorra nuestro arreglo:

const App = () => {
// ...

   return (
   <div className="posts-container">
      {posts.map((post) => {
         return (
            <div className="post-card" key={post.id}>
               <h2 className="post-title">{post.title}</h2>
               <p className="post-body">{post.body}</p>
               <div className="button">
               <div className="delete-btn">Delete</div>
               </div>
            </div>
         );
      })}
   </div>
   );
};

export default App;

Cómo realizar una petición POST en React con Fetch API

Es posible usar el método HTTP POST para enviar información a un endpoint. Funciona de manera similar a la petición GET, la única diferencia está en que es necesario agregar el método y dos parámetros adicionales al objeto opcional:

const addPosts = async (title, body) => {
await fetch('https://jsonplaceholder.typicode.com/posts', {
method: 'POST',
body: JSON.stringify({
   title: title,
   body: body,
   userId: Math.random().toString(36).slice(2),
}),
headers: {
   'Content-type': 'application/json; charset=UTF-8',
},
})
.then((response) => response.json())
.then((data) => {
   setPosts((posts) => [data, ...posts]);
   setTitle('');
   setBody('');
})
.catch((err) => {
   console.log(err.message);
});
};

Los dos parámetros que pueden parecer extraños son el body (cuerpo) y el header (encabezado).

En el body va a estar toda la información que queremos enviar a la API, la cual primero debemos convertir en una cadena de texto porque estamos enviando información al navegador. El header nos dice el tipo de información, que es siempre el mismo cuando consumimos APIs REST. También creamos el estado que va a guardar ésta nueva información y distribuir la información restante por el arreglo.

Si miramos el método addPost() que creamos, va a necesitar que esa información venga de un formulario o de otro lado. En nuestro caso, hice un formulario, obtuve la información mediante estados. Al enviar el formulario, la información es incluida en el método:

import React, { useState, useEffect } from 'react';
const App = () => {
const [title, setTitle] = useState('');
const [body, setBody] = useState('');
// ...
const addPosts = async (title, body) => {
   await fetch('https://jsonplaceholder.typicode.com/posts', {
      method: 'POST',
      body: JSON.stringify({
         title: title,
         body: body,
         userId: Math.random().toString(36).slice(2),
      }),
      headers: {
         'Content-type': 'application/json; charset=UTF-8',
      },
   })
      .then((response) => response.json())
      .then((data) => {
         setPosts((posts) => [data, ...posts]);
         setTitle('');
         setBody('');
      })
      .catch((err) => {
         console.log(err.message);
      });
};

const handleSubmit = (e) => {
   e.preventDefault();
   addPosts(title, body);
};    

return (
   <div className="app">
      <div className="add-post-container">
         <form onSubmit={handleSubmit}>
            <input type="text" className="form-control" value={title}
               onChange={(e) => setTitle(e.target.value)}
            />
            <textarea name="" className="form-control" id="" cols="10" rows="8" 
               value={body} onChange={(e) => setBody(e.target.value)} 
            ></textarea>
            <button type="submit">Add Post</button>
         </form>
      </div>
      {/* ... */}
   </div>
);
};

export default App;

Cómo realizar una petición DELETE en React con Fetch API

Es posible usar el método HTTP DELETE para eliminar información de un endpoint. También funciona de forma similar a la petición GET, la principal diferencia radica en que tenemos que agregar el método:

const deletePost = async (id) => {
await fetch(`https://jsonplaceholder.typicode.com/posts/${id}`, {
   method: 'DELETE',
}).then((response) => {
   if (response.status === 200) {
      setPosts(
         posts.filter((post) => {
            return post.id !== id;
         })
      );
   } else {
      return;
   }
});
};

Este código se dispara al hacer click en el botón. De esta manera, obtenemos el id del post específico en el cual se hizo click.

Este método hace que se elimine la información del resultado devuelto. Esto permite que la información sea borrada de la API, pero no inmediatamente de la UI y por eso necesitamos agregar un filtro que elimine la información también de ahí. Para cada ítem del bucle, tú botón de borrar debería lucir así:

const App = () => {
// ...

   return (
   <div className="posts-container">
      {posts.map((post) => {
         return (
            <div className="post-card" key={post.id}>
               {/* ... */}
               <div className="button">
                  <div className="delete-btn" onClick={() => deletePost(post.id)}>
                     Delete
                  </div>
               </div>    
            </div>
         );
      })}
   </div>
   );
};

export default App;

Cómo usar Async/Await en Fetch API

Hasta ahora vimos como hacer peticiones fetch usando la sintaxis de las promesas, que puede ser confusa a veces. Y después, el encadenamiento con .then(). Podemos evitar el encadenamiento usando Async/await y así escribir código más legible.

Para usar async/awaiy, primero hay que escribir async en la función. Después, al hacer una petición y esperar un respuesta, hay que agregar la sintaxis await delante de la función para esperar a que la promesa devuelva el resultado.

Cuando usamos async/await, todas las peticiones Fetch se ven así:

import React, { useState, useEffect } from 'react';

const App = () => {
   const [title, setTitle] = useState('');
   const [body, setBody] = useState('');
   const [posts, setPosts] = useState([]);

   // GET with fetch API
   useEffect(() => {
      const fetchPost = async () => {
         const response = await fetch(
            'https://jsonplaceholder.typicode.com/posts?_limit=10'
         );
         const data = await response.json();
         console.log(data);
         setPosts(data);
      };
      fetchPost();
   }, []);

   // Delete with fetchAPI
   const deletePost = async (id) => {
      let response = await fetch(
         `https://jsonplaceholder.typicode.com/posts/${id}`,
         {
            method: 'DELETE',
         }
      );
      if (response.status === 200) {
         setPosts(
            posts.filter((post) => {
               return post.id !== id;
            })
         );
      } else {
         return;
      }
   };

   // Post with fetchAPI
   const addPosts = async (title, body) => {
      let response = await fetch('https://jsonplaceholder.typicode.com/posts', {
         method: 'POST',
         body: JSON.stringify({
            title: title,
            body: body,
            userId: Math.random().toString(36).slice(2),
         }),
         headers: {
            'Content-type': 'application/json; charset=UTF-8',
         },
      });
      let data = await response.json();
      setPosts((posts) => [data, ...posts]);
      setTitle('');
      setBody('');
   };

   const handleSubmit = (e) => {
      e.preventDefault();
      addPosts(title, body);
   };

   return (
      // ...
   );
};

export default App;

Aquí tienes un scrim interactivo para guiarte:

Cómo manejar errores con Fetch API

En esta sección, vamos a ver como manejar error de manera tradicional y con async/await.

Para manejar los errores con Fetch API, podemos usar la misma información de la respuesta o usar la sentencia try/catch si usamos async/await.

Primero veamos cómo podemos hacerlo con Fetch API:

const fetchPost = () => {
fetch('https://jsonplaceholder.typicode.com/posts?_limit=10')
   .then((response) => {
      if (!response.ok) {
         throw Error(response.statusText);
      }
      return response.json();
   })
   .then((data) => {
      console.log(data);
      setPosts(data);
   })
   .catch((err) => {
      console.log(err.message);
   });
};

Aquí (en inglés) puedes leer más sobre errores en Fetch API.

Para async/await podemos usar  try y catch de esta forma:

const fetchPost = async () => {
   try {
      const response = await fetch(
         'https://jsonplaceholder.typicode.com/posts?_limit=10'
      );
      const data = await response.json();
      setPosts(data);
   } catch (error) {
      console.log(error);
   }
};

Cómo consumir APIs con Axios:

Axios es un  cliente HTTP basado en promesas que hace más simple el envío de peticiones HTTP asíncronas a endpoints REST. El endpoint en nuestro caso la API de posts de JSONPlaceholder, a la cual haremos peticiones  GET, POST, y DELETE.

Aquí tienes un scrim interactivo que te guiará por los distintos pasos mientras lees:

Cómo instalar y configurar Axios

A diferencia de Fetch API, Axios no viene incluido en el navegador por lo que necesitamos instalarlo en nuestro proyecto para poder utilizarlo.

Para poder instalar Axios en tu proyecto necesitas correr el siguiente comando:

npm install axios

Una vez que lo instalamos correctamente, podemos crear una instancia, lo cual es opcional pero recomendable ya que nos evita repeticiones innecesarias.

Para crear una instancia, usamos el método .create(), que podemos usarlo para especificar información como la URL y posibles encabezados:

import axios from "axios";

const client = axios.create({
   baseURL: "https://jsonplaceholder.typicode.com/posts" 
});

Cómo realizar una petición GET en React con Axios

Usaremos la instancia que creamos anterior para realizar la petición GET. Todo lo que necesitamos es establecer parámetros, si los hay, y obtener la respuesta como un JSON por defecto.

A diferencia del método Fetch API, no se necesita una option para declarar el método. Solamente agregamos el método a la instancia y hacemos la petición.

useEffect(() => {
   client.get('?_limit=10').then((response) => {
      setPosts(response.data);
   });
}, []);

Cómo hacer una petición POST en React con Axios

Como dijimos antes, se puede usar el método POST para enviar información a un endpoint. Funciona de manera similar a la petición  GET, siendo la principal diferencia el requesito de incluir el método y una option para guardar la información que estamos enviando:

const addPosts = (title, body) => {
   client
      .post('', {
         title: title,
         body: body,
      })
      .then((response) => {
         setPosts((posts) => [response.data, ...posts]);
      });
};

Cómo hacer una petición DELETE en React con Axios

Podemos hacer peticiones delete con el método delete, el cual obtiene el id  y lo borra de la API. También usaremos el método filter para borrarlo de la UI, como lo hicimos con el método Fetch API:

const deletePost = (id) => {
   client.delete(`${id}`);
   setPosts(
      posts.filter((post) => {
         return post.id !== id;
      })
   );
};

Cómo usar Async/Await en Axios

Hasta ahora hemos visto con hacer peticiones con Axios usando la sintaxis para promesas. Pero ahora veamos cómo usar async/await para escribir menos código y evitar el encadenamiento con .then()

Cuando usemos async/await, todas nuestras peticiones Axios se verán así:

import React, { useState, useEffect } from 'react';

const App = () => {
   const [title, setTitle] = useState('');
   const [body, setBody] = useState('');
   const [posts, setPosts] = useState([]);

   // GET with Axios
   useEffect(() => {
      const fetchPost = async () => {
         let response = await client.get('?_limit=10');
         setPosts(response.data);
      };
      fetchPost();
   }, []);

   // Delete with Axios
   const deletePost = async (id) => {
      await client.delete(`${id}`);
      setPosts(
         posts.filter((post) => {
            return post.id !== id;
         })
      );
   };

   // Post with Axios
   const addPosts = async (title, body) => {
      let response = await client.post('', {
         title: title,
         body: body,
      });
      setPosts((posts) => [response.data, ...posts]);
   };

   const handleSubmit = (e) => {
      e.preventDefault();
      addPosts(title, body);
   };

   return (
      // ...
   );
};

export default App;

Cómo manejar errores con Axios

Para peticiones con Axios basadas en promesas, podemos usar los métodos .then() y .catch () , pero para async/awit, podemos usar el bloque try...catch. Esto es muy similar a como lo implementamos en Fetch API.
El bloque try...catch se verá así:

const fetchPost = async () => {
   try {
      let response = await client.get('?_limit=10');
      setPosts(response.data);
   } catch (error) {
      console.log(error);
   }
};

Aquí (en inglés) puedes leer más sobre como manejar errores en Axios.

Fetch API vs Axios

Quizás hayas notado algunas diferencias, pero vamos a ponerlas en un tabla así podemos comparar Fetch y Axios.

Estas distinciones le ayudarán a decidir qué método utilizar para un proyecto concreto. Entre estas distinciones se encuentran:

Conclusión

En esta guía aprendimos a consumir APIs REST en React con Fetch API y Axios.

Esto te ayudará a empezar a consumir API en React, y desde ahí podrás consumir información de manera más complejas y manipular APIs de la manera que quieras.

¡Embárcate en un viaje de aprendizaje! Explora más de 200 artículos escritos por expertos en desarrollo web. Pégale un vistazo a mí blog (en inglés) con contenido interesante escrito por mí.

Si deseas profundizar en cuanto a como funciona una API REST, sus elementos y particularidades, puedes consultar este artículo de freecodecamp.org, que describe de forma detallada los conceptos anteriormente mencionados.

Cuando construimos una API REST, debemos identificar que datos para gestionar, en nuestro caso, vamos a tomar como ejemplo un sistema de gestión de tickets, que tendría un modelo de datos similar al que vemos en el siguiente diagrama:

Tomando en cuenta lo indicado, a partir del modelo entidad-relación anterior, es importante identificar los elementos que van a actuar como componentes de nuestra API REST.

Elementos componentes de una API REST

Vamos a identificar 3 componentes principales en la construcción de una API REST, estos son:

• Modelos, que serán las representación de las entidades que iremos a gestionar en la API, es la abstracción de los datos del mundo real al mundo digital.
• Controladores, responsables de implementar las operaciones a realizar sobre los modelos, a veces denominada capa de lógica de negocios.
• Rutas, definiciones de como nuestra API puede interactuar con el mundo exterior, es decir a través de las rutas definimos la comunicación entre la implementación que vamos a realizar con los servicios o herramientas que irán a consumir lo que realicemos.

Para construir esta API vamos a usar NodeJS, que es el entorno de ejecución de javascript para backend.

Definiendo a NodeJS

Según la web oficial de nodejs.org, la definición de Node es:

Ideado como un entorno de ejecución de JavaScript orientado a eventos asíncronos, Node.js está diseñado para crear aplicaciones network escalables.

En el siguiente material tendrás algunas orientaciones básicas de como funciona y como realizar la instalación del mismo.

Qué es Fastify

Partiendo de los elementos indicados como componentes de una API, vamos a explicar que paquetes vamos a utilizar para la implementacion de cada uno de ellos. Comencemos por el responsable de las rutas o mejor en forma general, por la comunicación y transporte de datos.

Es a través de este proceso (comunicación y transporte) que nuestra API REST  va a recibir y enviar datos a quien esté consumiendo el servicio. Esto se hace a través de rutas.

Para esta tarea tenemos varias opciones, como usar las clases nativas de NodeJS, usar el framework expressjs o  en nuestro caso usar el framework fastify. Te preguntaras por qué Fastify?. Varias razones: simplicidad, rapidez y escabilidad del framework.

Primero vamos a crear nuestro proyecto node, con la siguiente instrucción:

npm init

Ahora avancemos a la instalación de fastify, esta muy simple, sólo ejecutanos el siguiente comando y con ello ya en nuestro proyecto podemos usar sus métodos y funcionalidades, pero comencemos por crear el proyecto:

npm install fastify

Ahora procedemos a construir el esqueleto de nuestra API.

Construyendo los elementos de nuestra API REST

Empecemos por el archivo principal, el cual será: index.js El contenido del archivo index.js será:

import Fastify from 'fastify';

const fastify = Fastify({
    logger: true
});

// Ruta inicial
fastify.get('/', async function handler (req, res) {
    return { hello: 'world' };
});
  
// Ejecución de la aplicación
try {
    await fastify.listen({ port: 3000 });
} catch (err) {
    fastify.log.error(err);
    process.exit(1);
}

Con lo anterior, ya tenemos en pocas líneas, una API funcional, que solo tiene una ruta, pero que en esencia está completa. Ahora pasemos a la extensión de sus rutas.

Definiendo las rutas básicas

Procedemos entonces a definir las rutas que nuestra API va a implementar, en este caso creamos un nuevo archivo llamado routes.js, en el cual definimos los CRUDs de cada uno de nuestros modelos, siendo que CRUD será (C-reate, R-ead, U-pdate, D-elete), en español serán las operaciones de Inserción, Lectura, Actualización y Borrado.

El archivo quedará de esta forma:

const rutas = [
    {
        method: "POST",
        url: "/usuarios",
        handler: async (req, res) => {
            res.status(200).send({status: 'OK - POST'});
        }
    },
    {
        method: "GET",
        url: "/usuarios",
        handler: async (req, res) => {
            res.status(200).send({status: 'OK - GET'});
        }
    },
    {
        method: "PUT",
        url: "/usuarios/:id",
        handler: async (req, res) => {
            res.status(200).send({status: 'OK - PUT'});
        }
    },
    {
        method: "DELETE",
        url: "/usuarios/:id",
        handler: async (req, res) => {
            res.status(200).send({status: 'OK - DELETE'});
        }
    }
]

export default rutas;

Observa que algunas rutas tienen :/id, esto lo explicaremos en detalle más adelante.

Con las rutas ya definidas, el siguiente paso será definir los modelos, notese que en el archivo anterior, dejamos la propiedad handler apuntando a una función básica que siempre retorna OK.

handler: (req,res) => {
	res.status(200).send('OK');
}

Esto significa que por ahora no tenemos ningún proceso asociado a las rutas, pero hemos dejado ya la estructura hecha. La implementación será realizada más adelante.

Incorporemos las rutas a nuestro archivo principal index.js, quedando este de la siguiente forma:

import Fastify from 'fastify';
import rutas from './rutas.js';
import cors from '@fastify/cors';

const fastify = Fastify({logger:true});
await fastify.register(cors, {

});

//POST - Inserciones                C-REATE
//GET - Consulta                    R-EAD
//PUT, PATCH - Actualizaciones      U-PDATE
//DELETE - Borrado                  D-ELETE

fastify.get("/",async function(req, res) {
    return { hello: 'world'};
});

//Incorporación de las rutas
rutas.forEach((ruta) => {
    fastify.route(ruta);
});

try {
    fastify.listen({port:3500});
} catch(erro) {
    console.log(erro);
}

En el siguiente material podrás visualizar el paso de la construcción que hemos hecho hasta ahora.

Modelos

Acá vamos a definir los datos que nuestra API procesará, tomemos la primera entidad "Usuarios" y definamos su modelo, para ello nos vamos a apoyar en sequelize, que nos permite hacer una definición que luego se reflejará en la base de datos, esto debido a que Sequelize actua como un ORM (Object Relation Mapping).

Pero qué es un ORM - Object Relation Mapping?

Tomando lo que https://en.wikipedia.com nos indica, podemos citar lo que es un ORM:

Un ORM (Object-Relational Mapping) es una técnica de programación que permite la conversión de datos entre una base de datos relacional y un lenguaje de programación orientado a objetos. En otras palabras, un ORM es una herramienta que ayuda a simplificar la traducción entre los dos paradigmas: objetos y tablas de bases de datos relacionales. Puede utilizar definiciones de clases (modelos) para crear, mantener y proporcionar acceso completo a los datos de los objetos y su persistencia en la base de datos.

Instalando Sequelizer

Para realizar la instalación de Sequelizer, necesitamos ejecutar sólo este comnpm install sequelizerando:

npm install sequelizer

Ejecutando lo anterior, tenemos ya disponible el paquete en nuestro proyecto, es momento de conectar nuestra base de datos, para ello creamos un nuevo archivo llamado db.js y colocamos los parámetros de conexión correspondientes:

/* eslint-disable require-jsdoc */
import Sequelize from 'sequelize';

/*
Clase de conexión a la base de datos
*/
class DBInstance {
	constructor() {
		const dbCfg = {
			user: '<usuario_base_datos>',
			host: '<ip_o_dns_servidor>',
			database: '<nombre_base_datos>',
			password: '<clave_usuario_base_datos>',
			port: 5432,
		};
		this.sequelize = new Sequelize(dbCfg.database, dbCfg.user, dbCfg.password, {
			host: dbCfg.host,
			dialect: 'postgres',
			logging: false,
		});
	}
}

export default new DBInstance().sequelize;

Con lo anterior, ya tenemos conexión a nuestra base de datos. Ajustamos nuestro archivo index.js para importar este proceso de conexión y dejarlo ejecutandose cuando sea iniciada la API. Quedando su código de esta forma:

import Fastify from 'fastify';
import db from './db.js';
import rutas from './rutas.js';
import cors from '@fastify/cors';

const fastify = Fastify({logger:true});
await fastify.register(cors, {

});

//POST - Inserciones                C-REATE
//GET - Consulta                    R-EAD
//PUT, PATCH - Actualizaciones      U-PDATE
//DELETE - Borrado                  D-ELETE

// eslint-disable-next-line no-unused-vars
fastify.get('/',async function(req, res) {
	return { hello: 'world'};
});

//Incorporación de las rutas
rutas.forEach((ruta) => {
	fastify.route(ruta);
});

async function database() {
	try {
		await db.sync();
		console.log('Conectado a la base de datos');
	} catch(e) {
		console.log(e);
	}
}

try {
	fastify.listen({port:3500});
	database();
} catch(erro) {
	console.log(erro);
}

Observa que hemos creado una función asincrona llamada database() y luego al iniciar la API, la invocamos para que se realice la conexión y sincronización del modelo.

Ahora procedemos a crear el modelo, recordando que un modelo es la representación de los datos que vamos a gestionar del mundo real en nuestra API.

Comencemos por el modelo de Usuarios:

import sequelize from "sequelizer";

const User = sequelize.define("User", {
    id : {
        type: sequelize.STRING,
        allowNull: false,
        primaryKey: true,
    },
    fullname: {
        type: sequelize.STRING,
        allowNull: false,
    },
    password: {
        type: sequelize.STRING,
        allowNull: false,
    },
});

export default User;

Observa que cada propiedad del objeto que define el modelo, corresponde con el nombre del campo que definimos en nuestro modelo de entidad-relación al inicio del documento, el nombre de cada propiedad representa cada campo, así que debemos tener cuidado con el nombre que le indiquemos, mi recomendación usar letras minusculas, no usar caracteres especiales.

En el caso de password, vamos usar un paquete adicional, para poder encriptar el contenido de la misma, recordando que por seguridad, los datos de claves no se deben guardar de forma plana o legible en la base de datos.

Para lograr que nuestro password quede guardado de forma segura, hacemos uso del paquete bcrypt, el cual nos permite codificar el valor enviado por el usuario y luego con un método propio del paquete podemos validar si clave es la guardada, de esta forma el modelo de Usuarios queda implementado con el siguiente código:

import sequelize from 'sequelize';
import bcrypt from 'bcrypt';
import db from '../db.js';


const UserModel = db.define('users', {
  id: {
    type: sequelize.STRING,
    allowNull: false,
    primaryKey: true,
  },
  fullname: {
    type: sequelize.STRING,
    allowNull: false,
  },
  password: {
    type: sequelize.STRING,
    allowNull: false,
  },
}, {
  hooks: {
    beforeCreate: (user) => {
      const salt = bcrypt.genSaltSync();
      user.password = bcrypt.hashSync(user.password, salt);
    },
  },
});

UserModel.prototype.validPassword = function(password) {
  return bcrypt.compareSync(password, this.password);
};

export default UserModel;

Para el caso del modelo de tiendas o comercios, siguiendo lo definido anteriormente, el modelo queda representado con el siguiente código:

import sequelize from 'sequelize';
import db from '../db.js';

const StoreModel = db.define('stores', {
  id: {
    type: sequelize.INTEGER,
    autoIncrement: true,
    allowNull: false,
    primaryKey: true,
  },
  store_name: {
    type: sequelize.STRING,
    allowNull: false,
  },
  category_store: {
    type: sequelize.STRING,
    allowNull: false,
  },
});


export default StoreModel;

Algunas diferencias notorias, en el caso de id, usamos una propiedad dentro del objeto id que es autoIncrement, la cual define que el campo en la base de datos será del valor automático e incremental, de esta forma la base de datos asignará el id correspondiente. Otro punto interesante es el tipo de datos, en el caso de id usamos el tipo INTEGER, para definir que es un número entero.

Pasemos ahora al modelo de Tickets o Turnos, hacemos la implementación, recordando que este modelo se relaciona con Usuarios y Tiendas, de forma que un Usuario tiene N Tickets y una Tienda también tiene N Tickets, de esta forma el modelo implementado será:

import sequelize from 'sequelize';
import db from '../db.js';
import UserModel from './Users.js';
import StoreModel from './Stores.js';

const TicketModel = db.define('tickets', {
  id: {
    type: sequelize.STRING,
    allowNull: false,
    primaryKey: true,
  },
  date_time: {
    type: 'TIMESTAMP',
    allowNull: false,
  },
  status: {
    // eslint-disable-next-line new-cap
    type: sequelize.ENUM(['Creado', 'Confirmado', 'Atendido', 'Cancelado',
      'En progreso']),
    allowNull: false,
  },
  observation: {
    type: sequelize.TEXT,
    allowNull: false,
  },
  end_date_time: {
    type: 'TIMESTAMP',
    allowNull: false,
  },
});

UserModel.hasMany(TicketModel, {
  foreignKey: {
    name: 'user_id',
    type: sequelize.STRING,
    allowNull: false,
  },
});

StoreModel.hasMany(TicketModel, {
  foreignKey: {
    name: 'store_id',
    type: sequelize.INTEGER,
    allowNull: false,
  },
});


export default TicketModel;

En este modelo tenemos algunas particularidades que valen la pena analizar:

• Tenemos nuevos tipos de datos: TEXTpara almacenar grandes cantidad de datos (mayores a 255 caracteres), ENUM para definir un conjunto de valores cerrados para un campo en particular. TIMESTAMP para definir campos de tipo fecha/hora.
• Relaciones, en este modelo le decimos a sequelize que queremos relacionar los modelos en este segmento de código:

UserModel.hasMany(TicketModel, {
  foreignKey: {
    name: 'user_id',
    type: sequelize.STRING,
    allowNull: false,
  },
});

StoreModel.hasMany(TicketModel, {
  foreignKey: {
    name: 'store_id',
    type: sequelize.INTEGER,
    allowNull: false,
  },
});

Observa que se indica que el modelo Usuarios (UserModel) tiene muchos Tickets con la instrucción: hasMany, lo mismo sucede en el caso de Tiendas (StoreModel), le indicamos que va a tener múlples Tickets.

Con ellos hemos finalizado los modelos a implementar, ahora pasemos a la lógica de negocios.

Controladores

Estos elementos tan importantes a la hora de construir nuestra API REST, son los responsables de implementar lo que denominamos la lógica de negocios, es decir ellos reciben los datos enviados por quienes consumen el servicio o la API, los procesan, envian a la capa de datos cuando corresponde y retornan una respuesta.

De acuerdo con lo anterior, entonces en los controladores donde vamos a implementar el famoso CRUD (Create, Read, Update and Delete), el cual ya citamos anteriormente. Ahora bien, definamos la anatomía de un controlador:

import Model from "../models/Model.js";

class ModeloController {
    constructor() {

    }
    
    //Creación de registros
    async create (req, res)  {
    }
    
    //Consulta de todos los registros del modelo
    async getAll(req, res) {
    }

	//Consulta de un registro en particular
    async getOne(req, res) {
    }
    
    //Actualización de un registro
    async update(req, res) {
    }
    
    
    //Borrado de un registro
    async delete(req, res) {
    }
    
 }
    

Notemos que el controlador implementar como comentarmos anteriormente cada una de las operaciones del CRUD, que la API va a realizar para cada uno de los modelos construidos, de esta forma, vamos a tener que crear un controlador para usuarios, otro para tiendas y uno más para los tickets o turnos.

En este material realizamos la implementación de los modelos y parte de los controladores:

Ahora para cada modelo que hemos definido en nuestra API, construimos sus controladores, quedando su código de esta forma:

• UsersController

/* eslint-disable require-jsdoc */
import UserModel from '../models/Users.js';

class UsersController {
  constructor() {

  }

  async create(req, res) {
    try {
      const userModel = await UserModel.create(req.body);

      if (userModel) {
        res.status(200).send({status: true, id: userModel.id});
      }
    } catch (e) {
      res.status(500).send({error: e});
    }
  }

  async getAll(req, res) {
    try {
      const where = {...req.query};
      const usuarios = await UserModel.findAll({where});
      res.status(201).send(usuarios);
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al consultar usuarios'},
      );
    }
  }

  async getOne(req, res) {
    try {
      const {id} = req.params;

      const userModel = await UserModel.findByPk(id);

      if (userModel) {
        res.status(201).send(userModel);
      } else {
        res.status(404).send(
            {message: 'Registro no encontrado'},
        );
      }
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al consultar el usuario'},
      );
    }
  }

  async update(req, res) {
    try {
      const {id} = req.params;

      const userModel = await UserModel.update(req.body,
          {where: {id}});

      if (typeof (userModel[0]) !== 'undefined' && userModel[0] === 1) {
        res.status(201).send({
          status: true,
        });
      } else {
        res.status(404).send(
            {message: 'Registro no encontrado'},
        );
      }
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al actualizar el usuario'},
      );
    }
  }

  async delete(req, res) {
    try {
      const {id} = req.params;

      const userModel = await UserModel.destroy({where: {id}});

      if (userModel) {
        res.status(201).send({
          status: true,
        });
      } else {
        res.status(404).send(
            {message: 'Registro no encontrado'},
        );
      }
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al intentar borrar un usuario'},
      );
    }
  }
}

export default new UsersController();

Del código anterior podemos resaltar algunas caracteristicas:

• Todos los métodos son asincronos, es decir por ser operaciones de base de datos, estos procesos deben esperar resultados y recordamos que Javascript no espera a nadie por lo tanto usamos las palabras reservadas async e await para lograr ese objetivo.
• Encerramos el procesamiento o la lógica de cada operación entre las palabras try y catch de forma tal que cualquier error, lo podamos capturar y retornar a quien nos consume los servicios.
• En cada uno de los métodos de nuestros controladores, nos vamos a apoyar en métodos de Sequelize, que nos van a facilitar el acceso y la gestión de los datos a nivel de base de datos. En la creación usamos create, en la búsqueda usamos findAll, para conseguir un registro en particular usamos findByPk, para actualizar usamos update y para borrar usamos destroy.
• En las operaciones que envuelven acceso a un registro en particular usamos del objeto req la propiedad params, es decir usamos req.params para obtener el id del registro. Este parámetro lo definimos en la ruta.
• Cuando hacemos operaciones de envio de datos, sea en la creación o en la actualización, el cuerpo o data la recibimos en lo que se denomina el body de la requisición, esto se obtiene con req.body.

Veamos como ha quedado el controlador de tiendas:

import StoreModel from '../models/Stores.js';


/* eslint-disable require-jsdoc */
class StoreController {
  constructor() {

  }

  async create(req, res) {
    try {
      const storeModel = await StoreModel.create(req.body);

      if (storeModel) {
        res.status(201).send({status: true, id: storeModel.id});
      }
    } catch (e) {
      res.status(500).send(e);
    }
  }

  async getAll(req, res) {
    try {
      const where = req.query;

      const tiendas = await StoreModel.findAll({where});
      res.status(201).send(tiendas);
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al consultar tiendas'},
      );
    }
  }

  async getOne(req, res) {
    try {
      const {id} = req.params;

      const storeModel = await StoreModel.findByPk(id);
      if (storeModel) {
        res.status(201).send(storeModel);
      } else {
        res.status(404).send(
            {message: 'Registro no encontrado'},
        );
      }
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al consultar la tienda'},
      );
    }
  }

  async update(req, res) {
    try {
      const {id} = req.params;
      const data = {...req.body};

      delete data.id;

      const storeModel = await StoreModel.update(data,
          {where: {id}});

      if (typeof (storeModel[0]) !== 'undefined' && storeModel[0] === 1) {
        res.status(201).send({
          status: true,
        });
      } else {
        res.status(404).send(
            {message: 'Registro no encontrado'},
        );
      }
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al actualizar la tienda'},
      );
    }
  }

  async delete(req, res) {
    try {
      const {id} = req.params;

      const storeModel = await StoreModel.destroy({where: {id}});

      if (storeModel) {
        res.status(201).send({
          status: true,
        });
      } else {
        res.status(404).send(
            {message: 'Registro no encontrado'},
        );
      }
    } catch (err) {
      res.status(500).send(
          {message: err.message || 'Error al intentar borrar una tienda'},
      );
    }
  }
}

export default new StoreController();

El controlador es bien similar al de usuarios, implementado en la clase UserController, solo en el método de actualización (update), agregamos está linea: delete data.id; para evitar que sea modificar el id interno del registro.

El controlador de Turnos, sigue a continuación, este controlador también tiene la protección para evitar que el campo autonumérico sea modificado en el método de actualización (update).

import TicketModel from '../models/Tickets.js';

/* eslint-disable require-jsdoc */
class TicketController {
	constructor() {

	}

	async create(req, res) {
		try {
			const ticketModel = await TicketModel.create(req.body);

			if (ticketModel) {
				res.status(201).send({status: true, id: ticketModel.id});
			}
		} catch (e) {
			res.status(500).send(e);
		}
	}

	async getAll(req, res) {
		try {
			const where = req.query;

			const tickets = await TicketModel.findAll({where});
			res.status(201).send(tickets);
		} catch (err) {
			res.status(500).send(
				{message: err.message || 'Error al consultar tickets'},
			);
		}
	}

	async getOne(req, res) {
		try {
			const {id} = req.params;

			const ticketModel = await TicketModel.findByPk(id);
			if (ticketModel) {
				res.status(201).send(ticketModel);
			} else {
				res.status(404).send(
					{message: 'Registro no encontrado'},
				);
			}
		} catch (err) {
			res.status(500).send(
				{message: err.message || 'Error al consultar el ticket'},
			);
		}
	}

	async update(req, res) {
		try {
			const {id} = req.params;
			const data = {...req.body};
			delete data.id;

			const ticketModel = await TicketModel.update(data,
				{where: {id}});

			if (typeof (ticketModel[0]) !== 'undefined' && ticketModel[0] === 1) {
				res.status(201).send({
					status: true,
				});
			} else {
				res.status(404).send(
					{message: 'Registro no encontrado'},
				);
			}
		} catch (err) {
			res.status(500).send(
				{message: err.message || 'Error al actualizar el ticket'},
			);
		}
	}

	async delete(req, res) {
		try {
			const {id} = req.params;

			const ticketModel = await TicketModel.destroy({where: {id}});

			if (ticketModel) {
				res.status(201).send({
					status: true,
				});
			} else {
				res.status(404).send(
					{message: 'Registro no encontrado'},
				);
			}
		} catch (err) {
			res.status(500).send(
				{message: err.message || 'Error al intentar borrar un ticket'},
			);
		}
	}
}

export default new TicketController();

Con esto hemos finalizado los controladores.

Rutas actualizadas

Ahora es momento de revisar como llamamos todo lo implementado en nuestras rutas, recordando que al inicio generamos las rutas para el módelo de usuarios, pero llamando a métodos genéricos en lugar de nuestros controladores, con ellos implementados, podemos ajustar el código, el cual queda de la siguiente forma:

import UsersController from './controllers/Users.js';
import StoreController from './controllers/Stores.js';
import TicketController from './controllers/Tickets.js';

const rutas = [
	{
		method: 'POST',
		url: '/usuarios',
		handler: UsersController.create,
	},
	{
		method: 'GET',
		url: '/usuarios',
		handler: UsersController.getAll,
	},
	{
		method: 'GET',
		url: '/usuarios/:id',
		handler: UsersController.getOne,
	},
	{
		method: 'PUT',
		url: '/usuarios/:id',
		handler: UsersController.update,
	},
	{
		method: 'DELETE',
		url: '/usuarios/:id',
		handler: UsersController.delete,
	},

	/* Rutas de tiendas */
	{
		method: 'POST',
		url: '/tiendas',
		handler: StoreController.create,
	},
	{
		method: 'GET',
		url: '/tiendas',
		handler: StoreController.getAll,
	},
	{
		method: 'GET',
		url: '/tiendas/:id',
		handler: StoreController.getOne,
	},
	{
		method: 'PUT',
		url: '/tiendas/:id',
		handler: StoreController.update,
	},
	{
		method: 'DELETE',
		url: '/tiendas/:id',
		handler: StoreController.delete,
	},

	/* Rutas de turnos */
	{
		method: 'POST',
		url: '/turnos',
		handler: TicketController.create,
	},
	{
		method: 'GET',
		url: '/turnos',
		handler: TicketController.getAll,
	},
	{
		method: 'GET',
		url: '/turnos/:id',
		handler: TicketController.getOne,
	},
	{
		method: 'PUT',
		url: '/turnos/:id',
		handler: TicketController.update,
	},
	{
		method: 'DELETE',
		url: '/turnos/:id',
		handler: TicketController.delete,
	},
];

export default rutas;

Interesante que nuestro archivo raiz index.js no sufre ninguna alteración, esto debido al grado de encapsulamiento y desacoplamiento que hemos implementado.

Con esto ya tenemos una API Rest funcional, implementada con NodeJS, Fastify, Sequelize y PostgreSQL.

Puedes verificar la implementación de los controladores y de todos sus métodos en este material: