From 7fb4b18a4c2fb283299f1398ff6a03c7eb22e808 Mon Sep 17 00:00:00 2001 From: Adarsh Sahu Date: Sat, 21 Nov 2026 23:52:03 +0530 Subject: [PATCH] Deliver parent @defer payloads before nested child @defer payloads --- .../graphql/execution/ExecutionStrategy.java | 5 +- .../incremental/DeferredFragmentCall.java | 4 + .../incremental/IncrementalCallState.java | 107 ++++++++-- ...eferExecutionSupportIntegrationTest.groovy | 184 ++++++++++++++++++ .../IncrementalCallStateDeferTest.groovy | 35 ++++ 5 files changed, 315 insertions(+), 20 deletions(-) diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java index 7fd68755ee..998a79059d 100644 --- a/src/main/java/graphql/execution/ExecutionStrategy.java +++ b/src/main/java/graphql/execution/ExecutionStrategy.java @@ -399,7 +399,10 @@ Async.CombinedBuilder getAsyncFieldValueInfo( MergedSelectionSet fields = parameters.getFields(); - executionContext.getIncrementalCallState().enqueue(deferredExecutionSupport.createCalls()); + executionContext.getIncrementalCallState().enqueue( + deferredExecutionSupport.createCalls(), + parameters.getAlternativeCallContext() + ); // Only non-deferred fields should be considered for calculating the expected size of futures. Async.CombinedBuilder futures = Async diff --git a/src/main/java/graphql/execution/incremental/DeferredFragmentCall.java b/src/main/java/graphql/execution/incremental/DeferredFragmentCall.java index 79f4c9b78d..8120a361d3 100644 --- a/src/main/java/graphql/execution/incremental/DeferredFragmentCall.java +++ b/src/main/java/graphql/execution/incremental/DeferredFragmentCall.java @@ -44,6 +44,10 @@ public ResultPath getPath() { return path; } + public AlternativeCallContext getAlternativeCallContext() { + return alternativeCallContext; + } + private final ResultPath path; private final List>> calls; private final AlternativeCallContext alternativeCallContext; diff --git a/src/main/java/graphql/execution/incremental/IncrementalCallState.java b/src/main/java/graphql/execution/incremental/IncrementalCallState.java index fc1f352ca3..539a6e4e15 100644 --- a/src/main/java/graphql/execution/incremental/IncrementalCallState.java +++ b/src/main/java/graphql/execution/incremental/IncrementalCallState.java @@ -6,11 +6,19 @@ import graphql.incremental.IncrementalPayload; import graphql.util.InterThreadMemoizedSupplier; import graphql.util.LockKit; +import org.jspecify.annotations.Nullable; import org.reactivestreams.Publisher; +import java.util.ArrayDeque; +import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.Deque; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; import java.util.concurrent.ConcurrentLinkedDeque; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; @@ -29,36 +37,28 @@ public class IncrementalCallState { private final Supplier> publisher = createPublisher(); private final AtomicInteger pendingCalls = new AtomicInteger(); private final LockKit.ReentrantLock publisherLock = new LockKit.ReentrantLock(); + private final Set activeParents = new LinkedHashSet<>(); + private final Map, AlternativeCallContext> callParents = new LinkedHashMap<>(); + private final Map>> readyChildrenByParent = new LinkedHashMap<>(); + private final Map, IncrementalPayload> readyPayloads = new LinkedHashMap<>(); @SuppressWarnings("FutureReturnValueIgnored") private void drainIncrementalCalls() { IncrementalCall incrementalCall = incrementalCalls.poll(); while (incrementalCall != null) { - incrementalCall.invoke() + IncrementalCall currentCall = incrementalCall; + currentCall.invoke() .whenComplete((payload, exception) -> { if (exception != null) { publisher.get().offerError(exception); return; } - // The assigment of `remainingCalls` and `publisher.offer` need to be synchronized to ensure - // `hasNext` is `false` precisely on the last event offered to the publisher. - publisherLock.lock(); - final int remainingCalls; - - try { - remainingCalls = pendingCalls.decrementAndGet(); - - DelayedIncrementalPartialResult executionResult = newIncrementalExecutionResult() - .incrementalItems(Collections.singletonList(payload)) - .hasNext(remainingCalls != 0) - .build(); - - publisher.get().offer(executionResult); - } finally { - publisherLock.unlock(); - } + // The assignment of `remainingCalls` and `publisher.offer` need to be synchronized to ensure + // `hasNext` is `false` precisely on the last event offered to the publisher, and that parent + // deferred fragments are always offered before their nested children. + final int remainingCalls = publisherLock.callLocked(() -> onCallCompleted(currentCall, payload)); if (remainingCalls == 0) { publisher.get().noMoreData(); @@ -71,8 +71,70 @@ private void drainIncrementalCalls() { } } + private int onCallCompleted(IncrementalCall completedCall, IncrementalPayload payload) { + AlternativeCallContext parentContext = callParents.remove(completedCall); + if (parentContext != null && activeParents.contains(parentContext)) { + readyChildrenByParent.computeIfAbsent(parentContext, key -> new ArrayList<>()).add(completedCall); + readyPayloads.put(completedCall, payload); + return pendingCalls.get(); + } + + readyPayloads.put(completedCall, payload); + Deque> toEmit = new ArrayDeque<>(); + toEmit.add(completedCall); + + int remainingCalls = pendingCalls.get(); + while (!toEmit.isEmpty()) { + IncrementalCall nextCall = toEmit.poll(); + IncrementalPayload nextPayload = readyPayloads.remove(nextCall); + if (nextPayload != null) { + remainingCalls = publishPayload(nextPayload); + } + releaseChildren(nextCall, toEmit); + } + return remainingCalls; + } + + private int publishPayload(IncrementalPayload payload) { + int remainingCalls = pendingCalls.decrementAndGet(); + DelayedIncrementalPartialResult executionResult = newIncrementalExecutionResult() + .incrementalItems(Collections.singletonList(payload)) + .hasNext(remainingCalls != 0) + .build(); + publisher.get().offer(executionResult); + return remainingCalls; + } + + private void releaseChildren( + IncrementalCall emittedCall, + Deque> toEmit + ) { + if (!(emittedCall instanceof DeferredFragmentCall)) { + return; + } + AlternativeCallContext ownContext = ((DeferredFragmentCall) emittedCall).getAlternativeCallContext(); + activeParents.remove(ownContext); + List> readyChildren = readyChildrenByParent.remove(ownContext); + if (readyChildren != null) { + toEmit.addAll(readyChildren); + } + } + public void enqueue(IncrementalCall incrementalCall) { + enqueue(incrementalCall, null); + } + + public void enqueue( + IncrementalCall incrementalCall, + @Nullable AlternativeCallContext parentContext + ) { publisherLock.runLocked(() -> { + if (incrementalCall instanceof DeferredFragmentCall) { + activeParents.add(((DeferredFragmentCall) incrementalCall).getAlternativeCallContext()); + } + if (parentContext != null && activeParents.contains(parentContext)) { + callParents.put(incrementalCall, parentContext); + } incrementalCallsDetected.set(true); incrementalCalls.offer(incrementalCall); pendingCalls.incrementAndGet(); @@ -80,7 +142,14 @@ public void enqueue(IncrementalCall incrementalCal } public void enqueue(Collection> calls) { - calls.forEach(this::enqueue); + enqueue(calls, null); + } + + public void enqueue( + Collection> calls, + @Nullable AlternativeCallContext parentContext + ) { + calls.forEach(call -> enqueue(call, parentContext)); } public boolean getIncrementalCallsDetected() { diff --git a/src/test/groovy/graphql/execution/incremental/DeferExecutionSupportIntegrationTest.groovy b/src/test/groovy/graphql/execution/incremental/DeferExecutionSupportIntegrationTest.groovy index 487caee669..2846c5c233 100644 --- a/src/test/groovy/graphql/execution/incremental/DeferExecutionSupportIntegrationTest.groovy +++ b/src/test/groovy/graphql/execution/incremental/DeferExecutionSupportIntegrationTest.groovy @@ -1874,6 +1874,190 @@ class DeferExecutionSupportIntegrationTest extends Specification { ] } + def "nested defer is delivered after its parent defer even when nested resolves faster"() { + given: + def sdl = ''' + type Query { obj: Obj } + type Obj { fast: String slow: String inner: Inner } + type Inner { fast: String } + ''' + def runtimeWiring = RuntimeWiring.newRuntimeWiring() + .type(newTypeWiring("Query") + .dataFetcher("obj", { [:] } as DataFetcher) + ) + .type(newTypeWiring("Obj") + .dataFetcher("fast", { "obj-fast" } as DataFetcher) + .dataFetcher("slow", resolve("obj-slow", 200)) + .dataFetcher("inner", { [:] } as DataFetcher) + ) + .type(newTypeWiring("Inner") + .dataFetcher("fast", { "inner-fast" } as DataFetcher) + ) + .build() + + def schema = TestUtil.schema(sdl, runtimeWiring) + .transform({ b -> b.additionalDirective(Directives.DeferDirective) }) + def testGraphQL = GraphQL.newGraphQL(schema).build() + + def query = ''' + query { + obj { + fast + ... @defer(label: "parent") { + slow + inner { + ... @defer(label: "child") { + fast + } + } + } + } + } + ''' + + when: + def executionInput = ExecutionInput.newExecutionInput() + .graphQLContext([ + (ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT) : true, + (IncrementalExecutionContextKeys.ENABLE_EAGER_DEFER_START): eagerStart + ]) + .query(query) + .build() + IncrementalExecutionResult initialResult = testGraphQL.execute(executionInput) as IncrementalExecutionResult + def incrementalResults = getIncrementalResults(initialResult) + + then: + initialResult.toSpecification() == [ + data : [obj: [fast: "obj-fast"]], + hasNext: true + ] + incrementalResults == [ + [ + hasNext : true, + incremental: [ + [ + label: "parent", + path : ["obj"], + data : [slow: "obj-slow", inner: [:]] + ] + ] + ], + [ + hasNext : false, + incremental: [ + [ + label: "child", + path : ["obj", "inner"], + data : [fast: "inner-fast"] + ] + ] + ] + ] + + where: + eagerStart << [false, true] + } + + def "deeply nested defers are delivered in parent-before-child order when inner resolves faster"() { + given: + def sdl = ''' + type Query { obj: Obj } + type Obj { fast: String slowOuter: String mid: Mid } + type Mid { slowMid: String inner: Inner } + type Inner { fast: String } + ''' + def runtimeWiring = RuntimeWiring.newRuntimeWiring() + .type(newTypeWiring("Query") + .dataFetcher("obj", { [:] } as DataFetcher) + ) + .type(newTypeWiring("Obj") + .dataFetcher("fast", { "obj-fast" } as DataFetcher) + .dataFetcher("slowOuter", resolve("outer-val", 250)) + .dataFetcher("mid", { [:] } as DataFetcher) + ) + .type(newTypeWiring("Mid") + .dataFetcher("slowMid", resolve("mid-val", 100)) + .dataFetcher("inner", { [:] } as DataFetcher) + ) + .type(newTypeWiring("Inner") + .dataFetcher("fast", { "inner-val" } as DataFetcher) + ) + .build() + + def schema = TestUtil.schema(sdl, runtimeWiring) + .transform({ b -> b.additionalDirective(Directives.DeferDirective) }) + def testGraphQL = GraphQL.newGraphQL(schema).build() + + def query = ''' + query { + obj { + fast + ... @defer(label: "grandparent") { + slowOuter + mid { + ... @defer(label: "parent") { + slowMid + inner { + ... @defer(label: "child") { + fast + } + } + } + } + } + } + } + ''' + + when: + def executionInput = ExecutionInput.newExecutionInput() + .graphQLContext([ + (ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT) : true, + (IncrementalExecutionContextKeys.ENABLE_EAGER_DEFER_START): eagerStart + ]) + .query(query) + .build() + IncrementalExecutionResult initialResult = testGraphQL.execute(executionInput) as IncrementalExecutionResult + def incrementalResults = getIncrementalResults(initialResult) + + then: + incrementalResults == [ + [ + hasNext : true, + incremental: [ + [ + label: "grandparent", + path : ["obj"], + data : [slowOuter: "outer-val", mid: [:]] + ] + ] + ], + [ + hasNext : true, + incremental: [ + [ + label: "parent", + path : ["obj", "mid"], + data : [slowMid: "mid-val", inner: [:]] + ] + ] + ], + [ + hasNext : false, + incremental: [ + [ + label: "child", + path : ["obj", "mid", "inner"], + data : [fast: "inner-val"] + ] + ] + ] + ] + + where: + eagerStart << [false, true] + } + private ExecutionResult executeQuery(String query) { return this.executeQuery(query, true, [:]) diff --git a/src/test/groovy/graphql/execution/incremental/IncrementalCallStateDeferTest.groovy b/src/test/groovy/graphql/execution/incremental/IncrementalCallStateDeferTest.groovy index db9085274f..f18494a08e 100644 --- a/src/test/groovy/graphql/execution/incremental/IncrementalCallStateDeferTest.groovy +++ b/src/test/groovy/graphql/execution/incremental/IncrementalCallStateDeferTest.groovy @@ -272,6 +272,41 @@ class IncrementalCallStateDeferTest extends Specification { results[2].incremental[0].data["a"] == "A" } + def "child call is delivered after its parent call even when child completes first"() { + given: + def incrementalCallState = new IncrementalCallState() + def parentCall = offThread("Parent", 150, "/obj") + def childCall = offThread("Child", 10, "/obj/inner") + def siblingCall = offThread("Sibling", 30, "/other") + + incrementalCallState.enqueue(parentCall) + incrementalCallState.enqueue(childCall, parentCall.getAlternativeCallContext()) + incrementalCallState.enqueue(siblingCall) + + when: + List results = startAndWaitCalls(incrementalCallState) + + then: + assertResultsSizeAndHasNextRule(3, results) + results[0].incremental[0].data["sibling"] == "Sibling" + results[1].incremental[0].data["parent"] == "Parent" + results[2].incremental[0].data["child"] == "Child" + } + + def "call with an unregistered parent context is not blocked"() { + given: + def incrementalCallState = new IncrementalCallState() + def unregisteredContext = new AlternativeCallContext() + incrementalCallState.enqueue(offThread("A", 10, "/field/path"), unregisteredContext) + + when: + List results = startAndWaitCalls(incrementalCallState) + + then: + assertResultsSizeAndHasNextRule(1, results) + results[0].incremental[0].data["a"] == "A" + } + private static DeferredFragmentCall offThread(String data, int sleepTime, String path) { offThread(() -> data, sleepTime, path) }