extension point for ExecutionStrategy

dfa1 · dfa1 · commit bf510c23164d · 2025-04-05T19:45:45.000+02:00
This will allows to customize which java.util.Map concrete class to use.
For example, eclipse-collections has Map implementations with better
memory footprint than JDK maps.
diff --git a/src/main/java/graphql/execution/AbstractAsyncExecutionStrategy.java b/src/main/java/graphql/execution/AbstractAsyncExecutionStrategy.java
@@ -21,20 +21,4 @@ public AbstractAsyncExecutionStrategy(DataFetcherExceptionHandler dataFetcherExc
         super(dataFetcherExceptionHandler);
     }
 
-    protected BiConsumer<List<Object>, Throwable> handleResults(ExecutionContext executionContext, List<String> fieldNames, CompletableFuture<ExecutionResult> overallResult) {
-        return (List<Object> results, Throwable exception) -> executionContext.run(exception, () -> {
-            if (exception != null) {
-                handleNonNullException(executionContext, overallResult, exception);
-                return;
-            }
-
-            Map<String, Object> resolvedValuesByField = Maps.newLinkedHashMapWithExpectedSize(fieldNames.size());
-            int ix = 0;
-            for (Object result : results) {
-                String fieldName = fieldNames.get(ix++);
-                resolvedValuesByField.put(fieldName, result);
-            }
-            overallResult.complete(new ExecutionResultImpl(resolvedValuesByField, executionContext.getErrors()));
-        });
-    }
 }
diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java
@@ -291,8 +291,12 @@ private BiConsumer<List<Object>, Throwable> buildFieldValueMap(List<String> fiel
         };
     }
 
-    @NonNull
-    private static Map<String, Object> buildFieldValueMap(List<String> fieldNames, List<Object> results) {
+    /**
+     * Default implementation that creates a mutable {@link java.util.LinkedHashMap}.
+     * Concrete classes are enabled to override this method to change the concrete {@link Map} implementation
+     * (e.g. immutable maps, unified maps from eclipse-collections and so on).
+     */
+    protected Map<String, Object> buildFieldValueMap(List<String> fieldNames, List<Object> results) {
         Map<String, Object> resolvedValuesByField = Maps.newLinkedHashMapWithExpectedSize(fieldNames.size());
         int ix = 0;
         for (Object fieldValue : results) {
@@ -1135,6 +1139,17 @@ protected ExecutionStepInfo createExecutionStepInfo(ExecutionContext executionCo
                 .build();
     }
 
+    protected BiConsumer<List<Object>, Throwable> handleResults(ExecutionContext executionContext, List<String> fieldNames, CompletableFuture<ExecutionResult> overallResult) {
+        return (List<Object> results, Throwable exception) -> {
+            if (exception != null) {
+                handleNonNullException(executionContext, overallResult, exception);
+                return;
+            }
+            final var map = buildFieldValueMap(fieldNames, results);
+            overallResult.complete(new ExecutionResultImpl(map, executionContext.getErrors()));
+        };
+    }
+
     @NonNull
     private static Supplier<ImmutableMapWithNullValues<String, Object>> getArgumentValues(ExecutionContext executionContext,
                                                                                           List<GraphQLArgument> fieldArgDefs,
diff --git a/src/test/groovy/graphql/CustomMapImplementation.groovy b/src/test/groovy/graphql/CustomMapImplementation.groovy
@@ -0,0 +1,72 @@
+package graphql
+
+import graphql.execution.AsyncExecutionStrategy
+import graphql.schema.idl.RuntimeWiring
+import groovy.transform.Immutable
+import spock.lang.Specification
+
+class CustomMapImplementation extends Specification {
+
+    @Immutable
+    static class Person {
+        String name
+        @SuppressWarnings('unused') // used by graphql-java
+        int age
+    }
+
+    class CustomMapExecutionStrategy extends  AsyncExecutionStrategy {
+
+        @Override
+        protected Map<String, Object> buildFieldValueMap(List<String> fieldNames, List<Object> results) {
+            var mutable = super.buildFieldValueMap(fieldNames, results)
+            // just change the Map to be immutable
+            // real world implementation could use eclipse-collections unified maps that are 50% smaller than JDK maps
+            return Collections.unmodifiableMap(mutable)
+        }
+    }
+
+    def graphql = TestUtil.graphQL("""
+                type Query {
+                    people: [Person!]!
+                }
+                
+                type Person {
+                    name: String!
+                    age: Int!
+                }
+                
+            """,
+            RuntimeWiring.newRuntimeWiring()
+                .type("Query", {
+                    it.dataFetcher("people", { List.of(new Person("Mario", 18), new Person("Luigi", 21))})
+                })
+                .build())
+            .queryExecutionStrategy(new CustomMapExecutionStrategy())
+            .build()
+
+    def "customMapImplementation"() {
+        when:
+        def input = ExecutionInput.newExecutionInput()
+                .query('''
+                        query {
+                            people {
+                                name
+                                age
+                            }
+                        }
+                        ''')
+                .build()
+
+        def executionResult = graphql.execute(input)
+
+        then:
+        executionResult.errors.isEmpty()
+        executionResult.data == [ people: [
+                [name: "Mario", age: 18],
+                [name: "Luigi", age: 21],
+        ]]
+        executionResult.data.getClass().getSimpleName() == 'UnmodifiableMap'
+        executionResult.data['people'].each { it -> it.getClass().getSimpleName() == 'UnmodifiableMap' }
+    }
+
+}
