Add GraphQLSchema types field, refactored code and added extra comments

Related GraphQL-js commits: graphql/graphql-js@6a1f23e graphql/graphql-js@09be751

Author: syrusakbary

graphql/execution/base.py

@@ -230,7 +230,7 @@ def does_fragment_condition_match(ctx, fragment, type_):
         return True
 
     if isinstance(conditional_type, (GraphQLInterfaceType, GraphQLUnionType)):
-        return conditional_type.is_possible_type(type_)
+        return ctx.schema.is_possible_type(conditional_type, type_)
 
     return False
 

graphql/execution/executor.py

@@ -312,7 +312,8 @@ def complete_abstract_value(exe_context, return_type, field_asts, info, result):
     if not runtime_type:
         return None
 
-    if not return_type.is_possible_type(runtime_type):
+    schema = exe_context.schema
+    if not schema.is_possible_type(return_type, runtime_type):
         raise GraphQLError(
             u'Runtime Object type "{}" is not a possible type for "{}".'.format(runtime_type, return_type),
             field_asts
@@ -322,7 +323,7 @@ def complete_abstract_value(exe_context, return_type, field_asts, info, result):
 
 
 def get_default_resolve_type_fn(value, info, abstract_type):
-    possible_types = abstract_type.get_possible_types()
+    possible_types = info.schema.get_possible_types(abstract_type)
     for type in possible_types:
         if callable(type.is_type_of) and type.is_type_of(value, info):
             return type

graphql/execution/tests/test_abstract.py

@@ -81,7 +81,8 @@ def test_is_type_of_used_to_resolve_runtime_type_for_interface():
                     resolver=lambda *_: [Dog('Odie', True), Cat('Garfield', False)]
                 )
             }
-        )
+        ),
+        types=[CatType, DogType]
     )
 
     query = '''
@@ -136,7 +137,8 @@ def test_is_type_of_used_to_resolve_runtime_type_for_union():
                     resolver=lambda *_: [Dog('Odie', True), Cat('Garfield', False)]
                 )
             }
-        )
+        ),
+        types=[CatType, DogType]
     )
 
     query = '''
@@ -206,7 +208,8 @@ def test_resolve_type_on_interface_yields_useful_error():
                     resolver=lambda *_: [Dog('Odie', True), Cat('Garfield', False), Human('Jon')]
                 )
             }
