graphql-java · bbakerman · Mar 16, 2026 · Mar 6, 2026 · Mar 6, 2026 · Mar 6, 2026
diff --git a/src/main/java/graphql/execution/Execution.java b/src/main/java/graphql/execution/Execution.java
@@ -1,6 +1,7 @@
 package graphql.execution;
 
 
+import com.google.common.collect.ImmutableList;
 import graphql.Directives;
 import graphql.EngineRunningState;
 import graphql.ExecutionInput;
@@ -12,6 +13,8 @@
 import graphql.GraphQLException;
 import graphql.Internal;
 import graphql.Profiler;
+import graphql.execution.directives.OperationDirectivesResolver;
+import graphql.execution.directives.QueryAppliedDirective;
 import graphql.execution.incremental.IncrementalCallState;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.execution.instrumentation.InstrumentationContext;
@@ -40,6 +43,7 @@
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Supplier;
@@ -55,6 +59,7 @@
 @Internal
 public class Execution {
     private final FieldCollector fieldCollector = new FieldCollector();
+    private final OperationDirectivesResolver operationDirectivesResolver = new OperationDirectivesResolver();
     private final ExecutionStrategy queryStrategy;
     private final ExecutionStrategy mutationStrategy;
     private final ExecutionStrategy subscriptionStrategy;
@@ -100,9 +105,15 @@ public CompletableFuture<ExecutionResult> execute(Document document, GraphQLSche
 
         boolean propagateErrorsOnNonNullContractFailure = propagateErrorsOnNonNullContractFailure(getOperationResult.operationDefinition.getDirectives());
 
-        ResponseMapFactory responseMapFactory = GraphQL.unusualConfiguration(executionInput.getGraphQLContext())
+        GraphQLContext graphQLContext = executionInput.getGraphQLContext();
+        Locale locale = executionInput.getLocale();
+
+        ResponseMapFactory responseMapFactory = GraphQL.unusualConfiguration(graphQLContext)
                 .responseMapFactory().getOr(ResponseMapFactory.DEFAULT);
 
+        Supplier<Map<OperationDefinition, ImmutableList<QueryAppliedDirective>>> operationDirectives = FpKit.interThreadMemoize(() ->
+                operationDirectivesResolver.resolveDirectives(document, graphQLSchema, coercedVariables, graphQLContext, locale));
+
         ExecutionContext executionContext = newExecutionContextBuilder()
                 .instrumentation(instrumentation)
                 .instrumentationState(instrumentationState)
@@ -112,16 +123,17 @@ public CompletableFuture<ExecutionResult> execute(Document document, GraphQLSche
                 .mutationStrategy(mutationStrategy)
                 .subscriptionStrategy(subscriptionStrategy)
                 .context(executionInput.getContext())
-                .graphQLContext(executionInput.getGraphQLContext())
+                .graphQLContext(graphQLContext)
                 .localContext(executionInput.getLocalContext())
                 .root(executionInput.getRoot())
                 .fragmentsByName(getOperationResult.fragmentsByName)
                 .coercedVariables(coercedVariables)
                 .normalizedVariableValues(normalizedVariableValues)
                 .document(document)
                 .operationDefinition(getOperationResult.operationDefinition)
+                .operationDirectives(operationDirectives)
                 .dataLoaderRegistry(executionInput.getDataLoaderRegistry())
-                .locale(executionInput.getLocale())
+                .locale(locale)
                 .valueUnboxer(valueUnboxer)
                 .responseMapFactory(responseMapFactory)
                 .executionInput(executionInput)

diff --git a/src/main/java/graphql/execution/ExecutionContext.java b/src/main/java/graphql/execution/ExecutionContext.java
@@ -11,14 +11,15 @@
 import graphql.Profiler;
 import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
+import graphql.execution.directives.OperationDirectivesResolver;
+import graphql.execution.directives.QueryAppliedDirective;
 import graphql.execution.incremental.IncrementalCallState;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.execution.instrumentation.InstrumentationState;
 import graphql.language.Document;
 import graphql.language.FragmentDefinition;
 import graphql.language.OperationDefinition;
 import graphql.normalized.ExecutableNormalizedOperation;
-import graphql.normalized.ExecutableNormalizedOperationFactory;
 import graphql.schema.GraphQLSchema;
 import graphql.util.FpKit;
 import graphql.util.LockKit;
@@ -34,6 +35,9 @@
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 
+import static graphql.normalized.ExecutableNormalizedOperationFactory.Options;
+import static graphql.normalized.ExecutableNormalizedOperationFactory.createExecutableNormalizedOperation;
+
 @SuppressWarnings("TypeParameterUnusedInFormals")
 @PublicApi
 public class ExecutionContext {
@@ -73,6 +77,8 @@ public class ExecutionContext {
     private final ResultNodesInfo resultNodesInfo = new ResultNodesInfo();
     private final EngineRunningState engineRunningState;
 
+    private final Supplier<Map<OperationDefinition, ImmutableList<QueryAppliedDirective>>> allOperationsDirectives;
+    private final Supplier<Map<String, ImmutableList<QueryAppliedDirective>>> operationDirectives;
     private final Profiler profiler;
 
     ExecutionContext(ExecutionContextBuilder builder) {
@@ -99,10 +105,27 @@ public class ExecutionContext {
         this.localContext = builder.localContext;
         this.executionInput = builder.executionInput;
         this.dataLoaderDispatcherStrategy = builder.dataLoaderDispatcherStrategy;
-        this.queryTree = FpKit.interThreadMemoize(() -> ExecutableNormalizedOperationFactory.createExecutableNormalizedOperation(graphQLSchema, operationDefinition, fragmentsByName, coercedVariables));
         this.propagateErrorsOnNonNullContractFailure = builder.propagateErrorsOnNonNullContractFailure;
         this.engineRunningState = builder.engineRunningState;
         this.profiler = builder.profiler;
+        // lazy loading for performance
+        this.queryTree = mkExecutableNormalizedOperation();
+        this.allOperationsDirectives = builder.allOperationsDirectives;
+        this.operationDirectives = mkOpDirectives(builder.allOperationsDirectives);
+    }
+
+    private Supplier<ExecutableNormalizedOperation> mkExecutableNormalizedOperation() {
+        return FpKit.interThreadMemoize(() -> {
+            Options options = Options.defaultOptions().graphQLContext(graphQLContext).locale(locale);
+            return createExecutableNormalizedOperation(graphQLSchema, operationDefinition, fragmentsByName, coercedVariables, options);
+        });
+    }
+
+    private Supplier<Map<String, ImmutableList<QueryAppliedDirective>>> mkOpDirectives(Supplier<Map<OperationDefinition, ImmutableList<QueryAppliedDirective>>> allOperationsDirectives) {
+        return FpKit.interThreadMemoize(() -> {
+            List<QueryAppliedDirective> list = allOperationsDirectives.get().get(operationDefinition);
+            return OperationDirectivesResolver.toAppliedDirectivesByName(list);
+        });
     }
 
     public ExecutionId getExecutionId() {
@@ -137,6 +160,21 @@ public OperationDefinition getOperationDefinition() {
         return operationDefinition;
     }
 
+    /**
+     * @return the map of {@link QueryAppliedDirective}s by name that were on this executing operation
+     */
+    public Map<String, ImmutableList<QueryAppliedDirective>> getOperationDirectives() {
+        return operationDirectives.get();
+    }
+
+    /**
+     * @return the map of all the  {@link QueryAppliedDirective}s that were on the {@link Document} including
+     * {@link OperationDefinition}s that are not currently executing.
+     */
+    public Map<OperationDefinition, ImmutableList<QueryAppliedDirective>> getAllOperationDirectives() {
+        return allOperationsDirectives.get();
+    }
+
     public CoercedVariables getCoercedVariables() {
         return coercedVariables;
     }
@@ -156,7 +194,7 @@ public Supplier<NormalizedVariables> getNormalizedVariables() {
      * @deprecated use {@link #getGraphQLContext()} instead
      */
     @Deprecated(since = "2021-07-05")
-    @SuppressWarnings({ "unchecked", "TypeParameterUnusedInFormals" })
+    @SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"})
     public @Nullable <T> T getContext() {
         return (T) context;
     }

diff --git a/src/main/java/graphql/execution/ExecutionContextBuilder.java b/src/main/java/graphql/execution/ExecutionContextBuilder.java
@@ -10,6 +10,7 @@
 import graphql.Internal;
 import graphql.Profiler;
 import graphql.collect.ImmutableKit;
+import graphql.execution.directives.QueryAppliedDirective;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.execution.instrumentation.InstrumentationState;
 import graphql.language.Document;
@@ -19,6 +20,7 @@
 import org.dataloader.DataLoaderRegistry;
 import org.jspecify.annotations.Nullable;
 
+import java.util.Collections;
 import java.util.Locale;
 import java.util.Map;
 import java.util.function.Supplier;
@@ -55,6 +57,7 @@ public class ExecutionContextBuilder {
     EngineRunningState engineRunningState;
     ResponseMapFactory responseMapFactory = ResponseMapFactory.DEFAULT;
     Profiler profiler;
+    Supplier<Map<OperationDefinition, ImmutableList<QueryAppliedDirective>>> allOperationsDirectives = Collections::emptyMap;
 
     /**
      * @return a new builder of {@link graphql.execution.ExecutionContext}s
@@ -168,6 +171,7 @@ public ExecutionContextBuilder root(Object root) {
 
     /**
      * @param variables map of already coerced variables
+     *
      * @return this builder
      *
      * @deprecated use {@link #coercedVariables(CoercedVariables)} instead
@@ -246,13 +250,6 @@ public ExecutionContextBuilder propagapropagateErrorsOnNonNullContractFailureeEr
         return this;
     }
 
-
-    public ExecutionContext build() {
-        // preconditions
-        assertNotNull(executionId, "You must provide a query identifier");
-        return new ExecutionContext(this);
-    }
-
     public ExecutionContextBuilder engineRunningState(EngineRunningState engineRunningState) {
         this.engineRunningState = engineRunningState;
         return this;
@@ -262,4 +259,16 @@ public ExecutionContextBuilder profiler(Profiler profiler) {
         this.profiler = profiler;
         return this;
     }
+
+    public ExecutionContextBuilder operationDirectives(Supplier<Map<OperationDefinition, ImmutableList<QueryAppliedDirective>>> allOperationsDirectives) {
+        this.allOperationsDirectives = allOperationsDirectives;
+        return this;
+    }
+
+
+    public ExecutionContext build() {
+        // preconditions
+        assertNotNull(executionId, "You must provide a query identifier");
+        return new ExecutionContext(this);
+    }
 }
diff --git a/src/main/java/graphql/execution/directives/DirectivesResolver.java b/src/main/java/graphql/execution/directives/DirectivesResolver.java
@@ -3,8 +3,10 @@
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
 import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableList;
 import graphql.GraphQLContext;
 import graphql.Internal;
+import graphql.collect.ImmutableKit;
 import graphql.execution.CoercedVariables;
 import graphql.execution.ValuesResolver;
 import graphql.language.Directive;
@@ -61,4 +63,34 @@ private void buildArguments(GraphQLDirective.Builder directiveBuilder,
             }
         });
     }
+
+    public ImmutableList<QueryAppliedDirective> toAppliedDirectives(List<Directive> directives, GraphQLSchema schema, CoercedVariables variables, GraphQLContext graphQLContext, Locale locale) {
+        BiMap<GraphQLDirective, Directive> directivesMap = resolveDirectives(directives, schema, variables, graphQLContext, locale);
+        return ImmutableKit.map(directivesMap.keySet(), this::toAppliedDirective);
+    }
+
+    /**
+     * This helps us remodel the applied GraphQLDirective back to the better modelled and named {@link QueryAppliedDirective}
+     *
+     * @param directive the directive to remodel
+     *
+     * @return a QueryAppliedDirective
+     */
+    public QueryAppliedDirective toAppliedDirective(GraphQLDirective directive) {
+        QueryAppliedDirective.Builder builder = QueryAppliedDirective.newDirective();
+        builder.name(directive.getName());
+        for (GraphQLArgument argument : directive.getArguments()) {
+            builder.argument(toAppliedArgument(argument));
+        }
+        return builder.build();
+    }
+
+    public QueryAppliedDirectiveArgument toAppliedArgument(GraphQLArgument argument) {
+        return QueryAppliedDirectiveArgument.newArgument()
+                .name(argument.getName())
+                .type(argument.getType())
+                .inputValueWithState(argument.getArgumentValue())
+                .build();
+    }
+
 }
diff --git a/src/main/java/graphql/execution/directives/OperationDirectivesResolver.java b/src/main/java/graphql/execution/directives/OperationDirectivesResolver.java
@@ -0,0 +1,52 @@
+package graphql.execution.directives;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import graphql.GraphQLContext;
+import graphql.Internal;
+import graphql.execution.CoercedVariables;
+import graphql.language.Document;
+import graphql.language.OperationDefinition;
+import graphql.schema.GraphQLSchema;
+import graphql.util.FpKit;
+import org.jspecify.annotations.NullMarked;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+@Internal
+@NullMarked
+public class OperationDirectivesResolver {
+
+    private final DirectivesResolver directivesResolver = new DirectivesResolver();
+
+    public ImmutableMap<OperationDefinition, ImmutableList<QueryAppliedDirective>> resolveDirectives(Document document, GraphQLSchema schema, CoercedVariables variables, GraphQLContext graphQLContext, Locale locale) {
+        ImmutableMap.Builder<OperationDefinition, ImmutableList<QueryAppliedDirective>> builder = ImmutableMap.builder();
+        for (OperationDefinition operationDefinition : document.getDefinitionsOfType(OperationDefinition.class)) {
+            builder.put(operationDefinition, resolveDirectives(operationDefinition, schema, variables, graphQLContext, locale));
+        }
+        return builder.build();
+    }
+
+    public ImmutableList<QueryAppliedDirective> resolveDirectives(OperationDefinition operationDefinition, GraphQLSchema schema, CoercedVariables variables, GraphQLContext graphQLContext, Locale locale) {
+        return directivesResolver.toAppliedDirectives(
+                operationDefinition.getDirectives(),
+                schema,
+                variables,
+                graphQLContext,
+                locale
+        );
+    }
+
+    public ImmutableMap<String, ImmutableList<QueryAppliedDirective>> resolveDirectivesByName(OperationDefinition operationDefinition, GraphQLSchema schema, CoercedVariables variables, GraphQLContext graphQLContext, Locale locale) {
+        List<QueryAppliedDirective> list = resolveDirectives(operationDefinition, schema, variables, graphQLContext, locale);
+        return toAppliedDirectivesByName(list);
+    }
+
+    public static ImmutableMap<String, ImmutableList<QueryAppliedDirective>> toAppliedDirectivesByName(List<QueryAppliedDirective> queryAppliedDirectives) {
+        Map<String, ImmutableList<QueryAppliedDirective>> immutableListMap = FpKit.groupingBy(queryAppliedDirectives, QueryAppliedDirective::getName);
+        return ImmutableMap.copyOf(immutableListMap);
+    }
+
+}
diff --git a/src/main/java/graphql/execution/directives/QueryDirectivesImpl.java b/src/main/java/graphql/execution/directives/QueryDirectivesImpl.java
@@ -80,7 +80,7 @@ private void computeValuesLazily() {
 
                 ImmutableList.Builder<QueryAppliedDirective> appliedDirectiveBuilder = ImmutableList.builder();
                 for (GraphQLDirective resolvedDirective : resolvedDirectives) {
-                    QueryAppliedDirective appliedDirective = toAppliedDirective(resolvedDirective);
+                    QueryAppliedDirective appliedDirective = directivesResolver.toAppliedDirective(resolvedDirective);
                     appliedDirectiveBuilder.add(appliedDirective);
                     gqlDirectiveCounterParts.put(resolvedDirective, appliedDirective);
                 }
@@ -125,23 +125,6 @@ private void computeValuesLazily() {
         });
     }
 
-    private QueryAppliedDirective toAppliedDirective(GraphQLDirective directive) {
-        QueryAppliedDirective.Builder builder = QueryAppliedDirective.newDirective();
-        builder.name(directive.getName());
-        for (GraphQLArgument argument : directive.getArguments()) {
-            builder.argument(toAppliedArgument(argument));
-        }
-        return builder.build();
-    }
-
-    private QueryAppliedDirectiveArgument toAppliedArgument(GraphQLArgument argument) {
-        return QueryAppliedDirectiveArgument.newArgument()
-                .name(argument.getName())
-                .type(argument.getType())
-                .inputValueWithState(argument.getArgumentValue())
-                .build();
-    }
-
 
     @Override
     public Map<Field, List<GraphQLDirective>> getImmediateDirectivesByField() {