//определение клиента
@GraphQLClientApi(configKey = "star-wars-typesafe")
public interface StarWarsClientApi {

    FilmConnection allFilms();

}

//пример запроса
public class StarWarsResource {
    @Inject
    StarWarsClientApi typesafeClient;

    public FilmConnection getAllFilms() {
        return typesafeClient.allFilms();
    }
}

public class StarWarsResource {

    @Inject
    @GraphQLClient("star-wars-dynamic")
    DynamicGraphQLClient dynamicClient;
    
    public FilmConnection getAllFilmsUsingDynamicClient() {
        Document query = document(
                operation(
                        field("allFilms",
                                field("films",
                                        field("title"),
                                        field("planetConnection",
                                                field("planets",
                                                        field("name")
                                                )
                                        )
                                )
                        )
                )
        );
        Response response = dynamicClient.executeSync(query);
        return response.getObject(FilmConnection.class, "allFilms");
    }

}

ext {
        quarkusVersion = "2.7.4.Final"
        graphqlVersion = "17.0"
        lombokVersion = "1.18.22"
}

dependencies {
    implementation(
            platform("io.quarkus:quarkus-bom:$quarkusVersion"),
            "io.quarkus:quarkus-config-yaml",
            "io.quarkus:quarkus-grpc-common",
            "io.quarkus:quarkus-grpc-stubs",
            "com.graphql-java:graphql-java-extended-scalars:$graphqlVersion",
            "com.graphql-java:graphql-java-extended-validation:$graphqlVersion",
            "io.vertx:vertx-web-graphql",
            "com.google.protobuf:protobuf-java-util",
            "com.fasterxml.jackson.core:jackson-databind",
    )
    compileOnly("org.projectlombok:lombok:$lombokVersion")
    annotationProcessor("org.projectlombok:lombok:$lombokVersion")
}

У Quarkus под капотом находится Vertx, что бывает очень полезно для написания каких-то низкоуровневых вещей. Серверная часть Quarkus полностью основана на Vertx, реактивные REST/GraphQL клиенты под капотом используют HTTP-клиент из Vertx, работа с БД идёт через библиотеки Vertx. Однако не все компоненты, для которых есть реализация в Vertx, переиспользуются в Quarkus. Серверная часть для GraphQL и обёртка для работы с gRPC в Quarkus написана без использования Vertx.

package ru.craftysoft.platform.gateway.configuration;

import graphql.GraphQL;
import graphql.language.FieldDefinition;
import graphql.language.ObjectTypeDefinition;
import graphql.schema.DataFetcher;
import graphql.schema.DataFetchingEnvironment;
import graphql.schema.idl.SchemaGenerator;
import graphql.schema.idl.SchemaParser;
import graphql.schema.idl.TypeDefinitionRegistry;
import graphql.schema.idl.TypeRuntimeWiring;
import graphql.validation.constraints.standard.SizeConstraint;
import graphql.validation.rules.OnValidationErrorStrategy;
import graphql.validation.rules.ValidationRules;
import graphql.validation.schemawiring.ValidationSchemaWiring;
import io.vertx.core.Future;
import io.vertx.ext.web.handler.graphql.schema.VertxDataFetcher;
import lombok.NoArgsConstructor;

import java.util.Collection;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

import static graphql.scalars.ExtendedScalars.*;
import static graphql.schema.idl.RuntimeWiring.newRuntimeWiring;
import static lombok.AccessLevel.PRIVATE;

@NoArgsConstructor(access = PRIVATE)
public class GraphQlFactory {

    private static final LoggingInstrumentation loggingInstrumentation = new LoggingInstrumentation();

    public static <T> GraphQL graphQl(Function<DataFetchingEnvironment, Future<T>> dataFetcher, String graphql) {
        var typeRegistry = new SchemaParser().parse(graphql);
        var validationRules = ValidationRules.newValidationRules()
                .onValidationErrorStrategy(OnValidationErrorStrategy.RETURN_NULL)
                .addRule(new SizeConstraint())
                .build();
        var queries = resolveMethods(typeRegistry, "Query");
        var mutations = resolveMethods(typeRegistry, "Mutation");
        var runtimeWiring = newRuntimeWiring()
                .directiveWiring(new ValidationSchemaWiring(validationRules))
                .scalar(GraphQLLong)
                .scalar(DateTime)
                .scalar(Date)
                .type("Query", builder -> resolveBuilder(queries, dataFetcher, builder))
                .type("Mutation", builder -> resolveBuilder(mutations, dataFetcher, builder))
                .build();
        var graphQLSchema = new SchemaGenerator().makeExecutableSchema(typeRegistry, runtimeWiring);
        return GraphQL.newGraphQL(graphQLSchema)
                .instrumentation(loggingInstrumentation)
                .build();
    }

    private static List<String> resolveMethods(TypeDefinitionRegistry typeRegistry, String type) {
        return typeRegistry.getType(type)
                .map(ObjectTypeDefinition.class::cast)
                .map(ObjectTypeDefinition::getChildren)
                .stream()
                .flatMap(Collection::stream)
                .map(FieldDefinition.class::cast)
                .map(FieldDefinition::getName)
                .toList();
    }

