Introdução à fabricação de APIs e aplicativos grafql no nó.JS

A comunicação e a transferência de dados entre o front -end e o back -end de qualquer aplicativo ocorre através de APIs (Application Programming Interface). Existem muitos tipos diferentes de APIs usados ​​para se comunicar entre os aplicativos frontal e back-end, como API RESTful, API SOAP, API do GraphQL, etc. A API do GraphQL é uma tecnologia relativamente nova e é muito mais rápida do que outros tipos de APIs disponíveis. Buscar dados do banco de dados usando a API GraphQL é muito mais rápido que a API REST. Ao usar a API GraphQL, o cliente tem controle para buscar apenas os dados necessários em vez de obter todos os detalhes; É por isso que a API grafql funciona mais rápido que a API REST.

Instalando pacotes

Vamos construir um nó.Aplicativo JS usando API grafql, então precisamos instalar o nó.JS e NPM para isso antes de iniciar o projeto.

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

Configurando o projeto

Usaremos a estrutura 'express' do nó.JS para construir nosso aplicativo. Crie um diretório chamado 'graphql' e inicie o projeto.

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

Configuração do MongoDB

Em nosso projeto GraphQL, usaremos o MongoDB como nosso banco de dados. MongoDB é um banco de dados esquemado e armazena dados na forma de pares de chaves. Para instalar o MongoDB, siga as etapas fornecidas.

Importar a chave GPG pública para MongoDB.

ubuntu@ubuntu: ~ $ wget -qo - https: // www.MongoDB.org/static/pgp/server-4.4.ASC | Sudo Apt-Key Add -

Crie o arquivo de lista para MongoDB.

ubuntu@ubuntu: ~ $ echo "Deb [arch = amd64, arm64] https: // repo.MongoDB.org/apt/ubuntu bionic/mongodb-org/4.4 multiverso "| sudo tee/etc/apt/fontes.lista.D/MONGODB-ORG-4.4.lista

Atualize os repositórios locais.

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

Instale o pacote MongoDB.

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

Inicie e habilite o MongoD.serviço.

ubuntu@ubuntu: ~ $ sudo systemctl start mongod.serviço
ubuntu@ubuntu: ~ $ sudo systemctl atability mongod.serviço

Instalando módulos NPM

Para o nosso aplicativo GraphQL, precisamos instalar alguns pacotes NPM. Instalaremos CORS, Express, Body-Parser, Mongoose, etc.

ubuntu@ubuntu: ~ $ cd graphql/
ubuntu@ubuntu: ~ $ npm install cors express parsper mongoose-save

Para criar uma API grafql, precisamos instalar um pacote NPM extra chamado 'Apollo-Server-Express.'Este pacote NPM é usado para executar o GraphQL Server com todos os nó.JS HTTP Frameworks como 'Express.'

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

Definindo esquema MongoDB

Agora temos nosso ambiente configurado para o nosso aplicativo GraphQL no nó.JS, e é hora de definir um esquema para nossa aplicação. Criar um arquivo 'modelos/aluno.JS 'no diretório raiz do projeto.

// Definindo o esquema do aluno
const Mongoose = requer ('Mongoose');
const Studentschema = novo Mongoose.Esquema(
nome:
Tipo: string,
Necessário: Verdadeiro
,
aula:
Tipo: Número,
Necessário: Verdadeiro
,
principal:
Tipo: string,
Necessário: Verdadeiro

,
Timestamps: verdadeiro
);
const Student = Mongoose.Model ('Student', Studentchema);
módulo.exports = Student, StudentsChema

No esquema acima definido, todo aluno deve ter um nome, classe e major.

Construindo API GraphQL

Depois de criar o esquema do aluno, agora criaremos a API grafql. Crie um 'esquema.JS 'para escrever parâmetros grafql. Existem dois parâmetros, 'tipos' e 'resolvedores', usados ​​na API grafql. Em 'tipos', especificaremos nosso esquema, as consultas (e.g., Fazendo solicitações de obter) e mutações (e.g., Fazendo atualizar ou excluir solicitações) ao esquema especificado. Escreveremos os diferentes métodos definidos em 'tipos' para vincular as consultas e mutações ao banco de dados em 'resolvedores.'