-        )
+        ),
+        types=[DogType, CatType]
     )
 
     query = '''

graphql/execution/tests/test_resolve.py

@@ -1,8 +1,9 @@
-from collections import OrderedDict
 import json
+from collections import OrderedDict
 
 from graphql import graphql
-from graphql.type import GraphQLSchema, GraphQLString, GraphQLObjectType, GraphQLInt, GraphQLField, GraphQLArgument
+from graphql.type import (GraphQLArgument, GraphQLField, GraphQLInt,
+                          GraphQLObjectType, GraphQLSchema, GraphQLString)
 
 
 def _test_schema(test_field):

graphql/execution/tests/test_union_interface.py

@@ -73,7 +73,7 @@ def resolve_pet_type(value, info):
     is_type_of=lambda value, info: isinstance(value, Person)
 )
 
-schema = GraphQLSchema(PersonType)
+schema = GraphQLSchema(query=PersonType, types=[PetType])
 
 garfield = Cat('Garfield', False)
 odie = Dog('Odie', True)
@@ -114,7 +114,7 @@ def test_can_introspect_on_union_and_intersection_types():
             'kind': 'INTERFACE',
             'interfaces': None,
             'fields': [{'name': 'name'}],
-            'possibleTypes': [{'name': 'Dog'}, {'name': 'Cat'}, {'name': 'Person'}],
+            'possibleTypes': [{'name': 'Person'}, {'name': 'Dog'}, {'name': 'Cat'}],
             'inputFields': None
         },
         'Pet': {

graphql/type/definition.py

@@ -187,7 +187,6 @@ def __init__(self, name, fields, interfaces=None, is_type_of=None, description=N
         self._provided_interfaces = interfaces
         self._field_map = None
         self._interfaces = None
-        add_impl_to_interfaces(self)
 
     def get_fields(self):
         if self._field_map is None:
@@ -289,11 +288,6 @@ def define_interfaces(type, interfaces):
     return interfaces
 
 
-def add_impl_to_interfaces(impl):
-    for type in impl.get_interfaces():
-        type._impls.append(impl)
-
-
 class GraphQLField(object):
     __slots__ = 'name', 'type', 'args', 'resolver', 'deprecation_reason', 'description'
 
@@ -360,7 +354,7 @@ class GraphQLInterfaceType(GraphQLType):
                 'name': GraphQLField(GraphQLString),
             })
     """
-    __slots__ = 'name', 'description', 'resolve_type', '_fields', '_impls', '_field_map', '_possible_type_names'
+    __slots__ = 'name', 'description', 'resolve_type', '_fields', '_field_map'
 
     def __init__(self, name, fields=None, resolve_type=None, description=None):
         assert name, 'Type must be named.'
@@ -374,26 +368,14 @@ def __init__(self, name, fields=None, resolve_type=None, description=None):
         self.resolve_type = resolve_type
         self._fields = fields
 
-        self._impls = []
         self._field_map = None
-        self._possible_type_names = None
 
     def get_fields(self):
         if self._field_map is None:
             self._field_map = define_field_map(self, self._fields)
 
         return self._field_map
 
-    def get_possible_types(self):
-        return self._impls
-
-    def is_possible_type(self, type):
-        if self._possible_type_names is None:
-            self._possible_type_names = set(
-                t.name for t in self.get_possible_types()
-            )
-        return type.name in self._possible_type_names
-
 
 class GraphQLUnionType(GraphQLType):
     """Union Type Definition
@@ -413,7 +395,7 @@ def resolve_type(self, value):
                 if isinstance(value, Cat):
                     return CatType()
     """
-    __slots__ = 'name', 'description', 'resolve_type', '_types', '_possible_type_names', '_possible_types'
+    __slots__ = 'name', 'description', 'resolve_type', '_types'
 
     def __init__(self, name, types=None, resolve_type=None, description=None):
         assert name, 'Type must be named.'
@@ -425,23 +407,10 @@ def __init__(self, name, types=None, resolve_type=None, description=None):
             assert callable(resolve_type), '{} must provide "resolve_type" as a function.'.format(self)
 
         self.resolve_type = resolve_type
-        self._types = types
-        self._possible_types = None
-        self._possible_type_names = None
-
-    def get_possible_types(self):
-        if self._possible_types is None:
-            self._possible_types = define_types(self, self._types)
-
-        return self._possible_types
-
-    def is_possible_type(self, type):
-        if self._possible_type_names is None:
-            self._possible_type_names = set(
-                t.name for t in self.get_possible_types()
-            )
+        self._types = define_types(self, types)
 
-        return type.name in self._possible_type_names
+    def get_types(self):
+        return self._types
 
 
 def define_types(union_type, types):

graphql/type/introspection.py

@@ -168,9 +168,9 @@ def interfaces(type, *_):
             return type.get_interfaces()
 
     @staticmethod
-    def possible_types(type, *_):
+    def possible_types(type, args, info):
         if isinstance(type, (GraphQLInterfaceType, GraphQLUnionType)):
-            return type.get_possible_types()
+            return info.schema.get_possible_types(type)
 
     @staticmethod
     def enum_values(type, args, *_):

graphql/type/schema.py

@@ -1,4 +1,4 @@
-from collections import OrderedDict
+from collections import Iterable, OrderedDict, defaultdict
 from functools import reduce
 
 from ..utils.type_comparators import is_equal_type, is_type_sub_type_of
@@ -23,9 +23,9 @@ class GraphQLSchema(object):
             mutation=MyAppMutationRootType
         )
     """
-    __slots__ = '_query', '_mutation', '_subscription', '_type_map', '_directives',
+    __slots__ = '_query', '_mutation', '_subscription', '_type_map', '_directives', '_implementations', '_possible_type_map'
 
-    def __init__(self, query, mutation=None, subscription=None, directives=None):
+    def __init__(self, query, mutation=None, subscription=None, directives=None, types=None):
         assert isinstance(query, GraphQLObjectType), 'Schema query must be Object Type but got: {}.'.format(query)
         if mutation:
             assert isinstance(mutation, GraphQLObjectType), \
@@ -35,6 +35,10 @@ def __init__(self, query, mutation=None, subscription=None, directives=None):
             assert isinstance(subscription, GraphQLObjectType), \
                 'Schema subscription must be Object Type but got: {}.'.format(subscription)
 
+        if types:
+            assert isinstance(types, Iterable), \
+                'Schema types must be iterable if provided but got: {}.'.format(types)
+
         self._query = query
         self._mutation = mutation
         self._subscription = subscription
@@ -50,13 +54,20 @@ def __init__(self, query, mutation=None, subscription=None, directives=None):
         )
 
         self._directives = directives
-        self._type_map = self._build_type_map()
+        self._possible_type_map = defaultdict(set)
+        self._type_map = self._build_type_map(types)
+        # Keep track of all implementations by interface name.
+        self._implementations = defaultdict(list)
+        for type in self._type_map.values():
+            if isinstance(type, GraphQLObjectType):
+                for interface in type.get_interfaces():
+                    self._implementations[interface.name].append(type)
 
         # Enforce correct interface implementations.
         for type in self._type_map.values():
             if isinstance(type, GraphQLObjectType):
                 for interface in type.get_interfaces():
-                    assert_object_implements_interface(type, interface)
+                    assert_object_implements_interface(self, type, interface)
 
     def get_query_type(self):
         return self._query
@@ -83,11 +94,32 @@ def get_directive(self, name):
 
         return None
 
-    def _build_type_map(self):
-        types = [self.get_query_type(), self.get_mutation_type(), self.get_subscription_type(), IntrospectionSchema]
+    def _build_type_map(self, _types):
+        types = [
+            self.get_query_type(),
+            self.get_mutation_type(),
+            self.get_subscription_type(),
+            IntrospectionSchema
+        ]
+        if _types:
+            types += _types
+
         type_map = reduce(type_map_reducer, types, OrderedDict())
         return type_map
 
+    def get_possible_types(self, abstract_type):
+        if isinstance(abstract_type, GraphQLUnionType):
+            return abstract_type.get_types()
+        assert isinstance(abstract_type, GraphQLInterfaceType)
+        return self._implementations[abstract_type.name]
+
+    def is_possible_type(self, abstract_type, possible_type):
+        if not self._possible_type_map[abstract_type.name]:
+            possible_types = self.get_possible_types(abstract_type)
+            self._possible_type_map[abstract_type.name].update([p.name for p in possible_types])
+
+        return possible_type.name in self._possible_type_map[abstract_type.name]
+
 
 def type_map_reducer(map, type):
     if not type:
@@ -107,8 +139,8 @@ def type_map_reducer(map, type):
 
     reduced_map = map
 
-    if isinstance(type, (GraphQLUnionType, GraphQLInterfaceType)):
-        for t in type.get_possible_types():
+    if isinstance(type, (GraphQLUnionType)):
+        for t in type.get_types():
             reduced_map = type_map_reducer(reduced_map, t)
 
     if isinstance(type, GraphQLObjectType):
@@ -129,7 +161,7 @@ def type_map_reducer(map, type):
     return reduced_map
 
 
-def assert_object_implements_interface(object, interface):
+def assert_object_implements_interface(schema, object, interface):
     object_field_map = object.get_fields()
     interface_field_map = interface.get_fields()
 
@@ -140,7 +172,7 @@ def assert_object_implements_interface(object, interface):
             interface, field_name, object
         )
 
-        assert is_type_sub_type_of(object_field.type, interface_field.type), (
+        assert is_type_sub_type_of(schema, object_field.type, interface_field.type), (
             '{}.{} expects type "{}" but {}.{} provides type "{}".'
         ).format(interface, field_name, interface_field.type, object, field_name, object_field.type)
 

graphql/type/tests/test_definition.py

@@ -183,7 +183,7 @@ def test_includes_interfaces_thunk_subtypes_in_the_type_map():
         fields={
             'iface': GraphQLField(SomeInterface)
         }
-    ))
+    ), types=[SomeSubtype])
 
     assert schema.get_type_map()['SomeSubtype'] is SomeSubtype
 
@@ -196,7 +196,7 @@ def test_includes_interfaces_subtypes_in_the_type_map():
         interfaces=[SomeInterface],
         is_type_of=lambda: None
     )
-    schema = GraphQLSchema(query=GraphQLObjectType(name='Query', fields={'iface': GraphQLField(SomeInterface)}))
+    schema = GraphQLSchema(query=GraphQLObjectType(name='Query', fields={'iface': GraphQLField(SomeInterface)}), types=[SomeSubtype])
     assert schema.get_type_map()['SomeSubtype'] == SomeSubtype
 
 

graphql/type/tests/test_validation.py

@@ -107,7 +107,8 @@ def schema_with_field_type(t):
             fields={
                 'f': GraphQLField(t)
             }
-        )
+        ),
+        types=[t]
     )
 
 
@@ -218,7 +219,7 @@ def test_it_rejects_a_schema_which_have_same_named_objects_implementing_an_inter
         )
 
         with raises(AssertionError) as excinfo:
-            GraphQLSchema(query=QueryType)
+            GraphQLSchema(query=QueryType, types=[FirstBadObject, SecondBadObject])
 
         assert str(excinfo.value) == 'Schema must contain unique named types but contains multiple types named ' \
                                      '"BadObject".'