Validate directive arguments inside SDL

Replicates graphql/graphql-js@4631744

Author: Cito

README.md

@@ -13,7 +13,7 @@ a query language for APIs created by Facebook.
 
 The current version 1.0.0rc2 of GraphQL-core-next is up-to-date with GraphQL.js
 version 14.0.0rc2. All parts of the API are covered by an extensive test
-suite of currently 1585 unit tests.
+suite of currently 1602 unit tests.
 
 
 ## Documentation

graphql/validation/rules/known_argument_names.py

@@ -1,12 +1,14 @@
-from typing import List
+from typing import Dict, List, Union
 
 from ...error import GraphQLError
-from ...language import ArgumentNode, FieldNode, DirectiveNode
+from ...language import (
+    ArgumentNode, FieldNode, DirectiveDefinitionNode, DirectiveNode, SKIP)
 from ...pyutils import quoted_or_list, suggestion_list
-from . import ValidationRule
+from ...type import specified_directives
+from . import ASTValidationRule, SDLValidationContext, ValidationContext
 
 __all__ = [
-    'KnownArgumentNamesRule',
+    'KnownArgumentNamesRule', 'KnownArgumentNamesOnDirectivesRule',
     'unknown_arg_message', 'unknown_directive_arg_message']
 
 
@@ -30,38 +32,72 @@ def unknown_directive_arg_message(
     return message
 
 
-class KnownArgumentNamesRule(ValidationRule):
+class KnownArgumentNamesOnDirectivesRule(ASTValidationRule):
+    """Known argument names on directives
+
+    A GraphQL directive is only valid if all supplied arguments are defined.
+    """
+
+    context: Union[ValidationContext, SDLValidationContext]
+
+    def __init__(self, context: Union[
+            ValidationContext, SDLValidationContext]) -> None:
+        super().__init__(context)
+        directive_args: Dict[str, List[str]] = {}
+
+        schema = context.schema
+        defined_directives = (
+            schema.directives if schema else specified_directives)
+        for directive in defined_directives:
+            directive_args[directive.name] = list(directive.args)
+
+        ast_definitions = context.document.definitions
+        for def_ in ast_definitions:
+            if isinstance(def_, DirectiveDefinitionNode):
+                directive_args[def_.name.value] = [
+                    arg.name.value for arg in def_.arguments
+                ] if def_.arguments else []
+
+        self.directive_args = directive_args
+
+    def enter_directive(self, directive_node: DirectiveNode, *_args):
+        directive_name = directive_node.name.value
+        known_args = self.directive_args.get(directive_name)
+        if directive_node.arguments and known_args:
+            for arg_node in directive_node.arguments:
+                arg_name = arg_node.name.value
+                if arg_name not in known_args:
+                    suggestions = suggestion_list(arg_name, known_args)
+                    self.report_error(GraphQLError(
+                        unknown_directive_arg_message(
+                            arg_name, directive_name, suggestions), arg_node))
+        return SKIP
+
+
+class KnownArgumentNamesRule(KnownArgumentNamesOnDirectivesRule):
     """Known argument names
 
     A GraphQL field is only valid if all supplied arguments are defined by
     that field.
     """
 
+    context: ValidationContext
+
+    def __init__(self, context: ValidationContext) -> None:
+        super().__init__(context)
+
     def enter_argument(
-            self, node: ArgumentNode, _key, _parent, _path, ancestors):
+            self, arg_node: ArgumentNode, *args):
         context = self.context
         arg_def = context.get_argument()
