Rename DeferredCall -> DeferredFragmentCall

andimarek · Feb 13, 2024 · Dec 20, 2023 · Dec 20, 2023 · Dec 20, 2023 · Jan 2, 2024
commit d87a6df1222655b6da540c3c468ed87b4c70b103
diff --git a/src/main/java/graphql/execution/AsyncExecutionStrategy.java b/src/main/java/graphql/execution/AsyncExecutionStrategy.java
@@ -6,7 +6,7 @@
 import graphql.ExecutionResult;
 import graphql.GraphQLContext;
 import graphql.PublicApi;
-import graphql.execution.incremental.DeferredCall;
+import graphql.execution.incremental.DeferredFragmentCall;
 import graphql.execution.incremental.DeferredCallContext;
 import graphql.execution.incremental.DeferredExecution;
 import graphql.execution.incremental.IncrementalCall;
@@ -159,7 +159,7 @@ class DeferredExecutionSupportImpl implements DeferredExecutionSupport {
             private final ExecutionStrategyParameters parameters;
             private final ExecutionContext executionContext;
             private final BiFunction<ExecutionContext, ExecutionStrategyParameters, CompletableFuture<FieldValueInfo>> resolveFieldWithInfoFn;
-            private final Map<String, Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>>> dfCache = new HashMap<>();
+            private final Map<String, Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>>> dfCache = new HashMap<>();
 
             private DeferredExecutionSupportImpl(
                     MergedSelectionSet mergedSelectionSet,
@@ -207,28 +207,28 @@ public List<String> getNonDeferredFieldNames(List<String> allFieldNames) {
             @Override
             public Set<IncrementalCall<? extends IncrementalPayload>> createCalls() {
                 return deferredExecutionToFields.keySet().stream()
-                        .map(this::createDeferredCall)
+                        .map(this::createDeferredFragmentCall)
                         .collect(Collectors.toSet());
             }
 
-            private DeferredCall createDeferredCall(DeferredExecution deferredExecution) {
+            private DeferredFragmentCall createDeferredFragmentCall(DeferredExecution deferredExecution) {
                 DeferredCallContext deferredCallContext = new DeferredCallContext();
 
                 List<MergedField> mergedFields = deferredExecutionToFields.get(deferredExecution);
 
-                List<Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>>> calls = mergedFields.stream()
+                List<Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>>> calls = mergedFields.stream()
                         .map(currentField -> this.createResultSupplier(currentField, deferredCallContext))
                         .collect(Collectors.toList());
 
-                return new DeferredCall(
+                return new DeferredFragmentCall(
                         deferredExecution.getLabel(),
                         this.parameters.getPath(),
                         calls,
                         deferredCallContext
                 );
             }
 
-            private Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>> createResultSupplier(
+            private Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>> createResultSupplier(
                     MergedField currentField,
                     DeferredCallContext deferredCallContext
             ) {
@@ -266,7 +266,7 @@ private Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>> creat
 
                                     return executionResultCF
                                             .thenApply(executionResult ->
-                                                    new DeferredCall.FieldWithExecutionResult(currentField.getName(), executionResult)
+                                                    new DeferredFragmentCall.FieldWithExecutionResult(currentField.getName(), executionResult)
                                             );
                                 }
                         )

diff --git a/src/main/java/graphql/execution/incremental/DeferredCallContext.java b/src/main/java/graphql/execution/incremental/DeferredCallContext.java
@@ -10,12 +10,12 @@
 import java.util.concurrent.CopyOnWriteArrayList;
 
 /**
- * Contains data relevant to the execution of a {@link DeferredCall}.
+ * Contains data relevant to the execution of a {@link DeferredFragmentCall}.
  * <p>
  * The responsibilities of this class are similar to {@link graphql.execution.ExecutionContext}, but restricted to the
  * execution of a deferred call (instead of the whole GraphQL execution like {@link graphql.execution.ExecutionContext}).
  * <p>
- * Some behaviours, like error capturing, need to be scoped to a single {@link DeferredCall}, because each defer payload
+ * Some behaviours, like error capturing, need to be scoped to a single {@link DeferredFragmentCall}, because each defer payload
  * contains its own distinct list of errors.
  */
 @Internal

diff --git a/...l/execution/incremental/DeferredCall.java → ...ion/incremental/DeferredFragmentCall.java b/...l/execution/incremental/DeferredCall.java → ...ion/incremental/DeferredFragmentCall.java
@@ -37,7 +37,7 @@
  * Will result on 1 instance of `DeferredCall`, containing calls for the 2 fields: "text" and "summary".
  */
 @Internal
-public class DeferredCall implements IncrementalCall<DeferPayload> {
+public class DeferredFragmentCall implements IncrementalCall<DeferPayload> {
     private final String label;
 
     public ResultPath getPath() {
@@ -48,7 +48,7 @@ public ResultPath getPath() {
     private final List<Supplier<CompletableFuture<FieldWithExecutionResult>>> calls;
     private final DeferredCallContext deferredCallContext;
 
-    public DeferredCall(
+    public DeferredFragmentCall(
             String label,
             ResultPath path,
             List<Supplier<CompletableFuture<FieldWithExecutionResult>>> calls,
@@ -77,7 +77,7 @@ public CompletableFuture<DeferPayload> invoke() {
     /**
      * Non-nullable errors need special treatment.
      * When they happen, all the sibling fields will be ignored in the result. So as soon as one of the field calls
-     * throw this error, we can ignore the {@link ExecutionResult} from all the fields associated with this {@link DeferredCall}
+     * throw this error, we can ignore the {@link ExecutionResult} from all the fields associated with this {@link DeferredFragmentCall}
      * and build a special {@link DeferPayload} that captures the details of the error.
      */
     private DeferPayload handleNonNullableFieldError(DeferPayload result, Throwable throwable) {

diff --git a/src/test/groovy/graphql/execution/incremental/DeferredCallTest.groovy b/src/test/groovy/graphql/execution/incremental/DeferredCallTest.groovy
@@ -4,8 +4,6 @@ import graphql.ExecutionResultImpl
 import graphql.GraphQLError
 import graphql.execution.NonNullableFieldWasNullException
 import graphql.execution.ResultPath
-import graphql.execution.incremental.DeferredCall
-import graphql.execution.incremental.DeferredCallContext
 import spock.lang.Specification
 
 import java.util.concurrent.CompletableFuture
@@ -18,7 +16,7 @@ class DeferredCallTest extends Specification {
 
     def "test call capture gives a CF"() {
         given:
-        DeferredCall call = new DeferredCall("my-label", parse("/path"),
+        DeferredFragmentCall call = new DeferredFragmentCall("my-label", parse("/path"),
                 [createResolvedFieldCall("field", "some data")], new DeferredCallContext())
 
         when:
@@ -33,7 +31,7 @@ class DeferredCallTest extends Specification {
 
     def "multiple field calls are resolved together"() {
         given:
-        DeferredCall call = new DeferredCall("my-label", parse("/path"),
+        DeferredFragmentCall call = new DeferredFragmentCall("my-label", parse("/path"),
                 [
                         createResolvedFieldCall("field1", "some data 1"),
                         createResolvedFieldCall("field2", "some data 2"),
@@ -60,7 +58,7 @@ class DeferredCallTest extends Specification {
             getPath() >> ResultPath.parse("/path")
         }
 
-        DeferredCall call = new DeferredCall("my-label", parse("/path"), [
+        DeferredFragmentCall call = new DeferredFragmentCall("my-label", parse("/path"), [
                 createFieldCallThatThrowsException(mockedException),
                 createResolvedFieldCall("field1", "some data")
         ], deferredCallContext)
@@ -83,36 +81,36 @@ class DeferredCallTest extends Specification {
         ]
     }
 
-    private static Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>> createResolvedFieldCall(
+    private static Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>> createResolvedFieldCall(
             String fieldName,
             Object data
     ) {
         return createResolvedFieldCall(fieldName, data, Collections.emptyList())
     }
 
-    private static Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>> createResolvedFieldCall(
+    private static Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>> createResolvedFieldCall(
             String fieldName,
             Object data,
             List<GraphQLError> errors
     ) {
-        return new Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>>() {
+        return new Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>>() {
             @Override
-            CompletableFuture<DeferredCall.FieldWithExecutionResult> get() {
+            CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult> get() {
                 return completedFuture(
-                        new DeferredCall.FieldWithExecutionResult(fieldName,
+                        new DeferredFragmentCall.FieldWithExecutionResult(fieldName,
                                 new ExecutionResultImpl(data, errors)
                         )
                 )
             }
         }
     }
 
-    private static Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>> createFieldCallThatThrowsException(
+    private static Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>> createFieldCallThatThrowsException(
             Throwable exception
     ) {
-        return new Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>>() {
+        return new Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>>() {
             @Override
-            CompletableFuture<DeferredCall.FieldWithExecutionResult> get() {
+            CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult> get() {
                 return CompletableFuture.failedFuture(exception)
             }
         }

diff --git a/src/test/groovy/graphql/execution/incremental/IncrementalCallStateDeferTest.groovy b/src/test/groovy/graphql/execution/incremental/IncrementalCallStateDeferTest.groovy
@@ -142,27 +142,27 @@ class IncrementalCallStateDeferTest extends Specification {
 
     def "multiple fields are part of the same call"() {
         given: "a DeferredCall that contains resolution of multiple fields"
-        def call1 = new Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>>() {
+        def call1 = new Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>>() {
             @Override
-            CompletableFuture<DeferredCall.FieldWithExecutionResult> get() {
+            CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult> get() {
                 return CompletableFuture.supplyAsync({
                     Thread.sleep(10)
-                    new DeferredCall.FieldWithExecutionResult("call1", new ExecutionResultImpl("Call 1", []))
+                    new DeferredFragmentCall.FieldWithExecutionResult("call1", new ExecutionResultImpl("Call 1", []))
                 })
             }
         }
 
-        def call2 = new Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>>() {
+        def call2 = new Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>>() {
             @Override
-            CompletableFuture<DeferredCall.FieldWithExecutionResult> get() {
+            CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult> get() {
                 return CompletableFuture.supplyAsync({
                     Thread.sleep(100)
-                    new DeferredCall.FieldWithExecutionResult("call2", new ExecutionResultImpl("Call 2", []))
+                    new DeferredFragmentCall.FieldWithExecutionResult("call2", new ExecutionResultImpl("Call 2", []))
                 })
             }
         }
 
-        def deferredCall = new DeferredCall(null, ResultPath.parse("/field/path"), [call1, call2], new DeferredCallContext())
+        def deferredCall = new DeferredFragmentCall(null, ResultPath.parse("/field/path"), [call1, call2], new DeferredCallContext())
 
         when:
         def incrementalCallState = new IncrementalCallState()
@@ -195,35 +195,35 @@ class IncrementalCallStateDeferTest extends Specification {
         results.any { it.incremental[0].data["c"] == "C" }
     }
 
-    private static DeferredCall offThread(String data, int sleepTime, String path) {
-        def callSupplier = new Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>>() {
+    private static DeferredFragmentCall offThread(String data, int sleepTime, String path) {
+        def callSupplier = new Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>>() {
             @Override
-            CompletableFuture<DeferredCall.FieldWithExecutionResult> get() {
+            CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult> get() {
                 return CompletableFuture.supplyAsync({
                     Thread.sleep(sleepTime)
                     if (data == "Bang") {
                         throw new RuntimeException(data)
                     }
-                    new DeferredCall.FieldWithExecutionResult(data.toLowerCase(), new ExecutionResultImpl(data, []))
+                    new DeferredFragmentCall.FieldWithExecutionResult(data.toLowerCase(), new ExecutionResultImpl(data, []))
                 })
             }
         }
 
-        return new DeferredCall(null, ResultPath.parse(path), [callSupplier], new DeferredCallContext())
+        return new DeferredFragmentCall(null, ResultPath.parse(path), [callSupplier], new DeferredCallContext())
     }
 
-    private static DeferredCall offThreadCallWithinCall(IncrementalCallState incrementalCallState, String dataParent, String dataChild, int sleepTime, String path) {
-        def callSupplier = new Supplier<CompletableFuture<DeferredCall.FieldWithExecutionResult>>() {
+    private static DeferredFragmentCall offThreadCallWithinCall(IncrementalCallState incrementalCallState, String dataParent, String dataChild, int sleepTime, String path) {
+        def callSupplier = new Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>>() {
             @Override
-            CompletableFuture<DeferredCall.FieldWithExecutionResult> get() {
+            CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult> get() {
                 CompletableFuture.supplyAsync({
                     Thread.sleep(sleepTime)
                     incrementalCallState.enqueue(offThread(dataChild, sleepTime, path))
-                    new DeferredCall.FieldWithExecutionResult(dataParent.toLowerCase(), new ExecutionResultImpl(dataParent, []))
+                    new DeferredFragmentCall.FieldWithExecutionResult(dataParent.toLowerCase(), new ExecutionResultImpl(dataParent, []))
                 })
             }
         }
-        return new DeferredCall(null, ResultPath.parse("/field/path"), [callSupplier], new DeferredCallContext())
+        return new DeferredFragmentCall(null, ResultPath.parse("/field/path"), [callSupplier], new DeferredCallContext())
     }
 
     private static void assertResultsSizeAndHasNextRule(int expectedSize, List<DelayedIncrementalPartialResult> results) {