// Esquema de importação e módulo
const gql = requer ('apollo-server-express');
const student = requer ('./modelos/aluno ').Estudante;
// Esquema definindo, consulta e tipo de mutação
const typedefs = gql '
Tipo de aluno
eu fiz!,
Nome: String!,
Classe: int!,
Principal: String!

Consulta de tipos
GetStudents: [estudante],
getStudentById (id: id!): Estudante

Tipo de mutação
addStudent (nome: string!, Classe: int!, Principal: String! ): Estudante
UpdateStudent (Nome: String!, Classe: int!, Principal: String! ): Estudante
Deletestudent (ID: ID! ): Estudante
'
// Definindo resolvedores
const resolvedores =
Consulta:
getStudents: (pai, args) =>
Retornar aluno.encontrar();
,
getStudentById: (pai, args) =>
Retornar aluno.FindbyId (args.eu ia);

,
Mutação:
addStudent: (pai, args) =>
Deixe o aluno = novo aluno (
Nome: Args.nome,
Classe: Args.aula,
Principal: Args.principal
);
Retornar aluno.salvar();
,
UpdateStudent: (pai, args) =>
se(!args.id) retornar;
Retornar aluno.FinDoneAndupdate (
_id: args.eu ia
,

$ set:
Nome: Args.nome,
Classe: Args.aula,
Principal: Args.principal

,
new: true, (err, aluno) =>
if (err)
console.log (err);
outro ;
)



módulo.exports =
typedefs,
resolvedores

Criando o servidor API GraphQL

Agora quase terminamos de criar o aplicativo GraphQL. A única etapa restante é criar o servidor. Crie um arquivo chamado 'App.JS 'para configurar os parâmetros do servidor.

// Importando pacotes necessários
const express = requer ('express');
const Mongoose = requer ('Mongoose');
Const BodyParser = requer ('Body-Parser');
const cors = requer ('cors');
const Apolloserver = requer ('apollo-server-express');
// Esquema de importação
const typedefs, resolvedores = requer ('./esquema');
// conectando -se ao mongodb
const url = “MongoDB: // 127.0.0.1: 27017/estudantes ”;
const Connect = Mongoose.conectar (url, usenewurlparser: true);
conectar.então ((db) =>
console.log ('conexão bem -sucedida');
, (err) =>
console.log (err);
);
// criando servidor
const server = new Apolloserver (
typedefs: typedefs,
Resolvers: resolvedores
);
const app = express ();
aplicativo.Use (BodyParser.json ());
aplicativo.use ('*', cors ());
servidor.aplicar middleware (app);
aplicativo.Ouça (8000, () =>

console.log ('ouvindo 8000');
)

Testando a API do GraphQL

Temos nosso servidor grafql em funcionamento na porta 8000 e é hora de testar a API do GraphQL. Abra a página da Web GraphQL no navegador visitando o seguinte URL.

http: // localhost: 8000/graphql

E abrirá a seguinte página da web.

Adicione o aluno ao banco de dados usando a API GraphQL.

Da mesma forma, adicione mais alunos e, depois de adicionar o aluno, obtenha todos os alunos usando a API grafql.

Observe o ID de qualquer um dos alunos e obtenha o aluno específico usando seu ID.

Conclusão

Buscar dados do banco de dados usando a API REST padrão torna a consulta lenta, pois às vezes obtemos mais dados do que o necessário. Usando grafql, podemos buscar exatamente os dados necessários que tornam a API grafql mais rápida. Neste projeto de demonstração, temos apenas um único esquema, por isso criamos a API GraphQL para esse esquema único. Além disso, definimos três a quatro métodos para o esquema. Você pode criar mais de uma consulta ou mutações de acordo com o seu aplicativo.