fix(deps): update graphql-java to v20.0.0

To update graphql-java to version 20.0.0 some changes are necessary:
 - the signature of DataLoaderDispatcherInstrumentation methods now have
   the InstrumentationState parameter. The ConfigurableDispatchInstrumentation is aligned to these changes
 - The SimpleInstrumentation is replaced by SimplePerformantInstrumentation. Now all the codebase uses the new class

(cherry picked from commit 76fb7bd)

Author: federicorispo

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLQueryInvoker.java

@@ -50,13 +50,12 @@ public static class Builder {
 
     private Supplier<ExecutionStrategyProvider> getExecutionStrategyProvider =
         DefaultExecutionStrategyProvider::new;
-    private Supplier<Instrumentation> getInstrumentation =
-        () -> SimplePerformantInstrumentation.INSTANCE;
+    private Supplier<Instrumentation> getInstrumentation = () -> SimplePerformantInstrumentation.INSTANCE;
     private Supplier<PreparsedDocumentProvider> getPreparsedDocumentProvider =
         () -> NoOpPreparsedDocumentProvider.INSTANCE;
     private Supplier<DataLoaderDispatcherInstrumentationOptions>
         dataLoaderDispatcherInstrumentationOptionsSupplier =
-            DataLoaderDispatcherInstrumentationOptions::newOptions;
+        DataLoaderDispatcherInstrumentationOptions::newOptions;
 
     public Builder withExecutionStrategyProvider(ExecutionStrategyProvider provider) {
       return withExecutionStrategyProvider(() -> provider);

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLBuilder.java

@@ -20,8 +20,7 @@ public class GraphQLBuilder {
       () -> NoOpPreparsedDocumentProvider.INSTANCE;
 
   @Getter
-  private Supplier<Instrumentation> instrumentationSupplier =
-      () -> SimplePerformantInstrumentation.INSTANCE;
+  private Supplier<Instrumentation> instrumentationSupplier = () -> SimplePerformantInstrumentation.INSTANCE;
 
   private Supplier<GraphQLBuilderConfigurer> graphQLBuilderConfigurerSupplier = () -> builder -> {};
 

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/ConfigurableDispatchInstrumentation.java

@@ -35,7 +35,9 @@ public class ConfigurableDispatchInstrumentation extends DataLoaderDispatcherIns
 
   private final Function<DataLoaderRegistry, TrackingApproach> approachFunction;
 
-  /** Creates a DataLoaderDispatcherInstrumentation with the default options */
+  /**
+   * Creates a DataLoaderDispatcherInstrumentation with the default options
+   */
   public ConfigurableDispatchInstrumentation(
       Function<DataLoaderRegistry, TrackingApproach> approachFunction) {
     this(DataLoaderDispatcherInstrumentationOptions.newOptions(), approachFunction);
@@ -46,8 +48,7 @@ public ConfigurableDispatchInstrumentation(
    *
    * @param options the options to control the behaviour
    */
-  public ConfigurableDispatchInstrumentation(
-      DataLoaderDispatcherInstrumentationOptions options,
+  public ConfigurableDispatchInstrumentation(DataLoaderDispatcherInstrumentationOptions options,
       Function<DataLoaderRegistry, TrackingApproach> approachFunction) {
     this.options = options;
     this.approachFunction = approachFunction;
@@ -59,29 +60,27 @@ public InstrumentationState createState(InstrumentationCreateStateParameters par
     return new DataLoaderDispatcherInstrumentationState(
         registry,
         approachFunction.apply(registry),
-        parameters.getExecutionInput().getExecutionId());
+        parameters.getExecutionInput().getExecutionId()
+    );
   }
 
   @Override
-  public DataFetcher<?> instrumentDataFetcher(
-      DataFetcher<?> dataFetcher,
-      InstrumentationFieldFetchParameters parameters,
-      InstrumentationState instrumentationState) {
-    DataLoaderDispatcherInstrumentationState state =
-        InstrumentationState.ofState(instrumentationState);
+  public DataFetcher<?> instrumentDataFetcher(DataFetcher<?> dataFetcher,
+      InstrumentationFieldFetchParameters parameters, InstrumentationState instrumentationState) {
+    DataLoaderDispatcherInstrumentationState state = InstrumentationState.ofState(
+        instrumentationState);
     if (state.isAggressivelyBatching()) {
       return dataFetcher;
     }
     //
     // currently only AsyncExecutionStrategy with DataLoader and hence this allows us to "dispatch"
     // on every object if it's not using aggressive batching for other execution strategies
     // which allows them to work if used.
-    return (DataFetcher<Object>)
-        environment -> {
-          Object obj = dataFetcher.get(environment);
-          doImmediatelyDispatch(state);
-          return obj;
-        };
+    return (DataFetcher<Object>) environment -> {
+      Object obj = dataFetcher.get(environment);
+      doImmediatelyDispatch(state);
+      return obj;
+    };
   }
 
   private void doImmediatelyDispatch(DataLoaderDispatcherInstrumentationState state) {
@@ -93,8 +92,8 @@ public InstrumentationContext<ExecutionResult> beginExecuteOperation(
       InstrumentationExecuteOperationParameters parameters,
       InstrumentationState instrumentationState) {
     if (!isDataLoaderCompatible(parameters.getExecutionContext())) {
-      DataLoaderDispatcherInstrumentationState state =
-          InstrumentationState.ofState(instrumentationState);
+      DataLoaderDispatcherInstrumentationState state = InstrumentationState.ofState(
+          instrumentationState);
       state.setAggressivelyBatching(false);
     }
     return SimpleInstrumentationContext.noOp();
@@ -118,8 +117,8 @@ private boolean isDataLoaderCompatible(ExecutionContext executionContext) {
   public ExecutionStrategyInstrumentationContext beginExecutionStrategy(
       InstrumentationExecutionStrategyParameters parameters,
       InstrumentationState instrumentationState) {
-    DataLoaderDispatcherInstrumentationState state =
-        InstrumentationState.ofState(instrumentationState);
+    DataLoaderDispatcherInstrumentationState state = InstrumentationState.ofState(
+        instrumentationState);
     //
     // if there are no data loaders, there is nothing to do
     //
@@ -142,8 +141,8 @@ public void onCompleted(ExecutionResult result, Throwable t) {
   @Override
   public InstrumentationContext<Object> beginFieldFetch(
       InstrumentationFieldFetchParameters parameters, InstrumentationState instrumentationState) {
-    DataLoaderDispatcherInstrumentationState state =
-        InstrumentationState.ofState(instrumentationState);
+    DataLoaderDispatcherInstrumentationState state = InstrumentationState.ofState(
+        instrumentationState);
     //
     // if there are no data loaders, there is nothing to do
     //
@@ -155,26 +154,25 @@ public InstrumentationContext<Object> beginFieldFetch(
 
   @Override
   public CompletableFuture<ExecutionResult> instrumentExecutionResult(
-      ExecutionResult executionResult,
-      InstrumentationExecutionParameters parameters,
+      ExecutionResult executionResult, InstrumentationExecutionParameters parameters,
       InstrumentationState instrumentationState) {
-    DataLoaderDispatcherInstrumentationState state =
-        InstrumentationState.ofState(instrumentationState);
+    DataLoaderDispatcherInstrumentationState state = InstrumentationState.ofState(
+        instrumentationState);
     state.getApproach().removeTracking(parameters.getExecutionInput().getExecutionId());
     if (!options.isIncludeStatistics()) {
       return CompletableFuture.completedFuture(executionResult);
     } else {
       Map<Object, Object> currentExt = executionResult.getExtensions();
-      Map<Object, Object> statsMap =
-          new LinkedHashMap<>(currentExt == null ? Collections.emptyMap() : currentExt);
+      Map<Object, Object> statsMap = new LinkedHashMap<>(
+          currentExt == null ? Collections.emptyMap() : currentExt);
       Map<Object, Object> dataLoaderStats = buildStatisticsMap(state);
       statsMap.put("dataloader", dataLoaderStats);
 
       log.debug("Data loader stats : {}", dataLoaderStats);
 
       return CompletableFuture.completedFuture(
-          new ExecutionResultImpl(
-              executionResult.getData(), executionResult.getErrors(), statsMap));
+          new ExecutionResultImpl(executionResult.getData(), executionResult.getErrors(),
+              statsMap));
     }
   }
 

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/NoOpInstrumentationProvider.java

@@ -1,13 +1,13 @@
 package graphql.kickstart.execution.instrumentation;
 
 import graphql.execution.instrumentation.Instrumentation;
-import graphql.execution.instrumentation.SimpleInstrumentation;
+import graphql.execution.instrumentation.SimplePerformantInstrumentation;
 import graphql.kickstart.execution.config.InstrumentationProvider;
 
 public class NoOpInstrumentationProvider implements InstrumentationProvider {
 
   @Override
   public Instrumentation getInstrumentation() {
-    return SimpleInstrumentation.INSTANCE;
+    return SimplePerformantInstrumentation.INSTANCE;
   }
 }

graphql-java-servlet/build.gradle

@@ -28,7 +28,7 @@ dependencies {
     compileOnly 'org.osgi:org.osgi.service.metatype.annotations:1.4.1'
     compileOnly 'org.osgi:org.osgi.annotation:6.0.0'
 
-    testImplementation 'io.github.graphql-java:graphql-java-annotations:8.3'
+    testImplementation 'io.github.graphql-java:graphql-java-annotations:9.1'
 
     // Unit testing
     testImplementation "org.codehaus.groovy:groovy-all:3.0.12"

graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/DataLoaderDispatchingSpec.groovy

@@ -4,7 +4,7 @@ import com.fasterxml.jackson.databind.ObjectMapper
 import graphql.ExecutionInput
 import graphql.execution.instrumentation.ChainedInstrumentation
 import graphql.execution.instrumentation.Instrumentation
-import graphql.execution.instrumentation.SimpleInstrumentation
+import graphql.execution.instrumentation.SimplePerformantInstrumentation
 import graphql.execution.instrumentation.dataloader.DataLoaderDispatcherInstrumentationOptions
 import graphql.kickstart.execution.context.ContextSetting
 import graphql.kickstart.execution.context.DefaultGraphQLContext
@@ -14,7 +14,7 @@ import graphql.kickstart.servlet.context.GraphQLServletContextBuilder
 import graphql.schema.DataFetcher
 import graphql.schema.DataFetchingEnvironment
 import org.dataloader.BatchLoader
-import org.dataloader.DataLoader
+import org.dataloader.DataLoaderFactory
 import org.dataloader.DataLoaderRegistry
 import org.springframework.mock.web.MockHttpServletRequest
 import org.springframework.mock.web.MockHttpServletResponse
@@ -59,9 +59,9 @@ class DataLoaderDispatchingSpec extends Specification {
 
   def registry() {
     DataLoaderRegistry registry = new DataLoaderRegistry()
-    registry.register("A", DataLoader.newDataLoader(batchLoaderWithCounter(fetchCounterA)))
-    registry.register("B", DataLoader.newDataLoader(batchLoaderWithCounter(fetchCounterB)))
-    registry.register("C", DataLoader.newDataLoader(batchLoaderWithCounter(fetchCounterC)))
+    registry.register("A", DataLoaderFactory.newDataLoader(batchLoaderWithCounter(fetchCounterA)))
+    registry.register("B", DataLoaderFactory.newDataLoader(batchLoaderWithCounter(fetchCounterB)))
+    registry.register("C", DataLoaderFactory.newDataLoader(batchLoaderWithCounter(fetchCounterC)))
     registry
   }
 
@@ -120,7 +120,7 @@ class DataLoaderDispatchingSpec extends Specification {
     mapper.readValue(response.getContentAsByteArray(), List)
   }
 
-  Instrumentation simpleInstrumentation = new SimpleInstrumentation()
+  Instrumentation simpleInstrumentation = new SimplePerformantInstrumentation()
   ChainedInstrumentation chainedInstrumentation = new ChainedInstrumentation(Collections.singletonList(simpleInstrumentation))
   def simpleSupplier = { simpleInstrumentation }
   def chainedSupplier = { chainedInstrumentation }

graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/OsgiGraphQLHttpServletSpec.groovy

@@ -5,7 +5,7 @@ import graphql.annotations.annotationTypes.GraphQLField
 import graphql.annotations.annotationTypes.GraphQLName
 import graphql.annotations.processor.GraphQLAnnotations
 import graphql.execution.instrumentation.InstrumentationState
-import graphql.execution.instrumentation.SimpleInstrumentation
+import graphql.execution.instrumentation.SimplePerformantInstrumentation
 import graphql.execution.instrumentation.parameters.InstrumentationCreateStateParameters
 import graphql.kickstart.execution.GraphQLRequest
 import graphql.kickstart.execution.config.ExecutionStrategyProvider
@@ -349,7 +349,7 @@ class OsgiGraphQLHttpServletSpec extends Specification {
   def "instrumentation provider is bound and unbound"() {
     setup:
     def servlet = new OsgiGraphQLHttpServlet()
-    def instrumentation = new SimpleInstrumentation()
+    def instrumentation = new SimplePerformantInstrumentation()
     def instrumentationProvider = Mock(InstrumentationProvider)
     instrumentationProvider.getInstrumentation() >> instrumentation
     def request = GraphQLRequest.createIntrospectionRequest()