11package graphql .execution .directives ;
22
33import com .google .common .collect .BiMap ;
4- import com .google .common .collect .HashBiMap ;
54import com .google .common .collect .ImmutableList ;
65import com .google .common .collect .ImmutableMap ;
76import graphql .GraphQLContext ;
1312import graphql .language .Directive ;
1413import graphql .language .Field ;
1514import graphql .normalized .NormalizedInputValue ;
16- import graphql .schema .GraphQLArgument ;
1715import graphql .schema .GraphQLDirective ;
1816import graphql .schema .GraphQLSchema ;
17+ import graphql .util .FpKit ;
1918import graphql .util .LockKit ;
2019
21- import java .util .ArrayList ;
2220import java .util .LinkedHashMap ;
2321import java .util .List ;
2422import java .util .Locale ;
2725
2826import static graphql .Assert .assertNotNull ;
2927import 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
0 commit comments