Bugfix cherry pick: RawVariables and CoercedVariables are public API (#2868)

src/main/java/graphql/ExecutionInput.java

@@ -367,7 +367,7 @@ public Builder root(Object root) {
          */
         public Builder variables(Map<String, Object> rawVariables) {
             assertNotNull(rawVariables, () -> "variables map can't be null");
-            this.rawVariables = new RawVariables(rawVariables);
+            this.rawVariables = RawVariables.of(rawVariables);
             return this;
         }
 

src/main/java/graphql/analysis/NodeVisitorWithTypeTracking.java

@@ -155,7 +155,7 @@ public TraversalControl visitField(Field field, TraverserContext<Node> context)
         boolean isTypeNameIntrospectionField = fieldDefinition == schema.getIntrospectionTypenameFieldDefinition();
         GraphQLFieldsContainer fieldsContainer = !isTypeNameIntrospectionField ? (GraphQLFieldsContainer) unwrapAll(parentEnv.getOutputType()) : null;
         GraphQLCodeRegistry codeRegistry = schema.getCodeRegistry();
-        Map<String, Object> argumentValues = valuesResolver.getArgumentValues(codeRegistry, fieldDefinition.getArguments(), field.getArguments(), new CoercedVariables(variables));
+        Map<String, Object> argumentValues = valuesResolver.getArgumentValues(codeRegistry, fieldDefinition.getArguments(), field.getArguments(), CoercedVariables.of(variables));
         QueryVisitorFieldEnvironment environment = new QueryVisitorFieldEnvironmentImpl(isTypeNameIntrospectionField,
                 field,
                 fieldDefinition,

src/main/java/graphql/analysis/QueryTraverser.java

@@ -257,7 +257,7 @@ public Builder document(Document document) {
          */
         public Builder variables(Map<String, Object> variables) {
             assertNotNull(variables, () -> "variables can't be null");
-            this.rawVariables = new RawVariables(variables);
+            this.rawVariables = RawVariables.of(variables);
             return this;
         }
 
@@ -326,7 +326,7 @@ public QueryTraverser build() {
                     // When traversing with an arbitrary root, there is no variable definition context available
                     // Thus, the variables must have already been coerced
                     // Retaining this builder for backwards compatibility
-                    return new QueryTraverser(schema, root, rootParentType, fragmentsByName, new CoercedVariables(rawVariables.toMap()));
+                    return new QueryTraverser(schema, root, rootParentType, fragmentsByName, CoercedVariables.of(rawVariables.toMap()));
                 }
                 return new QueryTraverser(schema, root, rootParentType, fragmentsByName, coercedVariables);
             }

src/main/java/graphql/execution/CoercedVariables.java

@@ -1,15 +1,15 @@
 package graphql.execution;
 
-import graphql.Internal;
+import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
 import graphql.collect.ImmutableMapWithNullValues;
 
 import java.util.Map;
 
 /**
- * Holds coerced variables
+ * Holds coerced variables, that is their values are now in a canonical form.
  */
-@Internal
+@PublicApi
 public class CoercedVariables {
     private final ImmutableMapWithNullValues<String, Object> coercedVariables;
 
@@ -32,4 +32,8 @@ public Object get(String key) {
     public static CoercedVariables emptyVariables() {
         return new CoercedVariables(ImmutableKit.emptyMap());
     }
+
+    public static CoercedVariables of(Map<String, Object> coercedVariables) {
+        return new CoercedVariables(coercedVariables);
+    }
 }

src/main/java/graphql/execution/ConditionalNodes.java

@@ -34,7 +34,7 @@ public boolean shouldInclude(Map<String, Object> variables, List<Directive> dire
     private boolean getDirectiveResult(Map<String, Object> variables, List<Directive> directives, String directiveName, boolean defaultValue) {
         Directive foundDirective = NodeUtil.findNodeByName(directives, directiveName);
         if (foundDirective != null) {
-            Map<String, Object> argumentValues = valuesResolver.getArgumentValues(SkipDirective.getArguments(), foundDirective.getArguments(), new CoercedVariables(variables));
+            Map<String, Object> argumentValues = valuesResolver.getArgumentValues(SkipDirective.getArguments(), foundDirective.getArguments(), CoercedVariables.of(variables));
             Object flag = argumentValues.get("if");
             Assert.assertTrue(flag instanceof Boolean, () -> String.format("The '%s' directive MUST have a value for the 'if' argument", directiveName));
             return (Boolean) flag;

src/main/java/graphql/execution/ExecutionContextBuilder.java

@@ -155,7 +155,7 @@ public ExecutionContextBuilder root(Object root) {
      */
     @Deprecated
     public ExecutionContextBuilder variables(Map<String, Object> variables) {
-        this.coercedVariables = new CoercedVariables(variables);
+        this.coercedVariables = CoercedVariables.of(variables);
         return this;
     }
 

src/main/java/graphql/execution/RawVariables.java

@@ -1,15 +1,15 @@
 package graphql.execution;
 
-import graphql.Internal;
+import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
 import graphql.collect.ImmutableMapWithNullValues;
 
 import java.util.Map;
 
 /**
- * Holds raw variables, which not have been coerced yet
+ * Holds raw variables, which have not been coerced yet into {@link CoercedVariables}
  */
-@Internal
+@PublicApi
 public class RawVariables {
     private final ImmutableMapWithNullValues<String, Object> rawVariables;
 
@@ -30,6 +30,10 @@ public Object get(String key) {
     }
 
     public static RawVariables emptyVariables() {
-        return new RawVariables(ImmutableKit.emptyMap());
+        return RawVariables.of(ImmutableKit.emptyMap());
+    }
+
+    public static RawVariables of(Map<String, Object> rawVariables) {
+        return new RawVariables(rawVariables);
     }
 }

src/main/java/graphql/execution/ValuesResolver.java

@@ -248,7 +248,7 @@ public static Object valueToInternalValue(InputValueWithState inputValueWithStat
             return inputValueWithState.getValue();
         }
         if (inputValueWithState.isLiteral()) {
-            return new ValuesResolver().literalToInternalValue(fieldVisibility, type, (Value<?>) inputValueWithState.getValue(), new CoercedVariables(emptyMap()));
+            return new ValuesResolver().literalToInternalValue(fieldVisibility, type, (Value<?>) inputValueWithState.getValue(), CoercedVariables.emptyVariables());
         }
         if (inputValueWithState.isExternal()) {
             return new ValuesResolver().externalValueToInternalValue(fieldVisibility, type, inputValueWithState.getValue());
@@ -421,7 +421,7 @@ private CoercedVariables externalValueToInternalValueForVariables(GraphQLSchema
             }
         }
 
-        return new CoercedVariables(coercedValues);
+        return CoercedVariables.of(coercedValues);
     }
 
 

src/main/java/graphql/execution/directives/DirectivesResolver.java

@@ -39,7 +39,7 @@ public Map<String, GraphQLDirective> resolveDirectives(List<Directive> directive
     }
 
     private void buildArguments(GraphQLDirective.Builder directiveBuilder, GraphQLCodeRegistry codeRegistry, GraphQLDirective protoType, Directive fieldDirective, Map<String, Object> variables) {
-        Map<String, Object> argumentValues = valuesResolver.getArgumentValues(codeRegistry, protoType.getArguments(), fieldDirective.getArguments(), new CoercedVariables(variables));
+        Map<String, Object> argumentValues = valuesResolver.getArgumentValues(codeRegistry, protoType.getArguments(), fieldDirective.getArguments(), CoercedVariables.of(variables));
         directiveBuilder.clearArguments();
         protoType.getArguments().forEach(protoArg -> {
             if (argumentValues.containsKey(protoArg.getName())) {

src/main/java/graphql/normalized/ExecutableNormalizedOperationFactory.java

@@ -306,7 +306,7 @@ private ExecutableNormalizedField createNF(FieldCollectorNormalizedQueryParams p
         String fieldName = field.getName();
         GraphQLFieldDefinition fieldDefinition = Introspection.getFieldDef(parameters.getGraphQLSchema(), objectTypes.iterator().next(), fieldName);
 
-        Map<String, Object> argumentValues = valuesResolver.getArgumentValues(fieldDefinition.getArguments(), field.getArguments(), new CoercedVariables(parameters.getCoercedVariableValues()));
+        Map<String, Object> argumentValues = valuesResolver.getArgumentValues(fieldDefinition.getArguments(), field.getArguments(),CoercedVariables.of(parameters.getCoercedVariableValues()));
         Map<String, NormalizedInputValue> normalizedArgumentValues = null;
         if (parameters.getNormalizedVariableValues() != null) {
             normalizedArgumentValues = valuesResolver.getNormalizedArgumentValues(fieldDefinition.getArguments(), field.getArguments(), parameters.getNormalizedVariableValues());

src/test/groovy/graphql/execution/ExecutionContextBuilderTest.groovy

@@ -66,7 +66,7 @@ class ExecutionContextBuilderTest extends Specification {
 
     def "builds the correct ExecutionContext with coerced variables"() {
         given:
-        def coercedVariables = new CoercedVariables([var: 'value'])
+        def coercedVariables = CoercedVariables.of([var: 'value'])
 
         when:
         def executionContext = new ExecutionContextBuilder()
@@ -105,7 +105,7 @@ class ExecutionContextBuilderTest extends Specification {
 
     def "builds the correct ExecutionContext, if both variables and coercedVariables are set, latest value set takes precedence"() {
         given:
-        def coercedVariables = new CoercedVariables([var: 'value'])
+        def coercedVariables = CoercedVariables.of([var: 'value'])
 
         when:
         def executionContext = new ExecutionContextBuilder()
@@ -164,7 +164,7 @@ class ExecutionContextBuilderTest extends Specification {
             .build()
 
         when:
-        def coercedVariables = new CoercedVariables([var: 'value'])
+        def coercedVariables = CoercedVariables.of([var: 'value'])
         def executionContext = executionContextOld.transform(builder -> builder
                                                         .coercedVariables(coercedVariables))
 
@@ -207,7 +207,7 @@ class ExecutionContextBuilderTest extends Specification {
                 .build()
 
         when:
-        def coercedVariables = new CoercedVariables([var: 'value'])
+        def coercedVariables = CoercedVariables.of([var: 'value'])
         def executionContext = executionContextOld.transform(builder -> builder
                 .variables([var: 'value'])
                 .coercedVariables(coercedVariables))

src/test/groovy/graphql/execution/ValuesResolverTest.groovy

@@ -45,7 +45,7 @@ class ValuesResolverTest extends Specification {
         def schema = TestUtil.schemaWithInputType(inputType)
         VariableDefinition variableDefinition = new VariableDefinition("variable", variableType, null)
         when:
-        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], new RawVariables([variable: inputValue]))
+        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], RawVariables.of([variable: inputValue]))
         then:
         resolvedValues.get('variable') == outputValue
 
@@ -74,7 +74,7 @@ class ValuesResolverTest extends Specification {
         VariableDefinition variableDefinition = new VariableDefinition("variable", new TypeName("Person"))
 
         when:
-        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], new RawVariables([variable: inputValue]))
+        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], RawVariables.of([variable: inputValue]))
         then:
         resolvedValues.get('variable') == outputValue
         where:
@@ -114,7 +114,7 @@ class ValuesResolverTest extends Specification {
 
         when:
         def obj = new Person('a', 123)
-        resolver.coerceVariableValues(schema, [variableDefinition], new RawVariables([variable: obj]))
+        resolver.coerceVariableValues(schema, [variableDefinition], RawVariables.of([variable: obj]))
         then:
         thrown(CoercingParseValueException)
     }
@@ -125,7 +125,7 @@ class ValuesResolverTest extends Specification {
         VariableDefinition variableDefinition = new VariableDefinition("variable", new ListType(new TypeName("String")))
         String value = "world"
         when:
-        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], new RawVariables([variable: value]))
+        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], RawVariables.of([variable: value]))
         then:
         resolvedValues.get('variable') == ['world']
     }
@@ -136,7 +136,7 @@ class ValuesResolverTest extends Specification {
         VariableDefinition variableDefinition = new VariableDefinition("variable", new ListType(new TypeName("String")))
         List<String> value = ["hello","world"]
         when:
-        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], new RawVariables([variable: value]))
+        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], RawVariables.of([variable: value]))
         then:
         resolvedValues.get('variable') == ['hello','world']
     }
@@ -147,14 +147,14 @@ class ValuesResolverTest extends Specification {
         VariableDefinition variableDefinition = new VariableDefinition("variable", new ListType(new TypeName("String")))
         String[] value = ["hello","world"] as String[]
         when:
-        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], new RawVariables([variable: value]))
+        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], RawVariables.of([variable: value]))
         then:
         resolvedValues.get('variable') == ['hello','world']
     }
 
     def "getArgumentValues: resolves argument with variable reference"() {
         given:
-        def variables = new CoercedVariables([var: 'hello'])
+        def variables = CoercedVariables.of([var: 'hello'])
         def fieldArgument = newArgument().name("arg").type(GraphQLString).build()
         def argument = new Argument("arg", new VariableReference("var"))
 
@@ -351,7 +351,7 @@ class ValuesResolverTest extends Specification {
         VariableDefinition variableDefinition = new VariableDefinition("variable", new TypeName("Test"))
 
         when:
-        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], new RawVariables([variable: inputValue]))
+        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], RawVariables.of([variable: inputValue]))
         then:
         resolvedValues.get('variable') == outputValue
         where:
