Tutorial de Módulos GraphQL: Como modularizar o esquema GraphQL

Neste tutorial, mostraremos como usar os Módulos GraphQL para dividir seu aplicativo GraphQL em módulos simples, reutilizáveis ​​e baseados em recursos.

Abordaremos o seguinte:

• O que são módulos GraphQL?
• Por que usar os módulos GraphQL?
• Como funcionam os módulos GraphQL
• Mesclando esquemas com módulos GraphQL
• Injeção de dependência

O que são módulos GraphQL?

Módulos GraphQL é um conjunto de bibliotecas e diretrizes projetadas para ajudá-lo a criar módulos reutilizáveis, sustentáveis, testáveis ​​e extensíveis. O conceito básico por trás dos Módulos GraphQL é separar seu servidor GraphQL em módulos menores, independentes e baseados em recursos.

Módulos GraphQL ajudam a implementar a separação de interesses padrão de design no GraphQL, permitindo que você escreva módulos simples que fazem apenas o que precisam. Isso torna seu código mais fácil de escrever, testar e manter.

A estrutura de uma implementação inicial básica de um servidor GraphQL seria mais ou menos assim:

Conforme seu aplicativo GraphQL cresce, também aumenta a complexidade do seu esquema e resolvedores, o que pode dificultar a manutenção do esquema. Para organizar seu código, você desejará separar seus tipos de esquema e seus resolvedores associados em vários arquivos ou módulos e adicionar qualquer coisa relacionada a uma parte específica do aplicativo em um módulo. A biblioteca de módulos graphql ajuda a facilitar esse processo gradual.

Com graphql-modules , seu aplicativo seria estruturado da seguinte maneira:

Por que usar os módulos GraphQL?

A maioria dos desenvolvedores que usam os Módulos GraphQL selecionam o conjunto de ferramentas para seus módulos reutilizáveis, estrutura escalável, caminho claro para o crescimento e capacidade de teste. Vamos dar uma olhada em alguns dos motivos pelos quais os desenvolvedores recorrem aos Módulos GraphQL para escrever módulos reutilizáveis ​​e extensíveis para seus aplicativos GraphQL.

• Módulos reutilizáveis ​​: os módulos são definidos por seu esquema GraphQL em partes menores, que você pode mover e reutilizar posteriormente
• Estrutura escalonável : cada módulo tem um limite claramente definido, o que torna o gerenciamento de várias equipes e recursos, vários microsserviços e servidores muito mais fácil. Os módulos podem se comunicar entre si usando mensagens personalizadas
• Caminho claro para o crescimento : separando os recursos em módulos, é fácil ver como seu aplicativo pode crescer de módulos muito simples e rápidos de um único arquivo para uma equipe escalável de vários arquivos , módulos-repo e-server
• Testabilidade : testar pequenos trechos de código é mais fácil do que testar trechos maiores de código. Os Módulos GraphQL fornecem um conjunto de ferramentas rico para testar e simular seu aplicativo

Como funcionam os módulos GraphQL

Usaremos um aplicativo de biblioteca simples para mostrar como dividir seu aplicativo GraphQL em módulos. O aplicativo terá os módulos Book, Author e Genre e cada módulo será composto de definições de tipo e funções de resolução.

Criando um módulo GraphQL

Para começar a usar graphql-modules , tudo que você precisa é instalar seu pacote e o graphql :

//NPM
npm install-salvar graphql graphql-modules //Fio yarn adicionar módulos graphql graphql

Para criar um módulo, use createModule :

 import {createModule} de'graphql-modules'; export const myModule=createModule ({ id:'meu-módulo', dirname: __dirname, typeDefs: [ `type Query { olá: String! } `, ], resolvedores: { Inquerir: { Olá: ()=& gt;'mundo', }, },
});

Adicionar um id exclusivo ao módulo é importante porque o ajudará a localizar problemas na definição do tipo. O dirname , embora opcional, torna mais simples corresponder ao arquivo correto quando ocorre uma exceção.

Definições de tipo e resolvedores

Para definir esquemas, os Módulos GraphQL usam Schema Definition Language (SDL), assim como o GraphQL Schema.

Módulos GraphQL também implementam resolvedores da mesma maneira que qualquer outra implementação GraphQL. De acordo com a documentação dos Módulos GraphQL , os módulos criados pelos Módulos GraphQL podem detectar resolvedores duplicados, incorretos ou antigos (por exemplo , resolvedores que não correspondem às definições de tipo ou extensões).

Criação do módulo do livro

Veja como criar um módulo de livro para nosso aplicativo GraphQL:

//book.type.graphql
importar {gql} de'módulos do graphql'; export const Book=gql` tipo Query { livro (id: ID!): Livro } type Book { id: String título: String autor: autor resumo: String isbn: String gênero: [gênero] url: String }
`; //book.resolver.graphql export const BookResolver={ Inquerir: { livro (raiz, {id}) { Retorna { _eu fiz, título:"Para o farol", autor:"Virginia Woolf", resumo:"Resumo do livro", isbn:"12345678EDB" gênero: ["ficton"], url:"http://lighouse.com" }; }, }, Livro: { id (livro) { return book._id; }, título (livro) { return book.title; }, autor (livro) { return book.author; }, resumo (livro) { return book.summary; }, isbn (livro) { return book.isbn; }, gênero (livro) { return book.genre; }, url (livro) { return book.url; }, }, }, //book.module.graphql.ts
import {Book} from'./book.type.graphql';
import {BookResolver}'.book.resolver.graphql';
import {createModule} de'graphql-modules'; export const BookModule=createModule ({ id:'módulo de livro', dirname: __dirname, typeDefs: [Livro], resolvers: [BookResolvers]
});

Outros módulos

Para criar os módulos de autor e gênero para nosso aplicativo de biblioteca GraphQL de exemplo, siga as etapas abaixo:

//author.module.graphql.ts
import {Author} from'./author.type.graphql';
import {AuthorResolver}'.author.resolver.graphql';
import {createModule} de'graphql-modules'; export const AuthorModule=createModule ({ id:'módulo de livro', dirname: __dirname, typeDefs: [Autor], resolvers: [AuthorResolvers]
}); //genre.module.graphql.ts
import {Genre} de'./genre.type.graphql';
import {GenreResolver}'.genre.resolver.graphql';
import {createModule} de'graphql-modules'; export const GenreModule=createModule ({ id:'módulo de livro', dirname: __dirname, typeDefs: [gênero], resolvers: [GenreResolvers]
});

Mesclando esquemas com módulos GraphQL

Cada um dos módulos que definimos contribui com uma pequena parte de todo o esquema.

Para mesclar os esquemas, crie um aplicativo usando createApplication dos módulos GraphQL:

 import {createApplication} de'graphql-modules';
import {GenreModule} de'./genre/genre.module.graphql';
import {BookModule} de'./book/book.module.graphql';
import {AuthorModule} de'./author/author.module.graphql'; export const application=createApplication ({ módulos: [BookModule, AuthorModule, GenreModule],
});

O aplicativo contém seu esquema GraphQL e a implementação dele. Precisamos torná-lo consumível por um servidor GraphQL.

Módulos GraphQL têm várias implementações para servidores GraphQL populares, como Apollo , Express GraphQL e GraphQL Helix . Se você estiver usando o Apollo Servidor , você pode usar createSchemaForApollo para obter um esquema que seja adaptado para este servidor e se integre perfeitamente a ele:

 importar {ApolloServer} de'apollo-server';
import {application} from'./application'; esquema const=application.createSchemaForApollo (); const server=new ApolloServer ({ esquema,
}); server.listen (). then (({url})=& gt; { console.log (`& # x1f680; Servidor pronto em $ {url}`);
});

GraphQL context

No GraphQL, o contexto argumento é compartilhado por todos os resolvedores que estão executando para um operação particular. Você pode usar context para compartilhar o estado por operação, incluindo dados de autenticação, instâncias do dataloader, etc.

 const resolvers={ Inquerir: { myQuery (root, args, context, info) { //... }, },
};

//book.service.ts
import {Injectable} from'graphql-modules'; @Injectable ()
exportar classe BookService {} //book.module.graphql.ts
import {Book} from'./book.type.graphql';
import {BookResolver}'.book.resolver.graphql';
import {createModule} de'graphql-modules'; export const BookModule=createModule ({ id:'módulo de livro', dirname: __dirname, typeDefs: [Livro], resolvers: [BookResolvers], provedores: [BookService]
});

//book.resolver.graphql
importar {BookService} de'./book.service.ts'
export const BookResolver={ Inquerir: { livro (raiz, {id}, contexto) { const bookService=context.injector.get (BookService); Retorna { _eu fiz, //... }; }, }, Livro: { id (livro) { return book._id; }, //... }, },

 import {Injectable} from'graphql-modules';
importar {BookService} de'./book'; @Injectable ()
class AuthorService { construtor (bookService privado: BookService) {} allbooks (authorId) { retornar this.bookService.books (authorId) }
}

 import {InjectionToken} de'graphql-modules';
const ApiKey=new InjectionToken & lt; string & gt; ('api-key');
import {createModule} de'graphql-modules'; export const BookModule=createModule ({ id:'módulo de livro', /*... */ provedores: [ { fornecer: ApiKey, useValue:'my-api-key', }, ],
});

 import {InjectionToken} de'graphql-modules';
const ApiKey=new InjectionToken & lt; string & gt; ('api-key');
import {createModule} de'graphql-modules'; export const BookModule=createModule ({ id:'módulo de livro', /*... */ provedores: [ { fornecer: ApiKey, useFactory (config: Config) { if (context.environment) { return'my-api-key'; } return null; }, deps: [Config], }, ],
});

 import {Injectable} from'graphql-modules';
importar {BookService} de'./book'; @Injectable ()
class AuthorService { construtor (@Inject (ApiKey) chave privada: string, bookService privado: BookService) {} allbooks (authorId) { retornar this.bookService.books (authorId) }
}

//genre.service.ts
import {Injectable, Scope} from'graphql-modules'; @Injectable ({ escopo: Scope.Operation,
})
exportar classe GenreService {} //genre.module.graphql.ts
import {Genre} de'./genre.type.graphql';
import {GenreResolver}'.genre.resolver.graphql';
import {createModule} de'graphql-modules';
importar {GenreService} de'./genre.service.ts' export const GenreModule=createModule ({ id:'módulo de livro', dirname: __dirname, typeDefs: [gênero], resolvers: [GenreResolvers], provedores: [GenreService]
});