-        if not arg_def:
-            argument_of = ancestors[-1]
-            if isinstance(argument_of, FieldNode):
-                field_def = context.get_field_def()
-                parent_type = context.get_parent_type()
-                if field_def and parent_type:
-                    context.report_error(GraphQLError(
-                        unknown_arg_message(
-                            node.name.value,
-                            argument_of.name.value,
-                            parent_type.name,
-                            suggestion_list(
-                                node.name.value, list(field_def.args))),
-                        [node]))
-            elif isinstance(argument_of, DirectiveNode):
-                directive = context.get_directive()
-                if directive:
-                    context.report_error(GraphQLError(
-                        unknown_directive_arg_message(
-                            node.name.value,
-                            directive.name,
-                            suggestion_list(
-                                node.name.value, list(directive.args))),
-                        [node]))
+        field_def = context.get_field_def()
+        parent_type = context.get_parent_type()
+        if not arg_def and field_def and parent_type:
+            arg_name = arg_node.name.value
+            field_name = args[3][-1].name.value
+            known_args_names = list(field_def.args)
+            context.report_error(GraphQLError(
+                unknown_arg_message(
+                    arg_name, field_name, parent_type.name,
+                    suggestion_list(arg_name, known_args_names)), arg_node))
+

graphql/validation/rules/known_directives.py

@@ -27,11 +27,14 @@ class KnownDirectivesRule(ASTValidationRule):
     schema and legally positioned.
     """
 
+    context: Union[ValidationContext, SDLValidationContext]
+
     def __init__(self, context: Union[
             ValidationContext, SDLValidationContext]) -> None:
         super().__init__(context)
-        schema = context.schema
         locations_map: Dict[str, List[DirectiveLocation]] = {}
+
+        schema = context.schema
         defined_directives = (
             schema.directives if schema else cast(List, specified_directives))
         for directive in defined_directives:

graphql/validation/rules/lone_schema_definition.py

@@ -3,7 +3,7 @@
 from . import SDLValidationRule, SDLValidationContext
 
 __all__ = [
-    'LoneSchemaDefinition',
+    'LoneSchemaDefinitionRule',
     'schema_definition_not_alone_message',
     'cannot_define_schema_within_extension_message']
 
@@ -16,7 +16,7 @@ def cannot_define_schema_within_extension_message():
     return 'Cannot define a new schema within a schema extension.'
 
 
-class LoneSchemaDefinition(SDLValidationRule):
+class LoneSchemaDefinitionRule(SDLValidationRule):
     """Lone Schema definition
 
     A GraphQL document is only valid if it contains only one schema definition.

graphql/validation/rules/provided_required_arguments.py

@@ -1,10 +1,16 @@
+from typing import Dict, Union
+
 from ...error import GraphQLError
-from ...language import DirectiveNode, FieldNode
-from ...type import is_required_argument
-from . import ValidationRule
+from ...language import (
+    DirectiveDefinitionNode, DirectiveNode, FieldNode,
+    InputValueDefinitionNode, NonNullTypeNode, print_ast)
+from ...type import (
+    GraphQLArgument, is_required_argument, is_type, specified_directives)
+from . import ASTValidationRule, SDLValidationContext, ValidationContext
 
 __all__ = [
     'ProvidedRequiredArgumentsRule',
+    'ProvidedRequiredArgumentsOnDirectivesRule',
     'missing_field_arg_message', 'missing_directive_arg_message']
 
 
@@ -20,37 +26,83 @@ def missing_directive_arg_message(
             f" of type '{type_}' is required but not provided.")
 
 
