Skip to content

Commit a0ddff6

Browse files
authored
Separate normalized directive computation from ordinary lookup (#4560)
* Compute normalized directive arguments only when requested * Cover normalized directive literals with default builder variables * Assert when normalized directive variables are unavailable
1 parent cb0eced commit a0ddff6

4 files changed

Lines changed: 277 additions & 66 deletions

File tree

‎src/main/java/graphql/execution/directives/QueryDirectives.java‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -74,10 +74,16 @@ public interface QueryDirectives {
7474
/**
7575
* This will return a map of {@link QueryAppliedDirective} to a map of their argument values in {@link NormalizedInputValue} form
7676
* <p>
77-
* NOTE : This will only be available when {@link graphql.normalized.ExecutableNormalizedOperationFactory} is used
78-
* to create the {@link QueryAppliedDirective} information
77+
* Normalized arguments are computed lazily when this method is called. Ordinary directive lookups do not
78+
* request normalized variables or compute normalized arguments.
79+
* <p>
80+
* Variable values in normalized form are supplied during execution and by the raw-variable methods of
81+
* {@link graphql.normalized.ExecutableNormalizedOperationFactory}. The factory's coerced-variable methods
82+
* do not supply them, so requesting normalized arguments for their directives throws an assertion exception.
83+
* Fields without directives return an empty map without requesting normalized variables.
7984
*
8085
* @return a map of applied directive to named argument values
86+
* @throws graphql.AssertException if directives are present but normalized variables are unavailable
8187
*/
8288
Map<QueryAppliedDirective, Map<String, NormalizedInputValue>> getNormalizedInputValueByImmediateAppliedDirectives();
8389

‎src/main/java/graphql/execution/directives/QueryDirectivesImpl.java‎

Lines changed: 64 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
11
package graphql.execution.directives;
22

33
import com.google.common.collect.BiMap;
4-
import com.google.common.collect.HashBiMap;
54
import com.google.common.collect.ImmutableList;
65
import com.google.common.collect.ImmutableMap;
76
import graphql.GraphQLContext;
@@ -13,12 +12,11 @@
1312
import graphql.language.Directive;
1413
import graphql.language.Field;
1514
import graphql.normalized.NormalizedInputValue;
16-
import graphql.schema.GraphQLArgument;
1715
import graphql.schema.GraphQLDirective;
1816
import graphql.schema.GraphQLSchema;
17+
import graphql.util.FpKit;
1918
import graphql.util.LockKit;
2019

21-
import java.util.ArrayList;
2220
import java.util.LinkedHashMap;
2321
import java.util.List;
2422
import java.util.Locale;
@@ -27,6 +25,7 @@
2725

2826
import static graphql.Assert.assertNotNull;
2927
import static graphql.collect.ImmutableKit.emptyList;
28+
import static graphql.collect.ImmutableKit.emptyMap;
3029

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

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

6364
private void computeValuesLazily() {
64-
computedOnce.runOnce(() -> {
65-
66-
final Map<Field, List<GraphQLDirective>> byField = new LinkedHashMap<>();
67-
final Map<Field, List<QueryAppliedDirective>> byFieldApplied = new LinkedHashMap<>();
68-
69-
BiMap<GraphQLDirective, Directive> directiveCounterParts = HashBiMap.create();
70-
BiMap<GraphQLDirective, QueryAppliedDirective> gqlDirectiveCounterParts = HashBiMap.create();
71-
BiMap<QueryAppliedDirective, GraphQLDirective> gqlDirectiveCounterPartsInverse = gqlDirectiveCounterParts.inverse();
72-
mergedField.forEach(field -> {
73-
List<Directive> directives = field.getDirectives();
74-
BiMap<GraphQLDirective, Directive> directivesMap = directivesResolver
75-
.resolveDirectives(directives, schema, coercedVariables, graphQLContext, locale);
76-
77-
directiveCounterParts.putAll(directivesMap);
78-
79-
ImmutableList<GraphQLDirective> resolvedDirectives = ImmutableList.copyOf(directivesMap.keySet());
80-
81-
ImmutableList.Builder<QueryAppliedDirective> appliedDirectiveBuilder = ImmutableList.builder();
82-
for (GraphQLDirective resolvedDirective : resolvedDirectives) {
83-
QueryAppliedDirective appliedDirective = directivesResolver.toAppliedDirective(resolvedDirective);
84-
appliedDirectiveBuilder.add(appliedDirective);
85-
gqlDirectiveCounterParts.put(resolvedDirective, appliedDirective);
86-
}
87-
byField.put(field, resolvedDirectives);
88-
// at some point we will only use applied
89-
byFieldApplied.put(field, appliedDirectiveBuilder.build());
65+
computedOnce.runOnce(this::computeDirectiveValues);
66+
}
67+
68+
private void computeDirectiveValues() {
69+
Map<Field, List<GraphQLDirective>> byField = new LinkedHashMap<>();
70+
Map<Field, List<QueryAppliedDirective>> byFieldApplied = new LinkedHashMap<>();
71+
Map<QueryAppliedDirective, Directive> astDirectives = new LinkedHashMap<>();
72+
73+
mergedField.forEach(field -> {
74+
BiMap<GraphQLDirective, Directive> directivesMap = directivesResolver
75+
.resolveDirectives(field.getDirectives(), schema, coercedVariables, graphQLContext, locale);
76+
byField.put(field, ImmutableList.copyOf(directivesMap.keySet()));
77+
78+
ImmutableList.Builder<QueryAppliedDirective> appliedDirectiveBuilder = ImmutableList.builder();
79+
directivesMap.forEach((resolvedDirective, astDirective) -> {
80+
QueryAppliedDirective appliedDirective = directivesResolver.toAppliedDirective(resolvedDirective);
81+
appliedDirectiveBuilder.add(appliedDirective);
82+
astDirectives.put(appliedDirective, astDirective);
9083
});
84+
byFieldApplied.put(field, appliedDirectiveBuilder.build());
85+
});
9186

92-
Map<String, List<GraphQLDirective>> byName = new LinkedHashMap<>();
93-
Map<String, List<QueryAppliedDirective>> byNameApplied = new LinkedHashMap<>();
94-
byField.forEach((field, directiveList) -> directiveList.forEach(directive -> {
95-
String name = directive.getName();
96-
byName.computeIfAbsent(name, k -> new ArrayList<>()).add(directive);
97-
// at some point we will only use applied
98-
QueryAppliedDirective appliedDirective = gqlDirectiveCounterParts.get(directive);
99-
byNameApplied.computeIfAbsent(name, k -> new ArrayList<>()).add(appliedDirective);
100-
}));
101-
102-
// create NormalizedInputValue values for directive arguments
103-
Map<QueryAppliedDirective, Map<String, NormalizedInputValue>> normalizedValuesByAppliedDirective = new LinkedHashMap<>();
104-
NormalizedVariables normalizedVariableValues = this.normalizedVariableValues.get();
105-
if (normalizedVariableValues != null) {
106-
byNameApplied.values().forEach(directiveList -> {
107-
for (QueryAppliedDirective queryAppliedDirective : directiveList) {
108-
GraphQLDirective graphQLDirective = gqlDirectiveCounterPartsInverse.get(queryAppliedDirective);
109-
// we need this counterpart because the ValuesResolver needs the runtime and AST element
110-
Directive directive = directiveCounterParts.get(graphQLDirective);
111-
if (directive != null) {
112-
Map<String, NormalizedInputValue> normalizedVariables = normalizedVariableValues.toMap();
113-
Map<String, NormalizedInputValue> normalizedArgumentValues = ValuesResolver.getNormalizedArgumentValues(graphQLDirective.getArguments(), directive.getArguments(), normalizedVariables);
114-
normalizedValuesByAppliedDirective.put(queryAppliedDirective, normalizedArgumentValues);
115-
}
116-
}
117-
});
87+
Map<String, List<GraphQLDirective>> byName = new LinkedHashMap<>();
88+
for (List<GraphQLDirective> directives : byField.values()) {
89+
for (GraphQLDirective directive : directives) {
90+
byName.computeIfAbsent(directive.getName(), FpKit.newList()).add(directive);
11891
}
92+
}
93+
Map<String, List<QueryAppliedDirective>> byNameApplied = new LinkedHashMap<>();
94+
for (List<QueryAppliedDirective> directives : byFieldApplied.values()) {
95+
for (QueryAppliedDirective directive : directives) {
96+
byNameApplied.computeIfAbsent(directive.getName(), FpKit.newList()).add(directive);
97+
}
98+
}
11999

120-
this.fieldDirectivesByName = ImmutableMap.copyOf(byName);
121-
this.fieldDirectivesByField = ImmutableMap.copyOf(byField);
122-
this.fieldAppliedDirectivesByName = ImmutableMap.copyOf(byNameApplied);
123-
this.fieldAppliedDirectivesByField = ImmutableMap.copyOf(byFieldApplied);
124-
this.normalizedValuesByAppliedDirective = ImmutableMap.copyOf(normalizedValuesByAppliedDirective);
125-
});
100+
this.fieldDirectivesByName = ImmutableMap.copyOf(byName);
101+
this.fieldDirectivesByField = ImmutableMap.copyOf(byField);
102+
this.fieldAppliedDirectivesByName = ImmutableMap.copyOf(byNameApplied);
103+
this.fieldAppliedDirectivesByField = ImmutableMap.copyOf(byFieldApplied);
104+
this.astDirectivesByAppliedDirective = ImmutableMap.copyOf(astDirectives);
105+
}
106+
107+
private Map<QueryAppliedDirective, Map<String, NormalizedInputValue>> computeNormalizedValues() {
108+
computeValuesLazily();
109+
if (astDirectivesByAppliedDirective.isEmpty()) {
110+
return emptyMap();
111+
}
112+
NormalizedVariables normalizedVariables = assertNotNull(normalizedVariableValues.get(),
113+
"Normalized variables are required to compute normalized directive arguments");
114+
115+
Map<QueryAppliedDirective, Map<String, NormalizedInputValue>> result = new LinkedHashMap<>();
116+
Map<String, NormalizedInputValue> variables = normalizedVariables.toMap();
117+
fieldAppliedDirectivesByName.values().forEach(directives -> directives.forEach(directive ->
118+
result.put(directive, normalizeDirectiveArguments(directive, variables))));
119+
return ImmutableMap.copyOf(result);
120+
}
121+
122+
private Map<String, NormalizedInputValue> normalizeDirectiveArguments(QueryAppliedDirective directive,
123+
Map<String, NormalizedInputValue> variables) {
124+
Directive astDirective = assertNotNull(astDirectivesByAppliedDirective.get(directive));
125+
GraphQLDirective definition = assertNotNull(schema.getDirective(directive.getName()));
126+
return ValuesResolver.getNormalizedArgumentValues(definition.getArguments(), astDirective.getArguments(), variables);
126127
}
127128

128129

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

141142
@Override
142143
public Map<QueryAppliedDirective, Map<String, NormalizedInputValue>> getNormalizedInputValueByImmediateAppliedDirectives() {
143-
computeValuesLazily();
144-
return normalizedValuesByAppliedDirective;
144+
return normalizedValuesByAppliedDirective.get();
145145
}
146146

147147
@Override

‎src/test/groovy/graphql/execution/directives/QueryDirectivesImplTest.groovy‎

Lines changed: 127 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,9 +6,12 @@ import graphql.execution.CoercedVariables
66
import graphql.execution.MergedField
77
import graphql.execution.NormalizedVariables
88
import graphql.language.IntValue
9+
import graphql.language.StringValue
910
import graphql.normalized.NormalizedInputValue
1011
import spock.lang.Specification
1112

13+
import java.util.function.Supplier
14+
1215
import static graphql.language.AstPrinter.printAst
1316

1417
class QueryDirectivesImplTest extends Specification {
@@ -73,6 +76,114 @@ class QueryDirectivesImplTest extends Specification {
7376
appliedResult[1].getArgument("forMillis").getValue() == 10
7477
}
7578

79+
def "ordinary directive lookup does not request normalized variables: #getter"() {
80+
def normalizedVariables = Mock(Supplier)
81+
def queryDirectives = QueryDirectives.newQueryDirectives()
82+
.field(TestUtil.parseField('f @cached(forMillis: $var)'))
83+
.schema(schema)
84+
.coercedVariables(CoercedVariables.of([var: 10]))
85+
.normalizedVariables(normalizedVariables)
86+
.build()
87+
88+
when:
89+
def result = queryDirectives."$getter"(*arguments)
90+
91+
then:
92+
!result.isEmpty()
93+
0 * normalizedVariables.get()
94+
95+
where:
96+
getter | arguments
97+
"getImmediateDirectivesByName" | []
98+
"getImmediateDirectivesByField" | []
99+
"getImmediateDirective" | ["cached"]
100+
"getImmediateAppliedDirectivesByName" | []
101+
"getImmediateAppliedDirectivesByField" | []
102+
"getImmediateAppliedDirective" | ["cached"]
103+
}
104+
105+
def "normalized directives reuse resolved instances and are cached with normalized first: #normalizedFirst"() {
106+
def firstField = TestUtil.parseField('f @rep(place: $var) @cached @rep(place: "HELLO")')
107+
def secondField = TestUtil.parseField('f @rep(place: "second")')
108+
int normalizations = 0
109+
def queryDirectives = QueryDirectives.newQueryDirectives()
110+
.mergedField(MergedField.newMergedField([firstField, secondField]).build())
111+
.schema(schema)
112+
.coercedVariables(CoercedVariables.of([var: "ABC"]))
113+
.normalizedVariables({
114+
normalizations++
115+
NormalizedVariables.of([var: new NormalizedInputValue("String", StringValue.of("ABC"))])
116+
})
117+
.build()
118+
119+
when:
120+
def firstResult = normalizedFirst ? queryDirectives.getNormalizedInputValueByImmediateAppliedDirectives() :
121+
queryDirectives.getImmediateAppliedDirectivesByName()
122+
123+
then:
124+
normalizations == (normalizedFirst ? 1 : 0)
125+
126+
when:
127+
def normalized = queryDirectives.getNormalizedInputValueByImmediateAppliedDirectives()
128+
def applied = queryDirectives.getImmediateAppliedDirectivesByName()
129+
130+
then:
131+
normalizations == 1
132+
normalized.keySet().toList() == applied.values().flatten()
133+
applied.rep.collect { normalized[it].place.typeName } == ["String", "String", "String"]
134+
applied.rep.collect { printAst(normalized[it].place.value) } == ['"ABC"', '"HELLO"', '"second"']
135+
normalized[applied.cached[0]] == [:]
136+
applied.cached[0].getArgument("forMillis").getValue() == 99
137+
queryDirectives.getImmediateAppliedDirectivesByField()[firstField] == [applied.rep[0], applied.cached[0], applied.rep[1]]
138+
queryDirectives.getImmediateAppliedDirectivesByField()[secondField] == [applied.rep[2]]
139+
queryDirectives.getNormalizedInputValueByImmediateAppliedDirectives().is(normalized)
140+
firstResult.is(normalizedFirst ? normalized : applied)
141+
normalizations == 1
142+
143+
where:
144+
normalizedFirst << [true, false]
145+
}
146+
147+
def "fields without directives do not request normalized variables even for normalized lookup"() {
148+
def normalizedVariables = Mock(Supplier)
149+
def queryDirectives = QueryDirectives.newQueryDirectives()
150+
.field(TestUtil.parseField("f"))
151+
.schema(schema)
152+
.normalizedVariables(normalizedVariables)
153+
.build()
154+
155+
when:
156+
def normalized = queryDirectives.getNormalizedInputValueByImmediateAppliedDirectives()
157+
def applied = queryDirectives.getImmediateAppliedDirectivesByName()
158+
159+
then:
160+
normalized.isEmpty()
161+
applied.isEmpty()
162+
0 * normalizedVariables.get()
163+
}
164+
165+
def "a failed normalized lookup leaves ordinary directive values available"() {
166+
def queryDirectives = QueryDirectives.newQueryDirectives()
167+
.field(TestUtil.parseField('f @cached(forMillis: $var)'))
168+
.schema(schema)
169+
.coercedVariables(CoercedVariables.of([var: 10]))
170+
.normalizedVariables({ throw new UnsupportedOperationException("valueToLiteral is not supported") })
171+
.build()
172+
173+
when:
174+
queryDirectives.getNormalizedInputValueByImmediateAppliedDirectives()
175+
176+
then:
177+
thrown(UnsupportedOperationException)
178+
179+
when:
180+
def applied = queryDirectives.getImmediateAppliedDirective("cached")
181+
182+
then:
183+
applied[0].getArgument("forMillis").getValue() == 10
184+
queryDirectives.getImmediateDirective("cached")[0].getArgument("forMillis").getArgumentValue().value == 10
185+
}
186+
76187
def "builder works as expected"() {
77188
def f1 = TestUtil.parseField("f1 @cached @upper")
78189
def f2 = TestUtil.parseField("f2 @cached(forMillis : \$var) @timeout")
@@ -95,6 +206,22 @@ class QueryDirectivesImplTest extends Specification {
95206
appliedDirectivesByName.keySet().sort() == ["cached", "timeout", "upper"]
96207
}
97208

209+
def "builder normalizes literal directive arguments without variable configuration"() {
210+
def queryDirectives = QueryDirectives.newQueryDirectives()
211+
.field(TestUtil.parseField('f @cached(forMillis: 15)'))
212+
.schema(schema)
213+
.build()
214+
215+
when:
216+
def normalized = queryDirectives.getNormalizedInputValueByImmediateAppliedDirectives()
217+
def applied = queryDirectives.getImmediateAppliedDirective("cached")[0]
218+
219+
then:
220+
normalized[applied].forMillis.typeName == "Int"
221+
printAst(normalized[applied].forMillis.value) == "15"
222+
applied.getArgument("forMillis").getValue() == 15
223+
}
224+
98225
def "gets repeated definitions"() {
99226
def f1 = TestUtil.parseField("f1 @rep(place: \$var) @rep(place: \"HELLO\")")
100227

0 commit comments

Comments
 (0)