GraphQL ofrece una alternativa flexible al enfoque REST clásico cuando crea una API.

Uno de los factores más cruciales a considerar al diseñar una aplicación es el tipo de arquitectura de API que se utilizará. El diseño eficiente de API es crucial para garantizar que las aplicaciones funcionen durante todo su ciclo de vida.

La arquitectura RESTful es el enfoque más popular, pero tiene un inconveniente importante: una estructura de punto final fija que devuelve datos predeterminados. Este diseño puede resultar en una comunicación ineficiente.

Por el contrario, GraphQL, una alternativa a REST, ofrece más flexibilidad al permitirle solicitar solo los datos que necesita.

¿Qué son las API de GraphQL?

GráficoQL es un lenguaje de consulta que puede usar para escribir API de back-end (interfaces de programación de aplicaciones). A diferencia de API REST, que tienen múltiples puntos finales para diferentes datos, las API de GraphQL solo tienen un punto de entrada.

Los clientes pueden especificar los datos que necesitan en sus consultas desde este único punto de entrada, lo que lo hace más flexible y eficiente para recuperar solo los datos necesarios.

instagram viewer

En pocas palabras, una API GraphQL implementa la arquitectura GraphQL descrita por el Especificaciones de GraphQL. Este diseño implica definir el esquema, las consultas y las mutaciones con las que los clientes pueden interactuar.

Aquí hay un desglose simplificado de los componentes esenciales de la arquitectura de la API de GraphQL:

  1. Esquema: un esquema es una descripción de los tipos de datos y operaciones que proporciona la API. Básicamente, un esquema define la estructura de los datos disponibles y el tipo de consultas y mutaciones que un cliente puede ejecutar para modificar los datos.
  2. Consultas: los clientes utilizan consultas para obtener datos de la base de datos especificando la estructura de los datos que necesitan. Además, pueden anidar múltiples consultas en una sola solicitud HTTP para obtener datos relacionados desde múltiples puntos finales.
  3. Mutaciones: Las mutaciones son operaciones que se utilizan para modificar datos en la base de datos. Los clientes pueden enviar solicitudes de mutación para crear, actualizar o eliminar datos.

Configurar una base de datos MongoDB

Para empezar, crear una base de datos MongoDB. Alternativamente, puede configure un clúster de MongoDB en la nube de forma gratuita. Una vez que haya configurado su base de datos, copie la cadena URI de conexión de la base de datos de MongoDB.

Puedes encontrar el código de este proyecto en su repositorio GitHub.

Crear un servidor Apollo

Servidor Apolo es una implementación de servidor GraphQL popular que le permitirá crear API de GraphQL en entornos de JavaScript, incluidos Node.js, Express y más.

Cree un directorio para un nuevo proyecto y cd en ello:

mkdir graphql-API-mongoDB
cd graphql-API-mongoDB

A continuación, inicialice un nuevo proyecto de Node.js.

npm init --sí

Este comando crea un paquete.json archivo.

Instale las dependencias requeridas

Ejecute el siguiente comando para instalar los paquetes.

npm instala el servidor apollo graphql mangosta

Finalmente, crea un índice.js archivo en el directorio raíz de su proyecto.

Configurar el servidor Apollo

Abierto índice.js y agrega el siguiente código:

constante {ServidorApolo} = requerir('servidor apolo');
constante mangosta = requerir('mangosta');
constante tipoDefs = requerir("./graphql/typeDefs");
constante resolutores = requerir("./graphql/resolvers");
constante servidor = nuevo ServidorApolo({
 definiciones de tipo, 
 resolutores 
});


constante MONGO_URI = 'mongodb://localhost: 27017';
mangosta
 .conectar (MONGO_URI, {
 useNewUrlParser: verdadero,
 useUnifiedTopology: verdadero,
 })
 .entonces(() => {
consola.registro(`Base de datos conectada`);
devolver servidor.escuchar({ puerto: 5000 });
 })
 .entonces((resolución) => {
consola.registro(`Servidor ejecutándose en ${res.url}`);
 })
 .atrapar(errar => {
consola.log (err.mensaje);
 });

Este código inicializa un servidor GraphQL local utilizando la biblioteca del servidor Apollo. Luego establece una conexión a una base de datos MongoDB con el URI de conexión dado.

Observe cómo el código pasa dos argumentos a la nueva instancia de ApolloServer: typeDefs y resolvers. Estos especifican los tipos de datos y las operaciones que la API de GraphQL puede ejecutar.

Después de configurar la conexión a la base de datos MongoDB, el servidor comienza a escuchar en el puerto 5000.

Definir el modelo de datos

Cree una nueva carpeta en el directorio raíz de la carpeta de su proyecto y asígnele un nombre modelos. En esta carpeta, cree un nuevo nombre de archivo modelo de datos.js y agregarle el siguiente código:

constante {modelo, esquema} = requerir('mangosta');
constante esquemaempleado = nuevo Esquema({
 nombre: Cadena,
 departamento: Cadena,
 salario: Cadena,
});
módulo.exportaciones = modelo('Empleado', esquemaempleado);

Definir el esquema de GraphQL

