Phenquestions
La comunicación y la transferencia de datos entre el front-end y el back-end de cualquier aplicación se produce a través de API (interfaz de programación de aplicaciones). Hay muchos tipos diferentes de API que se utilizan para comunicarse entre las aplicaciones de front-end y back-end, como RESTful API, SOAP API, GraphQL API, etc. La API GraphQL es una tecnología relativamente nueva y es mucho más rápida que otros tipos de API disponibles. Obtener datos de la base de datos usando 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.js usando la API GraphQL, por lo que necesitamos instalar el nodo.js y npm para esto antes de comenzar el proyecto.
[correo electrónico protegido]: ~ $ sudo apt-get update -y[correo electrónico protegido]: ~ $ sudo apt-get install nodejs
[correo electrónico protegido]: ~ $ sudo apt-get install npm
Configuración del proyecto
Usaremos el marco 'express' del nodo.js para construir nuestra aplicación. Cree un directorio llamado 'graphql' e inicie el proyecto.
[correo electrónico protegido]: ~ $ mkdir graphql[correo electrónico protegido]: ~ $ cd graphql /
[correo electrónico protegido]: ~ $ npm init -y
Configuración de MongoDB
En nuestro proyecto GraphQL, usaremos MongoDB como nuestra base de datos. MongoDB es una base de datos sin esquema y almacena datos en forma de pares de claves. Para instalar mongoDB, siga los pasos dados.
Importar la clave GPG pública para MongoDB.
[correo electrónico protegido]: ~ $ wget -qO - https: // www.mongodb.org / static / pgp / server-4.4.asc | sudo apt-key add -
Crea el archivo de lista para mongodb.
Actualizar repositorios locales.
[correo electrónico protegido]: ~ $ sudo apt-get update -yInstalar el paquete mongodb.
[correo electrónico protegido]: ~ $ sudo apt-get install -y mongodb-orgIniciar y habilitar mongod.Servicio.
[correo electrónico protegido]: ~ $ sudo systemctl start mongod.Servicio[correo electrónico protegido]: ~ $ sudo systemctl enable mongod.Servicio
Instalación de módulos npm
Para nuestra aplicación GraphQL, necesitamos instalar algunos paquetes npm. Instalaremos cors, express, body-parser, mangosta, etc.
[correo electrónico protegido]: ~ $ cd graphql /[email protected]: ~ $ npm instalar cors express body-parser mongoose --save
Para crear una api GraphQL, necesitamos instalar un paquete npm adicional llamado 'apollo-server-express.'Este paquete npm se utiliza para ejecutar el servidor GraphQL con todos los Node.js marcos HTTP como 'express.'
[correo electrónico protegido]: ~ $ npm install apollo-server-express --saveDefinición del esquema de MongoDB
Ahora tenemos nuestro entorno configurado para nuestra aplicación GraphQL en Node.js, y es hora de definir un esquema para nuestra aplicación. Crear un archivo 'modelos / alumno.js 'en el directorio raíz del proyecto.
// definir el esquema del estudianteconst mangosta = require ('mangosta');
const studentSchema = nueva mangosta.Esquema(
nombre:
tipo: Cadena,
requerido: verdadero
,
clase:
teclea un número,
requerido: verdadero
,
importante:
tipo: Cadena,
requerido: verdadero
,
marcas de tiempo: verdadero
);
const Student = mangosta.modelo ('Student', studentSchema);
módulo.exportaciones = Student, studentSchema
En el esquema definido anteriormente, cada estudiante debe tener un nombre, una clase y una especialización.
Construyendo API GraphQL
Después de crear el esquema del estudiante, ahora crearemos la API GraphQL. Crea un 'esquema.js 'para escribir parámetros GraphQL. Hay dos parámetros, 'tipos' y 'resolutores', que se utilizan en la API GraphQL. En 'tipos' especificaremos nuestro esquema, las consultas (e.gramo., Realización de solicitudes GET) y mutaciones (e.gramo., Realización de solicitudes UPDATE o DELETE) al esquema especificado. Escribiremos los diferentes métodos definidos en 'tipos' para vincular las consultas y mutaciones con la base de datos en 'resolvers.'
// importando esquema y móduloconst gql = require ('apollo-server-express');
const Student = require ('./ modelos / estudiante ').Estudiante;
// Definición de esquema, consulta y tipo de mutación
const typeDefs = gql '
type Student
yo hice!,
nombre: String!,
clase: Int!,
mayor: String!
type Query
getStudents: [Estudiante],
getStudentById (id: ID!): Estudiante
type Mutation
addStudent (nombre: String!, clase: Int!, mayor: String! ): Estudiante
updateStudent (nombre: String!, clase: Int!, mayor: String! ): Estudiante
deleteStudent (id: ID! ): Estudiante
'
// Definición de Resolvers
const resolvers =
Consulta:
getStudents: (padre, argumentos) =>
estudiante de regreso.encontrar();
,
getStudentById: (padre, argumentos) =>
estudiante de regreso.findById (args.identificación);
,
Mutación:
addStudent: (padre, argumentos) =>
let student = new Student (
nombre: args.nombre,
clase: argumentos.clase,
mayor: argumentos.importante
);
estudiante de regreso.ahorrar();
,
updateStudent: (padre, argumentos) =>
Si(!argumentos.id) retorno;
estudiante de regreso.findOneAndUpdate (
_id: argumentos.identificación
,
$ conjunto:
nombre: args.nombre,
clase: argumentos.clase,
mayor: argumentos.importante
,
nuevo: verdadero, (err, Estudiante) =>
si (err)
consola.log (err);
demás ;
)
módulo.exportaciones =
typeDefs,
resolutores
Creación del servidor API GraphQL
Ahora casi hemos terminado de crear la aplicación GraphQL. El único paso que queda es crear el servidor. Crea un archivo llamado 'aplicación.js 'para configurar los parámetros del servidor.
// importando paquetes requeridosconst express = require ('express');
const mangosta = require ('mangosta');
const bodyParser = require ('body-parser');
const cors = require ('cors');
const ApolloServer = require ('apollo-server-express');
// esquema de importación
const typeDefs, resolvers = require ('./esquema');
// conectándose a MongoDB
const url = “mongodb: // 127.0.0.1: 27017 / estudiantes ”;
conexión constante = mangosta.connect (url, useNewUrlParser: true);
conectar.entonces ((db) =>
consola.log ('Conexión exitosa');
, (err) =>
consola.log (err);
);
// creando servidor
const server = new ApolloServer (
typeDefs: typeDefs,
resolutores: resolutores
);
aplicación constante = express ();
aplicación.use (bodyParser.json ());
aplicación.use ('*', cors ());
servidor.applyMiddleware (aplicación);
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 al estudiante a la base de datos usando GraphQL API.
De manera similar, agregue más estudiantes y, después de agregar al estudiante, obtenga todos los estudiantes que usen GraphQL API.
Anote la identificación de cualquiera de los estudiantes y obtenga el estudiante específico usando su identificación.
Conclusión
Obtener datos de la base de datos usando 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ápida. En este proyecto de demostración, solo tenemos un esquema único, por lo que hemos creado la API GraphQL para ese esquema único. Además, hemos definido de tres a cuatro métodos para el esquema. Puede crear más de una consulta o mutaciones según su aplicación.
