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.