Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 8 additions & 2 deletions src/main/java/graphql/execution/directives/QueryDirectives.java
Original file line number Diff line number Diff line change
Expand Up @@ -74,10 +74,16 @@ public interface QueryDirectives {
/**
* 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
* Normalized arguments are computed lazily when this method is called. Ordinary directive lookups do not
* request normalized variables or compute normalized arguments.
* <p>
* Variable values in normalized form are supplied during execution and by the raw-variable methods of
* {@link graphql.normalized.ExecutableNormalizedOperationFactory}. The factory's coerced-variable methods
* do not supply them, so requesting normalized arguments for their directives throws an assertion exception.
* Fields without directives return an empty map without requesting normalized variables.
*
* @return a map of applied directive to named argument values
* @throws graphql.AssertException if directives are present but normalized variables are unavailable
*/
Map<QueryAppliedDirective, Map<String, NormalizedInputValue>> getNormalizedInputValueByImmediateAppliedDirectives();

Expand Down
128 changes: 64 additions & 64 deletions src/main/java/graphql/execution/directives/QueryDirectivesImpl.java
Original file line number Diff line number Diff line change
@@ -1,7 +1,6 @@
package graphql.execution.directives;

import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import graphql.GraphQLContext;
Expand All @@ -13,12 +12,11 @@
import graphql.language.Directive;
import graphql.language.Field;
import graphql.normalized.NormalizedInputValue;
import graphql.schema.GraphQLArgument;
import graphql.schema.GraphQLDirective;
import graphql.schema.GraphQLSchema;
import graphql.util.FpKit;
import graphql.util.LockKit;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
Expand All @@ -27,6 +25,7 @@

import static graphql.Assert.assertNotNull;
import static graphql.collect.ImmutableKit.emptyList;
import static graphql.collect.ImmutableKit.emptyMap;

/**
* These objects are ALWAYS in the context of a single MergedField
Expand All @@ -49,7 +48,9 @@ public class QueryDirectivesImpl implements QueryDirectives {
private volatile ImmutableMap<String, List<GraphQLDirective>> fieldDirectivesByName;
private volatile ImmutableMap<Field, List<QueryAppliedDirective>> fieldAppliedDirectivesByField;
private volatile ImmutableMap<String, List<QueryAppliedDirective>> fieldAppliedDirectivesByName;
private volatile ImmutableMap<QueryAppliedDirective, Map<String, NormalizedInputValue>> normalizedValuesByAppliedDirective;
private volatile ImmutableMap<QueryAppliedDirective, Directive> astDirectivesByAppliedDirective;
private final Supplier<Map<QueryAppliedDirective, Map<String, NormalizedInputValue>>> normalizedValuesByAppliedDirective =
FpKit.interThreadMemoize(this::computeNormalizedValues);

public QueryDirectivesImpl(MergedField mergedField, GraphQLSchema schema, CoercedVariables coercedVariables, Supplier<NormalizedVariables> normalizedVariableValues, GraphQLContext graphQLContext, Locale locale) {
this.mergedField = assertNotNull(mergedField);
Expand All @@ -61,68 +62,68 @@ public QueryDirectivesImpl(MergedField mergedField, GraphQLSchema schema, Coerce
}

private void computeValuesLazily() {
computedOnce.runOnce(() -> {

final Map<Field, List<GraphQLDirective>> byField = new LinkedHashMap<>();
final Map<Field, List<QueryAppliedDirective>> byFieldApplied = new LinkedHashMap<>();

BiMap<GraphQLDirective, Directive> directiveCounterParts = HashBiMap.create();
BiMap<GraphQLDirective, QueryAppliedDirective> gqlDirectiveCounterParts = HashBiMap.create();
BiMap<QueryAppliedDirective, GraphQLDirective> gqlDirectiveCounterPartsInverse = gqlDirectiveCounterParts.inverse();
mergedField.forEach(field -> {
List<Directive> directives = field.getDirectives();
BiMap<GraphQLDirective, Directive> directivesMap = directivesResolver
.resolveDirectives(directives, schema, coercedVariables, graphQLContext, locale);

directiveCounterParts.putAll(directivesMap);

ImmutableList<GraphQLDirective> resolvedDirectives = ImmutableList.copyOf(directivesMap.keySet());

ImmutableList.Builder<QueryAppliedDirective> appliedDirectiveBuilder = ImmutableList.builder();
for (GraphQLDirective resolvedDirective : resolvedDirectives) {
QueryAppliedDirective appliedDirective = directivesResolver.toAppliedDirective(resolvedDirective);
appliedDirectiveBuilder.add(appliedDirective);
gqlDirectiveCounterParts.put(resolvedDirective, appliedDirective);
}
byField.put(field, resolvedDirectives);
// at some point we will only use applied
byFieldApplied.put(field, appliedDirectiveBuilder.build());
computedOnce.runOnce(this::computeDirectiveValues);
}

private void computeDirectiveValues() {
Map<Field, List<GraphQLDirective>> byField = new LinkedHashMap<>();
Map<Field, List<QueryAppliedDirective>> byFieldApplied = new LinkedHashMap<>();
Map<QueryAppliedDirective, Directive> astDirectives = new LinkedHashMap<>();

mergedField.forEach(field -> {
BiMap<GraphQLDirective, Directive> directivesMap = directivesResolver
.resolveDirectives(field.getDirectives(), schema, coercedVariables, graphQLContext, locale);
byField.put(field, ImmutableList.copyOf(directivesMap.keySet()));

ImmutableList.Builder<QueryAppliedDirective> appliedDirectiveBuilder = ImmutableList.builder();
directivesMap.forEach((resolvedDirective, astDirective) -> {
QueryAppliedDirective appliedDirective = directivesResolver.toAppliedDirective(resolvedDirective);
appliedDirectiveBuilder.add(appliedDirective);
astDirectives.put(appliedDirective, astDirective);
});
byFieldApplied.put(field, appliedDirectiveBuilder.build());
});

Map<String, List<GraphQLDirective>> byName = new LinkedHashMap<>();
Map<String, List<QueryAppliedDirective>> byNameApplied = new LinkedHashMap<>();
byField.forEach((field, directiveList) -> directiveList.forEach(directive -> {
String name = directive.getName();
byName.computeIfAbsent(name, k -> new ArrayList<>()).add(directive);
// at some point we will only use applied
QueryAppliedDirective appliedDirective = gqlDirectiveCounterParts.get(directive);
byNameApplied.computeIfAbsent(name, k -> new ArrayList<>()).add(appliedDirective);
}));

// create NormalizedInputValue values for directive arguments
Map<QueryAppliedDirective, Map<String, NormalizedInputValue>> normalizedValuesByAppliedDirective = new LinkedHashMap<>();
NormalizedVariables normalizedVariableValues = this.normalizedVariableValues.get();
if (normalizedVariableValues != null) {
byNameApplied.values().forEach(directiveList -> {
for (QueryAppliedDirective queryAppliedDirective : directiveList) {
GraphQLDirective graphQLDirective = gqlDirectiveCounterPartsInverse.get(queryAppliedDirective);
// we need this counterpart because the ValuesResolver needs the runtime and AST element
Directive directive = directiveCounterParts.get(graphQLDirective);
if (directive != null) {
Map<String, NormalizedInputValue> normalizedVariables = normalizedVariableValues.toMap();
Map<String, NormalizedInputValue> normalizedArgumentValues = ValuesResolver.getNormalizedArgumentValues(graphQLDirective.getArguments(), directive.getArguments(), normalizedVariables);
normalizedValuesByAppliedDirective.put(queryAppliedDirective, normalizedArgumentValues);
}
}
});
Map<String, List<GraphQLDirective>> byName = new LinkedHashMap<>();
for (List<GraphQLDirective> directives : byField.values()) {
for (GraphQLDirective directive : directives) {
byName.computeIfAbsent(directive.getName(), FpKit.newList()).add(directive);
}
}
Map<String, List<QueryAppliedDirective>> byNameApplied = new LinkedHashMap<>();
for (List<QueryAppliedDirective> directives : byFieldApplied.values()) {
for (QueryAppliedDirective directive : directives) {
byNameApplied.computeIfAbsent(directive.getName(), FpKit.newList()).add(directive);
}
}

this.fieldDirectivesByName = ImmutableMap.copyOf(byName);
this.fieldDirectivesByField = ImmutableMap.copyOf(byField);
this.fieldAppliedDirectivesByName = ImmutableMap.copyOf(byNameApplied);
this.fieldAppliedDirectivesByField = ImmutableMap.copyOf(byFieldApplied);
this.normalizedValuesByAppliedDirective = ImmutableMap.copyOf(normalizedValuesByAppliedDirective);
});
this.fieldDirectivesByName = ImmutableMap.copyOf(byName);
this.fieldDirectivesByField = ImmutableMap.copyOf(byField);
this.fieldAppliedDirectivesByName = ImmutableMap.copyOf(byNameApplied);
this.fieldAppliedDirectivesByField = ImmutableMap.copyOf(byFieldApplied);
this.astDirectivesByAppliedDirective = ImmutableMap.copyOf(astDirectives);
}

private Map<QueryAppliedDirective, Map<String, NormalizedInputValue>> computeNormalizedValues() {
computeValuesLazily();
if (astDirectivesByAppliedDirective.isEmpty()) {
return emptyMap();
}
NormalizedVariables normalizedVariables = assertNotNull(normalizedVariableValues.get(),
"Normalized variables are required to compute normalized directive arguments");

Map<QueryAppliedDirective, Map<String, NormalizedInputValue>> result = new LinkedHashMap<>();
Map<String, NormalizedInputValue> variables = normalizedVariables.toMap();
fieldAppliedDirectivesByName.values().forEach(directives -> directives.forEach(directive ->
result.put(directive, normalizeDirectiveArguments(directive, variables))));
return ImmutableMap.copyOf(result);
}

private Map<String, NormalizedInputValue> normalizeDirectiveArguments(QueryAppliedDirective directive,
Map<String, NormalizedInputValue> variables) {
Directive astDirective = assertNotNull(astDirectivesByAppliedDirective.get(directive));
GraphQLDirective definition = assertNotNull(schema.getDirective(directive.getName()));
return ValuesResolver.getNormalizedArgumentValues(definition.getArguments(), astDirective.getArguments(), variables);
}


Expand All @@ -140,8 +141,7 @@ public Map<Field, List<QueryAppliedDirective>> getImmediateAppliedDirectivesByFi

@Override
public Map<QueryAppliedDirective, Map<String, NormalizedInputValue>> getNormalizedInputValueByImmediateAppliedDirectives() {
computeValuesLazily();
return normalizedValuesByAppliedDirective;
return normalizedValuesByAppliedDirective.get();
}

@Override
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -6,9 +6,12 @@ import graphql.execution.CoercedVariables
import graphql.execution.MergedField
import graphql.execution.NormalizedVariables
import graphql.language.IntValue
import graphql.language.StringValue
import graphql.normalized.NormalizedInputValue
import spock.lang.Specification

import java.util.function.Supplier

import static graphql.language.AstPrinter.printAst

class QueryDirectivesImplTest extends Specification {
Expand Down Expand Up @@ -73,6 +76,114 @@ class QueryDirectivesImplTest extends Specification {
appliedResult[1].getArgument("forMillis").getValue() == 10
}

def "ordinary directive lookup does not request normalized variables: #getter"() {
def normalizedVariables = Mock(Supplier)
def queryDirectives = QueryDirectives.newQueryDirectives()
.field(TestUtil.parseField('f @cached(forMillis: $var)'))
.schema(schema)
.coercedVariables(CoercedVariables.of([var: 10]))
.normalizedVariables(normalizedVariables)
.build()

when:
def result = queryDirectives."$getter"(*arguments)

then:
!result.isEmpty()
0 * normalizedVariables.get()

where:
getter | arguments
"getImmediateDirectivesByName" | []
"getImmediateDirectivesByField" | []
"getImmediateDirective" | ["cached"]
"getImmediateAppliedDirectivesByName" | []
"getImmediateAppliedDirectivesByField" | []
"getImmediateAppliedDirective" | ["cached"]
}

def "normalized directives reuse resolved instances and are cached with normalized first: #normalizedFirst"() {
def firstField = TestUtil.parseField('f @rep(place: $var) @cached @rep(place: "HELLO")')
def secondField = TestUtil.parseField('f @rep(place: "second")')
int normalizations = 0
def queryDirectives = QueryDirectives.newQueryDirectives()
.mergedField(MergedField.newMergedField([firstField, secondField]).build())
.schema(schema)
.coercedVariables(CoercedVariables.of([var: "ABC"]))
.normalizedVariables({
normalizations++
NormalizedVariables.of([var: new NormalizedInputValue("String", StringValue.of("ABC"))])
})
.build()

when:
def firstResult = normalizedFirst ? queryDirectives.getNormalizedInputValueByImmediateAppliedDirectives() :
queryDirectives.getImmediateAppliedDirectivesByName()

then:
normalizations == (normalizedFirst ? 1 : 0)

when:
def normalized = queryDirectives.getNormalizedInputValueByImmediateAppliedDirectives()
def applied = queryDirectives.getImmediateAppliedDirectivesByName()

then:
normalizations == 1
normalized.keySet().toList() == applied.values().flatten()
applied.rep.collect { normalized[it].place.typeName } == ["String", "String", "String"]
applied.rep.collect { printAst(normalized[it].place.value) } == ['"ABC"', '"HELLO"', '"second"']
normalized[applied.cached[0]] == [:]
applied.cached[0].getArgument("forMillis").getValue() == 99
queryDirectives.getImmediateAppliedDirectivesByField()[firstField] == [applied.rep[0], applied.cached[0], applied.rep[1]]
queryDirectives.getImmediateAppliedDirectivesByField()[secondField] == [applied.rep[2]]
queryDirectives.getNormalizedInputValueByImmediateAppliedDirectives().is(normalized)
firstResult.is(normalizedFirst ? normalized : applied)
normalizations == 1

where:
normalizedFirst << [true, false]
}

def "fields without directives do not request normalized variables even for normalized lookup"() {
def normalizedVariables = Mock(Supplier)
def queryDirectives = QueryDirectives.newQueryDirectives()
.field(TestUtil.parseField("f"))
.schema(schema)
.normalizedVariables(normalizedVariables)
.build()

when:
def normalized = queryDirectives.getNormalizedInputValueByImmediateAppliedDirectives()
def applied = queryDirectives.getImmediateAppliedDirectivesByName()

then:
normalized.isEmpty()
applied.isEmpty()
0 * normalizedVariables.get()
}

def "a failed normalized lookup leaves ordinary directive values available"() {
def queryDirectives = QueryDirectives.newQueryDirectives()
.field(TestUtil.parseField('f @cached(forMillis: $var)'))
.schema(schema)
.coercedVariables(CoercedVariables.of([var: 10]))
.normalizedVariables({ throw new UnsupportedOperationException("valueToLiteral is not supported") })
.build()

when:
queryDirectives.getNormalizedInputValueByImmediateAppliedDirectives()

then:
thrown(UnsupportedOperationException)

when:
def applied = queryDirectives.getImmediateAppliedDirective("cached")

then:
applied[0].getArgument("forMillis").getValue() == 10
queryDirectives.getImmediateDirective("cached")[0].getArgument("forMillis").getArgumentValue().value == 10
}

def "builder works as expected"() {
def f1 = TestUtil.parseField("f1 @cached @upper")
def f2 = TestUtil.parseField("f2 @cached(forMillis : \$var) @timeout")
Expand All @@ -95,6 +206,22 @@ class QueryDirectivesImplTest extends Specification {
appliedDirectivesByName.keySet().sort() == ["cached", "timeout", "upper"]
}

def "builder normalizes literal directive arguments without variable configuration"() {
def queryDirectives = QueryDirectives.newQueryDirectives()
.field(TestUtil.parseField('f @cached(forMillis: 15)'))
.schema(schema)
.build()

when:
def normalized = queryDirectives.getNormalizedInputValueByImmediateAppliedDirectives()
def applied = queryDirectives.getImmediateAppliedDirective("cached")[0]

then:
normalized[applied].forMillis.typeName == "Int"
printAst(normalized[applied].forMillis.value) == "15"
applied.getArgument("forMillis").getValue() == 15
}

def "gets repeated definitions"() {
def f1 = TestUtil.parseField("f1 @rep(place: \$var) @rep(place: \"HELLO\")")

Expand Down
Loading
Loading