From 11fe2147714c5f081d0cbabd1c33ab1fbf7cf37c Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Sun, 1 Nov 2026 08:19:21 +1000 Subject: [PATCH 1/5] Add variable batching with shared DataLoader dispatch --- .../benchmark/VariableBatchBenchmark.java | 107 +++ src/main/java/graphql/ExecutionInput.java | 106 ++- src/main/java/graphql/GraphQL.java | 62 +- .../graphql/VariableBatchExecutionResult.java | 56 ++ .../VariableBatchExecutionResultImpl.java | 43 ++ .../java/graphql/VariableBatchResult.java | 58 ++ .../graphql/VariableBatchResultCollector.java | 50 ++ .../java/graphql/execution/Execution.java | 9 + .../ExhaustedDataLoaderDispatchStrategy.java | 24 + .../VariableBatchDataLoaderDispatcher.java | 95 +++ ...ariableBatchPreparsedDocumentProvider.java | 31 + .../reactive/RejectedBatchSubscription.java | 17 + .../VariableBatchIncrementalPublisher.java | 140 ++++ .../reactive/VariableBatchPublisher.java | 190 +++++ .../graphql/extensions/ExtensionsBuilder.java | 8 + src/test/groovy/graphql/GraphQLTest.groovy | 2 +- .../graphql/VariableBatchExecutionTest.groovy | 719 ++++++++++++++++++ 17 files changed, 1703 insertions(+), 14 deletions(-) create mode 100644 src/jmh/java/benchmark/VariableBatchBenchmark.java create mode 100644 src/main/java/graphql/VariableBatchExecutionResult.java create mode 100644 src/main/java/graphql/VariableBatchExecutionResultImpl.java create mode 100644 src/main/java/graphql/VariableBatchResult.java create mode 100644 src/main/java/graphql/VariableBatchResultCollector.java create mode 100644 src/main/java/graphql/execution/instrumentation/dataloader/VariableBatchDataLoaderDispatcher.java create mode 100644 src/main/java/graphql/execution/preparsed/VariableBatchPreparsedDocumentProvider.java create mode 100644 src/main/java/graphql/execution/reactive/RejectedBatchSubscription.java create mode 100644 src/main/java/graphql/execution/reactive/VariableBatchIncrementalPublisher.java create mode 100644 src/main/java/graphql/execution/reactive/VariableBatchPublisher.java create mode 100644 src/test/groovy/graphql/VariableBatchExecutionTest.groovy diff --git a/src/jmh/java/benchmark/VariableBatchBenchmark.java b/src/jmh/java/benchmark/VariableBatchBenchmark.java new file mode 100644 index 0000000000..db6097cfd0 --- /dev/null +++ b/src/jmh/java/benchmark/VariableBatchBenchmark.java @@ -0,0 +1,107 @@ +package benchmark; + +import graphql.ExecutionInput; +import graphql.ExecutionResult; +import graphql.GraphQL; +import graphql.VariableBatchExecutionResult; +import graphql.execution.preparsed.PreparsedDocumentEntry; +import graphql.schema.DataFetcher; +import graphql.schema.idl.RuntimeWiring; +import graphql.schema.idl.SchemaGenerator; +import graphql.schema.idl.SchemaParser; +import org.dataloader.BatchLoader; +import org.dataloader.DataLoaderFactory; +import org.dataloader.DataLoaderRegistry; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.Warmup; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; + +/** Compares one variable batch with repeated ordinary executions sharing the same registry. */ +@State(Scope.Thread) +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@Warmup(iterations = 3, time = 1) +@Measurement(iterations = 5, time = 1) +@Fork(2) +public class VariableBatchBenchmark { + private static final String QUERY = "query($id:Int!) { a:value(id:$id) b:value(id:$id) c:value(id:$id) }"; + + @Param({"16"}) + public int size; + + @Param({"false", "true"}) + public boolean cachedDocument; + + @Param({"false", "true"}) + public boolean dataLoader; + + private GraphQL graphQL; + private List> variables; + + @Setup + public void setup() { + DataFetcher fetcher = environment -> dataLoader + ? environment.getDataLoader("values").load(environment.getArgument("id")) + : environment.getArgument("id"); + var schema = new SchemaGenerator().makeExecutableSchema( + new SchemaParser().parse("type Query { value(id:Int!):Int! }"), + RuntimeWiring.newRuntimeWiring().type("Query", type -> type.dataFetcher("value", fetcher)).build()); + GraphQL.Builder builder = GraphQL.newGraphQL(schema); + if (cachedDocument) { + AtomicReference prepared = new AtomicReference<>(); + builder.preparsedDocumentProvider((input, compute) -> CompletableFuture.completedFuture( + prepared.updateAndGet(value -> value == null ? compute.apply(input) : value))); + } + graphQL = builder.build(); + variables = new ArrayList<>(); + for (int index = 0; index < size; index++) { + variables.add(Map.of("id", index % 4)); + } + } + + @Benchmark + public List variableBatch() { + ExecutionInput input = ExecutionInput.newExecutionInput(QUERY) + .variables(variables).dataLoaderRegistry(registry()).build(); + VariableBatchExecutionResult result = (VariableBatchExecutionResult) graphQL.execute(input); + return result.getResultsAsync().join(); + } + + @Benchmark + public List separateExecutions() { + DataLoaderRegistry registry = registry(); + List> results = new ArrayList<>(); + for (Map values : variables) { + results.add(graphQL.executeAsync(ExecutionInput.newExecutionInput(QUERY) + .variables(values).dataLoaderRegistry(registry).build())); + } + CompletableFuture.allOf(results.toArray(new CompletableFuture[0])).join(); + List completed = new ArrayList<>(); + results.forEach(result -> completed.add(result.join())); + return completed; + } + + private DataLoaderRegistry registry() { + DataLoaderRegistry registry = new DataLoaderRegistry(); + if (dataLoader) { + BatchLoader loader = keys -> CompletableFuture.completedFuture(keys); + registry.register("values", DataLoaderFactory.newDataLoader(loader)); + } + return registry; + } +} diff --git a/src/main/java/graphql/ExecutionInput.java b/src/main/java/graphql/ExecutionInput.java index a83c741e7f..567c3dec8e 100644 --- a/src/main/java/graphql/ExecutionInput.java +++ b/src/main/java/graphql/ExecutionInput.java @@ -4,11 +4,13 @@ import graphql.execution.ExecutionId; import graphql.execution.RawVariables; import graphql.execution.preparsed.persisted.PersistedQuerySupport; +import graphql.extensions.ExtensionsBuilder; import org.dataloader.DataLoaderRegistry; import org.jspecify.annotations.NullMarked; import org.jspecify.annotations.NullUnmarked; import org.jspecify.annotations.Nullable; +import java.util.List; import java.util.Locale; import java.util.Map; import java.util.concurrent.CompletableFuture; @@ -24,13 +26,16 @@ @PublicApi @NullMarked public class ExecutionInput { + private static final List EMPTY_VARIABLES_LIST = List.of(RawVariables.emptyVariables()); private final String query; private final String operationName; private final @Nullable Object context; private final GraphQLContext graphQLContext; private final @Nullable Object localContext; private final Object root; - private final RawVariables rawVariables; + private final List rawVariablesList; + private final @Nullable Integer variableIndex; + private final @Nullable ExecutionId variableBatchId; private final Map extensions; private final DataLoaderRegistry dataLoaderRegistry; private final ExecutionId executionId; @@ -55,7 +60,9 @@ private ExecutionInput(Builder builder) { this.context = builder.context; this.graphQLContext = assertNotNull(builder.graphQLContext); this.root = builder.root; - this.rawVariables = builder.rawVariables; + this.rawVariablesList = builder.rawVariablesList; + this.variableIndex = builder.variableIndex; + this.variableBatchId = builder.variableBatchId; this.dataLoaderRegistry = builder.dataLoaderRegistry; this.executionId = builder.executionId; this.locale = builder.locale != null ? builder.locale : Locale.getDefault(); // always have a locale in place @@ -145,14 +152,68 @@ public Object getRoot() { * @return a map of raw variables that can be referenced via $syntax in the query. */ public Map getVariables() { - return rawVariables.toMap(); + return getRawVariables().toMap(); } /** * @return a map of raw variables that can be referenced via $syntax in the query. */ public RawVariables getRawVariables() { - return rawVariables; + return rawVariablesList.isEmpty() ? RawVariables.emptyVariables() : rawVariablesList.get(0); + } + + /** + * Returns the variable maps in input order. An empty list or a singleton uses ordinary execution; + * a larger list executes the selected operation once per map, sharing the DataLoader registry. + * The legacy {@link #getVariables()} and {@link #getRawVariables()} accessors return the first map, + * or an empty map when the list is empty. + * + * @return the immutable list of immutable variable maps (values can be null) + */ + @ExperimentalApi + public List> getVariablesList() { + return ImmutableKit.map(rawVariablesList, RawVariables::toMap); + } + + /** @return whether this input requests multiple executions */ + @ExperimentalApi + public boolean isVariableBatch() { + return rawVariablesList.size() > 1; + } + + /** @return the zero-based index for an individual batch execution, otherwise null */ + @ExperimentalApi + public @Nullable Integer getVariableIndex() { + return variableIndex; + } + + /** @return the shared batch id for an individual batch execution, otherwise null */ + @ExperimentalApi + public @Nullable ExecutionId getVariableBatchId() { + return variableBatchId; + } + + @Internal + public ExecutionInput newVariableBatchEntry(int index, ExecutionId batchId) { + GraphQLContext entryContext = GraphQLContext.newContext().build().putAll(graphQLContext); + ExtensionsBuilder extensionsBuilder = graphQLContext.get(ExtensionsBuilder.class); + if (extensionsBuilder != null) { + entryContext.put(ExtensionsBuilder.class, extensionsBuilder.copy()); + } + Builder builder = newExecutionInput(query) + .operationName(operationName) + .internalTransferContext(entryContext) + .context(context == graphQLContext ? entryContext : context) + .localContext(localContext) + .root(root) + .variables(rawVariablesList.get(index).toMap()) + .extensions(extensions) + .dataLoaderRegistry(dataLoaderRegistry) + .locale(locale) + .profileExecution(profileExecution); + builder.variableIndex = index; + builder.variableBatchId = batchId; + return builder.build(); } /** @@ -257,10 +318,13 @@ public ExecutionInput transform(Consumer builderConsumer) { .localContext(this.localContext) .root(this.root) .dataLoaderRegistry(this.dataLoaderRegistry) - .variables(this.rawVariables.toMap()) .extensions(this.extensions) .executionId(this.executionId) - .locale(this.locale); + .locale(this.locale) + .profileExecution(this.profileExecution); + builder.rawVariablesList = this.rawVariablesList; + builder.variableIndex = this.variableIndex; + builder.variableBatchId = this.variableBatchId; builderConsumer.accept(builder); @@ -275,7 +339,7 @@ public String toString() { ", context=" + context + ", graphQLContext=" + graphQLContext + ", root=" + root + - ", rawVariables=" + rawVariables + + ", rawVariablesList=" + rawVariablesList + ", dataLoaderRegistry=" + dataLoaderRegistry + ", executionId= " + executionId + ", locale= " + locale + @@ -309,7 +373,9 @@ public static class Builder { private Object context = graphQLContext; // we make these the same object on purpose - legacy code will get the same object if this change nothing private Object localContext; private Object root; - private RawVariables rawVariables = RawVariables.emptyVariables(); + private List rawVariablesList = EMPTY_VARIABLES_LIST; + private Integer variableIndex; + private ExecutionId variableBatchId; private Map extensions = ImmutableKit.emptyMap(); // // this is important - it allows code to later known if we never really set a dataloader and hence it can optimize @@ -444,7 +510,23 @@ public Builder root(Object root) { */ public Builder variables(Map rawVariables) { assertNotNull(rawVariables, "variables map can't be null"); - this.rawVariables = RawVariables.of(rawVariables); + this.rawVariablesList = List.of(RawVariables.of(rawVariables)); + return this; + } + + /** + * Supplies complete variable maps for the same selected operation. An empty list executes once + * with empty variables; a singleton executes normally. Larger lists return a + * {@link VariableBatchExecutionResult}. Entries are never deduplicated. + * + * @param variables the maps in input order; neither the list nor its entries may be null + * @return this builder + */ + @ExperimentalApi + public Builder variables(List> variables) { + assertNotNull(variables, "variables list can't be null"); + this.rawVariablesList = List.copyOf(ImmutableKit.map(variables, + value -> RawVariables.of(assertNotNull(value, "variables list entry can't be null")))); return this; } @@ -456,7 +538,9 @@ public Builder extensions(Map extensions) { /** * You should create new {@link org.dataloader.DataLoaderRegistry}s and new {@link org.dataloader.DataLoader}s for each execution. Do not * re-use - * instances as this will create unexpected results. + * instances across independent requests as this will create unexpected results. Variable batching + * shares the supplied registry and its caches across all entries in that batch, including mutations. + * Mutation resolvers should clear or prime affected cache entries as usual. * * @param dataLoaderRegistry a registry of {@link org.dataloader.DataLoader}s * @@ -476,4 +560,4 @@ public ExecutionInput build() { return new ExecutionInput(this); } } -} \ No newline at end of file +} diff --git a/src/main/java/graphql/GraphQL.java b/src/main/java/graphql/GraphQL.java index d25f596175..7901b13eca 100644 --- a/src/main/java/graphql/GraphQL.java +++ b/src/main/java/graphql/GraphQL.java @@ -23,6 +23,8 @@ import graphql.execution.preparsed.NoOpPreparsedDocumentProvider; import graphql.execution.preparsed.PreparsedDocumentEntry; import graphql.execution.preparsed.PreparsedDocumentProvider; +import graphql.execution.preparsed.VariableBatchPreparsedDocumentProvider; +import graphql.execution.reactive.VariableBatchPublisher; import graphql.introspection.GoodFaithIntrospection; import graphql.language.Document; import graphql.schema.GraphQLSchema; @@ -165,6 +167,8 @@ public static GraphQLUnusualConfiguration.GraphQLContextConfiguration unusualCon private final PreparsedDocumentProvider preparsedDocumentProvider; private final ValueUnboxer valueUnboxer; private final boolean doNotAutomaticallyDispatchDataLoader; + private final int maxVariableBatchSize; + private final int maxVariableBatchConcurrency; private GraphQL(Builder builder) { @@ -177,6 +181,8 @@ private GraphQL(Builder builder) { this.preparsedDocumentProvider = assertNotNull(builder.preparsedDocumentProvider, "preparsedDocumentProvider must be non null"); this.valueUnboxer = assertNotNull(builder.valueUnboxer, "valueUnboxer must not be null"); this.doNotAutomaticallyDispatchDataLoader = builder.doNotAutomaticallyDispatchDataLoader; + this.maxVariableBatchSize = builder.maxVariableBatchSize; + this.maxVariableBatchConcurrency = builder.maxVariableBatchConcurrency; } /** @@ -266,6 +272,8 @@ public GraphQL transform(Consumer builderConsumer) { .subscriptionExecutionStrategy(this.subscriptionStrategy) .executionIdProvider(this.idProvider) .instrumentation(this.instrumentation) + .maxVariableBatchSize(this.maxVariableBatchSize) + .maxVariableBatchConcurrency(this.maxVariableBatchConcurrency) .preparsedDocumentProvider(this.preparsedDocumentProvider); builderConsumer.accept(builder); @@ -286,6 +294,8 @@ public static class Builder { private PreparsedDocumentProvider preparsedDocumentProvider = NoOpPreparsedDocumentProvider.INSTANCE; private boolean doNotAutomaticallyDispatchDataLoader = false; private ValueUnboxer valueUnboxer = ValueUnboxer.DEFAULT; + private int maxVariableBatchSize = 1024; + private int maxVariableBatchConcurrency = 16; public Builder(GraphQLSchema graphQLSchema) { this.graphQLSchema = graphQLSchema; @@ -334,6 +344,32 @@ public Builder preparsedDocumentProvider(PreparsedDocumentProvider preparsedDocu return this; } + /** + * Limits variable batch entries, checked before any execution starts. Defaults to 1024. + * @param maximum a positive limit + * @return this builder + */ + @ExperimentalApi + public Builder maxVariableBatchSize(int maximum) { + Assert.assertTrue(maximum > 0, () -> "maxVariableBatchSize must be positive"); + maxVariableBatchSize = maximum; + return this; + } + + /** + * Limits active executions up to their initial result and buffered initial results. Defaults to 16. + * Set to one for serial initial execution across variable maps. Mutation root fields remain serial + * within each execution. Incremental publishers retain their separate lifecycle and consumption. + * @param maximum a positive limit + * @return this builder + */ + @ExperimentalApi + public Builder maxVariableBatchConcurrency(int maximum) { + Assert.assertTrue(maximum > 0, () -> "maxVariableBatchConcurrency must be positive"); + maxVariableBatchConcurrency = maximum; + return this; + } + public Builder executionIdProvider(ExecutionIdProvider executionIdProvider) { this.idProvider = assertNotNull(executionIdProvider, "ExecutionIdProvider must be non null"); return this; @@ -343,7 +379,7 @@ public Builder executionIdProvider(ExecutionIdProvider executionIdProvider) { /** * Deactivates the automatic dispatching of DataLoaders. * If deactivated the user is responsible for dispatching the DataLoaders manually. - * + * Variable batches always coordinate dispatch automatically. * @return this builder */ public Builder doNotAutomaticallyDispatchDataLoader() { @@ -478,12 +514,15 @@ public CompletableFuture executeAsync(UnaryOperator * This will return a promise (aka {@link CompletableFuture}) to provide a {@link ExecutionResult} * which is the result of executing the provided query. - * + * Multiple variable maps return a lazy {@link VariableBatchExecutionResult}; see that type for consumption. * @param executionInput {@link ExecutionInput} * * @return a promise to an {@link ExecutionResult} which can include errors */ public CompletableFuture executeAsync(ExecutionInput executionInput) { + if (executionInput.isVariableBatch()) { + return executeVariableBatch(executionInput); + } Profiler profiler = executionInput.isProfileExecution() ? new ProfilerImpl(executionInput.getGraphQLContext()) : Profiler.NO_OP; EngineRunningState engineRunningState = new EngineRunningState(executionInput, profiler); return engineRunningState.engineRun(() -> { @@ -520,6 +559,25 @@ public CompletableFuture executeAsync(ExecutionInput executionI }); } + private CompletableFuture executeVariableBatch(ExecutionInput input) { + int size = input.getVariablesList().size(); + if (size > maxVariableBatchSize) { + return CompletableFuture.failedFuture(new AbortExecutionException( + "Variable batch has " + size + " entries which exceeds maximum allowed " + maxVariableBatchSize)); + } + ExecutionId batchId = assertNotNull(ensureInputHasId(input).getExecutionId()); + GraphQL executor = this; + // Custom providers and instrumentation retain their existing per-execution semantics. + if (preparsedDocumentProvider == NoOpPreparsedDocumentProvider.INSTANCE + && instrumentation.getClass() == SimplePerformantInstrumentation.class) { + executor = transform(builder -> builder + .preparsedDocumentProvider(new VariableBatchPreparsedDocumentProvider()) + .valueUnboxer(valueUnboxer)); + } + VariableBatchPublisher publisher = new VariableBatchPublisher(input, batchId, maxVariableBatchConcurrency, executor::executeAsync); + return CompletableFuture.completedFuture(new VariableBatchExecutionResultImpl(publisher, size)); + } + private CompletableFuture handleAbortException(ExecutionInput executionInput, InstrumentationState instrumentationState, AbortExecutionException abortException) { InstrumentationExecutionParameters instrumentationParameters = new InstrumentationExecutionParameters(executionInput, this.graphQLSchema); diff --git a/src/main/java/graphql/VariableBatchExecutionResult.java b/src/main/java/graphql/VariableBatchExecutionResult.java new file mode 100644 index 0000000000..00fa27fe97 --- /dev/null +++ b/src/main/java/graphql/VariableBatchExecutionResult.java @@ -0,0 +1,56 @@ +package graphql; + +import org.jspecify.annotations.NullMarked; +import org.reactivestreams.Publisher; + +import java.util.List; +import java.util.concurrent.CompletableFuture; + +/** + * The result of supplying more than one variable map to {@link GraphQL#executeAsync(ExecutionInput)}. + * Execution starts when the results publisher is subscribed to and receives demand. Each entry contains an ordinary + * execution result, including its own errors and, when applicable, its incremental publisher. + * {@link #getData()} returns the same publisher as {@link #getResults()}. + *

+ * Choose either streaming via {@link #getResults()} or collection via {@link #getResultsAsync()}: + * the publisher supports one subscriber. There is no single GraphQL response map for a batch, so + * {@link #toSpecification()} is unsupported. Serialize the individual execution results instead. + *

{@code
+ * ExecutionInput input = ExecutionInput.newExecutionInput()
+ *     .query("query($id: ID!) { product(id: $id) { name } }")
+ *     .variables(List.of(Map.of("id", "a"), Map.of("id", "b")))
+ *     .dataLoaderRegistry(registry)
+ *     .build();
+ * VariableBatchExecutionResult batch = (VariableBatchExecutionResult) graphQL.execute(input);
+ * CompletableFuture> results = batch.getResultsAsync();
+ * }
+ * The entries share DataLoaders and caches for queries and mutations; batch dispatch is always automatic. + * Mutations retain serial root fields within each entry; there is no ordering guarantee between + * entries. Applications must clear or prime affected loader cache entries after writes. + * Each entry has separate variable coercion, errors, instrumentation state, cancellation state, + * execution id and a shallow copy of the GraphQL context. Application objects in that context, + * the root and the local context remain shared. + *

+ * The configured concurrency limit bounds executions up to their initial result and buffered + * initial results. Incremental publishers retain their existing lifecycle: the consumer must + * subscribe to each one to receive subsequent payloads and control their consumption separately. + * Cancelling the input also cancels entries whose initial results have already been delivered. + * Subscription operations are not supported in a variable batch. + */ +@ExperimentalApi +@NullMarked +public interface VariableBatchExecutionResult extends ExecutionResult { + /** @return indexed results in completion order, subject to subscriber demand */ + Publisher getResults(); + + /** @return the number of executions in the batch */ + int getSize(); + + /** + * Subscribes to the results and collects them in input order. Cancelling the returned future + * cancels the batch subscription. Incremental results retain their individual publishers. + * + * @return a future containing the individual results in input order + */ + CompletableFuture> getResultsAsync(); +} diff --git a/src/main/java/graphql/VariableBatchExecutionResultImpl.java b/src/main/java/graphql/VariableBatchExecutionResultImpl.java new file mode 100644 index 0000000000..c7dea4aea3 --- /dev/null +++ b/src/main/java/graphql/VariableBatchExecutionResultImpl.java @@ -0,0 +1,43 @@ +package graphql; + +import org.jspecify.annotations.NullMarked; +import org.reactivestreams.Publisher; + +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletableFuture; + +@Internal +@NullMarked +public final class VariableBatchExecutionResultImpl extends ExecutionResultImpl implements VariableBatchExecutionResult { + private final Publisher results; + private final int size; + + public VariableBatchExecutionResultImpl(Publisher results, int size) { + super(results, List.of()); + this.results = results; + this.size = size; + } + + @Override + public Publisher getResults() { + return results; + } + + @Override + public int getSize() { + return size; + } + + @Override + public CompletableFuture> getResultsAsync() { + VariableBatchResultCollector collector = new VariableBatchResultCollector(size); + results.subscribe(collector); + return collector.getResult(); + } + + @Override + public Map toSpecification() { + throw new UnsupportedOperationException("Serialize each VariableBatchResult's executionResult instead of the batch"); + } +} diff --git a/src/main/java/graphql/VariableBatchResult.java b/src/main/java/graphql/VariableBatchResult.java new file mode 100644 index 0000000000..bce2cf134d --- /dev/null +++ b/src/main/java/graphql/VariableBatchResult.java @@ -0,0 +1,58 @@ +package graphql; + +import org.jspecify.annotations.NullMarked; +import org.jspecify.annotations.NullUnmarked; + +import java.util.function.Consumer; + +/** An individual execution result and its position in the input variables list. */ +@ExperimentalApi +@NullMarked +public final class VariableBatchResult { + private final int variableIndex; + private final ExecutionResult executionResult; + + private VariableBatchResult(Builder builder) { + Assert.assertTrue(builder.variableIndex >= 0, () -> "variableIndex must be non-negative"); + variableIndex = builder.variableIndex; + executionResult = Assert.assertNotNull(builder.executionResult); + } + + public int getVariableIndex() { + return variableIndex; + } + + public ExecutionResult getExecutionResult() { + return executionResult; + } + + public static Builder newVariableBatchResult() { + return new Builder(); + } + + public VariableBatchResult transform(Consumer consumer) { + Builder builder = newVariableBatchResult().variableIndex(variableIndex).executionResult(executionResult); + consumer.accept(builder); + return builder.build(); + } + + @NullUnmarked + public static final class Builder { + private int variableIndex; + private ExecutionResult executionResult; + + public Builder variableIndex(int variableIndex) { + this.variableIndex = variableIndex; + return this; + } + + public Builder executionResult(ExecutionResult executionResult) { + this.executionResult = executionResult; + return this; + } + + public VariableBatchResult build() { + return new VariableBatchResult(this); + } + } +} diff --git a/src/main/java/graphql/VariableBatchResultCollector.java b/src/main/java/graphql/VariableBatchResultCollector.java new file mode 100644 index 0000000000..47409eca52 --- /dev/null +++ b/src/main/java/graphql/VariableBatchResultCollector.java @@ -0,0 +1,50 @@ +package graphql; + +import org.jspecify.annotations.NullMarked; +import org.reactivestreams.Subscriber; +import org.reactivestreams.Subscription; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.CompletableFuture; + +@Internal +@NullMarked +public final class VariableBatchResultCollector implements Subscriber { + private final List results; + private final CompletableFuture> result = new CompletableFuture<>(); + + public VariableBatchResultCollector(int size) { + results = new ArrayList<>(Collections.nCopies(size, new ExecutionResultImpl(List.of()))); + } + + public CompletableFuture> getResult() { + return result; + } + + @Override + public void onSubscribe(Subscription subscription) { + result.whenComplete((ignored, failure) -> { + if (result.isCancelled()) { + subscription.cancel(); + } + }); + subscription.request(Long.MAX_VALUE); + } + + @Override + public void onNext(VariableBatchResult value) { + results.set(value.getVariableIndex(), value.getExecutionResult()); + } + + @Override + public void onError(Throwable failure) { + result.completeExceptionally(failure); + } + + @Override + public void onComplete() { + result.complete(List.copyOf(results)); + } +} diff --git a/src/main/java/graphql/execution/Execution.java b/src/main/java/graphql/execution/Execution.java index df7a0f6aeb..16f7689a99 100644 --- a/src/main/java/graphql/execution/Execution.java +++ b/src/main/java/graphql/execution/Execution.java @@ -22,6 +22,7 @@ import graphql.execution.instrumentation.InstrumentationState; import graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys; import graphql.execution.instrumentation.dataloader.ExhaustedDataLoaderDispatchStrategy; +import graphql.execution.instrumentation.dataloader.VariableBatchDataLoaderDispatcher; import graphql.execution.instrumentation.dataloader.PerLevelDataLoaderDispatchStrategy; import graphql.execution.instrumentation.parameters.InstrumentationExecuteOperationParameters; import graphql.execution.instrumentation.parameters.InstrumentationExecutionParameters; @@ -89,6 +90,10 @@ public CompletableFuture execute(Document document, GraphQLSche Supplier normalizedVariableValues; try { getOperationResult = NodeUtil.getOperation(document, executionInput.getOperationName()); + if (executionInput.getVariableIndex() != null + && getOperationResult.operationDefinition.getOperation() == OperationDefinition.Operation.SUBSCRIPTION) { + throw new AbortExecutionException("Variable batching does not support subscriptions"); + } coercedVariables = coerceVariableValues(graphQLSchema, executionInput, getOperationResult.operationDefinition); normalizedVariableValues = normalizedVariableValues(graphQLSchema, executionInput, getOperationResult); } catch (RuntimeException rte) { @@ -292,6 +297,10 @@ private CompletableFuture incrementalSupport(ExecutionContext e } private DataLoaderDispatchStrategy createDataLoaderDispatchStrategy(ExecutionContext executionContext, ExecutionStrategy executionStrategy) { + VariableBatchDataLoaderDispatcher batchDispatcher = executionContext.getGraphQLContext().get(VariableBatchDataLoaderDispatcher.class); + if (batchDispatcher != null) { + return new ExhaustedDataLoaderDispatchStrategy(executionContext, batchDispatcher); + } if (executionContext.getDataLoaderRegistry() == EMPTY_DATALOADER_REGISTRY || doNotAutomaticallyDispatchDataLoader) { return DataLoaderDispatchStrategy.NO_OP; } diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy.java index 191ce0b176..e1865708ef 100644 --- a/src/main/java/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy.java +++ b/src/main/java/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy.java @@ -7,6 +7,8 @@ import graphql.execution.ExecutionContext; import graphql.execution.ExecutionStrategyParameters; import graphql.execution.incremental.AlternativeCallContext; +import graphql.schema.DataFetcher; +import graphql.schema.DataFetchingEnvironment; import org.dataloader.DataLoader; import org.dataloader.DataLoaderRegistry; import graphql.VisibleForTesting; @@ -19,6 +21,7 @@ import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.Supplier; @Internal @NullMarked @@ -28,6 +31,7 @@ public class ExhaustedDataLoaderDispatchStrategy implements DataLoaderDispatchSt private final ExecutionContext executionContext; private final Profiler profiler; + private @Nullable VariableBatchDataLoaderDispatcher batchDispatcher; private final Map alternativeCallContextMap = new ConcurrentHashMap<>(); @@ -132,6 +136,22 @@ public ExhaustedDataLoaderDispatchStrategy(ExecutionContext executionContext) { this(executionContext, new CallStack()); } + public ExhaustedDataLoaderDispatchStrategy(ExecutionContext executionContext, VariableBatchDataLoaderDispatcher batchDispatcher) { + this(executionContext); + Assert.assertTrue(executionContext.getDataLoaderRegistry() == batchDispatcher.getRegistry(), + () -> "Variable batch executions must share their DataLoader registry"); + this.batchDispatcher = batchDispatcher; + } + + @Override + public void fieldFetched(ExecutionContext executionContext, ExecutionStrategyParameters parameters, + DataFetcher dataFetcher, Object fetchedValue, + Supplier dataFetchingEnvironment) { + if (batchDispatcher != null) { + newDataLoaderInvocationMaybeDispatch(getCallStack(parameters)); + } + } + @VisibleForTesting ExhaustedDataLoaderDispatchStrategy(ExecutionContext executionContext, CallStack callStack) { this.initialCallStack = callStack; @@ -264,6 +284,10 @@ private void dispatchImpl(CallStack callStack) { } } + if (batchDispatcher != null) { + batchDispatcher.dispatch().whenComplete((ignored, failure) -> dispatchImpl(callStack)); + return; + } DataLoaderRegistry dataLoaderRegistry = executionContext.getDataLoaderRegistry(); List> dataLoaders = dataLoaderRegistry.getDataLoaders(); List>> allDispatchedCFs = new ArrayList<>(); diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/VariableBatchDataLoaderDispatcher.java b/src/main/java/graphql/execution/instrumentation/dataloader/VariableBatchDataLoaderDispatcher.java new file mode 100644 index 0000000000..2f71e3984e --- /dev/null +++ b/src/main/java/graphql/execution/instrumentation/dataloader/VariableBatchDataLoaderDispatcher.java @@ -0,0 +1,95 @@ +package graphql.execution.instrumentation.dataloader; + +import graphql.Assert; +import graphql.Internal; +import org.dataloader.DataLoaderRegistry; +import org.jspecify.annotations.NullMarked; +import org.jspecify.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.function.Consumer; + +@Internal +@NullMarked +public final class VariableBatchDataLoaderDispatcher { + private final DataLoaderRegistry registry; + private final Consumer failureHandler; + private final List> waiting = new ArrayList<>(); + private int holds; + private boolean flushing; + + public VariableBatchDataLoaderDispatcher(DataLoaderRegistry registry, Consumer failureHandler) { + this.registry = registry; + this.failureHandler = failureHandler; + } + + public DataLoaderRegistry getRegistry() { + return registry; + } + + public synchronized void pause() { + holds++; + } + + public void resume() { + synchronized (this) { + Assert.assertTrue(holds > 0); + holds--; + } + flush(); + } + + public CompletableFuture dispatch() { + CompletableFuture result = new CompletableFuture<>(); + synchronized (this) { + waiting.add(result); + } + flush(); + return result; + } + + private void flush() { + List> wave = takeWave(); + while (!wave.isEmpty()) { + dispatchWave(wave); + synchronized (this) { + flushing = false; + } + wave = takeWave(); + } + } + + private synchronized List> takeWave() { + if (holds > 0 || flushing || waiting.isEmpty()) { + return List.of(); + } + flushing = true; + List> wave = new ArrayList<>(waiting); + waiting.clear(); + return wave; + } + + private void dispatchWave(List> wave) { + try { + List> dispatched = new ArrayList<>(); + registry.getDataLoaders().forEach(loader -> dispatched.add(loader.dispatch())); + CompletableFuture.allOf(dispatched.toArray(new CompletableFuture[0])) + .whenComplete((ignored, failure) -> completeWave(wave, failure)); + } catch (Throwable failure) { + completeWave(wave, failure); + failureHandler.accept(failure); + } + } + + private void completeWave(List> wave, @Nullable Throwable failure) { + for (CompletableFuture result : wave) { + if (failure == null) { + result.complete(null); + } else { + result.completeExceptionally(failure); + } + } + } +} diff --git a/src/main/java/graphql/execution/preparsed/VariableBatchPreparsedDocumentProvider.java b/src/main/java/graphql/execution/preparsed/VariableBatchPreparsedDocumentProvider.java new file mode 100644 index 0000000000..25e6a244f8 --- /dev/null +++ b/src/main/java/graphql/execution/preparsed/VariableBatchPreparsedDocumentProvider.java @@ -0,0 +1,31 @@ +package graphql.execution.preparsed; + +import graphql.ExecutionInput; +import graphql.Internal; +import org.jspecify.annotations.NullMarked; +import org.jspecify.annotations.Nullable; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Function; + +@Internal +@NullMarked +public final class VariableBatchPreparsedDocumentProvider implements PreparsedDocumentProvider { + private final AtomicReference<@Nullable CompletableFuture> prepared = new AtomicReference<>(); + + @Override + public CompletableFuture getDocumentAsync(ExecutionInput input, + Function compute) { + CompletableFuture result = new CompletableFuture<>(); + if (!prepared.compareAndSet(null, result)) { + return graphql.Assert.assertNotNull(prepared.get()); + } + try { + result.complete(compute.apply(input)); + } catch (Throwable failure) { + result.completeExceptionally(failure); + } + return result; + } +} diff --git a/src/main/java/graphql/execution/reactive/RejectedBatchSubscription.java b/src/main/java/graphql/execution/reactive/RejectedBatchSubscription.java new file mode 100644 index 0000000000..cce3eacd49 --- /dev/null +++ b/src/main/java/graphql/execution/reactive/RejectedBatchSubscription.java @@ -0,0 +1,17 @@ +package graphql.execution.reactive; + +import graphql.Internal; +import org.reactivestreams.Subscription; + +@Internal +public enum RejectedBatchSubscription implements Subscription { + INSTANCE; + + @Override + public void request(long amount) { + } + + @Override + public void cancel() { + } +} diff --git a/src/main/java/graphql/execution/reactive/VariableBatchIncrementalPublisher.java b/src/main/java/graphql/execution/reactive/VariableBatchIncrementalPublisher.java new file mode 100644 index 0000000000..7db6d49b8d --- /dev/null +++ b/src/main/java/graphql/execution/reactive/VariableBatchIncrementalPublisher.java @@ -0,0 +1,140 @@ +package graphql.execution.reactive; + +import graphql.Assert; +import graphql.ExecutionInput; +import graphql.Internal; +import graphql.incremental.DelayedIncrementalPartialResult; +import org.jspecify.annotations.NullMarked; +import org.jspecify.annotations.Nullable; +import org.reactivestreams.Publisher; +import org.reactivestreams.Subscriber; +import org.reactivestreams.Subscription; + +import java.util.concurrent.CancellationException; +import java.util.concurrent.atomic.AtomicBoolean; + +@Internal +@NullMarked +public final class VariableBatchIncrementalPublisher implements Publisher, + Subscriber, Subscription { + private final Publisher source; + private final ExecutionInput input; + private final NonBlockingMutexExecutor mutex = new NonBlockingMutexExecutor(); + private final AtomicBoolean subscribed = new AtomicBoolean(); + private @Nullable Subscriber downstream; + private @Nullable Subscription upstream; + private long demand; + private boolean terminated; + private volatile boolean cancelled; + + public VariableBatchIncrementalPublisher(Publisher source, ExecutionInput input) { + this.source = source; + this.input = input; + input.getCancellationFuture().thenRun(() -> onError(new CancellationException("Variable batch entry cancelled"))); + } + + @Override + public void subscribe(Subscriber subscriber) { + Assert.assertNotNullWithNPE(subscriber, "subscriber must not be null"); + if (!subscribed.compareAndSet(false, true)) { + subscriber.onSubscribe(RejectedBatchSubscription.INSTANCE); + subscriber.onError(new IllegalStateException("Incremental results support one subscriber")); + return; + } + mutex.execute(() -> subscribeImpl(subscriber)); + } + + private void subscribeImpl(Subscriber subscriber) { + downstream = subscriber; + subscriber.onSubscribe(this); + if (cancelled) { + return; + } + if (input.isCancelled()) { + subscriber.onError(new CancellationException("Variable batch entry cancelled")); + terminated = true; + return; + } + try { + source.subscribe(this); + } catch (Throwable failure) { + onError(failure); + } + } + + @Override + public void onSubscribe(Subscription subscription) { + mutex.execute(() -> { + if (cancelled || terminated || upstream != null) { + subscription.cancel(); + return; + } + upstream = subscription; + if (demand > 0) { + subscription.request(demand); + } + }); + } + + @Override + public void request(long amount) { + if (amount <= 0) { + onError(new IllegalArgumentException("Reactive Streams demand must be positive")); + return; + } + mutex.execute(() -> { + if (cancelled || terminated) { + return; + } + long sum = demand + amount; + demand = sum < 0 ? Long.MAX_VALUE : sum; + if (upstream != null) { + upstream.request(amount); + } + }); + } + + @Override + public void cancel() { + cancelled = true; + input.cancel(); + mutex.execute(this::cancelUpstream); + } + + private void cancelUpstream() { + if (upstream != null) { + upstream.cancel(); + } + } + + @Override + public void onNext(DelayedIncrementalPartialResult value) { + mutex.execute(() -> { + if (!cancelled && !terminated) { + Assert.assertNotNull(downstream).onNext(value); + } + }); + } + + @Override + public void onError(Throwable failure) { + mutex.execute(() -> { + if (cancelled || terminated || downstream == null) { + return; + } + terminated = true; + cancelUpstream(); + downstream.onError(failure); + }); + } + + @Override + public void onComplete() { + mutex.execute(() -> { + if (!cancelled && !terminated) { + terminated = true; + Assert.assertNotNull(downstream).onComplete(); + } + }); + } +} diff --git a/src/main/java/graphql/execution/reactive/VariableBatchPublisher.java b/src/main/java/graphql/execution/reactive/VariableBatchPublisher.java new file mode 100644 index 0000000000..e0abb289ae --- /dev/null +++ b/src/main/java/graphql/execution/reactive/VariableBatchPublisher.java @@ -0,0 +1,190 @@ +package graphql.execution.reactive; + +import graphql.Assert; +import graphql.ExecutionInput; +import graphql.ExecutionResult; +import graphql.Internal; +import graphql.VariableBatchResult; +import graphql.execution.ExecutionId; +import graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys; +import graphql.execution.instrumentation.dataloader.VariableBatchDataLoaderDispatcher; +import graphql.incremental.IncrementalExecutionResult; +import graphql.incremental.IncrementalExecutionResultImpl; +import org.jspecify.annotations.NullMarked; +import org.jspecify.annotations.Nullable; +import org.reactivestreams.Publisher; +import org.reactivestreams.Subscriber; +import org.reactivestreams.Subscription; + +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Deque; +import java.util.List; +import java.util.concurrent.CancellationException; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.Function; + +@Internal +@NullMarked +public final class VariableBatchPublisher implements Publisher, Subscription { + private final ExecutionInput input; + private final ExecutionId batchId; + private final int size; + private final int concurrency; + private final Function> execute; + private final VariableBatchDataLoaderDispatcher dispatcher; + private final NonBlockingMutexExecutor mutex = new NonBlockingMutexExecutor(); + private final AtomicBoolean subscribed = new AtomicBoolean(); + private final List entries = new ArrayList<>(); + private final Deque ready = new ArrayDeque<>(); + private @Nullable Subscriber subscriber; + private @Nullable Throwable failure; + private long demand; + private int next; + private int active; + private volatile boolean cancelled; + private boolean terminated; + + public VariableBatchPublisher(ExecutionInput input, ExecutionId batchId, int concurrency, + Function> execute) { + this.input = input; + this.batchId = batchId; + this.size = input.getVariablesList().size(); + this.concurrency = concurrency; + this.execute = execute; + this.dispatcher = new VariableBatchDataLoaderDispatcher(input.getDataLoaderRegistry(), this::fail); + input.getCancellationFuture().thenRun(() -> mutex.execute(() -> { + cancelEntries(); + failure = new CancellationException("Variable batch cancelled"); + drain(); + })); + } + + @Override + public void subscribe(Subscriber subscriber) { + Assert.assertNotNullWithNPE(subscriber, "subscriber must not be null"); + if (!subscribed.compareAndSet(false, true)) { + subscriber.onSubscribe(RejectedBatchSubscription.INSTANCE); + subscriber.onError(new IllegalStateException("Variable batch results support one subscriber")); + return; + } + mutex.execute(() -> { + this.subscriber = subscriber; + subscriber.onSubscribe(this); + drain(); + }); + } + + @Override + public void request(long amount) { + if (amount <= 0) { + fail(new IllegalArgumentException("Reactive Streams demand must be positive")); + return; + } + mutex.execute(() -> { + long sum = demand + amount; + demand = sum < 0 ? Long.MAX_VALUE : sum; + drain(); + }); + } + + @Override + public void cancel() { + cancelled = true; + mutex.execute(this::cancelEntries); + } + + private void fail(Throwable failure) { + mutex.execute(() -> { + this.failure = failure; + drain(); + }); + } + + private void drain() { + if (cancelled || terminated || subscriber == null) { + return; + } + if (failure != null) { + terminated = true; + cancelEntries(); + subscriber.onError(failure); + return; + } + emitReady(); + if (cancelled) { + return; + } + if (next == size && active == 0 && ready.isEmpty()) { + terminated = true; + subscriber.onComplete(); + return; + } + startWave(); + } + + private void emitReady() { + while (!cancelled && demand > 0 && !ready.isEmpty()) { + demand--; + Assert.assertNotNull(subscriber).onNext(ready.removeFirst()); + } + } + + private void startWave() { + // Let every newly started entry enqueue its keys before flushing the shared registry. + // Async continuations can request further dispatches without waiting for another entry to finish. + dispatcher.pause(); + try { + while (!cancelled && next < size && active + ready.size() < concurrency + && active + ready.size() < demand) { + startEntry(next++); + } + } finally { + dispatcher.resume(); + } + } + + private void startEntry(int index) { + ExecutionInput entry = input.newVariableBatchEntry(index, batchId); + entry.getGraphQLContext().put(VariableBatchDataLoaderDispatcher.class, dispatcher); + DataLoaderDispatchingContextKeys.setEnableDataLoaderChaining(entry.getGraphQLContext(), false); + DataLoaderDispatchingContextKeys.setEnableDataLoaderExhaustedDispatching(entry.getGraphQLContext(), true); + entries.add(entry); + active++; + try { + execute.apply(entry).whenComplete((result, failure) -> mutex.execute(() -> finishEntry(index, result, failure))); + } catch (Throwable failure) { + mutex.execute(() -> finishEntry(index, null, failure)); + } + } + + private void finishEntry(int index, @Nullable ExecutionResult result, @Nullable Throwable failure) { + active--; + if (cancelled || terminated) { + return; + } + if (failure != null) { + this.failure = failure; + } else { + ready.addLast(VariableBatchResult.newVariableBatchResult() + .variableIndex(index).executionResult(wrapIncremental(index, Assert.assertNotNull(result))).build()); + } + drain(); + } + + private ExecutionResult wrapIncremental(int index, ExecutionResult result) { + if (!(result instanceof IncrementalExecutionResult)) { + return result; + } + IncrementalExecutionResult incremental = (IncrementalExecutionResult) result; + return IncrementalExecutionResultImpl.fromIncrementalExecutionResult(incremental) + .incrementalItemPublisher(new VariableBatchIncrementalPublisher(incremental.getIncrementalItemPublisher(), entries.get(index))) + .build(); + } + + private void cancelEntries() { + entries.forEach(ExecutionInput::cancel); + ready.clear(); + } +} diff --git a/src/main/java/graphql/extensions/ExtensionsBuilder.java b/src/main/java/graphql/extensions/ExtensionsBuilder.java index e65e315e2f..dbc80859f6 100644 --- a/src/main/java/graphql/extensions/ExtensionsBuilder.java +++ b/src/main/java/graphql/extensions/ExtensionsBuilder.java @@ -2,6 +2,7 @@ import com.google.common.collect.ImmutableMap; import graphql.ExecutionResult; +import graphql.Internal; import graphql.PublicApi; import org.jspecify.annotations.NonNull; import org.jspecify.annotations.Nullable; @@ -62,6 +63,13 @@ public int getChangeCount() { return changes.size(); } + @Internal + public ExtensionsBuilder copy() { + ExtensionsBuilder copy = new ExtensionsBuilder(extensionsMerger); + copy.changes.addAll(changes); + return copy; + } + /** * Adds new values into the extension builder * diff --git a/src/test/groovy/graphql/GraphQLTest.groovy b/src/test/groovy/graphql/GraphQLTest.groovy index 7b9c48ad7d..8f8f50af52 100644 --- a/src/test/groovy/graphql/GraphQLTest.groovy +++ b/src/test/groovy/graphql/GraphQLTest.groovy @@ -1058,7 +1058,7 @@ many lines'''] given: when: - def input = newExecutionInput().query('query($var:String){ hello(arg: $var) }').variables(null).build() + def input = newExecutionInput().query('query($var:String){ hello(arg: $var) }').variables((Map) null).build() then: def assEx = thrown(AssertException) diff --git a/src/test/groovy/graphql/VariableBatchExecutionTest.groovy b/src/test/groovy/graphql/VariableBatchExecutionTest.groovy new file mode 100644 index 0000000000..9d4c8bd559 --- /dev/null +++ b/src/test/groovy/graphql/VariableBatchExecutionTest.groovy @@ -0,0 +1,719 @@ +package graphql + +import graphql.execution.ExecutionId +import graphql.execution.instrumentation.SimplePerformantInstrumentation +import graphql.execution.instrumentation.parameters.InstrumentationExecutionParameters +import graphql.execution.instrumentation.InstrumentationState +import graphql.execution.instrumentation.DocumentAndVariables +import graphql.execution.preparsed.PreparsedDocumentEntry +import graphql.execution.preparsed.PreparsedDocumentProvider +import graphql.execution.preparsed.VariableBatchPreparsedDocumentProvider +import graphql.extensions.ExtensionsBuilder +import graphql.incremental.IncrementalExecutionResult +import graphql.parser.Parser +import graphql.schema.DataFetcher +import org.dataloader.BatchLoader +import org.dataloader.DataLoaderFactory +import org.dataloader.DataLoaderRegistry +import org.reactivestreams.Subscriber +import org.reactivestreams.Subscription +import reactor.core.publisher.Flux +import spock.lang.Specification +import spock.lang.Timeout + +import java.time.Duration +import java.util.concurrent.CompletableFuture +import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicInteger + +import static graphql.ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT + +@Timeout(15) +class VariableBatchExecutionTest extends Specification { + def schema = TestUtil.schema('type Query { value(id: Int = 7): Int! }', + [Query: [value: { env -> env.getArgument('id') } as DataFetcher]]) + + def "empty and singleton lists retain ordinary execution"() { + when: + def result = GraphQL.newGraphQL(schema).build().execute(ExecutionInput.newExecutionInput() + .query('query($id:Int) { value(id:$id) }').variables(variables).build()) + + then: + !(result instanceof VariableBatchExecutionResult) + result.toSpecification() == [data: [value: expected]] + + where: + variables | expected + [] | 7 + [[:]] | 7 + [[id: 3]] | 3 + } + + def "legacy variables become a singleton and transforms preserve every map"() { + given: + def maps = [[id: 1], [id: null]] + def input = ExecutionInput.newExecutionInput('{ value }').variables(maps).profileExecution(true).build() + maps[0].id = 99 + maps.add([id: 3]) + + expect: + ExecutionInput.newExecutionInput('{ value }').variables([id: 1]).build().variablesList == [[id: 1]] + input.variablesList == [[id: 1], [id: null]] + input.transform { it.operationName('Op') }.variablesList == [[id: 1], [id: null]] + input.transform { it.operationName('Op') }.profileExecution + input.variables == [id: 1] + + when: + input.variablesList[0].put('id', 4) + + then: + thrown(UnsupportedOperationException) + } + + def "separate variable coercion and conditional selection for every entry"() { + when: + def batch = batch(GraphQL.newGraphQL(schema).build(), + 'query($id: Int!,$include:Boolean! = true) { value(id:$id) @include(if:$include) }', + [[id: 1], [id: 2, include: false], [id: 'bad'], [id: 1]]) + def results = batch.resultsAsync.get(5, TimeUnit.SECONDS) + + then: + results.size() == 4 + results[0].data == [value: 1] + results[1].data == [:] + !results[2].dataPresent + results[2].errors.size() == 1 + results[3].data == [value: 1] + } + + def "common request errors are returned for every index"() { + when: + def results = batch(GraphQL.newGraphQL(schema).build(), query, [[:], [:]]) + .resultsAsync.get(5, TimeUnit.SECONDS) + + then: + results.size() == 2 + results.every { !it.errors.empty && !it.dataPresent } + + where: + query << ['{', '{ missing }', 'query A { value } query B { value }'] + } + + def "shared dataloaders combine entries and cache repeated keys"() { + given: + def calls = [] + def registry = new DataLoaderRegistry() + registry.register('values', DataLoaderFactory.newDataLoader({ keys -> + calls.add(new ArrayList(keys)) + CompletableFuture.completedFuture(keys) + } as BatchLoader)) + def loadedSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> env.getDataLoader('values').load(env.getArgument('id')) } as DataFetcher]]) + def graphQL = GraphQL.newGraphQL(loadedSchema).build() + + when: + def input = ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') + .variables([[id: 1], [id: 2], [id: 1]]) + .dataLoaderRegistry(registry).build() + VariableBatchExecutionResult result = graphQL.execute(input) + def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) + + then: + entries*.data == [[value: 1], [value: 2], [value: 1]] + calls == [[1, 2]] + } + + def "chained loaders share their registries and dispatch without hanging"() { + given: + def calls = [] + def registry = new DataLoaderRegistry() + ['first', 'second'].each { name -> + registry.register(name, DataLoaderFactory.newDataLoader({ keys -> + calls.add([name, new ArrayList(keys)]) + CompletableFuture.completedFuture(keys) + } as BatchLoader)) + } + def loadedSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> + env.getDataLoader('first').load(env.getArgument('id')).thenCompose { value -> + env.getDataLoader('second').load(value) + } + } as DataFetcher]]) + + when: + VariableBatchExecutionResult result = GraphQL.newGraphQL(loadedSchema).build().execute( + ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') + .variables([[id: 1], [id: 2]]).dataLoaderRegistry(registry).build()) + def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) + + then: + entries*.data == [[value: 1], [value: 2]] + calls*.first().containsAll(['first', 'second']) + } + + def "completion order streams immediately while collection preserves input order"() { + given: + def values = [new CompletableFuture(), new CompletableFuture()] + def asyncSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> values[env.getArgument('id')] } as DataFetcher]]) + def emitted = [] + def result = batch(GraphQL.newGraphQL(asyncSchema).build(), + 'query($id:Int!) { value(id:$id) }', [[id: 0], [id: 1]]) + def completed = Flux.from(result.results).doOnNext { emitted.add(it) }.collectList().toFuture() + + when: + values[1].complete(11) + + then: + emitted*.variableIndex == [1] + !completed.done + + when: + values[0].complete(10) + + then: + completed.get(5, TimeUnit.SECONDS)*.variableIndex == [1, 0] + } + + def "non-null failure is confined to its execution"() { + given: + def failingSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> env.getArgument('id') == 1 ? null : 2 } as DataFetcher]]) + + when: + def results = batch(GraphQL.newGraphQL(failingSchema).build(), + 'query($id:Int!) { value(id:$id) }', [[id: 1], [id: 2]]).resultsAsync.get(5, TimeUnit.SECONDS) + + then: + results[0].data == null + results[0].errors[0].path == ['value'] + results[1].toSpecification() == [data: [value: 2]] + } + + def "instrumentation sees individual inputs contexts and ids"() { + given: + def seen = [] + def instrumentation = new SimplePerformantInstrumentation() { + @Override + ExecutionInput instrumentExecutionInput(ExecutionInput input, InstrumentationExecutionParameters parameters, + InstrumentationState state) { + seen.add(input) + input.graphQLContext.put('entry', input.variableIndex) + input.transform { it.variables([id: input.variables.id + 10]) } + } + } + def graphQL = GraphQL.newGraphQL(schema).instrumentation(instrumentation).build() + def input = ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') + .variables([[id: 1], [id: 2]]).executionId(ExecutionId.from('batch')) + .graphQLContext([app: 'shared']).build() + + when: + VariableBatchExecutionResult result = graphQL.execute(input) + def results = result.resultsAsync.get(5, TimeUnit.SECONDS) + + then: + results*.data == [[value: 11], [value: 12]] + seen*.variableIndex == [0, 1] + seen*.variableBatchId*.toString() == ['batch', 'batch'] + seen*.executionId.toSet().size() == 2 + !seen[0].graphQLContext.is(seen[1].graphQLContext) + !input.graphQLContext.hasKey('entry') + seen.every { it.graphQLContext.get('app') == 'shared' } + } + + def "batch input cancellation stops pending work"() { + given: + def invoked = [] + def asyncSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> + invoked.add(env.getArgument('id')) + new CompletableFuture() + } as DataFetcher]]) + def input = ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') + .variables([[id: 1], [id: 2], [id: 3]]).build() + VariableBatchExecutionResult batch = GraphQL.newGraphQL(asyncSchema).maxVariableBatchConcurrency(1).build().execute(input) + def result = batch.resultsAsync + + when: + input.cancel() + + then: + result.completedExceptionally + invoked == [1] + } + + def "subscriptions are rejected without invoking a subscription fetcher"() { + given: + def invoked = false + def subscriptionSchema = TestUtil.schema('type Query { value:Int } type Subscription { value:Int }', + [Subscription: [value: { invoked = true } as DataFetcher]]) + + when: + def results = batch(GraphQL.newGraphQL(subscriptionSchema).build(), 'subscription { value }', [[:], [:]]) + .resultsAsync.get(5, TimeUnit.SECONDS) + + then: + !invoked + results.every { !it.errors.empty } + } + + def "batch limits are checked before fetching and survive GraphQL transform"() { + given: + def graphQL = GraphQL.newGraphQL(schema).maxVariableBatchSize(2).maxVariableBatchConcurrency(1) + .build().transform { it.valueUnboxer(graphql.execution.ValueUnboxer.DEFAULT) } + + when: + graphQL.execute(ExecutionInput.newExecutionInput('{ value }').variables([[:], [:], [:]]).build()) + + then: + def error = thrown(graphql.execution.AbortExecutionException) + error.message.contains('exceeds maximum allowed 2') + + when: + GraphQL.newGraphQL(schema).maxVariableBatchSize(0) + + then: + thrown(AssertException) + + when: + GraphQL.newGraphQL(schema).maxVariableBatchConcurrency(0) + + then: + thrown(AssertException) + } + + def "subscriber demand bounds scheduling and cancellation stops new executions"() { + given: + def calls = [] + def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> calls.add(env.getArgument('id')); env.getArgument('id') } as DataFetcher]]) + def result = batch(GraphQL.newGraphQL(localSchema).build(), 'query($id:Int!) { value(id:$id) }', + [[id: 1], [id: 2], [id: 3]]) + + when: + def first = Flux.from(result.results).limitRate(1).take(1).collectList().block(Duration.ofSeconds(5)) + + then: + first*.variableIndex == [0] + calls == [1] + } + + def "collected results keep input order across asynchronous completion"() { + given: + def values = [new CompletableFuture(), new CompletableFuture()] + def asyncSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> values[env.getArgument('id')] } as DataFetcher]]) + def result = batch(GraphQL.newGraphQL(asyncSchema).build(), 'query($id:Int!) { value(id:$id) }', + [[id: 0], [id: 1]]).resultsAsync + + when: + values[1].complete(11) + values[0].complete(10) + + then: + result.get(5, TimeUnit.SECONDS)*.data == [[value: 10], [value: 11]] + } + + def "mutation fields stay serial and cache invalidation applies to the shared registry"() { + given: + def values = [key: 0] + def calls = [] + def registry = new DataLoaderRegistry() + def loader = DataLoaderFactory.newDataLoader({ keys -> + calls.add(new ArrayList(keys)) + CompletableFuture.completedFuture(keys.collect { values[it] }) + } as BatchLoader) + registry.register('values', loader) + def mutationSchema = TestUtil.schema(''' + type Query { value:Int } + type Mutation { update(value:Int!):Int! read:Int! } + ''', [Mutation: [update: { env -> + values.key = env.getArgument('value') + env.getDataLoader('values').clear('key').prime('key', values.key) + values.key + } as DataFetcher, read: { env -> env.getDataLoader('values').load('key') } as DataFetcher]]) + def input = ExecutionInput.newExecutionInput('mutation($value:Int!) { update(value:$value) read }') + .variables([[value: 1], [value: 2]]).dataLoaderRegistry(registry).build() + + when: + VariableBatchExecutionResult result = GraphQL.newGraphQL(mutationSchema) + .maxVariableBatchConcurrency(1).build().execute(input) + def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) + + then: + entries*.data == [[update: 1, read: 1], [update: 2, read: 2]] + calls.empty + values.key == 2 + } + + def "extension builders are isolated including a supplied builder"() { + given: + def extensions = ExtensionsBuilder.newExtensionsBuilder().addValue('initial', true) + def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> + env.graphQlContext.get(ExtensionsBuilder).addValue('entry', env.getArgument('id')) + env.getArgument('id') + } as DataFetcher]]) + def input = ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') + .variables([[id: 1], [id: 2]]).graphQLContext([(ExtensionsBuilder): extensions]).context('legacy').build() + + when: + VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).build().execute(input) + def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) + + then: + entries*.extensions == [[initial: true, entry: 1], [initial: true, entry: 2]] + extensions.buildExtensions() == [initial: true] + } + + def "custom document instrumentation and preparsed providers retain per-entry behavior"() { + given: + def seen = [] + def provider = { ExecutionInput input, compute -> + seen.add(input.variables.id) + CompletableFuture.completedFuture(compute.apply(input)) + } as PreparsedDocumentProvider + def instrumentation = new SimplePerformantInstrumentation() { + @Override + DocumentAndVariables instrumentDocumentAndVariables(DocumentAndVariables value, + InstrumentationExecutionParameters parameters, InstrumentationState state) { + value.transform { it.variables([id: parameters.variables.id + 10]) } + } + } + + when: + def result = batch(GraphQL.newGraphQL(schema).preparsedDocumentProvider(provider) + .instrumentation(instrumentation).build(), 'query($id:Int!) { value(id:$id) }', [[id: 1], [id: 2]]) + def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) + + then: + seen == [1, 2] + entries*.data == [[value: 11], [value: 12]] + } + + def "batch preparation computes only once including common errors"() { + given: + def provider = new VariableBatchPreparsedDocumentProvider() + def calls = new AtomicInteger() + def input = ExecutionInput.newExecutionInput('{ value }').build() + def compute = { ignored -> + calls.incrementAndGet() + new PreparsedDocumentEntry(Parser.parse('{ value }')) + } as java.util.function.Function + + when: + def first = provider.getDocumentAsync(input, compute) + def second = provider.getDocumentAsync(input.transform { it.variables([id: 2]) }, compute) + + then: + first.is(second) + first.join().document != null + calls.get() == 1 + } + + def "incremental execution remains available per variable entry"() { + given: + def registry = new DataLoaderRegistry() + registry.register('values', DataLoaderFactory.newDataLoader({ keys -> CompletableFuture.completedFuture(keys) } as BatchLoader)) + def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> env.getDataLoader('values').load(env.getArgument('id')) } as DataFetcher]]) + def input = ExecutionInput.newExecutionInput('query($id:Int!) { ... @defer { value(id:$id) } }') + .variables([[id: 1], [id: 2]]).dataLoaderRegistry(registry) + .graphQLContext([(ENABLE_INCREMENTAL_SUPPORT): true]).build() + + when: + VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).build().execute(input) + def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) + def payloads = entries.collect { IncrementalExecutionResult entry -> + Flux.from(entry.incrementalItemPublisher).collectList().block(Duration.ofSeconds(5)) + } + + then: + entries.every { it instanceof IncrementalExecutionResult } + payloads.collect { it[0].incremental[0].data } == [[value: 1], [value: 2]] + } + + def "an asynchronous shared loader failure belongs to each affected entry"() { + given: + def pending = new CompletableFuture>() + def keysSeen = [] + def registry = new DataLoaderRegistry().register('values', DataLoaderFactory.newDataLoader({ keys -> + keysSeen.add(new ArrayList(keys)) + pending + } as BatchLoader)) + def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> env.getDataLoader('values').load(env.getArgument('id')) } as DataFetcher]]) + VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).build().execute( + ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') + .variables([[id: 1], [id: 2]]).dataLoaderRegistry(registry).build()) + def entries = result.resultsAsync + + when: + pending.completeExceptionally(new IllegalStateException('backend unavailable')) + + then: + entries.get(5, TimeUnit.SECONDS).every { it.data == null && it.errors[0].path == ['value'] } + keysSeen == [[1, 2]] + } + + def "cancelling an individual execution does not cancel a shared loader future"() { + given: + def seen = [] + def instrumentation = new SimplePerformantInstrumentation() { + @Override + ExecutionInput instrumentExecutionInput(ExecutionInput input, InstrumentationExecutionParameters parameters, + InstrumentationState state) { + seen.add(input) + input + } + } + def pending = new CompletableFuture>() + def registry = new DataLoaderRegistry().register('values', DataLoaderFactory.newDataLoader({ keys -> pending } as BatchLoader)) + def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> env.getDataLoader('values').load(env.getArgument('id')) } as DataFetcher]]) + VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).instrumentation(instrumentation).build().execute( + ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') + .variables([[id: 1], [id: 1]]).dataLoaderRegistry(registry).build()) + def entries = result.resultsAsync + + when: + seen[0].cancel() + pending.complete([10]) + + then: + !pending.cancelled + !entries.get(5, TimeUnit.SECONDS)[0].errors.empty + entries.get(5, TimeUnit.SECONDS)[1].toSpecification() == [data: [value: 10]] + } + + def "pre-cancelled input and cancelled collection do not start queued entries"() { + given: + def calls = [] + def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> calls.add(env.getArgument('id')); new CompletableFuture() } as DataFetcher]]) + def input = ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') + .variables([[id: 1], [id: 2]]).build() + if (beforeSubscription) input.cancel() + VariableBatchExecutionResult batch = GraphQL.newGraphQL(localSchema).maxVariableBatchConcurrency(1).build().execute(input) + + when: + def result = batch.resultsAsync + if (!beforeSubscription) result.cancel(false) + + then: + result.completedExceptionally + calls == (beforeSubscription ? [] : [1]) + + where: + beforeSubscription << [true, false] + } + + def "batch cancellation still reaches deferred executions after initial results complete"() { + given: + def called = [] + def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> called.add(env.getArgument('id')); env.getArgument('id') } as DataFetcher]]) + def input = ExecutionInput.newExecutionInput('query($id:Int!) { ... @defer { value(id:$id) } }') + .variables([[id: 1], [id: 2]]).graphQLContext([(ENABLE_INCREMENTAL_SUPPORT): true]).build() + VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).build().execute(input) + def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) + + when: + input.cancel() + Flux.from((entries[0] as IncrementalExecutionResult).incrementalItemPublisher) + .collectList().block(Duration.ofSeconds(5)) + + then: + thrown(java.util.concurrent.CancellationException) + called.empty + } + + def "publisher rejects nonpositive demand and repeated subscriptions"() { + given: + def result = batch(GraphQL.newGraphQL(schema).build(), '{ value }', [[:], [:]]) + def errors = [] + def subscriber = [onSubscribe: { Subscription subscription -> subscription.request(0) }, + onNext: { throw new AssertionError('unexpected result') }, + onError: { errors.add(it) }, onComplete: {}] as Subscriber + + when: + result.results.subscribe(subscriber) + result.results.subscribe(subscriber) + + then: + errors*.class == [IllegalArgumentException, IllegalStateException] + result.data.is(result.results) + result.size == 2 + + when: + result.toSpecification() + + then: + thrown(UnsupportedOperationException) + } + + def "unexpected instrumentation failures fail the batch without starting pending entries"() { + given: + def seen = [] + def instrumentation = new SimplePerformantInstrumentation() { + @Override + ExecutionInput instrumentExecutionInput(ExecutionInput input, InstrumentationExecutionParameters parameters, + InstrumentationState state) { + seen.add(input.variableIndex) + throw new IllegalStateException('broken instrumentation') + } + } + + when: + batch(GraphQL.newGraphQL(schema).instrumentation(instrumentation).maxVariableBatchConcurrency(1).build(), + '{ value }', [[:], [:]]).resultsAsync.get(5, TimeUnit.SECONDS) + + then: + def failure = thrown(java.util.concurrent.ExecutionException) + failure.cause.message == 'broken instrumentation' + seen == [0] + } + + def "concurrency bounds active work without waiting for a slow earlier entry"() { + given: + def called = [] + def pending = (0..3).collect { new CompletableFuture() } + def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> + def id = env.getArgument('id') + called.add(id) + pending[id] + } as DataFetcher]]) + def result = batch(GraphQL.newGraphQL(localSchema).maxVariableBatchConcurrency(2).build(), + 'query($id:Int!) { value(id:$id) }', (0..3).collect { [id: it] }).resultsAsync + + expect: + called == [0, 1] + + when: + pending[1].complete(1) + + then: + called == [0, 1, 2] + + when: + pending[2].complete(2) + pending[3].complete(3) + pending[0].complete(0) + + then: + result.get(5, TimeUnit.SECONDS)*.data == [[value: 0], [value: 1], [value: 2], [value: 3]] + } + + def "persisted query lookup can replace the query while retaining every variables map"() { + given: + def seen = [] + def provider = { ExecutionInput input, compute -> + seen.add(input.extensions.id) + CompletableFuture.completedFuture(compute.apply(input.transform { + it.query('query($id:Int!) { value(id:$id) }') + })) + } as PreparsedDocumentProvider + def input = ExecutionInput.newExecutionInput(graphql.execution.preparsed.persisted.PersistedQuerySupport.PERSISTED_QUERY_MARKER) + .extensions([id: 'known-query']).variables([[id: 1], [id: 2]]).build() + + when: + VariableBatchExecutionResult result = GraphQL.newGraphQL(schema).preparsedDocumentProvider(provider).build().execute(input) + + then: + result.resultsAsync.get(5, TimeUnit.SECONDS)*.data == [[value: 1], [value: 2]] + seen == ['known-query', 'known-query'] + } + + def "cancelling a deferred subscription leaves other entries available"() { + given: + def pending = new CompletableFuture() + def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> env.getArgument('id') == 1 ? pending : 2 } as DataFetcher]]) + def input = ExecutionInput.newExecutionInput('query($id:Int!) { ... @defer { value(id:$id) } }') + .variables([[id: 1], [id: 2]]).graphQLContext([(ENABLE_INCREMENTAL_SUPPORT): true]).build() + VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).build().execute(input) + def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) + def first = Flux.from((entries[0] as IncrementalExecutionResult).incrementalItemPublisher).collectList().toFuture() + + when: + first.cancel(false) + pending.complete(1) + def second = Flux.from((entries[1] as IncrementalExecutionResult).incrementalItemPublisher) + .collectList().block(Duration.ofSeconds(5)) + + then: + first.cancelled + !pending.cancelled + second[0].incremental[0].data == [value: 2] + } + + def "input cancellation terminates an already subscribed deferred publisher"() { + given: + def localSchema = TestUtil.schema('type Query { value:Int! }', + [Query: [value: { new CompletableFuture() } as DataFetcher]]) + def input = ExecutionInput.newExecutionInput('{ ... @defer { value } }') + .variables([[:], [:]]).graphQLContext([(ENABLE_INCREMENTAL_SUPPORT): true]).build() + VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).build().execute(input) + def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) + def deferred = Flux.from((entries[0] as IncrementalExecutionResult).incrementalItemPublisher).collectList().toFuture() + + when: + input.cancel() + + then: + deferred.completedExceptionally + } + + def "variable lists reject a null list or a null entry"() { + when: + ExecutionInput.newExecutionInput('{ value }').variables((List>) values) + + then: + thrown(AssertException) + + where: + values << [null, [[id: 1], null]] + } + + def "instrumentation cannot replace the shared dataloader registry per entry"() { + given: + def instrumentation = new SimplePerformantInstrumentation() { + @Override + ExecutionInput instrumentExecutionInput(ExecutionInput input, InstrumentationExecutionParameters parameters, + InstrumentationState state) { + input.transform { it.dataLoaderRegistry(new DataLoaderRegistry()) } + } + } + + when: + batch(GraphQL.newGraphQL(schema).instrumentation(instrumentation).build(), '{ value }', [[:], [:]]) + .resultsAsync.get(5, TimeUnit.SECONDS) + + then: + def error = thrown(java.util.concurrent.ExecutionException) + error.cause.message.contains('must share their DataLoader registry') + } + + def "unexpected registry dispatch failure terminates the batch"() { + given: + def registry = Stub(DataLoaderRegistry) { + getDataLoaders() >> { throw new IllegalStateException('broken registry') } + } + def localSchema = TestUtil.schema('type Query { value:Int }', + [Query: [value: { new CompletableFuture() } as DataFetcher]]) + VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).build().execute( + ExecutionInput.newExecutionInput('{ value }').variables([[:], [:]]).dataLoaderRegistry(registry).build()) + + when: + result.resultsAsync.get(5, TimeUnit.SECONDS) + + then: + def error = thrown(java.util.concurrent.ExecutionException) + error.cause.message == 'broken registry' + } + + private static VariableBatchExecutionResult batch(GraphQL graphQL, String query, List> variables) { + graphQL.execute(ExecutionInput.newExecutionInput(query).variables(variables).build()) as VariableBatchExecutionResult + } +} From 2a748e4255a9ba9dd2e18da0c811b1bbeb3e7ab4 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Sun, 1 Nov 2026 08:40:04 +1000 Subject: [PATCH 2/5] Reject subscription variable batches before execution --- src/main/java/graphql/ExecutionInput.java | 2 +- src/main/java/graphql/GraphQL.java | 70 ++++++-- .../graphql/VariableBatchExecutionResult.java | 4 +- .../java/graphql/execution/Execution.java | 4 - ...ariableBatchPreparsedDocumentProvider.java | 31 ---- .../graphql/VariableBatchExecutionTest.groovy | 154 ++++++++++++++++-- 6 files changed, 193 insertions(+), 72 deletions(-) delete mode 100644 src/main/java/graphql/execution/preparsed/VariableBatchPreparsedDocumentProvider.java diff --git a/src/main/java/graphql/ExecutionInput.java b/src/main/java/graphql/ExecutionInput.java index 567c3dec8e..874ffde4eb 100644 --- a/src/main/java/graphql/ExecutionInput.java +++ b/src/main/java/graphql/ExecutionInput.java @@ -517,7 +517,7 @@ public Builder variables(Map rawVariables) { /** * Supplies complete variable maps for the same selected operation. An empty list executes once * with empty variables; a singleton executes normally. Larger lists return a - * {@link VariableBatchExecutionResult}. Entries are never deduplicated. + * {@link VariableBatchExecutionResult}. Entries are never deduplicated. Subscriptions cannot be batched. * * @param variables the maps in input order; neither the list nor its entries may be null * @return this builder diff --git a/src/main/java/graphql/GraphQL.java b/src/main/java/graphql/GraphQL.java index 7901b13eca..d8be414c47 100644 --- a/src/main/java/graphql/GraphQL.java +++ b/src/main/java/graphql/GraphQL.java @@ -11,6 +11,7 @@ import graphql.execution.ExecutionStrategy; import graphql.execution.SimpleDataFetcherExceptionHandler; import graphql.execution.SubscriptionExecutionStrategy; +import graphql.execution.UnknownOperationException; import graphql.execution.ValueUnboxer; import graphql.execution.instrumentation.DocumentAndVariables; import graphql.execution.instrumentation.Instrumentation; @@ -23,10 +24,11 @@ import graphql.execution.preparsed.NoOpPreparsedDocumentProvider; import graphql.execution.preparsed.PreparsedDocumentEntry; import graphql.execution.preparsed.PreparsedDocumentProvider; -import graphql.execution.preparsed.VariableBatchPreparsedDocumentProvider; import graphql.execution.reactive.VariableBatchPublisher; import graphql.introspection.GoodFaithIntrospection; import graphql.language.Document; +import graphql.language.NodeUtil; +import graphql.language.OperationDefinition; import graphql.schema.GraphQLSchema; import graphql.validation.GoodFaithIntrospectionExceeded; import graphql.validation.OperationValidationRule; @@ -34,6 +36,7 @@ import graphql.validation.ValidationError; import org.jspecify.annotations.NullMarked; import org.jspecify.annotations.NullUnmarked; +import org.jspecify.annotations.Nullable; import java.util.List; import java.util.Locale; @@ -514,7 +517,8 @@ public CompletableFuture executeAsync(UnaryOperator * This will return a promise (aka {@link CompletableFuture}) to provide a {@link ExecutionResult} * which is the result of executing the provided query. - * Multiple variable maps return a lazy {@link VariableBatchExecutionResult}; see that type for consumption. + * Multiple variable maps return a {@link VariableBatchExecutionResult}; preparation can run eagerly, + * while field execution starts on demand. Batched subscription operations fail with {@link IllegalArgumentException}. * @param executionInput {@link ExecutionInput} * * @return a promise to an {@link ExecutionResult} which can include errors @@ -544,7 +548,7 @@ public CompletableFuture executeAsync(ExecutionInput executionI GraphQLSchema graphQLSchema = instrumentation.instrumentSchema(this.graphQLSchema, instrumentationParameters, instrumentationState); - CompletableFuture executionResult = parseValidateAndExecute(instrumentedExecutionInput, graphQLSchema, instrumentationState, engineRunningState, profiler); + CompletableFuture executionResult = parseValidateAndExecute(instrumentedExecutionInput, graphQLSchema, instrumentationState, engineRunningState, profiler, executionInput.getVariableIndex() != null); // // finish up instrumentation executionResult = executionResult.whenComplete(completeInstrumentationCtxCF(executionInstrumentation)); @@ -565,17 +569,47 @@ private CompletableFuture executeVariableBatch(ExecutionInput i return CompletableFuture.failedFuture(new AbortExecutionException( "Variable batch has " + size + " entries which exceeds maximum allowed " + maxVariableBatchSize)); } - ExecutionId batchId = assertNotNull(ensureInputHasId(input).getExecutionId()); - GraphQL executor = this; + try { + GraphQL executor = prepareVariableBatch(input); + ExecutionId batchId = assertNotNull(ensureInputHasId(input).getExecutionId()); + VariableBatchPublisher publisher = new VariableBatchPublisher(input, batchId, maxVariableBatchConcurrency, executor::executeAsync); + return CompletableFuture.completedFuture(new VariableBatchExecutionResultImpl(publisher, size)); + } catch (RuntimeException exception) { + return CompletableFuture.failedFuture(exception); + } + } + + private GraphQL prepareVariableBatch(ExecutionInput input) { // Custom providers and instrumentation retain their existing per-execution semantics. - if (preparsedDocumentProvider == NoOpPreparsedDocumentProvider.INSTANCE - && instrumentation.getClass() == SimplePerformantInstrumentation.class) { - executor = transform(builder -> builder - .preparsedDocumentProvider(new VariableBatchPreparsedDocumentProvider()) - .valueUnboxer(valueUnboxer)); + if (preparsedDocumentProvider != NoOpPreparsedDocumentProvider.INSTANCE + || instrumentation.getClass() != SimplePerformantInstrumentation.class) { + assertVariableBatchOperationSupported(true, input, ParseAndValidate.parse(input).getDocument()); + return this; + } + PreparsedDocumentEntry prepared = parseAndValidate(new AtomicReference<>(input), graphQLSchema, null, true); + CompletableFuture preparedFuture = CompletableFuture.completedFuture(prepared); + return transform(builder -> builder + .preparsedDocumentProvider((entry, compute) -> preparedFuture) + .valueUnboxer(valueUnboxer)); + } + + private void assertVariableBatchOperationSupported(boolean variableBatch, ExecutionInput input, @Nullable Document document) { + if (!variableBatch || document == null) { + return; + } + if (document.getDefinitionsOfType(OperationDefinition.class).isEmpty()) { + return; + } + OperationDefinition operation; + try { + operation = NodeUtil.getOperation(document, input.getOperationName()).operationDefinition; + } catch (UnknownOperationException exception) { + // Keep the normal operation-selection errors when no operation can be selected. + return; + } + if (operation.getOperation() == OperationDefinition.Operation.SUBSCRIPTION) { + throw new IllegalArgumentException("Variable batching does not support subscription operations; supply at most one variable map."); } - VariableBatchPublisher publisher = new VariableBatchPublisher(input, batchId, maxVariableBatchConcurrency, executor::executeAsync); - return CompletableFuture.completedFuture(new VariableBatchExecutionResultImpl(publisher, size)); } @@ -595,15 +629,16 @@ private ExecutionInput ensureInputHasId(ExecutionInput executionInput) { } - private CompletableFuture parseValidateAndExecute(ExecutionInput executionInput, GraphQLSchema graphQLSchema, InstrumentationState instrumentationState, EngineRunningState engineRunningState, Profiler profiler) { + private CompletableFuture parseValidateAndExecute(ExecutionInput executionInput, GraphQLSchema graphQLSchema, InstrumentationState instrumentationState, EngineRunningState engineRunningState, Profiler profiler, boolean variableBatch) { AtomicReference executionInputRef = new AtomicReference<>(executionInput); Function computeFunction = transformedInput -> { // if they change the original query in the pre-parser, then we want to see it downstream from then on executionInputRef.set(transformedInput); - return parseAndValidate(executionInputRef, graphQLSchema, instrumentationState); + return parseAndValidate(executionInputRef, graphQLSchema, instrumentationState, variableBatch); }; CompletableFuture preparsedDoc = preparsedDocumentProvider.getDocumentAsync(executionInput, computeFunction); return engineRunningState.compose(preparsedDoc, (preparsedDocumentEntry -> { + assertVariableBatchOperationSupported(variableBatch, assertNotNull(executionInputRef.get()), preparsedDocumentEntry.getDocument()); if (preparsedDocumentEntry.hasErrors()) { return CompletableFuture.completedFuture(new ExecutionResultImpl(preparsedDocumentEntry.getErrors())); } @@ -615,7 +650,7 @@ private CompletableFuture parseValidateAndExecute(ExecutionInpu })); } - private PreparsedDocumentEntry parseAndValidate(AtomicReference executionInputRef, GraphQLSchema graphQLSchema, InstrumentationState instrumentationState) { + private PreparsedDocumentEntry parseAndValidate(AtomicReference executionInputRef, GraphQLSchema graphQLSchema, @Nullable InstrumentationState instrumentationState, boolean variableBatch) { ExecutionInput executionInput = assertNotNull(executionInputRef.get()); @@ -624,6 +659,7 @@ private PreparsedDocumentEntry parseAndValidate(AtomicReference return new PreparsedDocumentEntry(assertNotNull(parseResult.getSyntaxException(), "Parse result syntax exception cannot be null when failed").toInvalidSyntaxError()); } else { final Document document = assertNotNull(parseResult.getDocument(), "Document cannot be null when parse succeeded"); + assertVariableBatchOperationSupported(variableBatch, executionInput, document); // they may have changed the document and the variables via instrumentation so update the reference to it executionInput = executionInput.transform(builder -> builder.variables(parseResult.getVariables())); executionInputRef.set(executionInput); @@ -642,7 +678,7 @@ private PreparsedDocumentEntry parseAndValidate(AtomicReference } } - private ParseAndValidateResult parse(ExecutionInput executionInput, GraphQLSchema graphQLSchema, InstrumentationState instrumentationState) { + private ParseAndValidateResult parse(ExecutionInput executionInput, GraphQLSchema graphQLSchema, @Nullable InstrumentationState instrumentationState) { InstrumentationExecutionParameters parameters = new InstrumentationExecutionParameters(executionInput, graphQLSchema); InstrumentationContext parseInstrumentationCtx = nonNullCtx(instrumentation.beginParse(parameters, instrumentationState)); parseInstrumentationCtx.onDispatched(); @@ -661,7 +697,7 @@ private ParseAndValidateResult parse(ExecutionInput executionInput, GraphQLSchem } } - private List validate(ExecutionInput executionInput, Document document, GraphQLSchema graphQLSchema, InstrumentationState instrumentationState) { + private List validate(ExecutionInput executionInput, Document document, GraphQLSchema graphQLSchema, @Nullable InstrumentationState instrumentationState) { InstrumentationContext> validationCtx = nonNullCtx(instrumentation.beginValidation(new InstrumentationValidationParameters(executionInput, document, graphQLSchema), instrumentationState)); validationCtx.onDispatched(); diff --git a/src/main/java/graphql/VariableBatchExecutionResult.java b/src/main/java/graphql/VariableBatchExecutionResult.java index 00fa27fe97..ab115e8532 100644 --- a/src/main/java/graphql/VariableBatchExecutionResult.java +++ b/src/main/java/graphql/VariableBatchExecutionResult.java @@ -8,7 +8,7 @@ /** * The result of supplying more than one variable map to {@link GraphQL#executeAsync(ExecutionInput)}. - * Execution starts when the results publisher is subscribed to and receives demand. Each entry contains an ordinary + * Preparation can run eagerly; field execution starts when the publisher receives demand. Each entry contains an ordinary * execution result, including its own errors and, when applicable, its incremental publisher. * {@link #getData()} returns the same publisher as {@link #getResults()}. *

@@ -35,7 +35,7 @@ * initial results. Incremental publishers retain their existing lifecycle: the consumer must * subscribe to each one to receive subsequent payloads and control their consumption separately. * Cancelling the input also cancels entries whose initial results have already been delivered. - * Subscription operations are not supported in a variable batch. + * Subscription operations are rejected with {@link IllegalArgumentException} as soon as the selected operation is known. */ @ExperimentalApi @NullMarked diff --git a/src/main/java/graphql/execution/Execution.java b/src/main/java/graphql/execution/Execution.java index 16f7689a99..0e37a513ce 100644 --- a/src/main/java/graphql/execution/Execution.java +++ b/src/main/java/graphql/execution/Execution.java @@ -90,10 +90,6 @@ public CompletableFuture execute(Document document, GraphQLSche Supplier normalizedVariableValues; try { getOperationResult = NodeUtil.getOperation(document, executionInput.getOperationName()); - if (executionInput.getVariableIndex() != null - && getOperationResult.operationDefinition.getOperation() == OperationDefinition.Operation.SUBSCRIPTION) { - throw new AbortExecutionException("Variable batching does not support subscriptions"); - } coercedVariables = coerceVariableValues(graphQLSchema, executionInput, getOperationResult.operationDefinition); normalizedVariableValues = normalizedVariableValues(graphQLSchema, executionInput, getOperationResult); } catch (RuntimeException rte) { diff --git a/src/main/java/graphql/execution/preparsed/VariableBatchPreparsedDocumentProvider.java b/src/main/java/graphql/execution/preparsed/VariableBatchPreparsedDocumentProvider.java deleted file mode 100644 index 25e6a244f8..0000000000 --- a/src/main/java/graphql/execution/preparsed/VariableBatchPreparsedDocumentProvider.java +++ /dev/null @@ -1,31 +0,0 @@ -package graphql.execution.preparsed; - -import graphql.ExecutionInput; -import graphql.Internal; -import org.jspecify.annotations.NullMarked; -import org.jspecify.annotations.Nullable; - -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Function; - -@Internal -@NullMarked -public final class VariableBatchPreparsedDocumentProvider implements PreparsedDocumentProvider { - private final AtomicReference<@Nullable CompletableFuture> prepared = new AtomicReference<>(); - - @Override - public CompletableFuture getDocumentAsync(ExecutionInput input, - Function compute) { - CompletableFuture result = new CompletableFuture<>(); - if (!prepared.compareAndSet(null, result)) { - return graphql.Assert.assertNotNull(prepared.get()); - } - try { - result.complete(compute.apply(input)); - } catch (Throwable failure) { - result.completeExceptionally(failure); - } - return result; - } -} diff --git a/src/test/groovy/graphql/VariableBatchExecutionTest.groovy b/src/test/groovy/graphql/VariableBatchExecutionTest.groovy index 9d4c8bd559..cb5e0b42df 100644 --- a/src/test/groovy/graphql/VariableBatchExecutionTest.groovy +++ b/src/test/groovy/graphql/VariableBatchExecutionTest.groovy @@ -7,10 +7,11 @@ import graphql.execution.instrumentation.InstrumentationState import graphql.execution.instrumentation.DocumentAndVariables import graphql.execution.preparsed.PreparsedDocumentEntry import graphql.execution.preparsed.PreparsedDocumentProvider -import graphql.execution.preparsed.VariableBatchPreparsedDocumentProvider import graphql.extensions.ExtensionsBuilder import graphql.incremental.IncrementalExecutionResult import graphql.parser.Parser +import graphql.parser.ParserOptions +import graphql.parser.ParsingListener import graphql.schema.DataFetcher import org.dataloader.BatchLoader import org.dataloader.DataLoaderFactory @@ -96,7 +97,7 @@ class VariableBatchExecutionTest extends Specification { results.every { !it.errors.empty && !it.dataPresent } where: - query << ['{', '{ missing }', 'query A { value } query B { value }'] + query << ['{', '{ missing }', 'query A { value } query B { value }', 'fragment F on Query { value }'] } def "shared dataloaders combine entries and cache repeated keys"() { @@ -242,19 +243,136 @@ class VariableBatchExecutionTest extends Specification { invoked == [1] } - def "subscriptions are rejected without invoking a subscription fetcher"() { + def "subscription batches throw before producing a batch result"() { given: def invoked = false def subscriptionSchema = TestUtil.schema('type Query { value:Int } type Subscription { value:Int }', [Subscription: [value: { invoked = true } as DataFetcher]]) + def input = ExecutionInput.newExecutionInput(query).operationName(operationName).variables([[:], [:]]).build() when: - def results = batch(GraphQL.newGraphQL(subscriptionSchema).build(), 'subscription { value }', [[:], [:]]) - .resultsAsync.get(5, TimeUnit.SECONDS) + GraphQL.newGraphQL(subscriptionSchema).build().execute(input) + + then: + def error = thrown(IllegalArgumentException) + error.message == 'Variable batching does not support subscription operations; supply at most one variable map.' + !invoked + + where: + query | operationName + 'subscription { value }' | null + '# comment\nsubscription S { value }' | 'S' + 'subscription { missing }' | null + 'query Q { value } subscription S { value }' | 'S' + } + + def "async subscription batches fail before instrumentation or variable coercion"() { + given: + def instrumentation = Mock(graphql.execution.instrumentation.Instrumentation) + def input = ExecutionInput.newExecutionInput('subscription($id:Int!) { value(id:$id) }') + .variables([[id: 'bad'], [:]]).build() + + when: + def result = GraphQL.newGraphQL(schema).instrumentation(instrumentation).build().executeAsync(input) + result.get(5, TimeUnit.SECONDS) + + then: + def error = thrown(java.util.concurrent.ExecutionException) + error.cause instanceof IllegalArgumentException + error.cause.message.contains('subscription operations') + 0 * instrumentation._ + } + + def "empty and singleton variable lists still allow ordinary subscriptions"() { + given: + def subscriptionSchema = TestUtil.schema('type Query { value:Int } type Subscription { value:Int }', + [Subscription: [value: { Flux.just(7) } as DataFetcher]]) + + when: + def result = GraphQL.newGraphQL(subscriptionSchema).build().execute( + ExecutionInput.newExecutionInput('subscription { value }').variables(variables).build()) + def events = Flux.from(result.data).collectList().block(Duration.ofSeconds(5)) + + then: + !(result instanceof VariableBatchExecutionResult) + events*.data == [[value: 7]] + + where: + variables << [[], [[:]]] + } + + def "a query can be selected from a document that also contains a subscription"() { + given: + def subscriptionSchema = TestUtil.schema('type Query { value:Int } type Subscription { value:Int }', + [Query: [value: { 7 } as DataFetcher]]) + def input = ExecutionInput.newExecutionInput('query Q { value } subscription S { value }') + .operationName('Q').variables([[:], [:]]).build() + + when: + VariableBatchExecutionResult result = GraphQL.newGraphQL(subscriptionSchema).build().execute(input) + + then: + result.resultsAsync.get(5, TimeUnit.SECONDS)*.toSpecification() == [[data: [value: 7]], [data: [value: 7]]] + } + + def "cached persisted subscriptions fail the whole batch before any resolver runs"() { + given: + def invoked = false + def subscriptionSchema = TestUtil.schema('type Query { value:Int } type Subscription { value:Int }', + [Subscription: [value: { invoked = true; Flux.just(7) } as DataFetcher]]) + def provider = { input, compute -> CompletableFuture.completedFuture( + new PreparsedDocumentEntry(Parser.parse('subscription { value }'))) } as PreparsedDocumentProvider + def input = ExecutionInput.newExecutionInput(ExecutionInput.PERSISTED_QUERY_MARKER).variables([[:], [:]]).build() + VariableBatchExecutionResult result = GraphQL.newGraphQL(subscriptionSchema).preparsedDocumentProvider(provider).build().execute(input) + + when: + result.resultsAsync.get(5, TimeUnit.SECONDS) then: + def error = thrown(java.util.concurrent.ExecutionException) + error.cause instanceof IllegalArgumentException + error.cause.message.contains('subscription operations') !invoked - results.every { !it.errors.empty } + } + + def "document instrumentation cannot introduce a batched subscription"() { + given: + def instrumentation = new SimplePerformantInstrumentation() { + @Override + DocumentAndVariables instrumentDocumentAndVariables(DocumentAndVariables value, + InstrumentationExecutionParameters parameters, InstrumentationState state) { + value.transform { it.document(Parser.parse('subscription { missing }')) } + } + } + + when: + batch(GraphQL.newGraphQL(schema).instrumentation(instrumentation).build(), '{ value }', [[:], [:]]) + .resultsAsync.get(5, TimeUnit.SECONDS) + + then: + def error = thrown(java.util.concurrent.ExecutionException) + error.cause instanceof IllegalArgumentException + error.cause.message.contains('subscription operations') + } + + def "replacing an execution input cannot bypass the subscription batch restriction"() { + given: + def instrumentation = new SimplePerformantInstrumentation() { + @Override + ExecutionInput instrumentExecutionInput(ExecutionInput input, InstrumentationExecutionParameters parameters, + InstrumentationState state) { + ExecutionInput.newExecutionInput('subscription { value }').build() + } + } + + when: + batch(GraphQL.newGraphQL(schema).instrumentation(instrumentation).build(), '{ value }', [[:], [:]]) + .resultsAsync.get(5, TimeUnit.SECONDS) + + then: + def error = thrown(java.util.concurrent.ExecutionException) + error.cause instanceof IllegalArgumentException + error.cause.message.contains('subscription operations') } def "batch limits are checked before fetching and survive GraphQL transform"() { @@ -391,23 +509,25 @@ class VariableBatchExecutionTest extends Specification { entries*.data == [[value: 11], [value: 12]] } - def "batch preparation computes only once including common errors"() { + def "default batch preparation runs eagerly and is reused by every entry"() { given: - def provider = new VariableBatchPreparsedDocumentProvider() def calls = new AtomicInteger() - def input = ExecutionInput.newExecutionInput('{ value }').build() - def compute = { ignored -> - calls.incrementAndGet() - new PreparsedDocumentEntry(Parser.parse('{ value }')) - } as java.util.function.Function + def listener = { token -> if (token.text == 'query') calls.incrementAndGet() } as ParsingListener + def options = ParserOptions.newParserOptions().parsingListener(listener).build() + def input = ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') + .variables([[id: 1], [id: 2]]).graphQLContext([(ParserOptions): options]).build() + + when: + VariableBatchExecutionResult result = GraphQL.newGraphQL(schema).build().execute(input) + + then: + calls.get() == 1 when: - def first = provider.getDocumentAsync(input, compute) - def second = provider.getDocumentAsync(input.transform { it.variables([id: 2]) }, compute) + def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) then: - first.is(second) - first.join().document != null + entries*.data == [[value: 1], [value: 2]] calls.get() == 1 } From c6b614b18abccc8322373acb5c9cd39b28ecb35b Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Sun, 1 Nov 2026 08:55:34 +1000 Subject: [PATCH 3/5] Remove unrelated incremental cancellation workaround --- src/main/java/graphql/ExecutionInput.java | 3 +- .../graphql/VariableBatchExecutionResult.java | 2 +- .../VariableBatchIncrementalPublisher.java | 140 ------------------ .../reactive/VariableBatchPublisher.java | 41 ++--- .../graphql/VariableBatchExecutionTest.groovy | 76 ++-------- 5 files changed, 27 insertions(+), 235 deletions(-) delete mode 100644 src/main/java/graphql/execution/reactive/VariableBatchIncrementalPublisher.java diff --git a/src/main/java/graphql/ExecutionInput.java b/src/main/java/graphql/ExecutionInput.java index 874ffde4eb..7b43d22ad9 100644 --- a/src/main/java/graphql/ExecutionInput.java +++ b/src/main/java/graphql/ExecutionInput.java @@ -320,8 +320,7 @@ public ExecutionInput transform(Consumer builderConsumer) { .dataLoaderRegistry(this.dataLoaderRegistry) .extensions(this.extensions) .executionId(this.executionId) - .locale(this.locale) - .profileExecution(this.profileExecution); + .locale(this.locale); builder.rawVariablesList = this.rawVariablesList; builder.variableIndex = this.variableIndex; builder.variableBatchId = this.variableBatchId; diff --git a/src/main/java/graphql/VariableBatchExecutionResult.java b/src/main/java/graphql/VariableBatchExecutionResult.java index ab115e8532..c63c33be64 100644 --- a/src/main/java/graphql/VariableBatchExecutionResult.java +++ b/src/main/java/graphql/VariableBatchExecutionResult.java @@ -34,7 +34,7 @@ * The configured concurrency limit bounds executions up to their initial result and buffered * initial results. Incremental publishers retain their existing lifecycle: the consumer must * subscribe to each one to receive subsequent payloads and control their consumption separately. - * Cancelling the input also cancels entries whose initial results have already been delivered. + * Cancelling the input stops queued entries and cancels executions still awaiting their initial result. * Subscription operations are rejected with {@link IllegalArgumentException} as soon as the selected operation is known. */ @ExperimentalApi diff --git a/src/main/java/graphql/execution/reactive/VariableBatchIncrementalPublisher.java b/src/main/java/graphql/execution/reactive/VariableBatchIncrementalPublisher.java deleted file mode 100644 index 7db6d49b8d..0000000000 --- a/src/main/java/graphql/execution/reactive/VariableBatchIncrementalPublisher.java +++ /dev/null @@ -1,140 +0,0 @@ -package graphql.execution.reactive; - -import graphql.Assert; -import graphql.ExecutionInput; -import graphql.Internal; -import graphql.incremental.DelayedIncrementalPartialResult; -import org.jspecify.annotations.NullMarked; -import org.jspecify.annotations.Nullable; -import org.reactivestreams.Publisher; -import org.reactivestreams.Subscriber; -import org.reactivestreams.Subscription; - -import java.util.concurrent.CancellationException; -import java.util.concurrent.atomic.AtomicBoolean; - -@Internal -@NullMarked -public final class VariableBatchIncrementalPublisher implements Publisher, - Subscriber, Subscription { - private final Publisher source; - private final ExecutionInput input; - private final NonBlockingMutexExecutor mutex = new NonBlockingMutexExecutor(); - private final AtomicBoolean subscribed = new AtomicBoolean(); - private @Nullable Subscriber downstream; - private @Nullable Subscription upstream; - private long demand; - private boolean terminated; - private volatile boolean cancelled; - - public VariableBatchIncrementalPublisher(Publisher source, ExecutionInput input) { - this.source = source; - this.input = input; - input.getCancellationFuture().thenRun(() -> onError(new CancellationException("Variable batch entry cancelled"))); - } - - @Override - public void subscribe(Subscriber subscriber) { - Assert.assertNotNullWithNPE(subscriber, "subscriber must not be null"); - if (!subscribed.compareAndSet(false, true)) { - subscriber.onSubscribe(RejectedBatchSubscription.INSTANCE); - subscriber.onError(new IllegalStateException("Incremental results support one subscriber")); - return; - } - mutex.execute(() -> subscribeImpl(subscriber)); - } - - private void subscribeImpl(Subscriber subscriber) { - downstream = subscriber; - subscriber.onSubscribe(this); - if (cancelled) { - return; - } - if (input.isCancelled()) { - subscriber.onError(new CancellationException("Variable batch entry cancelled")); - terminated = true; - return; - } - try { - source.subscribe(this); - } catch (Throwable failure) { - onError(failure); - } - } - - @Override - public void onSubscribe(Subscription subscription) { - mutex.execute(() -> { - if (cancelled || terminated || upstream != null) { - subscription.cancel(); - return; - } - upstream = subscription; - if (demand > 0) { - subscription.request(demand); - } - }); - } - - @Override - public void request(long amount) { - if (amount <= 0) { - onError(new IllegalArgumentException("Reactive Streams demand must be positive")); - return; - } - mutex.execute(() -> { - if (cancelled || terminated) { - return; - } - long sum = demand + amount; - demand = sum < 0 ? Long.MAX_VALUE : sum; - if (upstream != null) { - upstream.request(amount); - } - }); - } - - @Override - public void cancel() { - cancelled = true; - input.cancel(); - mutex.execute(this::cancelUpstream); - } - - private void cancelUpstream() { - if (upstream != null) { - upstream.cancel(); - } - } - - @Override - public void onNext(DelayedIncrementalPartialResult value) { - mutex.execute(() -> { - if (!cancelled && !terminated) { - Assert.assertNotNull(downstream).onNext(value); - } - }); - } - - @Override - public void onError(Throwable failure) { - mutex.execute(() -> { - if (cancelled || terminated || downstream == null) { - return; - } - terminated = true; - cancelUpstream(); - downstream.onError(failure); - }); - } - - @Override - public void onComplete() { - mutex.execute(() -> { - if (!cancelled && !terminated) { - terminated = true; - Assert.assertNotNull(downstream).onComplete(); - } - }); - } -} diff --git a/src/main/java/graphql/execution/reactive/VariableBatchPublisher.java b/src/main/java/graphql/execution/reactive/VariableBatchPublisher.java index e0abb289ae..20e6503b88 100644 --- a/src/main/java/graphql/execution/reactive/VariableBatchPublisher.java +++ b/src/main/java/graphql/execution/reactive/VariableBatchPublisher.java @@ -8,8 +8,6 @@ import graphql.execution.ExecutionId; import graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys; import graphql.execution.instrumentation.dataloader.VariableBatchDataLoaderDispatcher; -import graphql.incremental.IncrementalExecutionResult; -import graphql.incremental.IncrementalExecutionResultImpl; import org.jspecify.annotations.NullMarked; import org.jspecify.annotations.Nullable; import org.reactivestreams.Publisher; @@ -17,9 +15,9 @@ import org.reactivestreams.Subscription; import java.util.ArrayDeque; -import java.util.ArrayList; import java.util.Deque; -import java.util.List; +import java.util.LinkedHashMap; +import java.util.Map; import java.util.concurrent.CancellationException; import java.util.concurrent.CompletableFuture; import java.util.concurrent.atomic.AtomicBoolean; @@ -36,13 +34,12 @@ public final class VariableBatchPublisher implements Publisher entries = new ArrayList<>(); + private final Map activeEntries = new LinkedHashMap<>(); private final Deque ready = new ArrayDeque<>(); private @Nullable Subscriber subscriber; private @Nullable Throwable failure; private long demand; private int next; - private int active; private volatile boolean cancelled; private boolean terminated; @@ -54,11 +51,7 @@ public VariableBatchPublisher(ExecutionInput input, ExecutionId batchId, int con this.concurrency = concurrency; this.execute = execute; this.dispatcher = new VariableBatchDataLoaderDispatcher(input.getDataLoaderRegistry(), this::fail); - input.getCancellationFuture().thenRun(() -> mutex.execute(() -> { - cancelEntries(); - failure = new CancellationException("Variable batch cancelled"); - drain(); - })); + input.getCancellationFuture().thenRun(() -> fail(new CancellationException("Variable batch cancelled"))); } @Override @@ -116,7 +109,7 @@ private void drain() { if (cancelled) { return; } - if (next == size && active == 0 && ready.isEmpty()) { + if (next == size && activeEntries.isEmpty() && ready.isEmpty()) { terminated = true; subscriber.onComplete(); return; @@ -136,8 +129,8 @@ private void startWave() { // Async continuations can request further dispatches without waiting for another entry to finish. dispatcher.pause(); try { - while (!cancelled && next < size && active + ready.size() < concurrency - && active + ready.size() < demand) { + while (!cancelled && next < size && activeEntries.size() + ready.size() < concurrency + && activeEntries.size() + ready.size() < demand) { startEntry(next++); } } finally { @@ -150,8 +143,7 @@ private void startEntry(int index) { entry.getGraphQLContext().put(VariableBatchDataLoaderDispatcher.class, dispatcher); DataLoaderDispatchingContextKeys.setEnableDataLoaderChaining(entry.getGraphQLContext(), false); DataLoaderDispatchingContextKeys.setEnableDataLoaderExhaustedDispatching(entry.getGraphQLContext(), true); - entries.add(entry); - active++; + activeEntries.put(index, entry); try { execute.apply(entry).whenComplete((result, failure) -> mutex.execute(() -> finishEntry(index, result, failure))); } catch (Throwable failure) { @@ -160,7 +152,7 @@ private void startEntry(int index) { } private void finishEntry(int index, @Nullable ExecutionResult result, @Nullable Throwable failure) { - active--; + activeEntries.remove(index); if (cancelled || terminated) { return; } @@ -168,23 +160,14 @@ private void finishEntry(int index, @Nullable ExecutionResult result, @Nullable this.failure = failure; } else { ready.addLast(VariableBatchResult.newVariableBatchResult() - .variableIndex(index).executionResult(wrapIncremental(index, Assert.assertNotNull(result))).build()); + .variableIndex(index).executionResult(Assert.assertNotNull(result)).build()); } drain(); } - private ExecutionResult wrapIncremental(int index, ExecutionResult result) { - if (!(result instanceof IncrementalExecutionResult)) { - return result; - } - IncrementalExecutionResult incremental = (IncrementalExecutionResult) result; - return IncrementalExecutionResultImpl.fromIncrementalExecutionResult(incremental) - .incrementalItemPublisher(new VariableBatchIncrementalPublisher(incremental.getIncrementalItemPublisher(), entries.get(index))) - .build(); - } - private void cancelEntries() { - entries.forEach(ExecutionInput::cancel); + activeEntries.values().forEach(ExecutionInput::cancel); + activeEntries.clear(); ready.clear(); } } diff --git a/src/test/groovy/graphql/VariableBatchExecutionTest.groovy b/src/test/groovy/graphql/VariableBatchExecutionTest.groovy index cb5e0b42df..9d81e9f6c0 100644 --- a/src/test/groovy/graphql/VariableBatchExecutionTest.groovy +++ b/src/test/groovy/graphql/VariableBatchExecutionTest.groovy @@ -53,7 +53,7 @@ class VariableBatchExecutionTest extends Specification { def "legacy variables become a singleton and transforms preserve every map"() { given: def maps = [[id: 1], [id: null]] - def input = ExecutionInput.newExecutionInput('{ value }').variables(maps).profileExecution(true).build() + def input = ExecutionInput.newExecutionInput('{ value }').variables(maps).build() maps[0].id = 99 maps.add([id: 3]) @@ -61,7 +61,6 @@ class VariableBatchExecutionTest extends Specification { ExecutionInput.newExecutionInput('{ value }').variables([id: 1]).build().variablesList == [[id: 1]] input.variablesList == [[id: 1], [id: null]] input.transform { it.operationName('Op') }.variablesList == [[id: 1], [id: null]] - input.transform { it.operationName('Op') }.profileExecution input.variables == [id: 1] when: @@ -533,6 +532,15 @@ class VariableBatchExecutionTest extends Specification { def "incremental execution remains available per variable entry"() { given: + def seen = [] + def instrumentation = new SimplePerformantInstrumentation() { + @Override + CompletableFuture instrumentExecutionResult(ExecutionResult result, + InstrumentationExecutionParameters parameters, InstrumentationState state) { + seen.add(result) + CompletableFuture.completedFuture(result) + } + } def registry = new DataLoaderRegistry() registry.register('values', DataLoaderFactory.newDataLoader({ keys -> CompletableFuture.completedFuture(keys) } as BatchLoader)) def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', @@ -542,7 +550,7 @@ class VariableBatchExecutionTest extends Specification { .graphQLContext([(ENABLE_INCREMENTAL_SUPPORT): true]).build() when: - VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).build().execute(input) + VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).instrumentation(instrumentation).build().execute(input) def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) def payloads = entries.collect { IncrementalExecutionResult entry -> Flux.from(entry.incrementalItemPublisher).collectList().block(Duration.ofSeconds(5)) @@ -550,6 +558,8 @@ class VariableBatchExecutionTest extends Specification { then: entries.every { it instanceof IncrementalExecutionResult } + entries[0].is(seen[0]) + entries[1].is(seen[1]) payloads.collect { it[0].incremental[0].data } == [[value: 1], [value: 2]] } @@ -628,26 +638,6 @@ class VariableBatchExecutionTest extends Specification { beforeSubscription << [true, false] } - def "batch cancellation still reaches deferred executions after initial results complete"() { - given: - def called = [] - def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', - [Query: [value: { env -> called.add(env.getArgument('id')); env.getArgument('id') } as DataFetcher]]) - def input = ExecutionInput.newExecutionInput('query($id:Int!) { ... @defer { value(id:$id) } }') - .variables([[id: 1], [id: 2]]).graphQLContext([(ENABLE_INCREMENTAL_SUPPORT): true]).build() - VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).build().execute(input) - def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) - - when: - input.cancel() - Flux.from((entries[0] as IncrementalExecutionResult).incrementalItemPublisher) - .collectList().block(Duration.ofSeconds(5)) - - then: - thrown(java.util.concurrent.CancellationException) - called.empty - } - def "publisher rejects nonpositive demand and repeated subscriptions"() { given: def result = batch(GraphQL.newGraphQL(schema).build(), '{ value }', [[:], [:]]) @@ -745,46 +735,6 @@ class VariableBatchExecutionTest extends Specification { seen == ['known-query', 'known-query'] } - def "cancelling a deferred subscription leaves other entries available"() { - given: - def pending = new CompletableFuture() - def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', - [Query: [value: { env -> env.getArgument('id') == 1 ? pending : 2 } as DataFetcher]]) - def input = ExecutionInput.newExecutionInput('query($id:Int!) { ... @defer { value(id:$id) } }') - .variables([[id: 1], [id: 2]]).graphQLContext([(ENABLE_INCREMENTAL_SUPPORT): true]).build() - VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).build().execute(input) - def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) - def first = Flux.from((entries[0] as IncrementalExecutionResult).incrementalItemPublisher).collectList().toFuture() - - when: - first.cancel(false) - pending.complete(1) - def second = Flux.from((entries[1] as IncrementalExecutionResult).incrementalItemPublisher) - .collectList().block(Duration.ofSeconds(5)) - - then: - first.cancelled - !pending.cancelled - second[0].incremental[0].data == [value: 2] - } - - def "input cancellation terminates an already subscribed deferred publisher"() { - given: - def localSchema = TestUtil.schema('type Query { value:Int! }', - [Query: [value: { new CompletableFuture() } as DataFetcher]]) - def input = ExecutionInput.newExecutionInput('{ ... @defer { value } }') - .variables([[:], [:]]).graphQLContext([(ENABLE_INCREMENTAL_SUPPORT): true]).build() - VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).build().execute(input) - def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) - def deferred = Flux.from((entries[0] as IncrementalExecutionResult).incrementalItemPublisher).collectList().toFuture() - - when: - input.cancel() - - then: - deferred.completedExceptionally - } - def "variable lists reject a null list or a null entry"() { when: ExecutionInput.newExecutionInput('{ value }').variables((List>) values) From 5f6cb17cdd878f7ce7992804b0a9a2fca46c4e6a Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Sun, 1 Nov 2026 09:12:13 +1000 Subject: [PATCH 4/5] Simplify variable batching to independent async executions --- src/main/java/graphql/GraphQL.java | 64 ++-- .../graphql/VariableBatchExecutionResult.java | 34 +-- .../VariableBatchExecutionResultImpl.java | 24 +- .../java/graphql/VariableBatchResult.java | 58 ---- .../graphql/VariableBatchResultCollector.java | 50 ---- .../java/graphql/execution/Execution.java | 5 - .../ExhaustedDataLoaderDispatchStrategy.java | 24 -- .../VariableBatchDataLoaderDispatcher.java | 95 ------ .../reactive/RejectedBatchSubscription.java | 17 -- .../reactive/VariableBatchPublisher.java | 173 ----------- .../graphql/VariableBatchExecutionTest.groovy | 280 +++++++++--------- 11 files changed, 172 insertions(+), 652 deletions(-) delete mode 100644 src/main/java/graphql/VariableBatchResult.java delete mode 100644 src/main/java/graphql/VariableBatchResultCollector.java delete mode 100644 src/main/java/graphql/execution/instrumentation/dataloader/VariableBatchDataLoaderDispatcher.java delete mode 100644 src/main/java/graphql/execution/reactive/RejectedBatchSubscription.java delete mode 100644 src/main/java/graphql/execution/reactive/VariableBatchPublisher.java diff --git a/src/main/java/graphql/GraphQL.java b/src/main/java/graphql/GraphQL.java index d8be414c47..57cedfdbd4 100644 --- a/src/main/java/graphql/GraphQL.java +++ b/src/main/java/graphql/GraphQL.java @@ -24,7 +24,6 @@ import graphql.execution.preparsed.NoOpPreparsedDocumentProvider; import graphql.execution.preparsed.PreparsedDocumentEntry; import graphql.execution.preparsed.PreparsedDocumentProvider; -import graphql.execution.reactive.VariableBatchPublisher; import graphql.introspection.GoodFaithIntrospection; import graphql.language.Document; import graphql.language.NodeUtil; @@ -38,6 +37,7 @@ import org.jspecify.annotations.NullUnmarked; import org.jspecify.annotations.Nullable; +import java.util.ArrayList; import java.util.List; import java.util.Locale; import java.util.concurrent.CompletableFuture; @@ -170,8 +170,6 @@ public static GraphQLUnusualConfiguration.GraphQLContextConfiguration unusualCon private final PreparsedDocumentProvider preparsedDocumentProvider; private final ValueUnboxer valueUnboxer; private final boolean doNotAutomaticallyDispatchDataLoader; - private final int maxVariableBatchSize; - private final int maxVariableBatchConcurrency; private GraphQL(Builder builder) { @@ -184,8 +182,6 @@ private GraphQL(Builder builder) { this.preparsedDocumentProvider = assertNotNull(builder.preparsedDocumentProvider, "preparsedDocumentProvider must be non null"); this.valueUnboxer = assertNotNull(builder.valueUnboxer, "valueUnboxer must not be null"); this.doNotAutomaticallyDispatchDataLoader = builder.doNotAutomaticallyDispatchDataLoader; - this.maxVariableBatchSize = builder.maxVariableBatchSize; - this.maxVariableBatchConcurrency = builder.maxVariableBatchConcurrency; } /** @@ -275,8 +271,6 @@ public GraphQL transform(Consumer builderConsumer) { .subscriptionExecutionStrategy(this.subscriptionStrategy) .executionIdProvider(this.idProvider) .instrumentation(this.instrumentation) - .maxVariableBatchSize(this.maxVariableBatchSize) - .maxVariableBatchConcurrency(this.maxVariableBatchConcurrency) .preparsedDocumentProvider(this.preparsedDocumentProvider); builderConsumer.accept(builder); @@ -297,8 +291,6 @@ public static class Builder { private PreparsedDocumentProvider preparsedDocumentProvider = NoOpPreparsedDocumentProvider.INSTANCE; private boolean doNotAutomaticallyDispatchDataLoader = false; private ValueUnboxer valueUnboxer = ValueUnboxer.DEFAULT; - private int maxVariableBatchSize = 1024; - private int maxVariableBatchConcurrency = 16; public Builder(GraphQLSchema graphQLSchema) { this.graphQLSchema = graphQLSchema; @@ -347,32 +339,6 @@ public Builder preparsedDocumentProvider(PreparsedDocumentProvider preparsedDocu return this; } - /** - * Limits variable batch entries, checked before any execution starts. Defaults to 1024. - * @param maximum a positive limit - * @return this builder - */ - @ExperimentalApi - public Builder maxVariableBatchSize(int maximum) { - Assert.assertTrue(maximum > 0, () -> "maxVariableBatchSize must be positive"); - maxVariableBatchSize = maximum; - return this; - } - - /** - * Limits active executions up to their initial result and buffered initial results. Defaults to 16. - * Set to one for serial initial execution across variable maps. Mutation root fields remain serial - * within each execution. Incremental publishers retain their separate lifecycle and consumption. - * @param maximum a positive limit - * @return this builder - */ - @ExperimentalApi - public Builder maxVariableBatchConcurrency(int maximum) { - Assert.assertTrue(maximum > 0, () -> "maxVariableBatchConcurrency must be positive"); - maxVariableBatchConcurrency = maximum; - return this; - } - public Builder executionIdProvider(ExecutionIdProvider executionIdProvider) { this.idProvider = assertNotNull(executionIdProvider, "ExecutionIdProvider must be non null"); return this; @@ -382,7 +348,7 @@ public Builder executionIdProvider(ExecutionIdProvider executionIdProvider) { /** * Deactivates the automatic dispatching of DataLoaders. * If deactivated the user is responsible for dispatching the DataLoaders manually. - * Variable batches always coordinate dispatch automatically. + * * @return this builder */ public Builder doNotAutomaticallyDispatchDataLoader() { @@ -517,8 +483,8 @@ public CompletableFuture executeAsync(UnaryOperator * This will return a promise (aka {@link CompletableFuture}) to provide a {@link ExecutionResult} * which is the result of executing the provided query. - * Multiple variable maps return a {@link VariableBatchExecutionResult}; preparation can run eagerly, - * while field execution starts on demand. Batched subscription operations fail with {@link IllegalArgumentException}. + * Multiple variable maps start one execution per map immediately and return a {@link VariableBatchExecutionResult} + * containing their futures in input order. Batched subscription operations fail with {@link IllegalArgumentException}. * @param executionInput {@link ExecutionInput} * * @return a promise to an {@link ExecutionResult} which can include errors @@ -565,15 +531,16 @@ public CompletableFuture executeAsync(ExecutionInput executionI private CompletableFuture executeVariableBatch(ExecutionInput input) { int size = input.getVariablesList().size(); - if (size > maxVariableBatchSize) { - return CompletableFuture.failedFuture(new AbortExecutionException( - "Variable batch has " + size + " entries which exceeds maximum allowed " + maxVariableBatchSize)); - } try { GraphQL executor = prepareVariableBatch(input); ExecutionId batchId = assertNotNull(ensureInputHasId(input).getExecutionId()); - VariableBatchPublisher publisher = new VariableBatchPublisher(input, batchId, maxVariableBatchConcurrency, executor::executeAsync); - return CompletableFuture.completedFuture(new VariableBatchExecutionResultImpl(publisher, size)); + List> results = new ArrayList<>(size); + for (int index = 0; index < size; index++) { + ExecutionInput entry = input.newVariableBatchEntry(index, batchId); + input.getCancellationFuture().thenRun(entry::cancel); + results.add(executor.executeAsync(entry)); + } + return CompletableFuture.completedFuture(new VariableBatchExecutionResultImpl(results)); } catch (RuntimeException exception) { return CompletableFuture.failedFuture(exception); } @@ -588,9 +555,12 @@ private GraphQL prepareVariableBatch(ExecutionInput input) { } PreparsedDocumentEntry prepared = parseAndValidate(new AtomicReference<>(input), graphQLSchema, null, true); CompletableFuture preparedFuture = CompletableFuture.completedFuture(prepared); - return transform(builder -> builder - .preparsedDocumentProvider((entry, compute) -> preparedFuture) - .valueUnboxer(valueUnboxer)); + return transform(builder -> { + builder.preparsedDocumentProvider((entry, compute) -> preparedFuture).valueUnboxer(valueUnboxer); + if (doNotAutomaticallyDispatchDataLoader) { + builder.doNotAutomaticallyDispatchDataLoader(); + } + }); } private void assertVariableBatchOperationSupported(boolean variableBatch, ExecutionInput input, @Nullable Document document) { diff --git a/src/main/java/graphql/VariableBatchExecutionResult.java b/src/main/java/graphql/VariableBatchExecutionResult.java index c63c33be64..95ba9251ba 100644 --- a/src/main/java/graphql/VariableBatchExecutionResult.java +++ b/src/main/java/graphql/VariableBatchExecutionResult.java @@ -1,20 +1,18 @@ package graphql; import org.jspecify.annotations.NullMarked; -import org.reactivestreams.Publisher; import java.util.List; import java.util.concurrent.CompletableFuture; /** * The result of supplying more than one variable map to {@link GraphQL#executeAsync(ExecutionInput)}. - * Preparation can run eagerly; field execution starts when the publisher receives demand. Each entry contains an ordinary - * execution result, including its own errors and, when applicable, its incremental publisher. - * {@link #getData()} returns the same publisher as {@link #getResults()}. - *

- * Choose either streaming via {@link #getResults()} or collection via {@link #getResultsAsync()}: - * the publisher supports one subscriber. There is no single GraphQL response map for a batch, so - * {@link #toSpecification()} is unsupported. Serialize the individual execution results instead. + * Each entry is submitted to {@code executeAsync} in input order, without waiting for earlier futures + * to complete. {@link #getResults()} exposes those futures; {@link #getResultsAsync()} collects their + * results in input order. Batching does not create threads or limit the number of executions in flight. + * {@link #getData()} returns the same list of futures as {@link #getResults()}. + * There is no single GraphQL response map for a batch, so {@link #toSpecification()} is unsupported. + * Serialize the individual execution results instead. *

{@code
  * ExecutionInput input = ExecutionInput.newExecutionInput()
  *     .query("query($id: ID!) { product(id: $id) { name } }")
@@ -24,33 +22,29 @@
  * VariableBatchExecutionResult batch = (VariableBatchExecutionResult) graphQL.execute(input);
  * CompletableFuture> results = batch.getResultsAsync();
  * }
- * The entries share DataLoaders and caches for queries and mutations; batch dispatch is always automatic. + * The entries share DataLoaders and caches for queries and mutations, using ordinary dispatch behavior. * Mutations retain serial root fields within each entry; there is no ordering guarantee between * entries. Applications must clear or prime affected loader cache entries after writes. * Each entry has separate variable coercion, errors, instrumentation state, cancellation state, * execution id and a shallow copy of the GraphQL context. Application objects in that context, - * the root and the local context remain shared. - *

- * The configured concurrency limit bounds executions up to their initial result and buffered - * initial results. Incremental publishers retain their existing lifecycle: the consumer must - * subscribe to each one to receive subsequent payloads and control their consumption separately. - * Cancelling the input stops queued entries and cancels executions still awaiting their initial result. + * the root and the local context remain shared. Cancelling the input requests cancellation of each entry. + * Incremental results retain their individual publishers and lifecycle. * Subscription operations are rejected with {@link IllegalArgumentException} as soon as the selected operation is known. */ @ExperimentalApi @NullMarked public interface VariableBatchExecutionResult extends ExecutionResult { - /** @return indexed results in completion order, subject to subscriber demand */ - Publisher getResults(); + /** @return an immutable list of execution futures in input order */ + List> getResults(); /** @return the number of executions in the batch */ int getSize(); /** - * Subscribes to the results and collects them in input order. Cancelling the returned future - * cancels the batch subscription. Incremental results retain their individual publishers. + * Collects the individual results in input order. This does not start new executions. + * Cancelling the returned future does not cancel the executions; use {@link ExecutionInput#cancel()} instead. * - * @return a future containing the individual results in input order + * @return a future containing an immutable list of the individual results in input order */ CompletableFuture> getResultsAsync(); } diff --git a/src/main/java/graphql/VariableBatchExecutionResultImpl.java b/src/main/java/graphql/VariableBatchExecutionResultImpl.java index c7dea4aea3..33d6346813 100644 --- a/src/main/java/graphql/VariableBatchExecutionResultImpl.java +++ b/src/main/java/graphql/VariableBatchExecutionResultImpl.java @@ -1,7 +1,7 @@ package graphql; +import graphql.execution.Async; import org.jspecify.annotations.NullMarked; -import org.reactivestreams.Publisher; import java.util.List; import java.util.Map; @@ -10,34 +10,28 @@ @Internal @NullMarked public final class VariableBatchExecutionResultImpl extends ExecutionResultImpl implements VariableBatchExecutionResult { - private final Publisher results; - private final int size; - - public VariableBatchExecutionResultImpl(Publisher results, int size) { - super(results, List.of()); - this.results = results; - this.size = size; + public VariableBatchExecutionResultImpl(List> results) { + super(List.copyOf(results), List.of()); } @Override - public Publisher getResults() { - return results; + public List> getResults() { + return Assert.assertNotNull(getData()); } @Override public int getSize() { - return size; + return getResults().size(); } @Override public CompletableFuture> getResultsAsync() { - VariableBatchResultCollector collector = new VariableBatchResultCollector(size); - results.subscribe(collector); - return collector.getResult(); + return Async., ExecutionResult>each(getResults(), result -> result) + .thenApply(List::copyOf); } @Override public Map toSpecification() { - throw new UnsupportedOperationException("Serialize each VariableBatchResult's executionResult instead of the batch"); + throw new UnsupportedOperationException("Serialize each execution result instead of the batch"); } } diff --git a/src/main/java/graphql/VariableBatchResult.java b/src/main/java/graphql/VariableBatchResult.java deleted file mode 100644 index bce2cf134d..0000000000 --- a/src/main/java/graphql/VariableBatchResult.java +++ /dev/null @@ -1,58 +0,0 @@ -package graphql; - -import org.jspecify.annotations.NullMarked; -import org.jspecify.annotations.NullUnmarked; - -import java.util.function.Consumer; - -/** An individual execution result and its position in the input variables list. */ -@ExperimentalApi -@NullMarked -public final class VariableBatchResult { - private final int variableIndex; - private final ExecutionResult executionResult; - - private VariableBatchResult(Builder builder) { - Assert.assertTrue(builder.variableIndex >= 0, () -> "variableIndex must be non-negative"); - variableIndex = builder.variableIndex; - executionResult = Assert.assertNotNull(builder.executionResult); - } - - public int getVariableIndex() { - return variableIndex; - } - - public ExecutionResult getExecutionResult() { - return executionResult; - } - - public static Builder newVariableBatchResult() { - return new Builder(); - } - - public VariableBatchResult transform(Consumer consumer) { - Builder builder = newVariableBatchResult().variableIndex(variableIndex).executionResult(executionResult); - consumer.accept(builder); - return builder.build(); - } - - @NullUnmarked - public static final class Builder { - private int variableIndex; - private ExecutionResult executionResult; - - public Builder variableIndex(int variableIndex) { - this.variableIndex = variableIndex; - return this; - } - - public Builder executionResult(ExecutionResult executionResult) { - this.executionResult = executionResult; - return this; - } - - public VariableBatchResult build() { - return new VariableBatchResult(this); - } - } -} diff --git a/src/main/java/graphql/VariableBatchResultCollector.java b/src/main/java/graphql/VariableBatchResultCollector.java deleted file mode 100644 index 47409eca52..0000000000 --- a/src/main/java/graphql/VariableBatchResultCollector.java +++ /dev/null @@ -1,50 +0,0 @@ -package graphql; - -import org.jspecify.annotations.NullMarked; -import org.reactivestreams.Subscriber; -import org.reactivestreams.Subscription; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.concurrent.CompletableFuture; - -@Internal -@NullMarked -public final class VariableBatchResultCollector implements Subscriber { - private final List results; - private final CompletableFuture> result = new CompletableFuture<>(); - - public VariableBatchResultCollector(int size) { - results = new ArrayList<>(Collections.nCopies(size, new ExecutionResultImpl(List.of()))); - } - - public CompletableFuture> getResult() { - return result; - } - - @Override - public void onSubscribe(Subscription subscription) { - result.whenComplete((ignored, failure) -> { - if (result.isCancelled()) { - subscription.cancel(); - } - }); - subscription.request(Long.MAX_VALUE); - } - - @Override - public void onNext(VariableBatchResult value) { - results.set(value.getVariableIndex(), value.getExecutionResult()); - } - - @Override - public void onError(Throwable failure) { - result.completeExceptionally(failure); - } - - @Override - public void onComplete() { - result.complete(List.copyOf(results)); - } -} diff --git a/src/main/java/graphql/execution/Execution.java b/src/main/java/graphql/execution/Execution.java index 0e37a513ce..df7a0f6aeb 100644 --- a/src/main/java/graphql/execution/Execution.java +++ b/src/main/java/graphql/execution/Execution.java @@ -22,7 +22,6 @@ import graphql.execution.instrumentation.InstrumentationState; import graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys; import graphql.execution.instrumentation.dataloader.ExhaustedDataLoaderDispatchStrategy; -import graphql.execution.instrumentation.dataloader.VariableBatchDataLoaderDispatcher; import graphql.execution.instrumentation.dataloader.PerLevelDataLoaderDispatchStrategy; import graphql.execution.instrumentation.parameters.InstrumentationExecuteOperationParameters; import graphql.execution.instrumentation.parameters.InstrumentationExecutionParameters; @@ -293,10 +292,6 @@ private CompletableFuture incrementalSupport(ExecutionContext e } private DataLoaderDispatchStrategy createDataLoaderDispatchStrategy(ExecutionContext executionContext, ExecutionStrategy executionStrategy) { - VariableBatchDataLoaderDispatcher batchDispatcher = executionContext.getGraphQLContext().get(VariableBatchDataLoaderDispatcher.class); - if (batchDispatcher != null) { - return new ExhaustedDataLoaderDispatchStrategy(executionContext, batchDispatcher); - } if (executionContext.getDataLoaderRegistry() == EMPTY_DATALOADER_REGISTRY || doNotAutomaticallyDispatchDataLoader) { return DataLoaderDispatchStrategy.NO_OP; } diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy.java index e1865708ef..191ce0b176 100644 --- a/src/main/java/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy.java +++ b/src/main/java/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy.java @@ -7,8 +7,6 @@ import graphql.execution.ExecutionContext; import graphql.execution.ExecutionStrategyParameters; import graphql.execution.incremental.AlternativeCallContext; -import graphql.schema.DataFetcher; -import graphql.schema.DataFetchingEnvironment; import org.dataloader.DataLoader; import org.dataloader.DataLoaderRegistry; import graphql.VisibleForTesting; @@ -21,7 +19,6 @@ import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicInteger; -import java.util.function.Supplier; @Internal @NullMarked @@ -31,7 +28,6 @@ public class ExhaustedDataLoaderDispatchStrategy implements DataLoaderDispatchSt private final ExecutionContext executionContext; private final Profiler profiler; - private @Nullable VariableBatchDataLoaderDispatcher batchDispatcher; private final Map alternativeCallContextMap = new ConcurrentHashMap<>(); @@ -136,22 +132,6 @@ public ExhaustedDataLoaderDispatchStrategy(ExecutionContext executionContext) { this(executionContext, new CallStack()); } - public ExhaustedDataLoaderDispatchStrategy(ExecutionContext executionContext, VariableBatchDataLoaderDispatcher batchDispatcher) { - this(executionContext); - Assert.assertTrue(executionContext.getDataLoaderRegistry() == batchDispatcher.getRegistry(), - () -> "Variable batch executions must share their DataLoader registry"); - this.batchDispatcher = batchDispatcher; - } - - @Override - public void fieldFetched(ExecutionContext executionContext, ExecutionStrategyParameters parameters, - DataFetcher dataFetcher, Object fetchedValue, - Supplier dataFetchingEnvironment) { - if (batchDispatcher != null) { - newDataLoaderInvocationMaybeDispatch(getCallStack(parameters)); - } - } - @VisibleForTesting ExhaustedDataLoaderDispatchStrategy(ExecutionContext executionContext, CallStack callStack) { this.initialCallStack = callStack; @@ -284,10 +264,6 @@ private void dispatchImpl(CallStack callStack) { } } - if (batchDispatcher != null) { - batchDispatcher.dispatch().whenComplete((ignored, failure) -> dispatchImpl(callStack)); - return; - } DataLoaderRegistry dataLoaderRegistry = executionContext.getDataLoaderRegistry(); List> dataLoaders = dataLoaderRegistry.getDataLoaders(); List>> allDispatchedCFs = new ArrayList<>(); diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/VariableBatchDataLoaderDispatcher.java b/src/main/java/graphql/execution/instrumentation/dataloader/VariableBatchDataLoaderDispatcher.java deleted file mode 100644 index 2f71e3984e..0000000000 --- a/src/main/java/graphql/execution/instrumentation/dataloader/VariableBatchDataLoaderDispatcher.java +++ /dev/null @@ -1,95 +0,0 @@ -package graphql.execution.instrumentation.dataloader; - -import graphql.Assert; -import graphql.Internal; -import org.dataloader.DataLoaderRegistry; -import org.jspecify.annotations.NullMarked; -import org.jspecify.annotations.Nullable; - -import java.util.ArrayList; -import java.util.List; -import java.util.concurrent.CompletableFuture; -import java.util.function.Consumer; - -@Internal -@NullMarked -public final class VariableBatchDataLoaderDispatcher { - private final DataLoaderRegistry registry; - private final Consumer failureHandler; - private final List> waiting = new ArrayList<>(); - private int holds; - private boolean flushing; - - public VariableBatchDataLoaderDispatcher(DataLoaderRegistry registry, Consumer failureHandler) { - this.registry = registry; - this.failureHandler = failureHandler; - } - - public DataLoaderRegistry getRegistry() { - return registry; - } - - public synchronized void pause() { - holds++; - } - - public void resume() { - synchronized (this) { - Assert.assertTrue(holds > 0); - holds--; - } - flush(); - } - - public CompletableFuture dispatch() { - CompletableFuture result = new CompletableFuture<>(); - synchronized (this) { - waiting.add(result); - } - flush(); - return result; - } - - private void flush() { - List> wave = takeWave(); - while (!wave.isEmpty()) { - dispatchWave(wave); - synchronized (this) { - flushing = false; - } - wave = takeWave(); - } - } - - private synchronized List> takeWave() { - if (holds > 0 || flushing || waiting.isEmpty()) { - return List.of(); - } - flushing = true; - List> wave = new ArrayList<>(waiting); - waiting.clear(); - return wave; - } - - private void dispatchWave(List> wave) { - try { - List> dispatched = new ArrayList<>(); - registry.getDataLoaders().forEach(loader -> dispatched.add(loader.dispatch())); - CompletableFuture.allOf(dispatched.toArray(new CompletableFuture[0])) - .whenComplete((ignored, failure) -> completeWave(wave, failure)); - } catch (Throwable failure) { - completeWave(wave, failure); - failureHandler.accept(failure); - } - } - - private void completeWave(List> wave, @Nullable Throwable failure) { - for (CompletableFuture result : wave) { - if (failure == null) { - result.complete(null); - } else { - result.completeExceptionally(failure); - } - } - } -} diff --git a/src/main/java/graphql/execution/reactive/RejectedBatchSubscription.java b/src/main/java/graphql/execution/reactive/RejectedBatchSubscription.java deleted file mode 100644 index cce3eacd49..0000000000 --- a/src/main/java/graphql/execution/reactive/RejectedBatchSubscription.java +++ /dev/null @@ -1,17 +0,0 @@ -package graphql.execution.reactive; - -import graphql.Internal; -import org.reactivestreams.Subscription; - -@Internal -public enum RejectedBatchSubscription implements Subscription { - INSTANCE; - - @Override - public void request(long amount) { - } - - @Override - public void cancel() { - } -} diff --git a/src/main/java/graphql/execution/reactive/VariableBatchPublisher.java b/src/main/java/graphql/execution/reactive/VariableBatchPublisher.java deleted file mode 100644 index 20e6503b88..0000000000 --- a/src/main/java/graphql/execution/reactive/VariableBatchPublisher.java +++ /dev/null @@ -1,173 +0,0 @@ -package graphql.execution.reactive; - -import graphql.Assert; -import graphql.ExecutionInput; -import graphql.ExecutionResult; -import graphql.Internal; -import graphql.VariableBatchResult; -import graphql.execution.ExecutionId; -import graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys; -import graphql.execution.instrumentation.dataloader.VariableBatchDataLoaderDispatcher; -import org.jspecify.annotations.NullMarked; -import org.jspecify.annotations.Nullable; -import org.reactivestreams.Publisher; -import org.reactivestreams.Subscriber; -import org.reactivestreams.Subscription; - -import java.util.ArrayDeque; -import java.util.Deque; -import java.util.LinkedHashMap; -import java.util.Map; -import java.util.concurrent.CancellationException; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.function.Function; - -@Internal -@NullMarked -public final class VariableBatchPublisher implements Publisher, Subscription { - private final ExecutionInput input; - private final ExecutionId batchId; - private final int size; - private final int concurrency; - private final Function> execute; - private final VariableBatchDataLoaderDispatcher dispatcher; - private final NonBlockingMutexExecutor mutex = new NonBlockingMutexExecutor(); - private final AtomicBoolean subscribed = new AtomicBoolean(); - private final Map activeEntries = new LinkedHashMap<>(); - private final Deque ready = new ArrayDeque<>(); - private @Nullable Subscriber subscriber; - private @Nullable Throwable failure; - private long demand; - private int next; - private volatile boolean cancelled; - private boolean terminated; - - public VariableBatchPublisher(ExecutionInput input, ExecutionId batchId, int concurrency, - Function> execute) { - this.input = input; - this.batchId = batchId; - this.size = input.getVariablesList().size(); - this.concurrency = concurrency; - this.execute = execute; - this.dispatcher = new VariableBatchDataLoaderDispatcher(input.getDataLoaderRegistry(), this::fail); - input.getCancellationFuture().thenRun(() -> fail(new CancellationException("Variable batch cancelled"))); - } - - @Override - public void subscribe(Subscriber subscriber) { - Assert.assertNotNullWithNPE(subscriber, "subscriber must not be null"); - if (!subscribed.compareAndSet(false, true)) { - subscriber.onSubscribe(RejectedBatchSubscription.INSTANCE); - subscriber.onError(new IllegalStateException("Variable batch results support one subscriber")); - return; - } - mutex.execute(() -> { - this.subscriber = subscriber; - subscriber.onSubscribe(this); - drain(); - }); - } - - @Override - public void request(long amount) { - if (amount <= 0) { - fail(new IllegalArgumentException("Reactive Streams demand must be positive")); - return; - } - mutex.execute(() -> { - long sum = demand + amount; - demand = sum < 0 ? Long.MAX_VALUE : sum; - drain(); - }); - } - - @Override - public void cancel() { - cancelled = true; - mutex.execute(this::cancelEntries); - } - - private void fail(Throwable failure) { - mutex.execute(() -> { - this.failure = failure; - drain(); - }); - } - - private void drain() { - if (cancelled || terminated || subscriber == null) { - return; - } - if (failure != null) { - terminated = true; - cancelEntries(); - subscriber.onError(failure); - return; - } - emitReady(); - if (cancelled) { - return; - } - if (next == size && activeEntries.isEmpty() && ready.isEmpty()) { - terminated = true; - subscriber.onComplete(); - return; - } - startWave(); - } - - private void emitReady() { - while (!cancelled && demand > 0 && !ready.isEmpty()) { - demand--; - Assert.assertNotNull(subscriber).onNext(ready.removeFirst()); - } - } - - private void startWave() { - // Let every newly started entry enqueue its keys before flushing the shared registry. - // Async continuations can request further dispatches without waiting for another entry to finish. - dispatcher.pause(); - try { - while (!cancelled && next < size && activeEntries.size() + ready.size() < concurrency - && activeEntries.size() + ready.size() < demand) { - startEntry(next++); - } - } finally { - dispatcher.resume(); - } - } - - private void startEntry(int index) { - ExecutionInput entry = input.newVariableBatchEntry(index, batchId); - entry.getGraphQLContext().put(VariableBatchDataLoaderDispatcher.class, dispatcher); - DataLoaderDispatchingContextKeys.setEnableDataLoaderChaining(entry.getGraphQLContext(), false); - DataLoaderDispatchingContextKeys.setEnableDataLoaderExhaustedDispatching(entry.getGraphQLContext(), true); - activeEntries.put(index, entry); - try { - execute.apply(entry).whenComplete((result, failure) -> mutex.execute(() -> finishEntry(index, result, failure))); - } catch (Throwable failure) { - mutex.execute(() -> finishEntry(index, null, failure)); - } - } - - private void finishEntry(int index, @Nullable ExecutionResult result, @Nullable Throwable failure) { - activeEntries.remove(index); - if (cancelled || terminated) { - return; - } - if (failure != null) { - this.failure = failure; - } else { - ready.addLast(VariableBatchResult.newVariableBatchResult() - .variableIndex(index).executionResult(Assert.assertNotNull(result)).build()); - } - drain(); - } - - private void cancelEntries() { - activeEntries.values().forEach(ExecutionInput::cancel); - activeEntries.clear(); - ready.clear(); - } -} diff --git a/src/test/groovy/graphql/VariableBatchExecutionTest.groovy b/src/test/groovy/graphql/VariableBatchExecutionTest.groovy index 9d81e9f6c0..ca42d2bde9 100644 --- a/src/test/groovy/graphql/VariableBatchExecutionTest.groovy +++ b/src/test/groovy/graphql/VariableBatchExecutionTest.groovy @@ -16,8 +16,6 @@ import graphql.schema.DataFetcher import org.dataloader.BatchLoader import org.dataloader.DataLoaderFactory import org.dataloader.DataLoaderRegistry -import org.reactivestreams.Subscriber -import org.reactivestreams.Subscription import reactor.core.publisher.Flux import spock.lang.Specification import spock.lang.Timeout @@ -28,6 +26,8 @@ import java.util.concurrent.TimeUnit import java.util.concurrent.atomic.AtomicInteger import static graphql.ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT +import static graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys.ENABLE_DATA_LOADER_CHAINING +import static graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys.ENABLE_DATA_LOADER_EXHAUSTED_DISPATCHING @Timeout(15) class VariableBatchExecutionTest extends Specification { @@ -99,7 +99,7 @@ class VariableBatchExecutionTest extends Specification { query << ['{', '{ missing }', 'query A { value } query B { value }', 'fragment F on Query { value }'] } - def "shared dataloaders combine entries and cache repeated keys"() { + def "shared dataloaders use ordinary dispatch and cache repeated keys"() { given: def calls = [] def registry = new DataLoaderRegistry() @@ -120,59 +120,105 @@ class VariableBatchExecutionTest extends Specification { then: entries*.data == [[value: 1], [value: 2], [value: 1]] - calls == [[1, 2]] + calls == [[1], [2]] } - def "chained loaders share their registries and dispatch without hanging"() { + def "manual dispatch still applies to the shared registry"() { given: def calls = [] + def registry = new DataLoaderRegistry().register('values', DataLoaderFactory.newDataLoader({ keys -> + calls.add(new ArrayList(keys)) + CompletableFuture.completedFuture(keys) + } as BatchLoader)) + def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> env.getDataLoader('values').load(env.getArgument('id')) } as DataFetcher]]) + def input = ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') + .variables([[id: 1], [id: 2], [id: 1]]).dataLoaderRegistry(registry).build() + + when: + VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema) + .doNotAutomaticallyDispatchDataLoader().build().execute(input) + + then: + result.results.every { !it.done } + calls.empty + + when: + registry.dispatchAll() + + then: + result.resultsAsync.get(5, TimeUnit.SECONDS)*.data == [[value: 1], [value: 2], [value: 1]] + calls == [[1, 2]] + } + + def "asynchronous chained loaders share their registry using the selected dispatch mode"() { + given: + def pending = [(1): new CompletableFuture>(), (2): new CompletableFuture>()] + def firstCalls = [] + def secondCalls = [] def registry = new DataLoaderRegistry() - ['first', 'second'].each { name -> - registry.register(name, DataLoaderFactory.newDataLoader({ keys -> - calls.add([name, new ArrayList(keys)]) - CompletableFuture.completedFuture(keys) - } as BatchLoader)) - } + registry.register('first', DataLoaderFactory.newDataLoader({ keys -> + firstCalls.add(new ArrayList(keys)) + pending[keys[0]] + } as BatchLoader)) + registry.register('second', DataLoaderFactory.newDataLoader({ keys -> + secondCalls.add(new ArrayList(keys)) + CompletableFuture.completedFuture(keys) + } as BatchLoader)) def loadedSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', [Query: [value: { env -> env.getDataLoader('first').load(env.getArgument('id')).thenCompose { value -> env.getDataLoader('second').load(value) } } as DataFetcher]]) - - when: VariableBatchExecutionResult result = GraphQL.newGraphQL(loadedSchema).build().execute( ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') - .variables([[id: 1], [id: 2]]).dataLoaderRegistry(registry).build()) - def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) + .variables([[id: 1], [id: 2], [id: 1]]).dataLoaderRegistry(registry) + .graphQLContext([(dispatchOption): true]).build()) + + expect: + firstCalls == [[1], [2]] + secondCalls.empty + + when: + pending[2].complete([2]) then: - entries*.data == [[value: 1], [value: 2]] - calls*.first().containsAll(['first', 'second']) + result.results[1].get(5, TimeUnit.SECONDS).data == [value: 2] + !result.results[0].done + !result.results[2].done + + when: + pending[1].complete([1]) + + then: + result.resultsAsync.get(5, TimeUnit.SECONDS)*.data == [[value: 1], [value: 2], [value: 1]] + secondCalls == [[2], [1]] + + where: + dispatchOption << [ENABLE_DATA_LOADER_CHAINING, ENABLE_DATA_LOADER_EXHAUSTED_DISPATCHING] } - def "completion order streams immediately while collection preserves input order"() { + def "execution futures can be consumed independently in any completion order"() { given: def values = [new CompletableFuture(), new CompletableFuture()] def asyncSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', [Query: [value: { env -> values[env.getArgument('id')] } as DataFetcher]]) - def emitted = [] def result = batch(GraphQL.newGraphQL(asyncSchema).build(), 'query($id:Int!) { value(id:$id) }', [[id: 0], [id: 1]]) - def completed = Flux.from(result.results).doOnNext { emitted.add(it) }.collectList().toFuture() when: values[1].complete(11) then: - emitted*.variableIndex == [1] - !completed.done + result.results[1].get(5, TimeUnit.SECONDS).data == [value: 11] + !result.results[0].done when: values[0].complete(10) then: - completed.get(5, TimeUnit.SECONDS)*.variableIndex == [1, 0] + result.results[0].get(5, TimeUnit.SECONDS).data == [value: 10] } def "non-null failure is confined to its execution"() { @@ -221,25 +267,27 @@ class VariableBatchExecutionTest extends Specification { seen.every { it.graphQLContext.get('app') == 'shared' } } - def "batch input cancellation stops pending work"() { + def "batch input cancellation reaches every running entry"() { given: def invoked = [] + def pending = (1..3).collect { new CompletableFuture() } def asyncSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', [Query: [value: { env -> invoked.add(env.getArgument('id')) - new CompletableFuture() + pending[env.getArgument('id') - 1] } as DataFetcher]]) def input = ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') .variables([[id: 1], [id: 2], [id: 3]]).build() - VariableBatchExecutionResult batch = GraphQL.newGraphQL(asyncSchema).maxVariableBatchConcurrency(1).build().execute(input) + VariableBatchExecutionResult batch = GraphQL.newGraphQL(asyncSchema).build().execute(input) def result = batch.resultsAsync when: input.cancel() + pending.each { it.complete(7) } then: - result.completedExceptionally - invoked == [1] + result.get(5, TimeUnit.SECONDS).every { !it.errors.empty } + invoked == [1, 2, 3] } def "subscription batches throw before producing a batch result"() { @@ -374,47 +422,6 @@ class VariableBatchExecutionTest extends Specification { error.cause.message.contains('subscription operations') } - def "batch limits are checked before fetching and survive GraphQL transform"() { - given: - def graphQL = GraphQL.newGraphQL(schema).maxVariableBatchSize(2).maxVariableBatchConcurrency(1) - .build().transform { it.valueUnboxer(graphql.execution.ValueUnboxer.DEFAULT) } - - when: - graphQL.execute(ExecutionInput.newExecutionInput('{ value }').variables([[:], [:], [:]]).build()) - - then: - def error = thrown(graphql.execution.AbortExecutionException) - error.message.contains('exceeds maximum allowed 2') - - when: - GraphQL.newGraphQL(schema).maxVariableBatchSize(0) - - then: - thrown(AssertException) - - when: - GraphQL.newGraphQL(schema).maxVariableBatchConcurrency(0) - - then: - thrown(AssertException) - } - - def "subscriber demand bounds scheduling and cancellation stops new executions"() { - given: - def calls = [] - def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', - [Query: [value: { env -> calls.add(env.getArgument('id')); env.getArgument('id') } as DataFetcher]]) - def result = batch(GraphQL.newGraphQL(localSchema).build(), 'query($id:Int!) { value(id:$id) }', - [[id: 1], [id: 2], [id: 3]]) - - when: - def first = Flux.from(result.results).limitRate(1).take(1).collectList().block(Duration.ofSeconds(5)) - - then: - first*.variableIndex == [0] - calls == [1] - } - def "collected results keep input order across asynchronous completion"() { given: def values = [new CompletableFuture(), new CompletableFuture()] @@ -454,7 +461,7 @@ class VariableBatchExecutionTest extends Specification { when: VariableBatchExecutionResult result = GraphQL.newGraphQL(mutationSchema) - .maxVariableBatchConcurrency(1).build().execute(input) + .build().execute(input) def entries = result.resultsAsync.get(5, TimeUnit.SECONDS) then: @@ -583,7 +590,7 @@ class VariableBatchExecutionTest extends Specification { then: entries.get(5, TimeUnit.SECONDS).every { it.data == null && it.errors[0].path == ['value'] } - keysSeen == [[1, 2]] + keysSeen == [[1], [2]] } def "cancelling an individual execution does not cancel a shared loader future"() { @@ -616,44 +623,62 @@ class VariableBatchExecutionTest extends Specification { entries.get(5, TimeUnit.SECONDS)[1].toSpecification() == [data: [value: 10]] } - def "pre-cancelled input and cancelled collection do not start queued entries"() { + def "pre-cancelled input cancels every entry before fetching"() { given: def calls = [] - def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', - [Query: [value: { env -> calls.add(env.getArgument('id')); new CompletableFuture() } as DataFetcher]]) - def input = ExecutionInput.newExecutionInput('query($id:Int!) { value(id:$id) }') - .variables([[id: 1], [id: 2]]).build() - if (beforeSubscription) input.cancel() - VariableBatchExecutionResult batch = GraphQL.newGraphQL(localSchema).maxVariableBatchConcurrency(1).build().execute(input) + def localSchema = TestUtil.schema('type Query { value:Int! }', + [Query: [value: { calls.add(1); 7 } as DataFetcher]]) + def input = ExecutionInput.newExecutionInput('{ value }').variables([[:], [:]]).build() + input.cancel() when: - def result = batch.resultsAsync - if (!beforeSubscription) result.cancel(false) + VariableBatchExecutionResult batch = GraphQL.newGraphQL(localSchema).build().execute(input) then: - result.completedExceptionally - calls == (beforeSubscription ? [] : [1]) - - where: - beforeSubscription << [true, false] + batch.resultsAsync.get(5, TimeUnit.SECONDS).every { !it.errors.empty } + calls.empty } - def "publisher rejects nonpositive demand and repeated subscriptions"() { + def "cancelling result collection leaves the independent executions running"() { given: - def result = batch(GraphQL.newGraphQL(schema).build(), '{ value }', [[:], [:]]) - def errors = [] - def subscriber = [onSubscribe: { Subscription subscription -> subscription.request(0) }, - onNext: { throw new AssertionError('unexpected result') }, - onError: { errors.add(it) }, onComplete: {}] as Subscriber + def values = [new CompletableFuture(), new CompletableFuture()] + def asyncSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', + [Query: [value: { env -> values[env.getArgument('id')] } as DataFetcher]]) + def result = batch(GraphQL.newGraphQL(asyncSchema).build(), + 'query($id:Int!) { value(id:$id) }', [[id: 0], [id: 1]]) + def collected = result.resultsAsync when: - result.results.subscribe(subscriber) - result.results.subscribe(subscriber) + collected.cancel(false) + values[1].complete(11) + values[0].complete(10) then: - errors*.class == [IllegalArgumentException, IllegalStateException] + collected.cancelled + result.resultsAsync.get(5, TimeUnit.SECONDS)*.data == [[value: 10], [value: 11]] + } + + def "batch exposes immutable futures and supports repeated result collection"() { + given: + def result = batch(GraphQL.newGraphQL(schema).build(), '{ value }', [[:], [:]]) + def collected = result.resultsAsync.get(5, TimeUnit.SECONDS) + + expect: result.data.is(result.results) result.size == 2 + result.resultsAsync.get(5, TimeUnit.SECONDS) == collected + + when: + result.results.clear() + + then: + thrown(UnsupportedOperationException) + + when: + collected.clear() + + then: + thrown(UnsupportedOperationException) when: result.toSpecification() @@ -662,7 +687,7 @@ class VariableBatchExecutionTest extends Specification { thrown(UnsupportedOperationException) } - def "unexpected instrumentation failures fail the batch without starting pending entries"() { + def "an exceptional execution does not prevent the other entries from starting"() { given: def seen = [] def instrumentation = new SimplePerformantInstrumentation() { @@ -670,49 +695,45 @@ class VariableBatchExecutionTest extends Specification { ExecutionInput instrumentExecutionInput(ExecutionInput input, InstrumentationExecutionParameters parameters, InstrumentationState state) { seen.add(input.variableIndex) - throw new IllegalStateException('broken instrumentation') + if (input.variableIndex == 0) throw new IllegalStateException('broken instrumentation') + input } } when: - batch(GraphQL.newGraphQL(schema).instrumentation(instrumentation).maxVariableBatchConcurrency(1).build(), + batch(GraphQL.newGraphQL(schema).instrumentation(instrumentation).build(), '{ value }', [[:], [:]]).resultsAsync.get(5, TimeUnit.SECONDS) then: def failure = thrown(java.util.concurrent.ExecutionException) failure.cause.message == 'broken instrumentation' - seen == [0] + seen == [0, 1] } - def "concurrency bounds active work without waiting for a slow earlier entry"() { + def "all entries start immediately without batch size or concurrency limits"() { given: def called = [] - def pending = (0..3).collect { new CompletableFuture() } + def pending = (0..1024).collect { new CompletableFuture() } def localSchema = TestUtil.schema('type Query { value(id:Int!):Int! }', [Query: [value: { env -> def id = env.getArgument('id') called.add(id) pending[id] } as DataFetcher]]) - def result = batch(GraphQL.newGraphQL(localSchema).maxVariableBatchConcurrency(2).build(), - 'query($id:Int!) { value(id:$id) }', (0..3).collect { [id: it] }).resultsAsync - - expect: - called == [0, 1] when: - pending[1].complete(1) + def result = batch(GraphQL.newGraphQL(localSchema).build(), + 'query($id:Int!) { value(id:$id) }', (0..1024).collect { [id: it] }) then: - called == [0, 1, 2] + called == (0..1024).toList() + result.results.every { !it.done } when: - pending[2].complete(2) - pending[3].complete(3) - pending[0].complete(0) + (1024..0).each { pending[it].complete(it) } then: - result.get(5, TimeUnit.SECONDS)*.data == [[value: 0], [value: 1], [value: 2], [value: 3]] + result.resultsAsync.get(5, TimeUnit.SECONDS)*.data == (0..1024).collect { [value: it] } } def "persisted query lookup can replace the query while retaining every variables map"() { @@ -746,43 +767,6 @@ class VariableBatchExecutionTest extends Specification { values << [null, [[id: 1], null]] } - def "instrumentation cannot replace the shared dataloader registry per entry"() { - given: - def instrumentation = new SimplePerformantInstrumentation() { - @Override - ExecutionInput instrumentExecutionInput(ExecutionInput input, InstrumentationExecutionParameters parameters, - InstrumentationState state) { - input.transform { it.dataLoaderRegistry(new DataLoaderRegistry()) } - } - } - - when: - batch(GraphQL.newGraphQL(schema).instrumentation(instrumentation).build(), '{ value }', [[:], [:]]) - .resultsAsync.get(5, TimeUnit.SECONDS) - - then: - def error = thrown(java.util.concurrent.ExecutionException) - error.cause.message.contains('must share their DataLoader registry') - } - - def "unexpected registry dispatch failure terminates the batch"() { - given: - def registry = Stub(DataLoaderRegistry) { - getDataLoaders() >> { throw new IllegalStateException('broken registry') } - } - def localSchema = TestUtil.schema('type Query { value:Int }', - [Query: [value: { new CompletableFuture() } as DataFetcher]]) - VariableBatchExecutionResult result = GraphQL.newGraphQL(localSchema).build().execute( - ExecutionInput.newExecutionInput('{ value }').variables([[:], [:]]).dataLoaderRegistry(registry).build()) - - when: - result.resultsAsync.get(5, TimeUnit.SECONDS) - - then: - def error = thrown(java.util.concurrent.ExecutionException) - error.cause.message == 'broken registry' - } - private static VariableBatchExecutionResult batch(GraphQL graphQL, String query, List> variables) { graphQL.execute(ExecutionInput.newExecutionInput(query).variables(variables).build()) as VariableBatchExecutionResult } From 642e42f0ade257263e4c9f5671dbeb281957b394 Mon Sep 17 00:00:00 2001 From: Andreas Marek Date: Sun, 1 Nov 2026 09:25:08 +1000 Subject: [PATCH 5/5] Reject multi-map access through single-variable accessors --- src/main/java/graphql/ExecutionInput.java | 8 +++- src/main/java/graphql/GraphQL.java | 5 ++- .../groovy/graphql/ExecutionInputTest.groovy | 39 +++++++++++++++++++ .../graphql/VariableBatchExecutionTest.groovy | 1 - 4 files changed, 48 insertions(+), 5 deletions(-) diff --git a/src/main/java/graphql/ExecutionInput.java b/src/main/java/graphql/ExecutionInput.java index 7b43d22ad9..a0e86fdbe0 100644 --- a/src/main/java/graphql/ExecutionInput.java +++ b/src/main/java/graphql/ExecutionInput.java @@ -150,6 +150,7 @@ public Object getRoot() { /** * @return a map of raw variables that can be referenced via $syntax in the query. + * @throws AssertException if more than one variable map is present; use {@link #getVariablesList()} instead */ public Map getVariables() { return getRawVariables().toMap(); @@ -157,16 +158,19 @@ public Map getVariables() { /** * @return a map of raw variables that can be referenced via $syntax in the query. + * @throws AssertException if more than one variable map is present; use {@link #getVariablesList()} instead */ public RawVariables getRawVariables() { + Assert.assertTrue(rawVariablesList.size() <= 1, + "getRawVariables() requires at most one variable map; use getVariablesList() for variable batches"); return rawVariablesList.isEmpty() ? RawVariables.emptyVariables() : rawVariablesList.get(0); } /** * Returns the variable maps in input order. An empty list or a singleton uses ordinary execution; * a larger list executes the selected operation once per map, sharing the DataLoader registry. - * The legacy {@link #getVariables()} and {@link #getRawVariables()} accessors return the first map, - * or an empty map when the list is empty. + * The {@link #getVariables()} and {@link #getRawVariables()} accessors require at most one map, + * and return an empty map when the list is empty. * * @return the immutable list of immutable variable maps (values can be null) */ diff --git a/src/main/java/graphql/GraphQL.java b/src/main/java/graphql/GraphQL.java index 57cedfdbd4..a58f5c5481 100644 --- a/src/main/java/graphql/GraphQL.java +++ b/src/main/java/graphql/GraphQL.java @@ -547,13 +547,14 @@ private CompletableFuture executeVariableBatch(ExecutionInput i } private GraphQL prepareVariableBatch(ExecutionInput input) { + ExecutionInput preparationInput = input.transform(builder -> builder.variables(List.of())); // Custom providers and instrumentation retain their existing per-execution semantics. if (preparsedDocumentProvider != NoOpPreparsedDocumentProvider.INSTANCE || instrumentation.getClass() != SimplePerformantInstrumentation.class) { - assertVariableBatchOperationSupported(true, input, ParseAndValidate.parse(input).getDocument()); + assertVariableBatchOperationSupported(true, preparationInput, ParseAndValidate.parse(preparationInput).getDocument()); return this; } - PreparsedDocumentEntry prepared = parseAndValidate(new AtomicReference<>(input), graphQLSchema, null, true); + PreparsedDocumentEntry prepared = parseAndValidate(new AtomicReference<>(preparationInput), graphQLSchema, null, true); CompletableFuture preparedFuture = CompletableFuture.completedFuture(prepared); return transform(builder -> { builder.preparsedDocumentProvider((entry, compute) -> preparedFuture).valueUnboxer(valueUnboxer); diff --git a/src/test/groovy/graphql/ExecutionInputTest.groovy b/src/test/groovy/graphql/ExecutionInputTest.groovy index 7099a495ab..b0c66d4986 100644 --- a/src/test/groovy/graphql/ExecutionInputTest.groovy +++ b/src/test/groovy/graphql/ExecutionInputTest.groovy @@ -49,6 +49,45 @@ class ExecutionInputTest extends Specification { executionInput.toString() != null } + def "single-map variable accessors accept empty and singleton lists"() { + given: + def input = ExecutionInput.newExecutionInput(query).variables(variableMaps).build() + + expect: + input.getRawVariables().toMap() == expected + input.getVariables() == expected + + where: + variableMaps | expected + [] | [:] + [[:]] | [:] + [[id: 1]] | [id: 1] + [[id: null]] | [id: null] + } + + def "single-map variable accessors reject multiple maps"() { + given: + def input = ExecutionInput.newExecutionInput(query).variables(variableMaps).build() + + when: + input.getRawVariables() + + then: + def rawVariablesError = thrown(AssertException) + rawVariablesError.message.contains('requires at most one variable map') + + when: + input.getVariables() + + then: + def variablesError = thrown(AssertException) + variablesError.message.contains('getVariablesList()') + input.getVariablesList() == variableMaps + + where: + variableMaps << [[[:], [:]], [[id: 1], [id: 2]], [[id: 1], [id: 2], [id: 3]]] + } + def "build without locale"() { when: def executionInput = ExecutionInput.newExecutionInput().query(query) diff --git a/src/test/groovy/graphql/VariableBatchExecutionTest.groovy b/src/test/groovy/graphql/VariableBatchExecutionTest.groovy index ca42d2bde9..4a5c00409f 100644 --- a/src/test/groovy/graphql/VariableBatchExecutionTest.groovy +++ b/src/test/groovy/graphql/VariableBatchExecutionTest.groovy @@ -61,7 +61,6 @@ class VariableBatchExecutionTest extends Specification { ExecutionInput.newExecutionInput('{ value }').variables([id: 1]).build().variablesList == [[id: 1]] input.variablesList == [[id: 1], [id: null]] input.transform { it.operationName('Op') }.variablesList == [[id: 1], [id: null]] - input.variables == [id: 1] when: input.variablesList[0].put('id', 4)