graphql-java · dugenkui03 · May 21, 2020 · May 21, 2020 · Jul 21, 2020 · Jul 24, 2020
diff --git a/src/main/antlr/GraphqlCommon.g4 b/src/main/antlr/GraphqlCommon.g4
@@ -91,6 +91,7 @@ INPUT: 'input';
 EXTEND: 'extend';
 DIRECTIVE: 'directive';
 ON_KEYWORD: 'on';
+REPEATABLE: 'repeatable';
 NAME: [_A-Za-z][_0-9A-Za-z]*;
 
 

diff --git a/src/main/antlr/GraphqlSDL.g4 b/src/main/antlr/GraphqlSDL.g4
@@ -120,7 +120,7 @@ inputObjectValueDefinitions : '{' inputValueDefinition* '}';
 extensionInputObjectValueDefinitions : '{' inputValueDefinition+ '}';
 
 
-directiveDefinition : description? DIRECTIVE '@' name argumentsDefinition? 'on' directiveLocations;
+directiveDefinition : description? DIRECTIVE '@' name argumentsDefinition? REPEATABLE? ON_KEYWORD directiveLocations;
 
 directiveLocation : name;
 

diff --git a/src/main/java/graphql/DirectivesUtil.java b/src/main/java/graphql/DirectivesUtil.java
@@ -11,15 +11,16 @@
 @Internal
 public class DirectivesUtil {
 
-    public static Map<String, GraphQLDirective> directivesByName(List<GraphQLDirective> directiveList) {
-        return FpKit.getByName(directiveList, GraphQLDirective::getName, FpKit.mergeFirst());
+    public static Map<String, List<GraphQLDirective>> directivesByName(List<GraphQLDirective> directiveList) {
+        return FpKit.groupingBy(directiveList, gd -> gd.getName());
     }
 
     public static Optional<GraphQLArgument> directiveWithArg(List<GraphQLDirective> directiveList, String directiveName, String argumentName) {
-        GraphQLDirective directive = directivesByName(directiveList).get(directiveName);
+        GraphQLDirective graphQLDirective = FpKit.findOneOrNull(directiveList, d -> d.getName().equals(directiveName));
+
         GraphQLArgument argument = null;
-        if (directive != null) {
-            argument = directive.getArgument(argumentName);
+        if (graphQLDirective != null) {
+            argument = graphQLDirective.getArgument(argumentName);
         }
         return Optional.ofNullable(argument);
     }

diff --git a/src/main/java/graphql/execution/ConditionalNodes.java b/src/main/java/graphql/execution/ConditionalNodes.java
@@ -3,13 +3,13 @@
 import graphql.Internal;
 import graphql.VisibleForTesting;
 import graphql.language.Directive;
+import graphql.util.FpKit;
 
 import java.util.List;
 import java.util.Map;
 
 import static graphql.Directives.IncludeDirective;
 import static graphql.Directives.SkipDirective;
-import static graphql.language.NodeUtil.directivesByName;
 
 
 @Internal
@@ -25,15 +25,9 @@ public boolean shouldInclude(Map<String, Object> variables, List<Directive> dire
         return !skip && include;
     }
 
-    private Directive getDirectiveByName(List<Directive> directives, String name) {
-        if (directives.isEmpty()) {
-            return null;
-        }
-        return directivesByName(directives).get(name);
-    }
-
     private boolean getDirectiveResult(Map<String, Object> variables, List<Directive> directives, String directiveName, boolean defaultValue) {
-        Directive directive = getDirectiveByName(directives, directiveName);
+        Directive directive = FpKit.findOneOrNull(directives, d -> d.getName().equals(directiveName));
+
         if (directive != null) {
             Map<String, Object> argumentValues = valuesResolver.getArgumentValues(SkipDirective.getArguments(), directive.getArguments(), variables);
             return (Boolean) argumentValues.get("if");

diff --git a/src/main/java/graphql/execution/defer/DeferSupport.java b/src/main/java/graphql/execution/defer/DeferSupport.java
@@ -9,6 +9,7 @@
 import graphql.execution.reactive.SingleSubscriberPublisher;
 import graphql.language.Directive;
 import graphql.language.Field;
+import graphql.util.FpKit;
 import org.reactivestreams.Publisher;
 
 import java.util.Deque;
@@ -34,7 +35,12 @@ public class DeferSupport {
 
     public boolean checkForDeferDirective(MergedField currentField, Map<String,Object> variables) {
         for (Field field : currentField.getFields()) {
-            Directive directive = field.getDirective(DeferDirective.getName());
+            List<Directive> directives = field.getDirectives();
+            if (directives == null || directives.isEmpty()) {
+                return false;
+            }
+
+            Directive directive = FpKit.findOneOrNull(directives, d -> d.getName().equals(DeferDirective.getName()));
             if (directive != null) {
                 Map<String, Object> argumentValues = valuesResolver.getArgumentValues(DeferDirective.getArguments(), directive.getArguments(), variables);
                 return (Boolean) argumentValues.get("if");

diff --git a/src/main/java/graphql/introspection/Introspection.java b/src/main/java/graphql/introspection/Introspection.java
@@ -416,18 +416,22 @@ public enum DirectiveLocation {
     @SuppressWarnings("deprecation") // because graphql spec still has the deprecated fields
     public static final GraphQLObjectType __Directive = newObject()
             .name("__Directive")
+            .description("The __Directive type represents a Directive that a server supports.")
             .field(newFieldDefinition()
                     .name("name")
-                    .type(GraphQLString))
+                    .type(nonNull(GraphQLString)))
             .field(newFieldDefinition()
                     .name("description")
                     .type(GraphQLString))
             .field(newFieldDefinition()
                     .name("locations")
-                    .type(list(nonNull(__DirectiveLocation))))
+                    .type(nonNull(list(nonNull(__DirectiveLocation)))))
             .field(newFieldDefinition()
                     .name("args")
                     .type(nonNull(list(nonNull(__InputValue)))))
+            .field(newFieldDefinition()
+                    .name("isRepeatable")
+                    .type(nonNull(GraphQLBoolean)))
             .field(newFieldDefinition()
                     .name("onOperation")
                     .type(GraphQLBoolean)

diff --git a/src/main/java/graphql/language/DirectiveDefinition.java b/src/main/java/graphql/language/DirectiveDefinition.java
@@ -21,6 +21,7 @@ public class DirectiveDefinition extends AbstractDescribedNode<DirectiveDefiniti
     private final String name;
     private final List<InputValueDefinition> inputValueDefinitions;
     private final List<DirectiveLocation> directiveLocations;
+    private final boolean isRepeatable;
 
     public static final String CHILD_INPUT_VALUE_DEFINITIONS = "inputValueDefinitions";
     public static final String CHILD_DIRECTIVE_LOCATION = "directiveLocation";
@@ -30,6 +31,7 @@ protected DirectiveDefinition(String name,
                                   Description description,
                                   List<InputValueDefinition> inputValueDefinitions,
                                   List<DirectiveLocation> directiveLocations,
+                                  boolean isRepeatable,
                                   SourceLocation sourceLocation,
                                   List<Comment> comments,
                                   IgnoredChars ignoredChars,
@@ -38,6 +40,7 @@ protected DirectiveDefinition(String name,
         this.name = name;
         this.inputValueDefinitions = inputValueDefinitions;
         this.directiveLocations = directiveLocations;
+        this.isRepeatable = isRepeatable;
     }
 
     /**
@@ -46,7 +49,7 @@ protected DirectiveDefinition(String name,
      * @param name of the directive definition
      */
     public DirectiveDefinition(String name) {
-        this(name, null, new ArrayList<>(), new ArrayList<>(), null, new ArrayList<>(), IgnoredChars.EMPTY, emptyMap());
+        this(name, null, new ArrayList<>(), new ArrayList<>(), false, null, new ArrayList<>(), IgnoredChars.EMPTY, emptyMap());
     }
 
     @Override
@@ -62,6 +65,10 @@ public List<DirectiveLocation> getDirectiveLocations() {
         return new ArrayList<>(directiveLocations);
     }
 
+    public boolean isRepeatable() {
+        return isRepeatable;
+    }
+
     @Override
     public List<Node> getChildren() {
         List<Node> result = new ArrayList<>();
@@ -106,6 +113,7 @@ public DirectiveDefinition deepCopy() {
                 description,
                 deepCopy(inputValueDefinitions),
                 deepCopy(directiveLocations),
+                isRepeatable,
                 getSourceLocation(),
                 getComments(),
                 getIgnoredChars(),
@@ -118,6 +126,7 @@ public String toString() {
                 "name='" + name + "'" +
                 ", inputValueDefinitions=" + inputValueDefinitions +
                 ", directiveLocations=" + directiveLocations +
+                ", isRepeatable=" + isRepeatable +
                 "}";
     }
 
@@ -143,6 +152,7 @@ public static final class Builder implements NodeBuilder {
         private Description description;
         private List<InputValueDefinition> inputValueDefinitions = new ArrayList<>();
         private List<DirectiveLocation> directiveLocations = new ArrayList<>();
+        private boolean isRepeatable;
         private IgnoredChars ignoredChars = IgnoredChars.EMPTY;
         private Map<String, String> additionalData = new LinkedHashMap<>();
 
@@ -156,6 +166,7 @@ private Builder(DirectiveDefinition existing) {
             this.description = existing.getDescription();
             this.inputValueDefinitions = existing.getInputValueDefinitions();
             this.directiveLocations = existing.getDirectiveLocations();
+            this.isRepeatable = existing.isRepeatable();
             this.ignoredChars = existing.getIgnoredChars();
             this.additionalData = new LinkedHashMap<>(existing.getAdditionalData());
         }
@@ -200,6 +211,11 @@ public Builder directiveLocation(DirectiveLocation directiveLocation) {
             return this;
         }
 
+        public Builder isRepeatable(boolean isRepeatable) {
+            this.isRepeatable = isRepeatable;
+            return this;
+        }
+
         public Builder ignoredChars(IgnoredChars ignoredChars) {
             this.ignoredChars = ignoredChars;
             return this;
@@ -217,7 +233,7 @@ public Builder additionalData(String key, String value) {
 
 
         public DirectiveDefinition build() {
-            return new DirectiveDefinition(name, description, inputValueDefinitions, directiveLocations, sourceLocation, comments, ignoredChars, additionalData);
+            return new DirectiveDefinition(name, description, inputValueDefinitions, directiveLocations, isRepeatable, sourceLocation, comments, ignoredChars, additionalData);
         }
     }
 }
diff --git a/src/main/java/graphql/language/DirectivesContainer.java b/src/main/java/graphql/language/DirectivesContainer.java
@@ -20,20 +20,20 @@ public interface DirectivesContainer<T extends DirectivesContainer> extends Node
     List<Directive> getDirectives();
 
     /**
-     * @return a a map of directives by directive name
+     * @return a map of directives by directive name
      */
-    default Map<String, Directive> getDirectivesByName() {
+    default Map<String, List<Directive>> getDirectivesByName() {
         return directivesByName(getDirectives());
     }
 
     /**
-     * Returns a directive with the provided name
+     * Returns a directive list with the provided name
      *
      * @param directiveName the name of the directive to retrieve
      *
-     * @return the directive or null if there is one one with that name
+     * @return the directive list or null if there is one one with that name
      */
-    default Directive getDirective(String directiveName) {
+    default List<Directive> getDirective(String directiveName) {
         return getDirectivesByName().get(directiveName);
     }
 }
diff --git a/src/main/java/graphql/language/InlineFragment.java b/src/main/java/graphql/language/InlineFragment.java
@@ -68,11 +68,11 @@ public List<Directive> getDirectives() {
         return new ArrayList<>(directives);
     }
 
-    public Map<String, Directive> getDirectivesByName() {
+    public Map<String, List<Directive>> getDirectivesByName() {
         return directivesByName(directives);
     }
 
-    public Directive getDirective(String directiveName) {
+    public List<Directive> getDirective(String directiveName) {
         return getDirectivesByName().get(directiveName);
     }
 

diff --git a/src/main/java/graphql/language/NodeUtil.java b/src/main/java/graphql/language/NodeUtil.java
@@ -29,8 +29,8 @@ public static boolean isEqualTo(String thisStr, String thatStr) {
     }
 
 
-    public static Map<String, Directive> directivesByName(List<Directive> directives) {
-        return FpKit.getByName(directives, Directive::getName, mergeFirst());
+    public static Map<String, List<Directive>> directivesByName(List<Directive> directives) {
+        return FpKit.groupingBy(directives, Directive::getName);
     }
 
     public static Map<String, Argument> argumentsByName(List<Argument> arguments) {

diff --git a/src/main/java/graphql/language/SchemaDefinition.java b/src/main/java/graphql/language/SchemaDefinition.java
@@ -17,7 +17,7 @@
 import static graphql.language.NodeUtil.directivesByName;
 
 @PublicApi
-public class SchemaDefinition extends AbstractNode<SchemaDefinition> implements SDLDefinition<SchemaDefinition> {
+public class SchemaDefinition extends AbstractNode<SchemaDefinition> implements DirectivesContainer<SchemaDefinition>, SDLDefinition<SchemaDefinition> {
 
     private final List<Directive> directives;
     private final List<OperationTypeDefinition> operationTypeDefinitions;
@@ -37,15 +37,18 @@ protected SchemaDefinition(List<Directive> directives,
         this.operationTypeDefinitions = operationTypeDefinitions;
     }
 
+    @Override
     public List<Directive> getDirectives() {
         return new ArrayList<>(directives);
     }
 
-    public Map<String, Directive> getDirectivesByName() {
+    @Override
+    public Map<String, List<Directive>> getDirectivesByName() {
         return directivesByName(directives);
     }
 
-    public Directive getDirective(String directiveName) {
+    @Override
+    public List<Directive> getDirective(String directiveName) {
         return getDirectivesByName().get(directiveName);
     }
 

diff --git a/src/main/java/graphql/parser/GraphqlAntlrToLanguage.java b/src/main/java/graphql/parser/GraphqlAntlrToLanguage.java
@@ -637,6 +637,7 @@ protected DirectiveDefinition createDirectiveDefinition(GraphqlParser.DirectiveD
         if (ctx.argumentsDefinition() != null) {
             def.inputValueDefinitions(createInputValueDefinitions(ctx.argumentsDefinition().inputValueDefinition()));
         }
+        def.isRepeatable(ctx.REPEATABLE() != null);
         return def.build();
     }
 

diff --git a/src/main/java/graphql/schema/GraphQLDirective.java b/src/main/java/graphql/schema/GraphQLDirective.java
@@ -31,6 +31,7 @@ public class GraphQLDirective implements GraphQLNamedSchemaElement {
 
     private final String name;
     private final String description;
+    private final boolean isRepeatable;
     private final EnumSet<DirectiveLocation> locations;
     private final List<GraphQLArgument> arguments = new ArrayList<>();
     private final DirectiveDefinition definition;
@@ -44,20 +45,23 @@ public class GraphQLDirective implements GraphQLNamedSchemaElement {
     @Deprecated
     public GraphQLDirective(String name,
                             String description,
+                            boolean isRepeatable,
                             EnumSet<DirectiveLocation> locations,
                             List<GraphQLArgument> arguments) {
-        this(name, description, locations, arguments, null);
+        this(name, description, isRepeatable, locations, arguments, null);
     }
 
     private GraphQLDirective(String name,
                              String description,
+                             boolean isRepeatable,
                              EnumSet<DirectiveLocation> locations,
                              List<GraphQLArgument> arguments,
                              DirectiveDefinition definition) {
         assertValidName(name);
         assertNotNull(arguments, () -> "arguments can't be null");
         this.name = name;
         this.description = description;
+        this.isRepeatable = isRepeatable;
         this.locations = locations;
         this.arguments.addAll(arguments);
         this.definition = definition;
@@ -89,6 +93,10 @@ public String getDescription() {
         return description;
     }
 
+    public boolean isRepeatable() {
+        return isRepeatable;
+    }
+
     public DirectiveDefinition getDefinition() {
         return definition;
     }
@@ -97,6 +105,7 @@ public DirectiveDefinition getDefinition() {
     public String toString() {
         return "GraphQLDirective{" +
                 "name='" + name + '\'' +
+                ", isRepeatable=" + isRepeatable +
                 ", arguments=" + arguments +
                 ", locations=" + locations +
                 '}';
@@ -150,6 +159,7 @@ public static Builder newDirective(GraphQLDirective existing) {
 
     public static class Builder extends GraphqlTypeBuilder {
 
+        private boolean isRepeatable;
         private EnumSet<DirectiveLocation> locations = EnumSet.noneOf(DirectiveLocation.class);
         private final Map<String, GraphQLArgument> arguments = new LinkedHashMap<>();
         private DirectiveDefinition definition;
@@ -161,6 +171,7 @@ public Builder() {
         public Builder(GraphQLDirective existing) {
             this.name = existing.getName();
             this.description = existing.getDescription();
+            this.isRepeatable = existing.isRepeatable();
             this.locations = existing.validLocations();
             this.arguments.putAll(getByName(existing.getArguments(), GraphQLArgument::getName));
         }
@@ -183,6 +194,11 @@ public Builder comparatorRegistry(GraphqlTypeComparatorRegistry comparatorRegist
             return this;
         }
 
+        public Builder isRepeatable(boolean isRepeatable) {
+            this.isRepeatable = isRepeatable;
+            return this;
+        }
+
         public Builder validLocations(DirectiveLocation... validLocations) {
             Collections.addAll(locations, validLocations);
             return this;
@@ -264,11 +280,12 @@ public GraphQLDirective build() {
             return new GraphQLDirective(
                     name,
                     description,
+                    isRepeatable,
                     locations,
                     sort(arguments, GraphQLDirective.class, GraphQLArgument.class),
                     definition);
         }
 
 
     }
-}
+}