[RFC] Proposed change to directive location introspection

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

Author: syrusakbary

graphql/pyutils/contain_subset.py

@@ -0,0 +1,24 @@
+obj = (dict, list, tuple)
+
+def contain_subset(expected, actual):
+    t_actual = type(actual)
+    t_expected = type(expected)
+    if not(issubclass(t_actual, t_expected) or issubclass(t_expected, t_actual)):
+        return False
+    if not isinstance(expected, obj) or expected is None:
+        return expected == actual
+    if expected and not actual:
+        return False
+    if isinstance(expected, list):
+        aa = actual[:]
+        return all([any([contain_subset(exp, act) for act in aa]) for exp in expected])
+    for key in expected.keys():
+        eo = expected[key]
+        ao = actual.get(key)
+        if isinstance(eo, obj) and eo is not None and ao is not None:
+            if not contain_subset(eo, ao):
+                return False
+            continue
+        if ao != eo:
+            return False
+    return True

graphql/pyutils/tests/test_contain_subset.py

@@ -0,0 +1,126 @@
+from ..contain_subset import contain_subset
+
+plain_object = {
+    'a':'b',
+    'c':'d'
+}
+
+complex_object = {
+    'a': 'b',
+    'c': 'd',
+    'e': {
+        'foo': 'bar',
+        'baz': {
+            'qux': 'quux'
+        }
+    }
+}
+
+def test_plain_object_should_pass_for_smaller_object():
+    assert contain_subset({'a': 'b'}, plain_object)
+
+
+def test_plain_object_should_pass_for_same_object():
+    assert contain_subset({
+        'a':'b',
+        'c':'d'
+    }, plain_object)
+
+
+def test_plain_object_should_reject_for_similar_object():
+    assert not contain_subset({
+        'a':'notB',
+        'c':'d'
+    }, plain_object)
+
+
+def test_complex_object_should_pass_for_smaller_object():
+    assert contain_subset({
+        'a':'b',
+        'e': {
+            'foo':'bar'
+        }
+    }, complex_object)
+
+
+def test_complex_object_should_pass_for_smaller_object_other():
+    assert contain_subset({
+        'e': {
+            'foo':'bar',
+            'baz':{
+                'qux': 'quux'
+            }
+        }
+    }, complex_object)
+
+
+def test_complex_object_should_pass_for_same_object():
+    assert contain_subset({
+        'a': 'b',
+        'c': 'd',
+        'e': {
+            'foo': 'bar',
+            'baz': {
+                'qux': 'quux'
+            }
+        }
+    }, complex_object)
+
+
+def test_complex_object_should_reject_for_similar_object():
+    assert not contain_subset({
+        'e': {
+            'foo':'bar',
+            'baz':{
+                'qux': 'notAQuux'
+            }
+        }
+    }, complex_object)
+
+
+def test_circular_objects_should_contain_subdocument():
+    obj = {}
+    obj['arr'] = [obj,obj]
+    obj['arr'].append(obj['arr'])
+    obj['obj'] = obj
+
+    assert contain_subset({
+            'arr': [
+                {'arr': []},
+                {'arr': []},
+                [
+                    {'arr': []},
+                    {'arr': []}
+                ]
+            ]
+        }, obj)
+
+
+def test_circular_objects_should_not_contain_similardocument():
+    obj = {}
+    obj['arr'] = [obj,obj]
+    obj['arr'].append(obj['arr'])
+    obj['obj'] = obj
+
+    assert not contain_subset({
+            'arr': [
+                {'arr': ['just random field']},
+                {'arr': []},
+                [
+                    {'arr': []},
+                    {'arr': []}
+                ]
+            ]
+        }, obj)
+
+
+def test_should_contain_others():
+    obj = {
+        'elems': [{'a':'b', 'c':'d', 'e':'f'}, {'g':'h'}]
+    }
+    assert contain_subset({
+        'elems': [{
+        'g':'h'
+        },{'a':'b','e':'f'}
+        ]
+    }, obj)

