Allow providing directives to GraphQLSchema

Closes #33

Author: jhgg

graphql/core/type/directives.py

@@ -3,7 +3,15 @@
 
 
 class GraphQLDirective(object):
-    pass
+    __slots__ = 'name', 'args', 'description', 'on_operation', 'on_fragment', 'on_field'
+
+    def __init__(self, name, description=None, args=None, on_operation=False, on_fragment=False, on_field=False):
+        self.name = name
+        self.description = description
+        self.args = args or []
+        self.on_operation = on_operation
+        self.on_fragment = on_fragment
+        self.on_field = on_field
 
 
 def arg(name, *args, **kwargs):
@@ -12,25 +20,26 @@ def arg(name, *args, **kwargs):
     return a
 
 
-class GraphQLIncludeDirective(GraphQLDirective):
-    name = 'include'
-    args = [arg(
+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.',
-    )]
-    on_operation = False
-    on_fragment = True
-    on_field = True
-
-
-class GraphQLSkipDirective(GraphQLDirective):
-    name = 'skip'
-    args = [arg(
+    )],
+    on_operation=False,
+    on_fragment=True,
+    on_field=True
+)
+
+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.',
-    )]
-    on_operation = False
-    on_fragment = True
-    on_field = True
+    )],
+    on_operation=False,
+    on_fragment=True,
+    on_field=True
+)

graphql/core/type/schema.py

@@ -7,7 +7,7 @@
     GraphQLObjectType,
     GraphQLUnionType,
 )
-from .directives import GraphQLIncludeDirective, GraphQLSkipDirective
+from .directives import GraphQLDirective, GraphQLIncludeDirective, GraphQLSkipDirective
 from .introspection import IntrospectionSchema
 
 
