Introducción a la fabricación de API y aplicaciones GraphQL en el nodo.js

La comunicación y la transferencia de datos entre el extremo frontal y el backend de cualquier aplicación ocurre a través de API (interfaz de programación de aplicaciones). Hay muchos tipos diferentes de API utilizadas para comunicarse entre las aplicaciones frontales y de fondo como API RESTFUL, API SOAP, API GraphQL, etc. La API GraphQL es una tecnología relativamente nueva, y es mucho más rápido que otros tipos de API disponibles. Obtener datos de la base de datos utilizando la API GraphQL es mucho más rápido que la API REST. Mientras usa la API GraphQL, el cliente tiene control para obtener solo los datos requeridos en lugar de obtener todos los detalles; Es por eso que GraphQL API funciona más rápido que REST API.

Instalación de paquetes

Construiremos un nodo.Aplicación JS usando la API GraphQL, por lo que necesitamos instalar el nodo.JS y NPM para esto antes de comenzar el proyecto.

ubuntu@ubuntu: ~ $ sudo apt -get update -y
ubuntu@ubuntu: ~ $ sudo apt-get install nodejs
ubuntu@ubuntu: ~ $ sudo apt-get install npm

Configuración del proyecto

Usaremos el marco 'Express' desde el nodo.JS para construir nuestra aplicación. Cree un directorio llamado 'GraphQL' e inicie el proyecto.

ubuntu@ubuntu: ~ $ mkdir graphql
ubuntu@ubuntu: ~ $ CD Graphql/
ubuntu@ubuntu: ~ $ npm init -y

Configuración de MongoDB

En nuestro proyecto GraphQL, utilizaremos MongoDB como nuestra base de datos. MongoDB es una base de datos de esquemas y almacena datos en forma de pares de claves. Para instalar MongoDB, siga los pasos dados.

Importar la clave GPG pública para MongoDB.

ubuntu@ubuntu: ~ $ wget -qo - https: // www.mongodb.org/static/pgp/server-4.4.ASC | sudo apt-key agregar -

Cree el archivo de lista para MongoDB.

ubuntu@ubuntu: ~ $ echo "Deb [arch = amd64, arm64] https: // repositorio.mongodb.org/apt/ubuntu bionic/mongoDB-org/4.4 multiverso "| Sudo Tee/etc/apt/fuentes.lista.D/MongoDB-ORG-4.4.lista

Actualizar repositorios locales.

ubuntu@ubuntu: ~ $ sudo apt -get update -y

Instalar el paquete MongoDB.

ubuntu@ubuntu: ~ $ sudo apt-get install -y mongodb-org

Iniciar y habilitar mongod.servicio.

ubuntu@ubuntu: ~ $ sudo systemctl start mongod.servicio
ubuntu@ubuntu: ~ $ sudo systemctl habilita mongod.servicio

Instalación de módulos NPM

Para nuestra aplicación GraphQL, necesitamos instalar algunos paquetes NPM. Instalaremos Cors, Express, Body-Parser, Mongoose, etc.

ubuntu@ubuntu: ~ $ CD Graphql/
ubuntu@ubuntu: ~ $ npm instalar Cors express cuerpo-pargoose --save

Para crear una API GraphQL, necesitamos instalar un paquete NPM adicional llamado 'Apollo-Server-Express.'Este paquete NPM se usa para ejecutar GraphQL Server con todo el nodo.marcos JS HTTP como 'Express.'

ubuntu@ubuntu: ~ $ npm install apollo-server-express --save

Definición del esquema MongoDB

Ahora tenemos nuestro entorno configurado para nuestra aplicación GraphQL en el nodo.JS, y es hora de definir un esquema para nuestra aplicación. Crear un archivo 'modelos/estudiante.JS 'en el directorio de la raíz del proyecto.

// Definición del esquema de estudiantes
const mongoose = requirir ('mangoose');
Estudios de constante CHEMA = nueva mangosta.Esquema(
nombre:
Tipo: cadena,
Requerido: Verdadero
,
clase:
teclea un número,
Requerido: Verdadero
,
importante:
Tipo: cadena,
Requerido: Verdadero

,
Marcas de tiempo: verdadero
);
Estudiante constante = mangosta.Modelo ('Estudiante', StudentsChema);
módulo.Exports = Student, StudentSchema

En el esquema definido anteriormente, cada estudiante debe tener un nombre, clase y especialización.

API GraphQL de construcción