    private static <T> TypeRuntimeWiring.Builder resolveBuilder(List<String> methods,
                                                                Function<DataFetchingEnvironment, Future<T>> dataFetcher,
                                                                TypeRuntimeWiring.Builder builder) {
        var dataFetcherMap = methods.stream()
                .collect(Collectors.toMap(name -> name, name -> (DataFetcher) VertxDataFetcher.create(dataFetcher)));
        return builder.dataFetchers(dataFetcherMap);
    }

}

package ru.craftysoft.platform.gateway.configuration;

import graphql.GraphQL;
import lombok.SneakyThrows;
import ru.craftysoft.platform.gateway.resolver.MainResolver;

import javax.enterprise.context.ApplicationScoped;
import java.nio.charset.StandardCharsets;
import java.util.Objects;

@ApplicationScoped
public class GraphQlConfiguration {

    @ApplicationScoped
    public GraphQL graphQl(MainResolver mainResolver) {
        var contract = parse();
        return GraphQlFactory.graphQl(mainResolver::resolve, contract);
    }

    @SneakyThrows
    private String parse() {
        var graphqlAsBytes = Objects.requireNonNull(GraphQlConfiguration.class.getResourceAsStream("/gateway.graphqls"))
                .readAllBytes();
        return new String(graphqlAsBytes, StandardCharsets.UTF_8);
    }
}

package ru.craftysoft.platform.gateway.handler;

import graphql.GraphQL;
import io.vertx.ext.web.RoutingContext;
import io.vertx.ext.web.handler.graphql.GraphQLHandler;
import io.vertx.ext.web.handler.graphql.GraphQLHandlerOptions;
import lombok.RequiredArgsConstructor;

import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
@RequiredArgsConstructor
public class MainHandler {

    private final GraphQL graphQl;
    private final GraphQLHandlerOptions graphQlHandlerOptions = new GraphQLHandlerOptions().setRequestBatchingEnabled(true);

    public void graphqlHandle(RoutingContext routingContext) {
        GraphQLHandler.create(graphQl, graphQlHandlerOptions).handle(routingContext);
    }
}

package ru.craftysoft.platform.gateway.configuration;

import io.vertx.core.Vertx;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.handler.BodyHandler;
import ru.craftysoft.platform.gateway.handler.MainHandler;

import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class RouterConfiguration {

    public static final String GRAPHQL_ROUTE_PATH = "/graphql";

    @ApplicationScoped
    public Router router(Vertx vertx, MainHandler mainHandler) {
        var router = Router.router(vertx);
        var bodyHandler = BodyHandler.create();
        router.post().handler(bodyHandler);
        router.post(GRAPHQL_ROUTE_PATH)
                .handler(mainHandler::graphqlHandle);
        return router;
    }

}

graphql:
  services-by-methods:
    filter: grpc-service
    getById: grpc-service
    update: grpc-service
    empty: grpc-service
grpc:
  services:
    grpc-service:
      service-name: "ru.craftysoft.platform.grpcservice.proto.GrpcService"
      host: 0.0.0.0
      port: 9000
      reflection-client-deadline: 1000
      dynamic-client-deadline: 2000

package ru.craftysoft.platform.gateway.configuration.property;

import io.smallrye.config.ConfigMapping;

import java.util.Map;

@ConfigMapping(prefix = "graphql")
public interface GraphQlServersByMethodsMap {

    Map<String, String> serversByMethods();

}

package ru.craftysoft.platform.gateway.configuration.property;

import io.smallrye.config.ConfigMapping;

import java.util.Map;

@ConfigMapping(prefix = "grpc")
public interface GrpcClientConfigurationMap {
    Map<String, ServerConfiguration> services();

    interface ServerConfiguration {
        String serviceName();

        String host();

        int port();

        long reflectionClientDeadline();

        long dynamicClientDeadline();
    }
}

package ru.craftysoft.platform.gateway.service.client.grpc;

import io.grpc.CallOptions;
import io.grpc.Channel;
import io.grpc.Deadline;
import io.grpc.reflection.v1alpha.ServerReflectionRequest;
import io.grpc.reflection.v1alpha.ServerReflectionResponse;
import io.smallrye.mutiny.Uni;
import lombok.RequiredArgsConstructor;

import java.util.concurrent.TimeUnit;

import static io.grpc.reflection.v1alpha.ServerReflectionGrpc.getServerReflectionInfoMethod;

@RequiredArgsConstructor
public class ReflectionGrpcClient {
    private final Channel channel;
    private final long deadline;

    public Uni<ServerReflectionResponse> serverReflectionInfo(ServerReflectionRequest request) {
        var call = channel
                .newCall(
                        getServerReflectionInfoMethod(),
                        CallOptions.DEFAULT.withDeadline(Deadline.after(deadline, TimeUnit.MILLISECONDS))
                );
        return io.quarkus.grpc.runtime.ClientCalls.oneToOne(
                request,
                (message, streamObserver) -> io.grpc.stub.ClientCalls.asyncUnaryCall(call, message, streamObserver)
        );
    }
}

