Como construir uma API GraphQL com Apollo Server e MongoDB

Um dos fatores mais cruciais a serem considerados ao projetar um aplicativo é o tipo de arquitetura de API a ser usada. O design eficiente da API é crucial para garantir que os aplicativos tenham bom desempenho durante todo o seu ciclo de vida.

A arquitetura RESTful é a abordagem mais popular, mas tem uma desvantagem significativa: uma estrutura de endpoint fixa que retorna dados predeterminados. Esse design pode resultar em comunicação ineficiente.

Por outro lado, o GraphQL — uma alternativa ao REST — oferece mais flexibilidade ao permitir que você solicite apenas os dados de que precisa.

O que são APIs GraphQL?

GraphQLGenericName é uma linguagem de consulta que você pode usar para escrever APIs de back-end (Application Programming Interfaces). Diferente API REST, que possuem vários endpoints para dados diferentes, as APIs do GraphQL possuem apenas um ponto de entrada.

Os clientes podem especificar os dados de que precisam em suas consultas a partir desse único ponto de entrada, tornando-o mais flexível e eficiente para recuperar apenas os dados necessários.

Simplificando, uma API GraphQL implementa a arquitetura GraphQL descrita pelo Especificações do GraphQL. Esse design envolve a definição do esquema, das consultas e das mutações com as quais os clientes podem interagir.

Aqui está uma análise simplificada dos componentes essenciais da arquitetura GraphQL API:

1. Esquema: um esquema é uma descrição dos tipos de dados e operações que a API fornece. Basicamente, um esquema define a estrutura dos dados disponíveis e o tipo de consultas e mutações que um cliente pode executar para modificar os dados.
2. Consultas: os clientes usam consultas para buscar dados do banco de dados, especificando a estrutura dos dados de que precisam. Além disso, eles podem aninhar várias consultas em uma única solicitação HTTP para buscar dados relacionados de vários terminais.
3. Mutações: Mutações são operações usadas para modificar dados no banco de dados. Os clientes podem enviar solicitações de mutação para criar, atualizar ou excluir dados.

Configurar um banco de dados MongoDB

Para começar, criar um banco de dados MongoDB. Como alternativa, você pode configurar um cluster MongoDB na nuvem gratuitamente.Depois de configurar seu banco de dados, copie a string URI de conexão do banco de dados do MongoDB.

Você pode encontrar o código deste projeto em seu Repositório GitHub.

Criar um servidor Apollo

Servidor Apolo é uma implementação de servidor GraphQL popular que permitirá que você crie APIs GraphQL em ambientes JavaScript, incluindo Node.js, Express e muito mais.

Crie um diretório para um novo projeto e cd afim disso:

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

Em seguida, inicialize um novo projeto Node.js.

npm init --sim

Este comando cria um pacote.json arquivo.

Instale as dependências necessárias

Execute o seguinte comando para instalar os pacotes.

npm instalar apollo-server graphql mongoose

Por fim, crie um index.js arquivo no diretório raiz do seu projeto.

Configurar o servidor Apollo

Abrir index.js e adicione o código abaixo:

const { ApoloServidor } = exigir('servidor apolo');
const mangusto = exigir('mangusto');
const typeDefs = exigir("./graphql/typeDefs");
const resolvedores = exigir("./graphql/resolvedores");
const servidor = novo ApolloServer({
 typeDefs, 
 resolvedores 
});
const MONGO_URI = 'mongodb://localhost: 27017';
mangusto
 .connect (MONGO_URI, {
 useNewUrlParser: verdadeiro,
 useUnifiedTopology: verdadeiro,
 })
 .então(() => {
console.registro(`Db conectado`);
retornar server.listen({ porta: 5000 });
 })
 .então((res) => {
console.registro(`Servidor rodando em ${res.url}`);
 })
 .pegar(errar => {
console.log (err.mensagem);
 });

Esse código inicializa um servidor GraphQL local usando a biblioteca Apollo Server. Em seguida, ele estabelece uma conexão com um banco de dados MongoDB com o URI de conexão fornecido.

Observe como o código passa dois argumentos para a nova instância do ApolloServer: typeDefs e resolvedores. Eles especificam os tipos de dados e as operações que a API do GraphQL pode executar.

Depois que a conexão com o banco de dados MongoDB é configurada, o servidor começa a escutar na porta 5000.

Definir o modelo de dados

Crie uma nova pasta no diretório raiz da pasta do seu projeto e nomeie-a modelos. Nesta pasta, crie um novo nome de arquivo dataModel.js e adicione o seguinte código a ele:

const {modelo, esquema} = exigir('mangusto');
const empregadoEsquema = novo Esquema({
 nome: Corda,
 departamento: Corda,
 salário: Corda,
});
módulo.exportações = modelo('Funcionário', esquema do empregado);

Definir o esquema GraphQL

Um esquema GraphQL define a estrutura dos dados que você pode consultar usando a API GraphQL. O esquema também descreve as consultas e mutações que a API pode executar. Você pode usar consultas para buscar dados e mutações para modificá-los.

