graphql-java · bbakerman · Mar 20, 2025 · Nov 27, 2024 · Nov 28, 2024 · Nov 28, 2024
diff --git a/src/main/java/graphql/execution/Execution.java b/src/main/java/graphql/execution/Execution.java
@@ -30,13 +30,15 @@
 import graphql.schema.GraphQLSchema;
 import graphql.schema.impl.SchemaUtil;
 import org.jspecify.annotations.NonNull;
+import graphql.util.FpKit;
 import org.reactivestreams.Publisher;
 
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
+import java.util.function.Supplier;
 
 import static graphql.Directives.EXPERIMENTAL_DISABLE_ERROR_PROPAGATION_DIRECTIVE_DEFINITION;
 import static graphql.execution.ExecutionContextBuilder.newExecutionContextBuilder;
@@ -71,12 +73,13 @@ public Execution(ExecutionStrategy queryStrategy,
     }
 
     public CompletableFuture<ExecutionResult> execute(Document document, GraphQLSchema graphQLSchema, ExecutionId executionId, ExecutionInput executionInput, InstrumentationState instrumentationState) {
-
         NodeUtil.GetOperationResult getOperationResult;
         CoercedVariables coercedVariables;
+        Supplier<NormalizedVariables> normalizedVariableValues;
         try {
             getOperationResult = NodeUtil.getOperation(document, executionInput.getOperationName());
             coercedVariables = coerceVariableValues(graphQLSchema, executionInput, getOperationResult.operationDefinition);
+            normalizedVariableValues = normalizedVariableValues(graphQLSchema, executionInput, getOperationResult);
         } catch (RuntimeException rte) {
             if (rte instanceof GraphQLError) {
                 return completedFuture(new ExecutionResultImpl((GraphQLError) rte));
@@ -100,6 +103,7 @@ public CompletableFuture<ExecutionResult> execute(Document document, GraphQLSche
                 .root(executionInput.getRoot())
                 .fragmentsByName(getOperationResult.fragmentsByName)
                 .coercedVariables(coercedVariables)
+                .normalizedVariableValues(normalizedVariableValues)
                 .document(document)
                 .operationDefinition(getOperationResult.operationDefinition)
                 .dataLoaderRegistry(executionInput.getDataLoaderRegistry())
@@ -124,6 +128,19 @@ public CompletableFuture<ExecutionResult> execute(Document document, GraphQLSche
         return ValuesResolver.coerceVariableValues(graphQLSchema, variableDefinitions, inputVariables, executionInput.getGraphQLContext(), executionInput.getLocale());
     }
 
+    private static @NonNull Supplier<NormalizedVariables> normalizedVariableValues(GraphQLSchema graphQLSchema, ExecutionInput executionInput, NodeUtil.GetOperationResult getOperationResult) {
+        Supplier<NormalizedVariables> normalizedVariableValues;
+        RawVariables inputVariables = executionInput.getRawVariables();
+        List<VariableDefinition> variableDefinitions = getOperationResult.operationDefinition.getVariableDefinitions();
+
+        normalizedVariableValues = FpKit.intraThreadMemoize(() ->
+                ValuesResolver.getNormalizedVariableValues(graphQLSchema,
+                        variableDefinitions,
+                        inputVariables,
+                        executionInput.getGraphQLContext(), executionInput.getLocale()));
+        return normalizedVariableValues;
+    }
+
 
     private CompletableFuture<ExecutionResult> executeOperation(ExecutionContext executionContext, Object root, OperationDefinition operationDefinition) {
 
@@ -235,7 +252,7 @@ private DataLoaderDispatchStrategy createDataLoaderDispatchStrategy(ExecutionCon
         if (executionContext.getDataLoaderRegistry() == EMPTY_DATALOADER_REGISTRY || doNotAutomaticallyDispatchDataLoader) {
             return DataLoaderDispatchStrategy.NO_OP;
         }
-        if (! executionContext.isSubscriptionOperation()) {
+        if (!executionContext.isSubscriptionOperation()) {
             boolean deferEnabled = Optional.ofNullable(executionContext.getGraphQLContext())
                     .map(graphqlContext -> graphqlContext.getBoolean(ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT))
                     .orElse(false);

diff --git a/src/main/java/graphql/execution/ExecutionContext.java b/src/main/java/graphql/execution/ExecutionContext.java
@@ -46,6 +46,7 @@ public class ExecutionContext {
     private final OperationDefinition operationDefinition;
     private final Document document;
     private final CoercedVariables coercedVariables;
+    private final Supplier<NormalizedVariables> normalizedVariables;
     private final Object root;
     private final Object context;
     private final GraphQLContext graphQLContext;
@@ -76,6 +77,7 @@ public class ExecutionContext {
         this.subscriptionStrategy = builder.subscriptionStrategy;
         this.fragmentsByName = builder.fragmentsByName;
         this.coercedVariables = builder.coercedVariables;
+        this.normalizedVariables = builder.normalizedVariables;
         this.document = builder.document;
         this.operationDefinition = builder.operationDefinition;
         this.context = builder.context;
@@ -130,6 +132,13 @@ public CoercedVariables getCoercedVariables() {
         return coercedVariables;
     }
 
+    /**
+     * @return a supplier that will give out the operations variables in normalized form
+     */
+    public Supplier<NormalizedVariables> getNormalizedVariables() {
+        return normalizedVariables;
+    }
+
     /**
      * @param <T> for two
      * @return the legacy context

diff --git a/src/main/java/graphql/execution/ExecutionContextBuilder.java b/src/main/java/graphql/execution/ExecutionContextBuilder.java
@@ -19,6 +19,7 @@
 
 import java.util.Locale;
 import java.util.Map;
+import java.util.function.Supplier;
 
 import static graphql.Assert.assertNotNull;
 import static graphql.collect.ImmutableKit.emptyList;
@@ -39,6 +40,7 @@ public class ExecutionContextBuilder {
     Document document;
     OperationDefinition operationDefinition;
     CoercedVariables coercedVariables = CoercedVariables.emptyVariables();
+    Supplier<NormalizedVariables> normalizedVariables = NormalizedVariables::emptyVariables;
     ImmutableMap<String, FragmentDefinition> fragmentsByName = ImmutableKit.emptyMap();
     DataLoaderRegistry dataLoaderRegistry;
     Locale locale;
@@ -173,6 +175,11 @@ public ExecutionContextBuilder coercedVariables(CoercedVariables coercedVariable
         return this;
     }
 
+    public ExecutionContextBuilder normalizedVariableValues(Supplier<NormalizedVariables> normalizedVariables) {
+        this.normalizedVariables = normalizedVariables;
+        return this;
+    }
+
     public ExecutionContextBuilder fragmentsByName(Map<String, FragmentDefinition> fragmentsByName) {
         this.fragmentsByName = ImmutableMap.copyOf(fragmentsByName);
         return this;

diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java
@@ -463,7 +463,8 @@ private Object fetchField(GraphQLFieldDefinition fieldDef, ExecutionContext exec
             DataFetchingFieldSelectionSet fieldCollector = DataFetchingFieldSelectionSetImpl.newCollector(executionContext.getGraphQLSchema(), fieldDef.getType(), normalizedFieldSupplier);
             QueryDirectives queryDirectives = new QueryDirectivesImpl(field,
                     executionContext.getGraphQLSchema(),
-                    executionContext.getCoercedVariables().toMap(),
+                    executionContext.getCoercedVariables(),
+                    executionContext.getNormalizedVariables(),
                     executionContext.getGraphQLContext(),
                     executionContext.getLocale());
 

diff --git a/src/main/java/graphql/execution/NormalizedVariables.java b/src/main/java/graphql/execution/NormalizedVariables.java
@@ -0,0 +1,45 @@
+package graphql.execution;
+
+import graphql.PublicApi;
+import graphql.collect.ImmutableKit;
+import graphql.collect.ImmutableMapWithNullValues;
+import graphql.normalized.NormalizedInputValue;
+
+import java.util.Map;
+
+/**
+ * Holds coerced variables, that is their values are now in a normalized {@link graphql.normalized.NormalizedInputValue} form.
+ */
+@PublicApi
+public class NormalizedVariables {
+    private final ImmutableMapWithNullValues<String, NormalizedInputValue> normalisedVariables;
+
+    public NormalizedVariables(Map<String, NormalizedInputValue> normalisedVariables) {
+        this.normalisedVariables = ImmutableMapWithNullValues.copyOf(normalisedVariables);
+    }
+
+    public Map<String, NormalizedInputValue> toMap() {
+        return normalisedVariables;
+    }
+
+    public boolean containsKey(String key) {
+        return normalisedVariables.containsKey(key);
+    }
+
+    public Object get(String key) {
+        return normalisedVariables.get(key);
+    }
+
+    public static NormalizedVariables emptyVariables() {
+        return new NormalizedVariables(ImmutableKit.emptyMap());
+    }
+
+    public static NormalizedVariables of(Map<String, NormalizedInputValue> normalisedVariables) {
+        return new NormalizedVariables(normalisedVariables);
+    }
+
+    @Override
+    public String toString() {
+        return normalisedVariables.toString();
+    }
+}
diff --git a/src/main/java/graphql/execution/ValuesResolver.java b/src/main/java/graphql/execution/ValuesResolver.java
@@ -101,7 +101,7 @@ public static CoercedVariables coerceVariableValues(GraphQLSchema schema,
      *
      * @return a map of the normalised values
      */
-    public static Map<String, NormalizedInputValue> getNormalizedVariableValues(
+    public static NormalizedVariables getNormalizedVariableValues(
             GraphQLSchema schema,
             List<VariableDefinition> variableDefinitions,
             RawVariables rawVariables,
@@ -131,9 +131,7 @@ public static Map<String, NormalizedInputValue> getNormalizedVariableValues(
                 }
             }
         }
-
-        return result;
-
+        return NormalizedVariables.of(result);
     }
 
 

diff --git a/src/main/java/graphql/execution/directives/DirectivesResolver.java b/src/main/java/graphql/execution/directives/DirectivesResolver.java
@@ -1,6 +1,8 @@
 package graphql.execution.directives;
 
-import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.ImmutableBiMap;
 import graphql.GraphQLContext;
 import graphql.Internal;
 import graphql.execution.CoercedVariables;
@@ -11,8 +13,6 @@
 import graphql.schema.GraphQLDirective;
 import graphql.schema.GraphQLSchema;
 
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ -26,27 +26,27 @@ public class DirectivesResolver {
     public DirectivesResolver() {
     }
 
-    public Map<String, List<GraphQLDirective>> resolveDirectives(List<Directive> directives, GraphQLSchema schema, Map<String, Object> variables, GraphQLContext graphQLContext, Locale locale) {
+    public BiMap<GraphQLDirective, Directive> resolveDirectives(List<Directive> directives, GraphQLSchema schema, CoercedVariables variables, GraphQLContext graphQLContext, Locale locale) {
         GraphQLCodeRegistry codeRegistry = schema.getCodeRegistry();
-        Map<String, List<GraphQLDirective>> directiveMap = new LinkedHashMap<>();
+        BiMap<GraphQLDirective, Directive> directiveMap = HashBiMap.create();
         directives.forEach(directive -> {
             GraphQLDirective protoType = schema.getDirective(directive.getName());
             if (protoType != null) {
-                GraphQLDirective newDirective = protoType.transform(builder -> buildArguments(builder, codeRegistry, protoType, directive, variables, graphQLContext, locale));
-                directiveMap.computeIfAbsent(newDirective.getName(), k -> new ArrayList<>()).add(newDirective);
+                GraphQLDirective graphQLDirective = protoType.transform(builder -> buildArguments(builder, codeRegistry, protoType, directive, variables, graphQLContext, locale));
+                directiveMap.put(graphQLDirective, directive);
             }
         });
-        return ImmutableMap.copyOf(directiveMap);
+        return ImmutableBiMap.copyOf(directiveMap);
     }
 
     private void buildArguments(GraphQLDirective.Builder directiveBuilder,
                                 GraphQLCodeRegistry codeRegistry,
                                 GraphQLDirective protoType,
                                 Directive fieldDirective,
-                                Map<String, Object> variables,
+                                CoercedVariables variables,
                                 GraphQLContext graphQLContext,
                                 Locale locale) {
-        Map<String, Object> argumentValues = ValuesResolver.getArgumentValues(codeRegistry, protoType.getArguments(), fieldDirective.getArguments(), CoercedVariables.of(variables), graphQLContext, locale);
+        Map<String, Object> argumentValues = ValuesResolver.getArgumentValues(codeRegistry, protoType.getArguments(), fieldDirective.getArguments(), variables, graphQLContext, locale);
         directiveBuilder.clearArguments();
         protoType.getArguments().forEach(protoArg -> {
             if (argumentValues.containsKey(protoArg.getName())) {

diff --git a/src/main/java/graphql/execution/directives/QueryDirectives.java b/src/main/java/graphql/execution/directives/QueryDirectives.java
@@ -4,13 +4,16 @@
 import graphql.PublicApi;
 import graphql.execution.CoercedVariables;
 import graphql.execution.MergedField;
+import graphql.execution.NormalizedVariables;
 import graphql.language.Field;
+import graphql.normalized.NormalizedInputValue;
 import graphql.schema.GraphQLDirective;
 import graphql.schema.GraphQLSchema;
 
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.function.Supplier;
 
 /**
  * This gives you access to the immediate directives on a {@link graphql.execution.MergedField}.  This does not include directives on parent
@@ -66,6 +69,16 @@ public interface QueryDirectives {
      */
     Map<Field, List<QueryAppliedDirective>> getImmediateAppliedDirectivesByField();
 
+    /**
+     * This will return a map of {@link QueryAppliedDirective} to a map of their argument values in {@link NormalizedInputValue} form
+     * <p>
+     * NOTE : This will only be available when {@link graphql.normalized.ExecutableNormalizedOperationFactory} is used
+     * to create the {@link QueryAppliedDirective} information
+     *
+     * @return a map of applied directive to named argument values
+     */
+    Map<QueryAppliedDirective, Map<String, NormalizedInputValue>> getNormalizedInputValueByImmediateAppliedDirectives();
+
     /**
      * This will return a list of the named directives that are immediately on this merged field.
      *
@@ -108,6 +121,8 @@ interface Builder {
 
         Builder coercedVariables(CoercedVariables coercedVariables);
 
+        Builder normalizedVariables(Supplier<NormalizedVariables> normalizedVariables);
+
         Builder graphQLContext(GraphQLContext graphQLContext);
 
         Builder locale(Locale locale);

diff --git a/src/main/java/graphql/execution/directives/QueryDirectivesBuilder.java b/src/main/java/graphql/execution/directives/QueryDirectivesBuilder.java
@@ -4,17 +4,20 @@
 import graphql.Internal;
 import graphql.execution.CoercedVariables;
 import graphql.execution.MergedField;
+import graphql.execution.NormalizedVariables;
 import graphql.language.Field;
 import graphql.schema.GraphQLSchema;
 
 import java.util.Locale;
+import java.util.function.Supplier;
 
 @Internal
 public class QueryDirectivesBuilder implements QueryDirectives.Builder {
 
     private MergedField mergedField;
     private GraphQLSchema schema;
     private CoercedVariables coercedVariables = CoercedVariables.emptyVariables();
+    private Supplier<NormalizedVariables> normalizedVariables = NormalizedVariables::emptyVariables;
     private GraphQLContext graphQLContext = GraphQLContext.getDefault();
     private Locale locale = Locale.getDefault();
 
@@ -42,6 +45,12 @@ public QueryDirectives.Builder coercedVariables(CoercedVariables coercedVariable
         return this;
     }
 
+    @Override
+    public QueryDirectives.Builder normalizedVariables(Supplier<NormalizedVariables> normalizedVariables) {
+        this.normalizedVariables = normalizedVariables;
+        return this;
+    }
+
     @Override
     public QueryDirectives.Builder graphQLContext(GraphQLContext graphQLContext) {
         this.graphQLContext = graphQLContext;
@@ -57,6 +66,6 @@ public QueryDirectives.Builder locale(Locale locale) {
 
     @Override
     public QueryDirectives build() {
-        return new QueryDirectivesImpl(mergedField, schema, coercedVariables.toMap(), graphQLContext, locale);
+        return new QueryDirectivesImpl(mergedField, schema, coercedVariables, normalizedVariables, graphQLContext, locale);
     }
 }