package ru.craftysoft.platform.gateway.builder.reflection;

import io.grpc.reflection.v1alpha.ServerReflectionRequest;

import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class ServerReflectionRequestBuilder {

    public ServerReflectionRequest build(String serviceName) {
        return ServerReflectionRequest.newBuilder()
                .setFileContainingSymbol(serviceName)
                .build();
    }

}

В protobuf нельзя передать null-значение. В отдельных случаях можно использовать стандартные классы-обёртки, которые есть в библиотеке, такие как StringValue, BooleanValue, рассматривая их значение по умолчанию как null. Но если для строк (в нашем случае) это будет работать, т.к. значением по умолчанию там является пустая строка, то 0 для числовых значений для нас неприемлем. Я подготовил небольшой proto-файл с обёртками для примитивов, в котором используется google.protobuf.NullValue для корректной работы с null.

package ru.craftysoft.platform.gateway.builder.dynamic;

import com.google.protobuf.Descriptors;
import com.google.protobuf.DynamicMessage;
import com.google.protobuf.ExtensionRegistryLite;
import io.grpc.MethodDescriptor;

import javax.enterprise.context.ApplicationScoped;
import java.io.IOException;
import java.io.InputStream;

import static io.grpc.MethodDescriptor.MethodType.UNARY;

@ApplicationScoped
public class DynamicMessageMethodDescriptorBuilder {

    public MethodDescriptor<DynamicMessage, DynamicMessage> build(String serviceName,
                                                                  String methodName,
                                                                  Descriptors.Descriptor inputType,
                                                                  Descriptors.Descriptor outputType) {
        var fullMethodName = MethodDescriptor.generateFullMethodName(serviceName, methodName);
        return MethodDescriptor.<DynamicMessage, DynamicMessage>newBuilder()
                .setType(UNARY)
                .setFullMethodName(fullMethodName)
                .setRequestMarshaller(new DynamicMessageMarshaller(inputType))
                .setResponseMarshaller(new DynamicMessageMarshaller(outputType))
                .build();
    }

    private static class DynamicMessageMarshaller implements MethodDescriptor.Marshaller<DynamicMessage> {
        private final Descriptors.Descriptor messageDescriptor;

        public DynamicMessageMarshaller(Descriptors.Descriptor messageDescriptor) {
            this.messageDescriptor = messageDescriptor;
        }

        @Override
        @SneakyThrows
        public DynamicMessage parse(InputStream inputStream) {
            return DynamicMessage.newBuilder(messageDescriptor)
                    .mergeFrom(inputStream, ExtensionRegistryLite.getEmptyRegistry())
                    .build();
        }

        @Override
        public InputStream stream(DynamicMessage abstractMessage) {
            return abstractMessage.toByteString().newInput();
        }
    }

}

public void refreshHandle(RoutingContext routingContext) {
    var contract = ofNullable(routingContext.getBody())
            .map(Buffer::getBytes)
            .map(bytes -> new String(bytes, StandardCharsets.UTF_8))
            .orElseThrow();
    var newGraphQl = GraphQlFactory.graphQl(mainResolver::resolve, contract);
    var newGraphQlHandler = GraphQLHandler.create(newGraphQl, graphQlHandlerOptions);
    router.getRoutes().stream()
            .filter(route -> GRAPHQL_ROUTE_PATH.equals(route.getName()))
            .findFirst()
            .orElseThrow()
            .remove();
    router.post(GRAPHQL_ROUTE_PATH)
            .handler(newGraphQlHandler);
    routingContext.response().end("OK");
}

@ApplicationScoped
public Router router(Vertx vertx, MainHandler mainHandler) {
    var router = Router.router(vertx);
    var bodyHandler = BodyHandler.create();
    router.post().handler(bodyHandler);
    router.post(GRAPHQL_ROUTE_PATH)
            .handler(mainHandler::graphqlHandle);
    router.post("/refresh")
            .handler(mainHandler::refreshHandle);
    return router;
}

implementation("io.quarkus:quarkus-cache")

public Uni<Descriptors.FileDescriptor> serverReflectionInfo(String serverName, String serviceName) {
    var serviceKey = new ServiceKey(serverName, serviceName);
    return serverReflectionInfo(serviceKey);
}

@CacheResult(cacheName = "server-reflection-info")
Uni<Descriptors.FileDescriptor> serverReflectionInfo(@CacheKey ServiceKey serviceKey) {
    var serverReflectionClient = reflectionClients.get(serviceKey.serverName);
    var request = requestBuilder.build(serviceKey.serviceName);
    return serverReflectionClient.serverReflectionInfo(request)
            .map(fileDescriptorResolver::resolve);
}

private record ServiceKey(String serverName, String serviceName) {
}

quarkus:
  cache:
    caffeine:
      server-reflection-info:
        expire-after-write: 60S
        maximum-size: 100

public void refreshHandle(RoutingContext routingContext) {
    invalidateCache().subscribe().asCompletionStage();
    // пересоздание Route
}

@CacheInvalidateAll(cacheName = "server-reflection-info")
Uni<Void> invalidateCache() {
    return Uni.createFrom().voidItem();
}