[RFC] Directives in schema language

Related GraphQL-js commit: graphql/graphql-js@fdafe32

Author: syrusakbary

graphql/language/ast.py

@@ -1196,3 +1196,42 @@ def __copy__(self):
 
     def __hash__(self):
         return id(self)
+
+
+class DirectiveDefinition(TypeDefinition):
+    __slots__ = ('loc', 'name', 'arguments', 'locations')
+    _fields = ('name', 'locations')
+
+    def __init__(self, name, locations, arguments=None, loc=None):
+        self.name = name
+        self.locations = locations
+        self.loc = loc
+        self.arguments = arguments
+
+    def __eq__(self, other):
+        return (
+            self is other or (
+                isinstance(other, DirectiveDefinition) and
+                self.name == other.name and
+                self.locations == other.locations and
+                self.loc == other.loc and
+                self.arguments == other.arguments
+            )
+        )
+
+    def __repr__(self):
+        return ('DirectiveDefinition('
+                'name={self.name!r}, '
+                'locations={self.locations!r}'
+                ')').format(self=self)
+
+    def __copy__(self):
+        return type(self)(
+            self.name,
+            self.locations,
+            self.arguments,
+            self.loc,
+        )
+
+    def __hash__(self):
+        return id(self)

graphql/language/parser.py

@@ -213,6 +213,8 @@ def parse_definition(parser):
             return parse_type_definition(parser)
         elif name == 'extend':
             return parse_type_extension_definition(parser)
+        elif name == 'directive':
+            return parse_directive_definition(parser)
 
     raise unexpected(parser)
 
@@ -677,3 +679,33 @@ def parse_type_extension_definition(parser):
         definition=parse_object_type_definition(parser),
         loc=loc(parser, start)
     )
+
+
+def parse_directive_definition(parser):
+    start = parser.token.start
+    expect_keyword(parser, 'directive')
+    expect(parser, TokenKind.AT)
+
+    name = parse_name(parser)
+    args = parse_argument_defs(parser)
+    expect_keyword(parser, 'on')
+
+    locations = parse_directive_locations(parser)
+    return ast.DirectiveDefinition(
+        name=name,
+        locations=locations,
+        arguments=args,
+        loc=loc(parser, start)
+    )
+
+
+def parse_directive_locations(parser):
+    locations = []
+
+    while True:
+        locations.append(parse_name(parser))
+
+        if not skip(parser, TokenKind.PIPE):
+            break
+
+    return locations

graphql/language/printer.py

@@ -145,6 +145,9 @@ def leave_InputObjectTypeDefinition(self, node, *args):
     def leave_TypeExtensionDefinition(self, node, *args):
         return 'extend ' + node.definition
 
+    def leave_DirectiveDefinition(self, node, *args):
+        return 'directive @{}{} on {}'.format(node.name, wrap('(', join(node.arguments, ', '), ')'), ' | '.join(node.locations))
+
 
 def join(maybe_list, separator=''):
     if maybe_list:

graphql/language/tests/fixtures.py

@@ -98,4 +98,8 @@
 extend type Foo {
   seven(argument: [String]): Type
 }
