Added partial support for repeatable directives

Replicates graphql/graphql-js@2c7224c

Author: Cito

README.md

@@ -13,7 +13,7 @@ a query language for APIs created by Facebook.
 [![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
 
 The current version 1.0.5 of GraphQL-core-next is up-to-date with GraphQL.js version
-14.3.1. All parts of the API are covered by an extensive test suite of currently 1816
+14.3.1. All parts of the API are covered by an extensive test suite of currently 1822
 unit tests.
 
 

graphql/language/ast.py

@@ -453,11 +453,12 @@ class InputObjectTypeDefinitionNode(TypeDefinitionNode):
 
 
 class DirectiveDefinitionNode(TypeSystemDefinitionNode):
-    __slots__ = "description", "name", "arguments", "locations"
+    __slots__ = "description", "name", "arguments", "repeatable", "locations"
 
     description: Optional[StringValueNode]
     name: NameNode
     arguments: Optional[List[InputValueDefinitionNode]]
+    repeatable: bool
     locations: List[NameNode]
 
 

graphql/language/parser.py

@@ -984,19 +984,21 @@ def parse_input_object_type_extension(lexer: Lexer) -> InputObjectTypeExtensionN
 
 
 def parse_directive_definition(lexer: Lexer) -> DirectiveDefinitionNode:
-    """InputObjectTypeExtension"""
+    """DirectiveDefinition"""
     start = lexer.token
     description = parse_description(lexer)
     expect_keyword(lexer, "directive")
     expect_token(lexer, TokenKind.AT)
     name = parse_name(lexer)
     args = parse_argument_defs(lexer)
+    repeatable = expect_optional_keyword(lexer, "repeatable")
     expect_keyword(lexer, "on")
     locations = parse_directive_locations(lexer)
     return DirectiveDefinitionNode(
         description=description,
         name=name,
         arguments=args,
+        repeatable=repeatable,
         locations=locations,
         loc=loc(lexer, start),
     )

graphql/language/printer.py

@@ -243,8 +243,9 @@ def leave_directive_definition(self, node, *_args):
             if has_multiline_items(args)
             else wrap("(", join(args, ", "), ")")
         )
+        repeatable = " repeatable" if node.repeatable else ""
         locations = join(node.locations, " | ")
-        return f"directive @{node.name}{args} on {locations}"
+        return f"directive @{node.name}{args}{repeatable} on {locations}"
 
     def leave_schema_extension(self, node, *_args):
         return join(

graphql/type/directives.py

@@ -28,6 +28,7 @@ class GraphQLDirective:
 
     name: str
     locations: Sequence[DirectiveLocation]
+    is_repeatable: bool
     args: Dict[str, GraphQLArgument]
     description: Optional[str]
     ast_node: Optional[ast.DirectiveDefinitionNode]
@@ -37,6 +38,7 @@ def __init__(
         name: str,
         locations: Sequence[DirectiveLocation],
         args: Dict[str, GraphQLArgument] = None,
+        is_repeatable: bool = False,
         description: str = None,
         ast_node: ast.DirectiveDefinitionNode = None,
     ) -> None:
@@ -46,6 +48,8 @@ def __init__(
             raise TypeError("The directive name must be a string.")
         if not isinstance(locations, (list, tuple)):
             raise TypeError(f"{name} locations must be a list/tuple.")
+        if not isinstance(is_repeatable, bool):
+            raise TypeError(f"{name} is_repeatable flag must be True or False.")
         if not all(isinstance(value, DirectiveLocation) for value in locations):
             try:
                 locations = [
@@ -83,6 +87,7 @@ def __init__(
         self.name = name
         self.locations = locations
         self.args = args
+        self.is_repeatable = is_repeatable
         self.description = description
         self.ast_node = ast_node
 
@@ -97,6 +102,7 @@ def to_kwargs(self) -> Dict[str, Any]:
             name=self.name,
             locations=self.locations,
             args=self.args,
+            is_repeatable=self.is_repeatable,
             description=self.description,
             ast_node=self.ast_node,
         )

graphql/utilities/build_ast_schema.py

@@ -211,6 +211,7 @@ def build_directive(self, directive: DirectiveDefinitionNode) -> GraphQLDirectiv
             name=directive.name.value,
             description=directive.description.value if directive.description else None,
             locations=locations,
+            is_repeatable=directive.repeatable,
             args={
                 arg.name.value: self.build_arg(arg) for arg in directive.arguments or []
             },

graphql/utilities/schema_printer.py

@@ -239,6 +239,7 @@ def print_directive(directive: GraphQLDirective) -> str:
         print_description(directive)
         + f"directive @{directive.name}"
         + print_args(directive.args)
+        + (" repeatable" if directive.is_repeatable else "")
         + " on "
         + " | ".join(location.name for location in directive.locations)
     )

graphql/validation/rules/unique_directives_per_location.py

@@ -1,8 +1,9 @@
-from typing import Dict, List
+from typing import Dict, List, Union, cast
 
 from ...error import GraphQLError
-from ...language import DirectiveNode, Node
-from . import ASTValidationRule
+from ...language import DirectiveDefinitionNode, DirectiveNode, Node
+from ...type import specified_directives
+from . import ASTValidationRule, SDLValidationContext, ValidationContext
 
 __all__ = ["UniqueDirectivesPerLocationRule", "duplicate_directive_message"]
 
@@ -14,10 +15,28 @@ def duplicate_directive_message(directive_name: str) -> str:
 class UniqueDirectivesPerLocationRule(ASTValidationRule):
     """Unique directive names per location
 
-    A GraphQL document is only valid if all directives at a given location are uniquely
-    named.
+    A GraphQL document is only valid if all non-repeatable directives at a given
+    location are uniquely named.
     """
 
+    context: Union[ValidationContext, SDLValidationContext]
+
+    def __init__(self, context: Union[ValidationContext, SDLValidationContext]) -> None:
+        super().__init__(context)
+        unique_directive_map: Dict[str, bool] = {}
+
+        schema = context.schema
+        defined_directives = (
+            schema.directives if schema else cast(List, specified_directives)
+        )
+        for directive in defined_directives:
+            unique_directive_map[directive.name] = not directive.is_repeatable
+        ast_definitions = context.document.definitions
+        for def_ in ast_definitions:
+            if isinstance(def_, DirectiveDefinitionNode):
+                unique_directive_map[def_.name.value] = not def_.repeatable
+        self.unique_directive_map = unique_directive_map
+
     # Many different AST nodes may contain directives. Rather than listing them all,
     # just listen for entering any node, and check to see if it defines any directives.
     def enter(self, node: Node, *_args):
@@ -26,12 +45,14 @@ def enter(self, node: Node, *_args):
             known_directives: Dict[str, DirectiveNode] = {}
             for directive in directives:
                 directive_name = directive.name.value
-                if directive_name in known_directives:
-                    self.report_error(
-                        GraphQLError(
-                            duplicate_directive_message(directive_name),
-                            [known_directives[directive_name], directive],
+
+                if self.unique_directive_map.get(directive_name):
+                    if directive_name in known_directives:
+                        self.report_error(
+                            GraphQLError(
+                                duplicate_directive_message(directive_name),
+                                [known_directives[directive_name], directive],
+                            )
                         )
-                    )
-                else:
-                    known_directives[directive_name] = directive
+                    else:
+                        known_directives[directive_name] = directive

tests/fixtures/schema_kitchen_sink.graphql

@@ -142,6 +142,10 @@ directive @include2(if: Boolean!) on
   | FRAGMENT_SPREAD
   | INLINE_FRAGMENT
 
+directive @myRepeatableDir(name: String!) repeatable on
+  | OBJECT
+  | INTERFACE
+
 extend schema @onSchema
 
 extend schema @onSchema {

tests/language/test_schema_parser.py

@@ -5,6 +5,8 @@
 from graphql.error import GraphQLSyntaxError
 from graphql.language import (
     BooleanValueNode,
+    DirectiveDefinitionNode,
+    DirectiveNode,
     DocumentNode,
     EnumTypeDefinitionNode,
     EnumValueDefinitionNode,
@@ -22,7 +24,6 @@
     OperationTypeDefinitionNode,
     ScalarTypeDefinitionNode,
     SchemaExtensionNode,
-    DirectiveNode,
     StringValueNode,
     UnionTypeDefinitionNode,
     parse,
@@ -610,6 +611,32 @@ def simple_input_object_with_args_should_fail():
             (3, 8),
         )
 
+    def directive_definition():
+        body = "directive @foo on OBJECT | INTERFACE"
+        definition = assert_definitions(body, (0, 36))
+        assert isinstance(definition, DirectiveDefinitionNode)
+        assert definition.name == name_node("foo", (11, 14))
+        assert definition.description is None
+        assert definition.arguments == []
+        assert definition.repeatable is False
+        assert definition.locations == [
+            name_node("OBJECT", (18, 24)),
+            name_node("INTERFACE", (27, 36)),
+        ]
+
+    def repeatable_directive_definition():
+        body = "directive @foo repeatable on OBJECT | INTERFACE"
+        definition = assert_definitions(body, (0, 47))
+        assert isinstance(definition, DirectiveDefinitionNode)
+        assert definition.name == name_node("foo", (11, 14))
+        assert definition.description is None
+        assert definition.arguments == []
+        assert definition.repeatable is True
+        assert definition.locations == [
+            name_node("OBJECT", (29, 35)),
+            name_node("INTERFACE", (38, 47)),
+        ]
+
     def directive_with_incorrect_locations():
         assert_syntax_error(
             "\ndirective @foo on FIELD | INCORRECT_LOCATION",