-class ProvidedRequiredArgumentsRule(ValidationRule):
+class ProvidedRequiredArgumentsOnDirectivesRule(ASTValidationRule):
+    """Provided required arguments on directives
+
+    A directive is only valid if all required (non-null without a
+    default value) arguments have been provided.
+    """
+
+    context: Union[ValidationContext, SDLValidationContext]
+
+    def __init__(self, context: Union[
+            ValidationContext, SDLValidationContext]) -> None:
+        super().__init__(context)
+        required_args_map: Dict[str, Dict[str, GraphQLArgument]] = {}
+
+        schema = context.schema
+        defined_directives = (
+            schema.directives if schema else specified_directives)
+        for directive in defined_directives:
+            required_args_map[directive.name] = {
+                name: arg for name, arg in directive.args.items()
+                if is_required_argument(arg)}
+
+        ast_definitions = context.document.definitions
+        for def_ in ast_definitions:
+            if isinstance(def_, DirectiveDefinitionNode):
+                required_args_map[def_.name.value] = {
+                    arg.name.value: arg for arg in filter(
+                        is_required_argument_node, def_.arguments)
+                    } if def_.arguments else {}
+
+        self.required_args_map = required_args_map
+
+    def leave_directive(self, directive_node: DirectiveNode, *_args):
+        # Validate on leave to allow for deeper errors to appear first.
+        directive_name = directive_node.name.value
+        required_args = self.required_args_map.get(directive_name)
+        if required_args:
+
+            arg_nodes = directive_node.arguments or []
+            arg_node_set = {arg.name.value for arg in arg_nodes}
+            for arg_name in required_args:
+                if arg_name not in arg_node_set:
+                    arg_type = required_args[arg_name].type
+                    self.report_error(GraphQLError(
+                        missing_directive_arg_message(
+                            directive_name, arg_name, str(arg_type)
+                            if is_type(arg_type) else print_ast(arg_type)),
+                        [directive_node]))
+
+
+class ProvidedRequiredArgumentsRule(ProvidedRequiredArgumentsOnDirectivesRule):
     """Provided required arguments
 
     A field or directive is only valid if all required (non-null without a
     default value) field arguments have been provided.
     """
 
-    def leave_field(self, node: FieldNode, *_args):
+    context: ValidationContext
+
+    def __init__(self, context: ValidationContext) -> None:
+        super().__init__(context)
+
+    def leave_field(self, field_node: FieldNode, *_args):
         # Validate on leave to allow for deeper errors to appear first.
         field_def = self.context.get_field_def()
         if not field_def:
             return self.SKIP
-        arg_nodes = node.arguments or []
+        arg_nodes = field_node.arguments or []
 
         arg_node_map = {arg.name.value: arg for arg in arg_nodes}
         for arg_name, arg_def in field_def.args.items():
             arg_node = arg_node_map.get(arg_name)
             if not arg_node and is_required_argument(arg_def):
                 self.report_error(GraphQLError(missing_field_arg_message(
-                    node.name.value, arg_name, str(arg_def.type)), [node]))
+                    field_node.name.value, arg_name, str(arg_def.type)),
+                    [field_node]))
 
-    def leave_directive(self, node: DirectiveNode, *_args):
-        # Validate on leave to allow for deeper errors to appear first.
-        directive_def = self.context.get_directive()
-        if not directive_def:
-            return False
-        arg_nodes = node.arguments or []
 
-        arg_node_map = {arg.name.value: arg for arg in arg_nodes}
-        for arg_name, arg_def in directive_def.args.items():
-            arg_node = arg_node_map.get(arg_name)
-            if not arg_node and is_required_argument(arg_def):
-                self.report_error(GraphQLError(missing_directive_arg_message(
-                    node.name.value, arg_name, str(arg_def.type)), [node]))
+def is_required_argument_node(arg: InputValueDefinitionNode) -> bool:
+    return isinstance(arg.type, NonNullTypeNode) and arg.default_value is None

graphql/validation/specified_rules.py

@@ -83,7 +83,10 @@
 from .rules.unique_input_field_names import UniqueInputFieldNamesRule
 
 # Schema definition language:
-from .rules.lone_schema_definition import LoneSchemaDefinition
+from .rules.lone_schema_definition import LoneSchemaDefinitionRule
+from .rules.known_argument_names import KnownArgumentNamesOnDirectivesRule
+from .rules.provided_required_arguments import (
+    ProvidedRequiredArgumentsOnDirectivesRule)
 
 __all__ = ['specified_rules', 'specified_sdl_rules']
 
@@ -122,8 +125,10 @@
     UniqueInputFieldNamesRule]
 
 specified_sdl_rules: List[RuleType] = [
-    LoneSchemaDefinition,
+    LoneSchemaDefinitionRule,
     KnownDirectivesRule,
     UniqueDirectivesPerLocationRule,
+    KnownArgumentNamesOnDirectivesRule,
     UniqueArgumentNamesRule,
-    UniqueInputFieldNamesRule]
+    UniqueInputFieldNamesRule,
+    ProvidedRequiredArgumentsOnDirectivesRule]