Dynamic schema based on directive

[markmashworth]

I'm in the process of migrating a service from graphql-java to DGS and I've hit a roadblock. Currently, we use an @internal directive on fields we don't want exposed to external users. We create two GraphQL beans for each set of users, with fields annotated with @internal being removed from the schema for the public version. Then we use whichever GraphQL bean we need depending on the user making the request. I'm struggling because DGS ignores these and uses its own GraphQL bean. What would be the best way to hook into the DGS framework to achieve this behavior?

To give you a better idea, this is how we configure the GraphQL beans.

@Bean
@Qualifier("internalGraphQL")
public GraphQL internalGraphQL() {
    return buildGraphQLFromSchema(schema);
}

@Bean
@Qualifier("publicGraphQL")
public GraphQL publicGraphQL() {
    return buildGraphQLFromSchema(transformSchemaForPublic(schema));
}

private GraphQLSchema transformSchemaForPublic(final GraphQLSchema originalSchema) {
    final GraphQLSchema schemaWithoutInternalFields = new FieldVisibilitySchemaTransformation(
        new InternalFieldPredicate() /* implementation of graphql.schema.transform.VisibleFieldPredicate for @internal directive */
    ).apply(originalSchema);
    return SchemaTransformer.transformSchema(schemaWithoutInternalFields, new EmptyMutationRemover());
}

private GraphQL buildGraphQLFromSchema(final GraphQLSchema graphQLSchema) {
    return GraphQL.newGraphQL(graphQLSchema)
        .queryExecutionStrategy(new AsyncExecutionStrategy(new DataFetcherExceptionHandler()))
        .mutationExecutionStrategy(new AsyncSerialExecutionStrategy(new DataFetcherExceptionHandler()))
        .subscriptionExecutionStrategy(new SubscriptionExecutionStrategy())
        .instrumentation(instrumentation)
        .build();
}

Then we serve whichever is appropriate in our Graphql Invocation implementation

@Primary
@Component
public class GraphQLInvocationImpl implements GraphQLInvocation {
    private final GraphQL publicGraphQL;
    private final GraphQL internalGraphQL;
    .....

    @Override
    public CompletableFuture<ExecutionResult> invoke(GraphQLInvocationData invocationData, WebRequest webRequest) {
        final ExecutionInput executionInput = ExecutionInput.newExecutionInput()
            .context(webRequest)
            .query(invocationData.getQuery())
            .dataLoaderRegistry(dataLoaderRegistry)
            .operationName(invocationData.getOperationName())
            .variables(invocationData.getVariables())
            .build();

        if (isRequestInternal()) {
            return internalGraphQL.executeAsync(executionInput);
        } else {
            return publicGraphQL.executeAsync(executionInput);
        }
    }
}