graphql/type/definition.py

@@ -1,8 +1,8 @@
 import collections
 import copy
-import re
 
 from ..language import ast
+from ..utils.assert_valid_name import assert_valid_name
 
 
 def is_type(type):
@@ -751,11 +751,3 @@ def __str__(self):
 
     def is_same_type(self, other):
         return isinstance(other, GraphQLNonNull) and self.of_type.is_same_type(other.of_type)
-
-
-NAME_PATTERN = r'^[_a-zA-Z][_a-zA-Z0-9]*$'
-COMPILED_NAME_PATTERN = re.compile(NAME_PATTERN)
-
-
-def assert_valid_name(name):
-    assert COMPILED_NAME_PATTERN.match(name), 'Names must match /{}/ but "{}" does not.'.format(NAME_PATTERN, name)

graphql/type/directives.py

@@ -1,17 +1,48 @@
+import collections
+
 from .definition import GraphQLArgument, GraphQLNonNull
 from .scalars import GraphQLBoolean
+from ..utils.assert_valid_name import assert_valid_name
+
+
+class DirectiveLocation(object):
+    QUERY = 'QUERY'
+    MUTATION = 'MUTATION'
+    SUBSCRIPTION = 'SUBSCRIPTION'
+    FIELD = 'FIELD'
+    FRAGMENT_DEFINITION = 'FRAGMENT_DEFINITION'
+    FRAGMENT_SPREAD = 'FRAGMENT_SPREAD'
+    INLINE_FRAGMENT = 'INLINE_FRAGMENT'
+
+    OPERATION_LOCATIONS = [
+        QUERY,
+        MUTATION,
+        SUBSCRIPTION
+    ]
+
+    FRAGMENT_LOCATIONS = [
+        FRAGMENT_DEFINITION,
+        FRAGMENT_SPREAD,
+        INLINE_FRAGMENT
+    ]
+
+    FIELD_LOCATIONS = [
+        FIELD
+    ]
 
 
 class GraphQLDirective(object):
-    __slots__ = 'name', 'args', 'description', 'on_operation', 'on_fragment', 'on_field'
+    __slots__ = 'name', 'args', 'description', 'locations'
+
+    def __init__(self, name, description=None, args=None, locations=None):
+        assert name, 'Directive must be named.'
+        assert_valid_name(name)
+        assert isinstance(locations, collections.Iterable), 'Must provide locations for directive.'
 
-    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
+        self.locations = locations
 
 
 def arg(name, *args, **kwargs):
@@ -27,9 +58,11 @@ def arg(name, *args, **kwargs):
         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
+    locations=[
+        DirectiveLocation.FIELD,
+        DirectiveLocation.FRAGMENT_SPREAD,
+        DirectiveLocation.INLINE_FRAGMENT,
+    ]
 )
 
 GraphQLSkipDirective = GraphQLDirective(
@@ -39,7 +72,9 @@ def arg(name, *args, **kwargs):
         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
+    locations=[
+        DirectiveLocation.FIELD,
+        DirectiveLocation.FRAGMENT_SPREAD,
+        DirectiveLocation.INLINE_FRAGMENT,
+    ]
 )

graphql/type/introspection.py

@@ -8,6 +8,8 @@
                          GraphQLObjectType, GraphQLScalarType,
                          GraphQLUnionType)
 from .scalars import GraphQLBoolean, GraphQLString
+from .directives import DirectiveLocation
+
 
 __Schema = GraphQLObjectType(
     '__Schema',
@@ -44,6 +46,10 @@
         )),
     ]))
 