+
+directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
 """

graphql/language/tests/test_schema_printer.py

@@ -67,6 +67,10 @@ def test_prints_kitchen_sink():
 extend type Foo {
   seven(argument: [String]): Type
 }
+
+directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
 '''
 
     assert printed == expected

graphql/language/visitor_meta.py

@@ -40,6 +40,7 @@
     ast.EnumValueDefinition: ('name',),
     ast.InputObjectTypeDefinition: ('name', 'fields'),
     ast.TypeExtensionDefinition: ('definition',),
+    ast.DirectiveDefinition: ('name', 'arguments', 'locations'),
 }
 
 AST_KIND_TO_TYPE = {c.__name__: c for c in QUERY_DOCUMENT_KEYS.keys()}

graphql/type/__init__.py

@@ -19,6 +19,9 @@
     is_leaf_type,
     is_output_type
 )
+from .directives import (
+    GraphQLDirective
+)
 from .scalars import (  # no import order
     GraphQLInt,
     GraphQLFloat,

graphql/type/directives.py

@@ -1,7 +1,7 @@
 import collections
 
 from ..utils.assert_valid_name import assert_valid_name
-from .definition import GraphQLArgument, GraphQLNonNull
+from .definition import GraphQLArgument, GraphQLNonNull, is_input_type
 from .scalars import GraphQLBoolean
 
 
@@ -41,9 +41,24 @@ def __init__(self, name, description=None, args=None, locations=None):
 
         self.name = name
         self.description = description
-        self.args = args or []
         self.locations = locations
 
+        self.args = []
+        if args:
+            assert isinstance(args, dict), '{} args must be a dict with argument names as keys.'.format(name)
+            for arg_name, _arg in args.items():
+                assert_valid_name(arg_name)
+                assert is_input_type(_arg.type), '{}({}) argument type must be Input Type but got {}.'.format(
+                    name,
+                    arg_name,
+                    _arg.type)
+                self.args.append(arg(
+                    arg_name,
+                    description=_arg.description,
+                    type=_arg.type,
+                    default_value=_arg.default_value
+                ))
+
 
 def arg(name, *args, **kwargs):
     a = GraphQLArgument(*args, **kwargs)
@@ -53,11 +68,12 @@ def arg(name, *args, **kwargs):
 
 GraphQLIncludeDirective = GraphQLDirective(
     name='include',
-    args=[arg(
-        'if',
-        type=GraphQLNonNull(GraphQLBoolean),
-        description='Directs the executor to include this field or fragment only when the `if` argument is true.',
-    )],
+    args={
+        'if': GraphQLArgument(
+            type=GraphQLNonNull(GraphQLBoolean),
+            description='Included when true.',
+        ),
+    },
     locations=[
         DirectiveLocation.FIELD,
         DirectiveLocation.FRAGMENT_SPREAD,
@@ -67,11 +83,12 @@ def arg(name, *args, **kwargs):
 
 GraphQLSkipDirective = GraphQLDirective(
     name='skip',
-    args=[arg(
-        'if',
-        type=GraphQLNonNull(GraphQLBoolean),
-        description='Directs the executor to skip this field or fragment only when the `if` argument is true.',
-    )],
+    args={
+        'if': GraphQLArgument(
+            type=GraphQLNonNull(GraphQLBoolean),
+            description='Skipped when true.',
+        ),
+    },
     locations=[
         DirectiveLocation.FIELD,
         DirectiveLocation.FRAGMENT_SPREAD,

graphql/utils/build_ast_schema.py

@@ -6,7 +6,7 @@
                     GraphQLInputObjectField, GraphQLInputObjectType,
                     GraphQLInt, GraphQLInterfaceType, GraphQLList,
                     GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
-                    GraphQLSchema, GraphQLString, GraphQLUnionType)
+                    GraphQLSchema, GraphQLString, GraphQLUnionType, GraphQLDirective)
 from ..utils.value_from_ast import value_from_ast
 
 
@@ -37,7 +37,24 @@ def build_ast_schema(document, query_type_name, mutation_type_name=None, subscri
     assert isinstance(document, ast.Document), 'must pass in Document ast.'
     assert query_type_name, 'must pass in query type'
 
-    type_defs = [d for d in document.definitions if isinstance(d, ast.TypeDefinition)]
+    type_asts = (
+        ast.ObjectTypeDefinition,
+        ast.InterfaceTypeDefinition,
+        ast.EnumTypeDefinition,
+        ast.UnionTypeDefinition,
+        ast.ScalarTypeDefinition,
+        ast.InputObjectTypeDefinition,
+    )
+
+    type_defs = []
+    directive_defs = []
+
+    for d in document.definitions:
+        if isinstance(d, type_asts):
+            type_defs.append(d)
+        elif isinstance(d, ast.DirectiveDefinition):
+            directive_defs.append(d)
+
     ast_map = {d.name.value: d for d in type_defs}
 
     if query_type_name not in ast_map:
@@ -158,7 +175,14 @@ def make_schema_def(definition):
 
         return handler(definition)
 
-    for definition in document.definitions:
+    def get_directive(directive_ast):
+        return GraphQLDirective(
+            name=directive_ast.name.value,
+            locations=[node.value for node in directive_ast.locations],
+            args=make_input_values(directive_ast.arguments, GraphQLArgument),
+        )
+
+    for definition in type_defs:
         produce_type_def(definition)
 
     schema_kwargs = {'query': produce_type_def(ast_map[query_type_name])}
@@ -169,4 +193,7 @@ def make_schema_def(definition):
     if subscription_type_name:
         schema_kwargs['subscription'] = produce_type_def(ast_map[subscription_type_name])
 
+    if directive_defs:
+        schema_kwargs['directives'] = [get_directive(d) for d in directive_defs]
+
     return GraphQLSchema(**schema_kwargs)

graphql/utils/build_client_schema.py

@@ -212,7 +212,8 @@ def build_directive(directive_introspection):
         return GraphQLDirective(
             name=directive_introspection['name'],
             description=directive_introspection.get('description'),
-            args=[build_input_value(a, GraphQLArgument) for a in directive_introspection.get('args', [])],
+            # TODO: {} ?
+            args=build_input_value_def_map(directive_introspection.get('args', []), GraphQLArgument),
             locations=locations
         )