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:
/graphql→ onde ficam os “endpoints” para acesso dos usuários/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_