No diretório raiz do seu projeto, crie uma nova pasta e nomeie-a gráficoql. Dentro desta pasta, adicione dois arquivos: typeDefs.js e resolvers.js

Adicione o código abaixo no arquivo typeDefs.js:

const {gql} = exigir("servidor apolo");
const typeDefs = gql`
 tipo Funcionário {
 eu fiz!
 nome: Corda
 departamento: Corda
 salário: Corda
 }
 entrada EmpregadoEntrada {
 nome: Corda
 departamento: Corda
 salário: Corda
 }
 digite Consulta { 
 getEmployee (id: ID): Empregado #retornar Empregado por id
 Funcionários: [Empregado] #retornar variedade de Funcionários
 }
 tipo Mutação {
 createEmployee (employeeInput: EmployeeInput): Funcionário
 updateEmployee (id: ID, empregadoEntrada: EmployeeInput): boleano
 deleteEmployee (id: ID): boleano
 }
`;
módulo.exports = typeDefs;

Este código acima usa o gql função fornecida pelo pacote apollo-server para criar um esquema GraphQL para os dados do funcionário.

O esquema consiste em quatro elementos principais: tipos de dados para informações de funcionários, tipos de entrada, consultas e mutações que a API pode executar.

Defina os resolvedores para a API GraphQL

Um resolvedor é uma função do GraphQL que define os dados a serem transmitidos quando um cliente envia uma consulta de API para buscar dados. Essencialmente, sua função principal é recuperar os dados necessários da fonte de dados especificada e retorná-los ao cliente.

Adicione o código abaixo ao resolvers.js arquivo no gráficoql pasta. Os resolvedores, neste caso, são especificados nos objetos Query e Mutation.

O objeto Query define dois métodos: funcionários e getEmployee. Esses métodos são responsáveis ​​por buscar dados de funcionários do banco de dados mediante solicitação de um cliente.

const Empregado= exigir("../models/employeesModelo");
// Resolvedores GraphQL
const resolvedores = {
 Consulta: {
 funcionários: assíncrono () => {
tentar {
const funcionários = aguardam Employee.find({});
retornar funcionários;
 } pegar (erro) {
console.erro (erro);
lançarnovoErro('Falha ao buscar funcionários');
 }
 },
 getFuncionário: assíncrono (pai, argumentos) => {
tentar {
const funcionário = aguardam Employee.findById (args.id);
retornar funcionário;
 } pegar (erro) {
console.erro (erro);
lançarnovoErro('Falha ao buscar funcionário por ID');
 }
 },
 },

O objeto Mutation tem três métodos: criarFuncionário, atualizarEmpregado, e deletar funcionário. Esses métodos fazem alterações nos dados armazenados no banco de dados MongoDB.

 Mutação: {
assíncrono criarFuncionário (_, { empregadoEntrada: { nome, departamento, salário } }) {
const novoEmpregado = novo Funcionário({
 nome nome,
 departamento: departamento,
 salário: salário
 });
const resposta = aguardam novoEmpregado.save();
console.log (novoFuncionário);
retornar {
 id: resposta._id,
 ...resposta._doc
 }
 },
assíncrono updateEmployee (_, {id, empregadoEntrada: {nome, departamento, salário}}) {
const funcionário atualizado = aguardam Employee.updateOne(
 { _eu ia: eu ia },
 { nome, departamento, salario }
 );
se (!funcionário atualizado) {
lançarnovoErro(`Empregado com ID: ${id} não encontrado`);
 }
retornarverdadeiro; // Retorna um valor booleano indicando o sucesso da atualização
 },
assíncrono deleteFuncionário (_, {id}) {
const funcionário excluído = aguardam Funcionário.deleteOne({ _eu ia: eu ia });

se (!deletedEmployee || deletedEmployee.deletedCount 0) {
lançarnovoErro(`Empregado com ID ${id} não encontrado`);
 }
retornarverdadeiro; // Retorna um valor booleano indicando o sucesso da exclusão
 },
 },
};
módulo.exports = resolvedores;

Por fim, execute este comando para ativar o servidor:

nó index.js

Depois de estabelecer uma conexão com o banco de dados, o servidor iniciará na porta 5000.

Você pode testar a funcionalidade da API do GraphQL fazendo solicitações HTTP no playground do GraphQL em seu navegador.

Por exemplo, você pode usar o criarFuncionário mutação para adicionar novos dados de funcionários no banco de dados MongoDB.

Popularidade do GraphQL na comunidade de desenvolvedores

O GraphQL está ganhando força na comunidade de desenvolvedores como uma abordagem alternativa de design de API para a popular arquitetura REST.

Isso se deve à sua capacidade de fornecer uma maneira mais flexível e eficiente de recuperar dados de várias fontes, tudo a partir de um único ponto de entrada. Isso evita ter que gerenciar vários endpoints para dados diferentes, o que é um problema comum com a arquitetura da API REST. Essa solução de design simplifica o processo de criação e gerenciamento de APIs de back-end.