@@ -379,7 +379,7 @@ class ValuesResolverTest extends Specification {
         VariableDefinition variableDefinition = new VariableDefinition("variable", new TypeName("InputObject"))
 
         when:
-        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], new RawVariables([variable: inputValue]))
+        def resolvedValues = resolver.coerceVariableValues(schema, [variableDefinition], RawVariables.of([variable: inputValue]))
 
         then:
         resolvedValues.get('variable') == outputValue
@@ -406,7 +406,7 @@ class ValuesResolverTest extends Specification {
         VariableDefinition variableDefinition = new VariableDefinition("variable", new TypeName("InputObject"))
 
         when:
-        resolver.coerceVariableValues(schema, [variableDefinition], new RawVariables([variable: inputValue]))
+        resolver.coerceVariableValues(schema, [variableDefinition], RawVariables.of([variable: inputValue]))
 
         then:
         thrown(GraphQLException)
@@ -425,7 +425,7 @@ class ValuesResolverTest extends Specification {
         VariableDefinition barVarDef = new VariableDefinition("bar", new TypeName("String"))
 
         when:
-        def resolvedValues = resolver.coerceVariableValues(schema, [fooVarDef, barVarDef], new RawVariables(InputValue))
+        def resolvedValues = resolver.coerceVariableValues(schema, [fooVarDef, barVarDef], RawVariables.of(InputValue))
 
         then:
         resolvedValues.toMap() == outputValue
@@ -459,7 +459,7 @@ class ValuesResolverTest extends Specification {
         def defaultValueForBar = new StringValue("defaultValueForBar")
         VariableDefinition barVarDef = new VariableDefinition("bar", new TypeName("String"), defaultValueForBar)
 
-        def variableValuesMap = new RawVariables(["foo": null, "bar": "barValue"])
+        def variableValuesMap = RawVariables.of(["foo": null, "bar": "barValue"])
 
         when:
         def resolvedVars = resolver.coerceVariableValues(schema, [fooVarDef, barVarDef], variableValuesMap)
@@ -476,7 +476,7 @@ class ValuesResolverTest extends Specification {
         def defaultValueForFoo = new StringValue("defaultValueForFoo")
         VariableDefinition fooVarDef = new VariableDefinition("foo", new NonNullType(new TypeName("String")), defaultValueForFoo)
 
-        def variableValuesMap = new RawVariables(["foo": null])
+        def variableValuesMap = RawVariables.of(["foo": null])
 
         when:
         resolver.coerceVariableValues(schema, [fooVarDef], variableValuesMap)
@@ -494,7 +494,7 @@ class ValuesResolverTest extends Specification {
         def type = new ListType(new NonNullType(new TypeName("String")))
         VariableDefinition fooVarDef = new VariableDefinition("foo", type, defaultValueForFoo)
 
-        def variableValuesMap = new RawVariables(["foo": [null]])
+        def variableValuesMap = RawVariables.of(["foo": [null]])
 
         when:
         resolver.coerceVariableValues(schema, [fooVarDef], variableValuesMap)
@@ -533,7 +533,7 @@ class ValuesResolverTest extends Specification {
         def argument = new Argument("arg", new VariableReference("var"))
 
         when:
-        def variables = new CoercedVariables(["var": null])
+        def variables = CoercedVariables.of(["var": null])
         def values = resolver.getArgumentValues([fieldArgument], [argument], variables)
 
         then:
@@ -550,7 +550,7 @@ class ValuesResolverTest extends Specification {
         def argument = new Argument("arg", new VariableReference("var"))
 
         when:
-        def variables = new CoercedVariables(["var": null])
+        def variables = CoercedVariables.of(["var": null])
         resolver.getArgumentValues([fieldArgument], [argument], variables)
 
         then: