GraphQL no Quarkus

Tudo que está nesse projeto pode ser encontrado no repositório GitHub.

Para a nossa poc o que fizemos foi primeiro pegar.

Intro ao projeto

Esse projeto já foi contextualizado no dev.to. Basicamente o que ele faz
é pegar usar o get da api encontrada em https://randomuser.me/api e aplica um GraphQL na resposta.

GRAPHQL On Quarkus

Dependências

Para utilizar o GraphQL neste projeto utilizamos uma dependência da Vert.x, documentação completa você pode encontrar
aqui para importar basta adicionar em seu pom.xml

 <dependency> <groupId>io.vertx</groupId> <artifactId>vertx-web-graphql</artifactId> </dependency> 

Vamos para o código

Antes de usar o GraphQL precisamos modelar alguns DTO's para nossa modelagem:

public class Names { private String title; private String first; private String last; // Getters and Setters } 

Para esse modelo precisamos utilizaremos um Fetcher, que deve ficar da seguinte forma:

public class UserFetcher implements DataFetcher<List<User>> { private final UserClient userClient; public UserFetcher(UserClient userClient) { this.userClient = userClient; } private Results getResult() { return userClient.getUsers(); } @Override public List<User> get(DataFetchingEnvironment environment) throws Exception { return getResult().getResults(); } } 

Producer

Para pegar os resultados, vamos precisar também de uma classe producer como a seguir, é um pouco de boilerplate, vou tentar fazer uma
extensão de quarkus para reduzir essa e outras partes que são repetitivas, enquanto isso não acontece, a classe fica da seguinte forma:

 public class GraphQLProducer { private Logger LOGGER = LoggerFactory.getLogger(GraphQLProducer.class); @RestClient @Inject private UserClient userClient; @Produces public GraphQL setup() { LOGGER.info("Setting up GraphQL.."); SchemaParser schemaParser = new SchemaParser(); TypeDefinitionRegistry registry = schemaParser.parse( new InputStreamReader( Objects.requireNonNull(Thread.currentThread().getContextClassLoader() .getResourceAsStream("META-INF/resources/graphql.schema")))); SchemaGenerator schemaGenerator = new SchemaGenerator(); GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(registry, wirings()); return GraphQL.newGraphQL(graphQLSchema).build(); } private RuntimeWiring wirings() { LOGGER.info("Wiring queries.."); return RuntimeWiring.newRuntimeWiring() .type("Query", builder -> builder.dataFetcher("allUsers", new UserFetcher(userClient))) .build(); } } 

Na parte de getResourceAsStream() você coloca o schema de graphql que você desejar, no nosso caso ficou o META-INF/resources/graphql.schema

type Names { first: String last: String } type User { email: String name: Names gender: String phone: String cell: String nat: String } type Query { allUsers : [User] } 

Além disto, na parte de wirings() colocamos quem será o Fetcher que vai ser utilizado para allUsers que foi declarado dentro do graphql.schema

Finalizando temos que declarar a parte de Rotas (outra parte que é um pouco boilerplate que também pode entrar na extensão).

@ApplicationScoped public class Routes { @Inject GraphQL graphQL; public void init(@Observes Router router) { boolean enableGraphiQL = true; router.route("/graphql") .handler(new GraphQLHandlerImpl(graphQL, new GraphQLHandlerOptions())); router.route("/graphiql/*").handler( GraphiQLHandler.create(new GraphiQLHandlerOptions().setEnabled(enableGraphiQL))); } } 

Foram declaradas duas rotas:

1. /graphql → onde ficam os "endpoints" para acesso dos usuários
2. /graphiql/* → onde fica a documentação para o que foi registrado.

## Concluindo
Resumindo tudo que fizemos não é muito complicado depois da primeira vez, mas falta muita documentação e várias vezes vi
lugares mostrando como se fosse meio que mágica, como se fizesse um import e já funciona. Depois de muitos testes funciona
bem, mas como já disse existem muitas partes que podem ser eliminadas por uma extensão mais completa.

Outra coisa que ficou muito obscuro e difícil são as headers como authorização não é muito simples de manipular e fazer alguma
validação com elas.

Com isso tudo não acho uma boa opção comparando com o que já tem em Spring Boot, para esse caso ainda não está maduro suficiente,
mas é claro que não está muito longe e, é fácil de ver como chegariam nesse ponto.

## Quer acompanhar um pouco mais?
Me siga nas plataformas._

GitHub: luizleite-hotmart

Twitter: luizleite_

Twitch: coffee_and_code

Linkedin: luizleiteoliveira

dev.to: luizleite_