@@ -26,7 +26,7 @@ class GraphQLSchema(object):
     """
     __slots__ = '_query', '_mutation', '_subscription', '_type_map', '_directives',
 
-    def __init__(self, query, mutation=None, subscription=None):
+    def __init__(self, query, mutation=None, subscription=None, directives=None):
         assert isinstance(query, GraphQLObjectType), 'Schema query must be Object Type but got: {}.'.format(query)
         if mutation:
             assert isinstance(mutation, GraphQLObjectType), \
@@ -40,7 +40,19 @@ def __init__(self, query, mutation=None, subscription=None):
         self._mutation = mutation
         self._subscription = subscription
         self._type_map = self._build_type_map()
-        self._directives = None
+
+        if directives is None:
+            directives = [
+                GraphQLIncludeDirective,
+                GraphQLSkipDirective
+            ]
+
+        assert all(isinstance(d, GraphQLDirective) for d in directives), \
+            'Schema directives must be List[GraphQLDirective] if provided but got: {}.'.format(
+                directives
+            )
+
+        self._directives = directives
 
         for type in self._type_map.values():
             if isinstance(type, GraphQLObjectType):
@@ -63,12 +75,6 @@ def get_type(self, name):
         return self._type_map.get(name)
 
     def get_directives(self):
-        if self._directives is None:
-            self._directives = [
-                GraphQLIncludeDirective,
-                GraphQLSkipDirective
-            ]
-
         return self._directives
 
     def get_directive(self, name):

graphql/core/utils/build_client_schema.py

@@ -22,6 +22,7 @@
     is_input_type,
     is_output_type
 )
+from ..type.directives import GraphQLDirective
 from ..type.introspection import TypeKind
 from .value_from_ast import value_from_ast
 
@@ -194,19 +195,42 @@ def build_default_value(f):
 
     def build_input_value_def_map(input_value_introspection, argument_type):
         return OrderedDict([
-            (f['name'], argument_type(
-                description=f['description'],
-                type=get_input_type(f['type']),
-                default_value=build_default_value(f)
-            )) for f in input_value_introspection
+            (f['name'], build_input_value(f, argument_type)) for f in input_value_introspection
         ])
 
+    def build_input_value(input_value_introspection, argument_type):
+        input_value = argument_type(
+            description=input_value_introspection['description'],
+            type=get_input_type(input_value_introspection['type']),
+            default_value=build_default_value(input_value_introspection)
+        )
+        input_value.name = input_value_introspection['name']
+        return input_value
+
+    def build_directive(directive_introspection):
+        return GraphQLDirective(
+            name=directive_introspection['name'],
+            description=directive_introspection['description'],
+            args=[build_input_value(a, GraphQLArgument) for a in directive_introspection['args']],
+            on_operation=directive_introspection['onOperation'],
+            on_fragment=directive_introspection['onFragment'],
+            on_field=directive_introspection['onField']
+        )
+
     for type_introspection_name in type_introspection_map:
         get_named_type(type_introspection_name)
 
-    query_type = get_type(schema_introspection['queryType'])
-    mutation_type = get_type(schema_introspection['mutationType']) if schema_introspection.get('mutationType') else None
-    subscription_type = get_type(schema_introspection['subscriptionType']) if \
+    query_type = get_object_type(schema_introspection['queryType'])
+    mutation_type = get_object_type(schema_introspection['mutationType']) if schema_introspection.get('mutationType') else None
+    subscription_type = get_object_type(schema_introspection['subscriptionType']) if \
         schema_introspection.get('subscriptionType') else None
 
-    return GraphQLSchema(query=query_type, mutation=mutation_type, subscription=subscription_type)
+    directives = [build_directive(d) for d in schema_introspection['directives']] \
+        if schema_introspection['directives'] else []
+
+    return GraphQLSchema(
+        query=query_type,
+        mutation=mutation_type,
+        subscription=subscription_type,
+        directives=directives
+    )

tests/core_type/test_validation.py

@@ -164,6 +164,13 @@ def test_rejects_a_schema_whose_subscription_type_is_an_input_type(self):
 
         assert str(excinfo.value) == 'Schema subscription must be Object Type but got: SomeInputObject.'
 
+    def test_rejects_a_schema_whose_directives_are_incorrectly_typed(self):
+        with raises(AssertionError) as excinfo:
+            GraphQLSchema(query=SomeObjectType, directives=['somedirective'])
+
+        assert str(excinfo.value) == 'Schema directives must be List[GraphQLDirective] if provided but got: ' \
+                                     '[\'somedirective\'].'
+
 
 # noinspection PyMethodMayBeStatic,PyPep8Naming
 class TestTypeSystem_ASchemaMustContainUniquelyNamedTypes:

tests/core_utils/test_build_client_schema.py

@@ -22,6 +22,7 @@
     GraphQLBoolean,
     GraphQLID,
 )
+from graphql.core.type.directives import GraphQLDirective
 from graphql.core.utils.introspection_query import introspection_query
 from graphql.core.utils.build_client_schema import build_client_schema
 
@@ -382,6 +383,30 @@ def test_builds_a_schema_with_field_arguments_with_default_values():
     _test_schema(schema)
 
 
+def test_builds_a_schema_with_custom_directives():
+    schema = GraphQLSchema(
+        query=GraphQLObjectType(
+            name='Simple',
+            description='This is a simple type',
+            fields={
+                'string': GraphQLField(
+                    type=GraphQLString,
+                    description='This is a string field'
+                )
+            },
+        ),
+        directives=[
+            GraphQLDirective(
+                name='customDirective',
+                description='This is a custom directive',
+                on_field=True
+            )
+        ]
+    )
+
+    _test_schema(schema)
+
+
 def test_builds_a_schema_aware_of_deprecation():
     schema = GraphQLSchema(
         query=GraphQLObjectType(

tests/core_validation/test_known_directives.py

@@ -89,9 +89,12 @@ def test_with_well_placed_directives():
 def test_with_misplaced_directives():
     expect_fails_rule(KnownDirectives, '''
       query Foo @include(if: true) {
-        name
-        ...Frag
+        name @operationOnly
+        ...Frag @operationOnly
       }
     ''', [
-        misplaced_directive('include', 'operation', 2, 17)
+        misplaced_directive('include', 'operation', 2, 17),
+        misplaced_directive('operationOnly', 'field', 3, 14),
+        misplaced_directive('operationOnly', 'fragment', 4, 17),
+
     ])

tests/core_validation/utils.py

@@ -1,3 +1,4 @@
+from graphql.core.type.directives import GraphQLDirective, GraphQLIncludeDirective, GraphQLSkipDirective
 from graphql.core.validation import validate
 from graphql.core.language.parser import parse
 from graphql.core.type import (
@@ -162,7 +163,11 @@
     'complicatedArgs': GraphQLField(ComplicatedArgs),
 })
 
-default_schema = GraphQLSchema(query=QueryRoot)
+default_schema = GraphQLSchema(query=QueryRoot, directives=[
+    GraphQLDirective(name='operationOnly', on_operation=True),
+    GraphQLIncludeDirective,
+    GraphQLSkipDirective
+])
 
 
 def expect_valid(schema, rules, query):