Un esquema de GraphQL define la estructura de los datos que puede consultar con la API de GraphQL. El esquema también describe las consultas y las mutaciones que puede ejecutar la API. Puede usar consultas para obtener datos y mutaciones para modificarlos.

En el directorio raíz de su proyecto, cree una nueva carpeta y asígnele el nombre gráficoql. Dentro de esta carpeta, agregue dos archivos: typeDefs.js y resolvers.js

Agregue el siguiente código en el archivo typeDefs.js:

constante {gql} = requerir("servidor apolo");
constante typeDefs = gql`
 tipo Empleado {
 ¡hice!
 nombre: Cadena
 departamento: Cadena
 salario: Cadena
 }
 entrada EmpleadoEntrada {
 nombre: Cadena
 departamento: Cadena
 salario: Cadena
 }
 escriba consulta { 
 getEmployee (id: ID): Número de empleadodevolver empleado por id
 empleados: [Empleado] #devolver formación de Empleados
 }
 tipo de mutación {
 createEmployee (entrada de empleado: entrada de empleado): empleado
 actualizarEmpleado (id: ID, empleadoEntrada: entrada de empleado): booleano
 eliminarEmpleado (id: ID): booleano
 }
`;
módulo.exportaciones = typeDefs;

Este código anterior utiliza el gql función proporcionada por el paquete apollo-server para crear un esquema GraphQL para los datos del empleado.

El esquema consta de cuatro elementos principales: tipos de datos para la información de los empleados, tipos de entrada, consultas y mutaciones que puede realizar la API.

Definir los solucionadores para la API de GraphQL

Un resolutor es una función de GraphQL que define los datos que se transmitirán cuando un cliente envíe una consulta API para obtener datos. Esencialmente, su función principal es recuperar los datos necesarios de la fuente de datos especificada y devolverlos al cliente.

Agregue el siguiente código a la resolvers.js archivo en el gráficoql carpeta. Los resolutores, en este caso, se especifican dentro de los objetos Query y Mutation.

El objeto Query define dos métodos: empleados y obtenerEmpleado. Estos métodos son responsables de obtener los datos de los empleados de la base de datos a pedido de un cliente.

constante empleado= requerir("../modelos/empleadosModelo");
// Resolutores GraphQL
constante resolutores = {
 Consulta: {
 empleados: asíncrono () => {
intentar {
constante empleados = esperar Empleado.find({});
devolver empleados;
 } atrapar (error) {
consola.error (error);
tirarnuevoError('Error al buscar empleados');
 }
 },
 obtenerEmpleado: asíncrono (padre, argumentos) => {
intentar {
constante empleado = esperar Empleado.findById (args.id);
devolver empleado;
 } atrapar (error) {
consola.error (error);
tirarnuevoError('No se pudo buscar al empleado por ID');
 }
 },
 },

El objeto Mutación tiene tres métodos: crearempleado, Actualizar empleado, y eliminar empleado. Estos métodos realizan cambios en los datos almacenados en la base de datos MongoDB.

 Mutación: {
asíncrono crear empleado (_, { empleadoEntrada: { nombre, departamento, salario } }) {
constante nuevo empleado = nuevo Empleado({
 nombre nombre,
 departamento: departamento,
 salario: salario
 });
constante respuesta = esperar nuevoEmpleado.guardar();
consola.log (nuevoEmpleado);


devolver {
 id: respuesta._id,
 ...respuesta._doc
 }
 },


asíncrono actualizarEmpleado (_, {id, empleadoEntrada: {nombre, departamento, salario}}) {
constante empleado actualizado = esperar Empleado.updateOne(
 { _identificación: identificación },
 { nombre, departamento, salario }
 );


si (!Empleado actualizado) {
tirarnuevoError(`Empleado con DNI: ${id} no encontrado`);
 }


devolververdadero; // Devuelve un valor booleano que indica el éxito de la actualización
 },


asíncrono eliminarEmpleado (_, {id}) {
constante empleado eliminado = esperar Empleado.deleteOne({ _identificación: identificación });

si (!Empleadoborrado || Empleadoborrado.cuentaborrada 0) {
tirarnuevoError(`Empleado con DNI ${id} no encontrado`);
 }


devolververdadero; // Devuelve un valor booleano que indica el éxito de la eliminación
 },
 },
};
módulo.exportaciones = resolutores;

Finalmente, ejecute este comando para activar el servidor:

nodo index.js

Una vez que haya establecido una conexión con la base de datos, el servidor se iniciará en el puerto 5000.

Puede continuar y probar la funcionalidad de la API de GraphQL realizando solicitudes HTTP desde el área de juegos de GraphQL en su navegador.

Por ejemplo, puede utilizar el crearempleado mutación para agregar nuevos datos de empleados en la base de datos MongoDB.

Popularidad de GraphQL en la comunidad de desarrolladores

GraphQL está ganando terreno en la comunidad de desarrolladores como un enfoque de diseño de API alternativo a la popular arquitectura REST.

Esto se debe a su capacidad para proporcionar una forma más flexible y eficiente de recuperar datos de varias fuentes, todo desde un único punto de entrada. Esto evita tener que administrar múltiples puntos finales para diferentes datos, lo cual es un problema común con la arquitectura de la API REST. Esta solución de diseño agiliza el proceso de creación y gestión de las API de back-end.