Después de crear el esquema estudiantil, ahora construiremos la API GraphQL. Crear un 'esquema.JS 'para escribir parámetros GraphQL. Hay dos parámetros, 'tipos' y 'resolvers', utilizados en la API GraphQL. En 'tipos', especificaremos nuestro esquema, las consultas (e.gramo., Hacer solicitudes de obtener) y mutaciones (e.gramo., Hacer solicitudes de actualización o eliminación) al esquema especificado. Escribiremos los diferentes métodos definidos en 'tipos' para vincular las consultas y mutaciones con la base de datos en 'Resolvers.'

// Importar esquema y módulo
const gql = require ('apolo-server-express');
constante constante = requerir ('./modelos/estudiante ').Alumno;
// Definición de esquema, consulta y tipo de mutación
const typedefs = gql '
Tipo de estudiante
hice!,
Nombre: cadena!,
Clase: int!,
Mayor: cadena!

Tipo de consulta
GetStudents: [estudiante],
GetStudentById (ID: ID!): Alumno

Tipo de mutación
AddStudent (nombre: cadena!, Clase: int!, Mayor: cadena! ): Alumno
UpdateTudent (nombre: cadena!, Clase: int!, Mayor: cadena! ): Alumno
Deletestudent (ID: ID! ): Alumno
'
// Definición de los resolutores
const resolvers =
Consulta:
GetStudents: (Parent, Args) =>
Estudiante de regreso.encontrar();
,
getStudentById: (padre, args) =>
Estudiante de regreso.findbyid (args.identificación);

,
Mutación:
addStudent: (parent, args) =>
Sea estudiante = nuevo estudiante (
Nombre: Args.nombre,
Clase: Args.clase,
Mayor: Args.importante
);
Estudiante de regreso.ahorrar();
,
UpdateStudent: (Parent, Args) =>
si(!argumentos.id) retorno;
Estudiante de regreso.FindOnEnDupdate (
_id: args.identificación
,

$ set:
Nombre: Args.nombre,
Clase: Args.clase,
Mayor: Args.importante

,
nuevo: true, (err, student) =>
if (err)
consola.log (err);
demás ;
)



módulo.exportaciones =
typedefs,
resolución

Creación del servidor API GraphQL

Ahora casi hemos terminado de crear la aplicación GraphQL. El único paso restante es crear el servidor. Crear un archivo llamado 'aplicación.JS 'para configurar los parámetros del servidor.

// Importar paquetes requeridos
const express = require ('express');
const mongoose = requirir ('mangoose');
const bodyParser = request ('Body-Parser');
const cors = require ('cors');
const apolloserver = require ('apolo-server-express');
// Esquema de importación
const typedefs, resolvers = require ('./esquema');
// Conectando a MongoDB
const url = "mongodb: // 127.0.0.1: 27017/estudiantes ”;
const Connect = Mongoose.Connect (url, useWurlParser: true);
conectar.luego ((db) =>
consola.log ('conexión exitosa');
, (err) =>
consola.log (err);
);
// Creando servidor
const servidor = new Apolloserver (
typedefs: typedefs,
Resolvers: Resolvers
);
const app = express ();
aplicación.Uso (BodyParser.json ());
aplicación.use ('*', cors ());
servidor.ApplyMiddleware (App);
aplicación.escuchar (8000, () =>

consola.log ('escuchando 8000');
)

Prueba de la API GraphQL

Tenemos nuestro servidor GraphQL en funcionamiento en el puerto 8000, y es hora de probar la API GraphQL. Abra la página web GraphQL en el navegador visitando la siguiente URL.

http: // localhost: 8000/graphql

Y abrirá la siguiente página web.

Agregue el estudiante a la base de datos utilizando la API GraphQL.

Del mismo modo, agregue más estudiantes, y después de agregar al estudiante, obtenga a todos los estudiantes usando la API GraphQL.

Tenga en cuenta la identificación de cualquiera de los estudiantes y haga que el estudiante específico use su identificación.

Conclusión

Obtener datos de la base de datos utilizando la API REST estándar hace que la consulta sea lenta, ya que a veces obtenemos más datos de los requeridos. Usando GraphQL, podemos obtener exactamente los datos requeridos que hacen que la API GraphQL sea más rápido. En este proyecto de demostración, solo tenemos un solo esquema, por lo que hemos creado una API GraphQL para ese único esquema. Además, hemos definido de tres a cuatro métodos para el esquema. Puede crear más de una consulta o mutaciones de acuerdo con su aplicación.