graphql-java · dondonz · Mar 26, 2024 · Mar 25, 2024 · Mar 25, 2024 · Mar 25, 2024
diff --git a/src/main/java/graphql/Assert.java b/src/main/java/graphql/Assert.java
@@ -85,6 +85,20 @@ public static void assertTrue(boolean condition) {
         throw new AssertException("condition expected to be true");
     }
 
+    public static void assertTrue(boolean condition, String constantMsg) {
+        if (condition) {
+            return;
+        }
+        throwAssert(constantMsg);
+    }
+
+    public static void assertTrue(boolean condition, String msgFmt, Object arg1) {
+        if (condition) {
+            return;
+        }
+        throwAssert(msgFmt, arg1);
+    }
+
     public static void assertFalse(boolean condition, Supplier<String> msg) {
         if (!condition) {
             return;
@@ -117,4 +131,7 @@ public static String assertValidName(String name) {
         throw new AssertException(String.format(invalidNameErrorMessage, name));
     }
 
+    private static <T> T throwAssert(String format, Object... args) {
+        throw new AssertException(format(format, args));
+    }
 }
diff --git a/src/main/java/graphql/analysis/NodeVisitorWithTypeTracking.java b/src/main/java/graphql/analysis/NodeVisitorWithTypeTracking.java
@@ -1,9 +1,10 @@
 package graphql.analysis;
 
+import graphql.GraphQLContext;
 import graphql.Internal;
 import graphql.execution.CoercedVariables;
-import graphql.execution.ConditionalNodes;
 import graphql.execution.ValuesResolver;
+import graphql.execution.conditional.ConditionalNodes;
 import graphql.introspection.Introspection;
 import graphql.language.Argument;
 import graphql.language.Directive;
@@ -66,7 +67,9 @@ public TraversalControl visitDirective(Directive node, TraverserContext<Node> co
 
     @Override
     public TraversalControl visitInlineFragment(InlineFragment inlineFragment, TraverserContext<Node> context) {
-        if (!conditionalNodes.shouldInclude(variables, inlineFragment.getDirectives())) {
+        QueryTraversalContext parentEnv = context.getVarFromParents(QueryTraversalContext.class);
+        GraphQLContext graphQLContext = parentEnv.getGraphQLContext();
+        if (!conditionalNodes.shouldInclude(inlineFragment, variables, null, graphQLContext)) {
             return TraversalControl.ABORT;
         }
 
@@ -80,7 +83,6 @@ public TraversalControl visitInlineFragment(InlineFragment inlineFragment, Trave
         preOrderCallback.visitInlineFragment(inlineFragmentEnvironment);
 
         // inline fragments are allowed not have type conditions, if so the parent type counts
-        QueryTraversalContext parentEnv = context.getVarFromParents(QueryTraversalContext.class);
 
         GraphQLCompositeType fragmentCondition;
         if (inlineFragment.getTypeCondition() != null) {
@@ -90,38 +92,41 @@ public TraversalControl visitInlineFragment(InlineFragment inlineFragment, Trave
             fragmentCondition = parentEnv.getUnwrappedOutputType();
         }
         // for unions we only have other fragments inside
-        context.setVar(QueryTraversalContext.class, new QueryTraversalContext(fragmentCondition, parentEnv.getEnvironment(), inlineFragment));
+        context.setVar(QueryTraversalContext.class, new QueryTraversalContext(fragmentCondition, parentEnv.getEnvironment(), inlineFragment, graphQLContext));
         return TraversalControl.CONTINUE;
     }
 
     @Override
-    public TraversalControl visitFragmentDefinition(FragmentDefinition node, TraverserContext<Node> context) {
-        if (!conditionalNodes.shouldInclude(variables, node.getDirectives())) {
+    public TraversalControl visitFragmentDefinition(FragmentDefinition fragmentDefinition, TraverserContext<Node> context) {
+        QueryTraversalContext parentEnv = context.getVarFromParents(QueryTraversalContext.class);
+        GraphQLContext graphQLContext = parentEnv.getGraphQLContext();
+        if (!conditionalNodes.shouldInclude(fragmentDefinition, variables, null, graphQLContext)) {
             return TraversalControl.ABORT;
         }
 
-        QueryVisitorFragmentDefinitionEnvironment fragmentEnvironment = new QueryVisitorFragmentDefinitionEnvironmentImpl(node, context, schema);
+        QueryVisitorFragmentDefinitionEnvironment fragmentEnvironment = new QueryVisitorFragmentDefinitionEnvironmentImpl(fragmentDefinition, context, schema);
 
         if (context.getPhase() == LEAVE) {
             postOrderCallback.visitFragmentDefinition(fragmentEnvironment);
             return TraversalControl.CONTINUE;
         }
         preOrderCallback.visitFragmentDefinition(fragmentEnvironment);
 
-        QueryTraversalContext parentEnv = context.getVarFromParents(QueryTraversalContext.class);
-        GraphQLCompositeType typeCondition = (GraphQLCompositeType) schema.getType(node.getTypeCondition().getName());
-        context.setVar(QueryTraversalContext.class, new QueryTraversalContext(typeCondition, parentEnv.getEnvironment(), node));
+        GraphQLCompositeType typeCondition = (GraphQLCompositeType) schema.getType(fragmentDefinition.getTypeCondition().getName());
+        context.setVar(QueryTraversalContext.class, new QueryTraversalContext(typeCondition, parentEnv.getEnvironment(), fragmentDefinition, graphQLContext));
         return TraversalControl.CONTINUE;
     }
 
     @Override
     public TraversalControl visitFragmentSpread(FragmentSpread fragmentSpread, TraverserContext<Node> context) {
-        if (!conditionalNodes.shouldInclude(variables, fragmentSpread.getDirectives())) {
+        QueryTraversalContext parentEnv = context.getVarFromParents(QueryTraversalContext.class);
+        GraphQLContext graphQLContext = parentEnv.getGraphQLContext();
+        if (!conditionalNodes.shouldInclude(fragmentSpread, variables, null, graphQLContext)) {
             return TraversalControl.ABORT;
         }
 
         FragmentDefinition fragmentDefinition = fragmentsByName.get(fragmentSpread.getName());
-        if (!conditionalNodes.shouldInclude(variables, fragmentDefinition.getDirectives())) {
+        if (!conditionalNodes.shouldInclude(fragmentDefinition, variables, null, graphQLContext)) {
             return TraversalControl.ABORT;
         }
 
@@ -133,19 +138,19 @@ public TraversalControl visitFragmentSpread(FragmentSpread fragmentSpread, Trave
 
         preOrderCallback.visitFragmentSpread(fragmentSpreadEnvironment);
 
-        QueryTraversalContext parentEnv = context.getVarFromParents(QueryTraversalContext.class);
 
         GraphQLCompositeType typeCondition = (GraphQLCompositeType) schema.getType(fragmentDefinition.getTypeCondition().getName());
         assertNotNull(typeCondition,
                 () -> format("Invalid type condition '%s' in fragment '%s'", fragmentDefinition.getTypeCondition().getName(),
                         fragmentDefinition.getName()));
-        context.setVar(QueryTraversalContext.class, new QueryTraversalContext(typeCondition, parentEnv.getEnvironment(), fragmentDefinition));
+        context.setVar(QueryTraversalContext.class, new QueryTraversalContext(typeCondition, parentEnv.getEnvironment(), fragmentDefinition, graphQLContext));
         return TraversalControl.CONTINUE;
     }
 
     @Override
     public TraversalControl visitField(Field field, TraverserContext<Node> context) {
         QueryTraversalContext parentEnv = context.getVarFromParents(QueryTraversalContext.class);
+        GraphQLContext graphQLContext = parentEnv.getGraphQLContext();
 
         GraphQLFieldDefinition fieldDefinition = Introspection.getFieldDef(schema, (GraphQLCompositeType) unwrapAll(parentEnv.getOutputType()), field.getName());
         boolean isTypeNameIntrospectionField = fieldDefinition == schema.getIntrospectionTypenameFieldDefinition();
@@ -167,16 +172,16 @@ public TraversalControl visitField(Field field, TraverserContext<Node> context)
             return TraversalControl.CONTINUE;
         }
 
-        if (!conditionalNodes.shouldInclude(variables, field.getDirectives())) {
+        if (!conditionalNodes.shouldInclude(field, variables, null, graphQLContext)) {
             return TraversalControl.ABORT;
         }
 
         TraversalControl traversalControl = preOrderCallback.visitFieldWithControl(environment);
 
         GraphQLUnmodifiedType unmodifiedType = unwrapAll(fieldDefinition.getType());
         QueryTraversalContext fieldEnv = (unmodifiedType instanceof GraphQLCompositeType)
-                ? new QueryTraversalContext(fieldDefinition.getType(), environment, field)
-                : new QueryTraversalContext(null, environment, field);// Terminal (scalar) node, EMPTY FRAME
+                ? new QueryTraversalContext(fieldDefinition.getType(), environment, field, graphQLContext)
+                : new QueryTraversalContext(null, environment, field, graphQLContext);// Terminal (scalar) node, EMPTY FRAME
 
 
         context.setVar(QueryTraversalContext.class, fieldEnv);
@@ -252,4 +257,4 @@ protected TraversalControl visitValue(Value<?> value, TraverserContext<Node> con
         }
         return preOrderCallback.visitArgumentValue(environment);
     }
-}
+}
diff --git a/src/main/java/graphql/analysis/QueryTransformer.java b/src/main/java/graphql/analysis/QueryTransformer.java
@@ -1,5 +1,6 @@
 package graphql.analysis;
 
+import graphql.GraphQLContext;
 import graphql.PublicApi;
 import graphql.language.FragmentDefinition;
 import graphql.language.Node;
@@ -67,7 +68,7 @@ public Node transform(QueryVisitor queryVisitor) {
         NodeVisitorWithTypeTracking nodeVisitor = new NodeVisitorWithTypeTracking(queryVisitor, noOp, variables, schema, fragmentsByName);
 
         Map<Class<?>, Object> rootVars = new LinkedHashMap<>();
-        rootVars.put(QueryTraversalContext.class, new QueryTraversalContext(rootParentType, null, null));
+        rootVars.put(QueryTraversalContext.class, new QueryTraversalContext(rootParentType, null, null, GraphQLContext.getDefault()));
 
         TraverserVisitor<Node> nodeTraverserVisitor = new TraverserVisitor<Node>() {
 
@@ -163,4 +164,4 @@ public QueryTransformer build() {
             return new QueryTransformer(schema, root, rootParentType, fragmentsByName, variables);
         }
     }
-}
+}
diff --git a/src/main/java/graphql/analysis/QueryTraversalContext.java b/src/main/java/graphql/analysis/QueryTraversalContext.java
@@ -1,5 +1,6 @@
 package graphql.analysis;
 
+import graphql.GraphQLContext;
 import graphql.Internal;
 import graphql.language.SelectionSetContainer;
 import graphql.schema.GraphQLCompositeType;
@@ -16,14 +17,17 @@ class QueryTraversalContext {
     // never used for scalars/enums, always a possibly wrapped composite type
     private final GraphQLOutputType outputType;
     private final QueryVisitorFieldEnvironment environment;
-    private final SelectionSetContainer selectionSetContainer;
+    private final SelectionSetContainer<?> selectionSetContainer;
+    private final GraphQLContext graphQLContext;
 
     QueryTraversalContext(GraphQLOutputType outputType,
                           QueryVisitorFieldEnvironment environment,
-                          SelectionSetContainer selectionSetContainer) {
+                          SelectionSetContainer<?> selectionSetContainer,
+                          GraphQLContext graphQLContext) {
         this.outputType = outputType;
         this.environment = environment;
         this.selectionSetContainer = selectionSetContainer;
+        this.graphQLContext = graphQLContext;
     }
 
     public GraphQLOutputType getOutputType() {
@@ -34,13 +38,15 @@ public GraphQLCompositeType getUnwrappedOutputType() {
         return (GraphQLCompositeType) GraphQLTypeUtil.unwrapAll(outputType);
     }
 
-
     public QueryVisitorFieldEnvironment getEnvironment() {
         return environment;
     }
 
-    public SelectionSetContainer getSelectionSetContainer() {
-
+    public SelectionSetContainer<?> getSelectionSetContainer() {
         return selectionSetContainer;
     }
-}
+
+    public GraphQLContext getGraphQLContext() {
+        return graphQLContext;
+    }
+}
diff --git a/src/main/java/graphql/analysis/QueryTraverser.java b/src/main/java/graphql/analysis/QueryTraverser.java
@@ -1,5 +1,6 @@
 package graphql.analysis;
 
+import graphql.GraphQLContext;
 import graphql.PublicApi;
 import graphql.execution.CoercedVariables;
 import graphql.execution.RawVariables;
@@ -175,7 +176,7 @@ private List<Node> childrenOf(Node<?> node) {
 
     private Object visitImpl(QueryVisitor visitFieldCallback, Boolean preOrder) {
         Map<Class<?>, Object> rootVars = new LinkedHashMap<>();
-        rootVars.put(QueryTraversalContext.class, new QueryTraversalContext(rootParentType, null, null));
+        rootVars.put(QueryTraversalContext.class, new QueryTraversalContext(rootParentType, null, null, GraphQLContext.getDefault()));
 
         QueryVisitor preOrderCallback;
         QueryVisitor postOrderCallback;
@@ -341,4 +342,4 @@ private void checkState() {
         }
 
     }
-}
+}
diff --git a/src/main/java/graphql/execution/ExecutionContext.java b/src/main/java/graphql/execution/ExecutionContext.java
@@ -80,7 +80,7 @@ public class ExecutionContext {
         this.errors.set(builder.errors);
         this.localContext = builder.localContext;
         this.executionInput = builder.executionInput;
-        queryTree = FpKit.interThreadMemoize(() -> ExecutableNormalizedOperationFactory.createExecutableNormalizedOperation(graphQLSchema, operationDefinition, fragmentsByName, coercedVariables));
+        this.queryTree = FpKit.interThreadMemoize(() -> ExecutableNormalizedOperationFactory.createExecutableNormalizedOperation(graphQLSchema, operationDefinition, fragmentsByName, coercedVariables));
     }
 
 

diff --git a/src/main/java/graphql/execution/FieldCollector.java b/src/main/java/graphql/execution/FieldCollector.java
@@ -2,6 +2,7 @@
 
 
 import graphql.Internal;
+import graphql.execution.conditional.ConditionalNodes;
 import graphql.language.Field;
 import graphql.language.FragmentDefinition;
 import graphql.language.FragmentSpread;
@@ -76,13 +77,19 @@ private void collectFragmentSpread(FieldCollectorParameters parameters, Set<Stri
         if (visitedFragments.contains(fragmentSpread.getName())) {
             return;
         }
-        if (!conditionalNodes.shouldInclude(parameters.getVariables(), fragmentSpread.getDirectives())) {
+        if (!conditionalNodes.shouldInclude(fragmentSpread,
+                parameters.getVariables(),
+                parameters.getGraphQLSchema(),
+                parameters.getGraphQLContext())) {
             return;
         }
         visitedFragments.add(fragmentSpread.getName());
         FragmentDefinition fragmentDefinition = parameters.getFragmentsByName().get(fragmentSpread.getName());
 
-        if (!conditionalNodes.shouldInclude(parameters.getVariables(), fragmentDefinition.getDirectives())) {
+        if (!conditionalNodes.shouldInclude(fragmentDefinition,
+                parameters.getVariables(),
+                parameters.getGraphQLSchema(),
+                parameters.getGraphQLContext())) {
             return;
         }
         if (!doesFragmentConditionMatch(parameters, fragmentDefinition)) {
@@ -92,15 +99,21 @@ private void collectFragmentSpread(FieldCollectorParameters parameters, Set<Stri
     }
 
     private void collectInlineFragment(FieldCollectorParameters parameters, Set<String> visitedFragments, Map<String, MergedField> fields, InlineFragment inlineFragment) {
-        if (!conditionalNodes.shouldInclude(parameters.getVariables(), inlineFragment.getDirectives()) ||
+        if (!conditionalNodes.shouldInclude(inlineFragment,
+                parameters.getVariables(),
+                parameters.getGraphQLSchema(),
+                parameters.getGraphQLContext()) ||
                 !doesFragmentConditionMatch(parameters, inlineFragment)) {
             return;
         }
         collectFields(parameters, inlineFragment.getSelectionSet(), visitedFragments, fields);
     }
 
     private void collectField(FieldCollectorParameters parameters, Map<String, MergedField> fields, Field field) {
-        if (!conditionalNodes.shouldInclude(parameters.getVariables(), field.getDirectives())) {
+        if (!conditionalNodes.shouldInclude(field,
+                parameters.getVariables(),
+                parameters.getGraphQLSchema(),
+                parameters.getGraphQLContext())) {
             return;
         }
         String name = field.getResultKey();
@@ -143,4 +156,4 @@ private boolean checkTypeCondition(FieldCollectorParameters parameters, GraphQLT
     }
 
 
-}
+}
diff --git a/src/main/java/graphql/execution/FieldCollectorParameters.java b/src/main/java/graphql/execution/FieldCollectorParameters.java
@@ -1,6 +1,7 @@
 package graphql.execution;
 
 import graphql.Assert;
+import graphql.GraphQLContext;
 import graphql.Internal;
 import graphql.language.FragmentDefinition;
 import graphql.schema.GraphQLObjectType;
@@ -17,6 +18,7 @@ public class FieldCollectorParameters {
     private final Map<String, FragmentDefinition> fragmentsByName;
     private final Map<String, Object> variables;
     private final GraphQLObjectType objectType;
+    private final GraphQLContext graphQLContext;
 
     public GraphQLSchema getGraphQLSchema() {
         return graphQLSchema;
@@ -34,11 +36,16 @@ public GraphQLObjectType getObjectType() {
         return objectType;
     }
 
-    private FieldCollectorParameters(GraphQLSchema graphQLSchema, Map<String, Object> variables, Map<String, FragmentDefinition> fragmentsByName, GraphQLObjectType objectType) {
-        this.fragmentsByName = fragmentsByName;
-        this.graphQLSchema = graphQLSchema;
-        this.variables = variables;
-        this.objectType = objectType;
+    public GraphQLContext getGraphQLContext() {
+        return graphQLContext;
+    }
+
+    private FieldCollectorParameters(Builder builder) {
+        this.fragmentsByName = builder.fragmentsByName;
+        this.graphQLSchema = builder.graphQLSchema;
+        this.variables = builder.variables;
+        this.objectType = builder.objectType;
+        this.graphQLContext = builder.graphQLContext;
     }
 
     public static Builder newParameters() {
@@ -50,6 +57,7 @@ public static class Builder {
         private Map<String, FragmentDefinition> fragmentsByName;
         private Map<String, Object> variables;
         private GraphQLObjectType objectType;
+        private GraphQLContext graphQLContext = GraphQLContext.getDefault();
 
         /**
          * @see FieldCollectorParameters#newParameters()
@@ -68,6 +76,11 @@ public Builder objectType(GraphQLObjectType objectType) {
             return this;
         }
 
+        public Builder graphQLContext(GraphQLContext graphQLContext) {
+            this.graphQLContext = graphQLContext;
+            return this;
+        }
+
         public Builder fragments(Map<String, FragmentDefinition> fragmentsByName) {
             this.fragmentsByName = fragmentsByName;
             return this;
@@ -80,8 +93,8 @@ public Builder variables(Map<String, Object> variables) {
 
         public FieldCollectorParameters build() {
             Assert.assertNotNull(graphQLSchema, () -> "You must provide a schema");
-            return new FieldCollectorParameters(graphQLSchema, variables, fragmentsByName, objectType);
+            return new FieldCollectorParameters(this);
         }
 
     }
-}
+}