+_on_operation_locations = set(DirectiveLocation.OPERATION_LOCATIONS)
+_on_fragment_locations = set(DirectiveLocation.FRAGMENT_LOCATIONS)
+_on_field_locations = set(DirectiveLocation.FIELD_LOCATIONS)
+
 __Directive = GraphQLObjectType(
     '__Directive',
     description='A Directive provides a way to describe alternate runtime execution and '
@@ -55,24 +61,67 @@
     fields=lambda: OrderedDict([
         ('name', GraphQLField(GraphQLNonNull(GraphQLString))),
         ('description', GraphQLField(GraphQLString)),
+        ('locations', GraphQLField(
+            type=GraphQLNonNull(GraphQLList(GraphQLNonNull(__DirectiveLocation))),
+        )),
         ('args', GraphQLField(
             type=GraphQLNonNull(GraphQLList(GraphQLNonNull(__InputValue))),
             resolver=lambda directive, *args: directive.args or [],
         )),
         ('onOperation', GraphQLField(
             type=GraphQLNonNull(GraphQLBoolean),
-            resolver=lambda directive, *args: directive.on_operation,
+            deprecation_reason='Use `locations`.',
+            resolver=lambda directive, *args: set(directive.locations) & _on_operation_locations,
         )),
         ('onFragment', GraphQLField(
             type=GraphQLNonNull(GraphQLBoolean),
-            resolver=lambda directive, *args: directive.on_fragment,
+            deprecation_reason='Use `locations`.',
+            resolver=lambda directive, *args: set(directive.locations) & _on_fragment_locations,
         )),
         ('onField', GraphQLField(
             type=GraphQLNonNull(GraphQLBoolean),
-            resolver=lambda directive, *args: directive.on_field,
+            deprecation_reason='Use `locations`.',
+            resolver=lambda directive, *args: set(directive.locations) & _on_field_locations,
         ))
     ]))
 
+__DirectiveLocation = GraphQLEnumType(
+    '__DirectiveLocation',
+    description=(
+        'A Directive can be adjacent to many parts of the GraphQL language, a ' +
+        '__DirectiveLocation describes one such possible adjacencies.'
+    ),
+    values=OrderedDict([
+        ('QUERY', GraphQLEnumValue(
+            DirectiveLocation.QUERY,
+            description='Location adjacent to a query operation.'
+        )),
+        ('MUTATION', GraphQLEnumValue(
+            DirectiveLocation.MUTATION,
+            description='Location adjacent to a mutation operation.'
+        )),
+        ('SUBSCRIPTION', GraphQLEnumValue(
+            DirectiveLocation.SUBSCRIPTION,
+            description='Location adjacent to a subscription operation.'
+        )),
+        ('FIELD', GraphQLEnumValue(
+            DirectiveLocation.FIELD,
+            description='Location adjacent to a field.'
+        )),
+        ('FRAGMENT_DEFINITION', GraphQLEnumValue(
+            DirectiveLocation.FRAGMENT_DEFINITION,
+            description='Location adjacent to a fragment definition.'
+        )),
+        ('FRAGMENT_SPREAD', GraphQLEnumValue(
+            DirectiveLocation.FRAGMENT_SPREAD,
+            description='Location adjacent to a fragment spread.'
+        )),
+        ('INLINE_FRAGMENT', GraphQLEnumValue(
+            DirectiveLocation.INLINE_FRAGMENT,
+            description='Location adjacent to an inline fragment.'
+        )),
+    ]))
+
 
 class TypeKind(object):
     SCALAR = 'SCALAR'

graphql/type/schema.py

@@ -83,11 +83,8 @@ def get_directive(self, name):
         return None
 
     def _build_type_map(self):
-        type_map = OrderedDict()
-        types = (self.get_query_type(), self.get_mutation_type(), self.get_subscription_type(), IntrospectionSchema)
-        for type in types:
-            type_map = type_map_reducer(type_map, type)
-
+        types = [self.get_query_type(), self.get_mutation_type(), self.get_subscription_type(), IntrospectionSchema]
+        type_map = reduce(type_map_reducer, types, OrderedDict())
         return type_map