[Schema] Implementing interfaces with covariant return types.

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

Author: syrusakbary

graphql/core/type/schema.py

@@ -9,6 +9,7 @@
 )
 from .directives import GraphQLDirective, GraphQLIncludeDirective, GraphQLSkipDirective
 from .introspection import IntrospectionSchema
+from ..utils.type_comparators import is_equal_type, is_type_sub_type_of
 
 
 class GraphQLSchema(object):
@@ -144,7 +145,7 @@ def assert_object_implements_interface(object, interface):
             interface, field_name, object
         )
 
-        assert is_equal_type(interface_field.type, object_field.type), (
+        assert is_type_sub_type_of(object_field.type, interface_field.type), (
             '{}.{} expects type "{}" but {}.{} provides type "{}".'
         ).format(interface, field_name, interface_field.type, object, field_name, object_field.type)
 
@@ -171,13 +172,3 @@ def assert_object_implements_interface(object, interface):
                     '"{}" but is not also provided by the '
                     'interface {}.{}.'
                 ).format(object, field_name, arg_name, object_arg.type, interface, field_name)
-
-
-def is_equal_type(type_a, type_b):
-    if isinstance(type_a, GraphQLNonNull) and isinstance(type_b, GraphQLNonNull):
-        return is_equal_type(type_a.of_type, type_b.of_type)
-
-    if isinstance(type_a, GraphQLList) and isinstance(type_b, GraphQLList):
-        return is_equal_type(type_a.of_type, type_b.of_type)
-
-    return type_a is type_b

graphql/core/utils/type_comparators.py

@@ -0,0 +1,43 @@
+from ..type.definition import (
+    is_abstract_type,
+    GraphQLObjectType,
+    GraphQLList,
+    GraphQLNonNull,
+)
+
+
+def is_equal_type(type_a, type_b):
+    if type_a is type_b:
+        return True
+
+    if isinstance(type_a, GraphQLNonNull) and isinstance(type_b, GraphQLNonNull):
+        return is_equal_type(type_a.of_type, type_b.of_type)
+
+    if isinstance(type_a, GraphQLList) and isinstance(type_b, GraphQLList):
+        return is_equal_type(type_a.of_type, type_b.of_type)
+
+    return False
+
+
+def is_type_sub_type_of(maybe_subtype, super_type):
+    if maybe_subtype is super_type:
+        return True
+
+    if isinstance(super_type, GraphQLNonNull):
+        if isinstance(maybe_subtype, GraphQLNonNull):
+            return is_type_sub_type_of(maybe_subtype.of_type, super_type.of_type)
+        return False
+    elif isinstance(maybe_subtype, GraphQLNonNull):
+        return is_type_sub_type_of(maybe_subtype.of_type, super_type)
+
+    if isinstance(super_type, GraphQLList):
+        if isinstance(maybe_subtype, GraphQLList):
+            return is_type_sub_type_of(maybe_subtype.of_type, super_type.of_type)
+        return False
+    elif isinstance(maybe_subtype, GraphQLList):
+        return False
+
+    if is_abstract_type(super_type) and isinstance(maybe_subtype, GraphQLObjectType) and super_type.is_possible_type(maybe_subtype):
+        return True
+
+    return False

graphql/core/validation/rules/overlapping_fields_can_be_merged.py

@@ -11,6 +11,7 @@
     get_named_type,
 )
 from ...utils.type_from_ast import type_from_ast
+from ...utils.type_comparators import is_equal_type
 from .base import ValidationRule
 
 
@@ -128,7 +129,8 @@ def leave_SelectionSet(self, node, key, parent, path, ancestors):
 
     @staticmethod
     def same_type(type1, type2):
-        return type1.is_same_type(type2)
+        return is_equal_type(type1, type2)
+        # return type1.is_same_type(type2)
 
     @staticmethod
     def same_value(value1, value2):

graphql/core/validation/rules/variables_in_allowed_position.py

@@ -1,9 +1,9 @@
 from ...error import GraphQLError
 from ...type.definition import (
-    GraphQLList,
     GraphQLNonNull
 )
 from ...utils.type_from_ast import type_from_ast
+from ...utils.type_comparators import is_type_sub_type_of
 from .base import ValidationRule
 
 
@@ -27,7 +27,7 @@ def leave_OperationDefinition(self, operation, key, parent, path, ancestors):
             var_def = self.var_def_map.get(var_name)
             if var_def and type:
                 var_type = type_from_ast(self.context.get_schema(), var_def.type)
-                if var_type and not self.var_type_allowed_for_type(self.effective_type(var_type, var_def), type):
+                if var_type and not is_type_sub_type_of(self.effective_type(var_type, var_def), type):
                     self.context.report_error(GraphQLError(
                         self.bad_var_pos_message(var_name, var_type, type),
                         [var_def, node]
@@ -43,22 +43,6 @@ def effective_type(var_type, var_def):
 
         return GraphQLNonNull(var_type)
 
-    @classmethod
-    def var_type_allowed_for_type(cls, var_type, expected_type):
-        if isinstance(expected_type, GraphQLNonNull):
-            if isinstance(var_type, GraphQLNonNull):
-                return cls.var_type_allowed_for_type(var_type.of_type, expected_type.of_type)
-
-            return False
-
-        if isinstance(var_type, GraphQLNonNull):
-            return cls.var_type_allowed_for_type(var_type.of_type, expected_type)
-
-        if isinstance(var_type, GraphQLList) and isinstance(expected_type, GraphQLList):
-            return cls.var_type_allowed_for_type(var_type.of_type, expected_type.of_type)
-
-        return var_type == expected_type
-
     @staticmethod
     def bad_var_pos_message(var_name, var_type, expected_type):
         return 'Variable "{}" of type "{}" used in position expecting type "{}".'.format(var_name, var_type,

tests/core_type/test_validation.py

@@ -1459,6 +1459,98 @@ def test_rejects_an_object_with_an_incorrectly_typed_interface_argument(self):
         assert str(excinfo.value) == 'AnotherInterface.field(input:) expects type "String" ' \
                                      'but AnotherObject.field(input:) provides type "SomeScalar".'
 
+    def test_rejects_an_object_with_an_incorrectly_typed_interface_field(self):
+        AnotherInterface = GraphQLInterfaceType(
+            name='AnotherInterface',
+            resolve_type=_none,
+            fields={
+                'field': GraphQLField(GraphQLString)
+            }
+        )
+        AnotherObject = GraphQLObjectType(
+            name='AnotherObject',
+            interfaces=[AnotherInterface],
+            fields={
+                'field': GraphQLField(SomeScalarType)
+            }
+        )
+
+        with raises(AssertionError) as excinfo:
+            schema_with_field_type(AnotherObject)
+
+        assert str(excinfo.value) == 'AnotherInterface.field expects type "String" ' \
+                                     'but AnotherObject.field provides type "SomeScalar".'
+
+    def test_rejects_an_object_with_a_differently_typed_Interface_field(self):
+        TypeA = GraphQLObjectType(
+            name='A',
+            fields={
+                'foo': GraphQLField(GraphQLString)
+            }
+        )
+        TypeB = GraphQLObjectType(
+            name='B',
+            fields={
+                'foo': GraphQLField(GraphQLString)
+            }
+        )
+        AnotherInterface = GraphQLInterfaceType(
+            name='AnotherInterface',
+            resolve_type=_none,
+            fields={
+                'field': GraphQLField(TypeA)
+            }
+        )
+        AnotherObject = GraphQLObjectType(
+            name='AnotherObject',
+            interfaces=[AnotherInterface],
+            fields={
+                'field': GraphQLField(TypeB)
+            }
+        )
+
+        with raises(AssertionError) as excinfo:
+            schema_with_field_type(AnotherObject)
+
+        assert str(excinfo.value) == 'AnotherInterface.field expects type "A" but ' \
+                                     'AnotherObject.field provides type "B".'
+
+    def test_accepts_an_object_with_a_subtyped_interface_field_interface(self):
+        AnotherInterface = GraphQLInterfaceType(
+            name='AnotherInterface',
+            resolve_type=_none,
+            fields=lambda: {
+                'field': GraphQLField(AnotherInterface)
+            }
+        )
+        AnotherObject = GraphQLObjectType(
+            name='AnotherObject',
+            interfaces=[AnotherInterface],
+            fields=lambda: {
+                'field': GraphQLField(AnotherObject)
+            }
+        )
+
+        assert schema_with_field_type(AnotherObject)
+
+    def test_accepts_an_object_with_a_subtyped_interface_field_union(self):
+        AnotherInterface = GraphQLInterfaceType(
+            name='AnotherInterface',
+            resolve_type=_none,
+            fields=lambda: {
+                'field': GraphQLField(SomeUnionType)
+            }
+        )
+        AnotherObject = GraphQLObjectType(
+            name='AnotherObject',
+            interfaces=[AnotherInterface],
+            fields=lambda: {
+                'field': GraphQLField(SomeObjectType)
+            }
+        )
+
+        assert schema_with_field_type(AnotherObject)
+
     def test_accepts_an_object_with_an_equivalently_modified_interface_field_type(self):
         AnotherInterface = GraphQLInterfaceType(
             name='AnotherInterface',
@@ -1478,7 +1570,29 @@ def test_accepts_an_object_with_an_equivalently_modified_interface_field_type(se
 
         assert schema_with_field_type(AnotherObject)
 
-    def test_rejects_an_object_with_an_differently_modified_interface_field_type(self):
+    def test_rejects_an_object_with_a_non_list_interface_field_list_type(self):
+        AnotherInterface = GraphQLInterfaceType(
+            name='AnotherInterface',
+            resolve_type=_none,
+            fields={
+                'field': GraphQLField(GraphQLList(GraphQLString))
+            }
+        )
+        AnotherObject = GraphQLObjectType(
+            name='AnotherObject',
+            interfaces=[AnotherInterface],
+            fields={
+                'field': GraphQLField(GraphQLString)
+            }
+        )
+
+        with raises(AssertionError) as excinfo:
+            schema_with_field_type(AnotherObject)
+
+        assert str(excinfo.value) == 'AnotherInterface.field expects type "[String]" ' \
+                                     'but AnotherObject.field provides type "String".'
+
+    def test_rejects_a_object_with_a_list_interface_field_non_list_type(self):
         AnotherInterface = GraphQLInterfaceType(
             name='AnotherInterface',
             resolve_type=_none,
@@ -1490,7 +1604,7 @@ def test_rejects_an_object_with_an_differently_modified_interface_field_type(sel
             name='AnotherObject',
             interfaces=[AnotherInterface],
             fields={
-                'field': GraphQLField(GraphQLNonNull(GraphQLString))
+                'field': GraphQLField(GraphQLList(GraphQLString))
 
             }
         )
@@ -1499,4 +1613,45 @@ def test_rejects_an_object_with_an_differently_modified_interface_field_type(sel
             schema_with_field_type(AnotherObject)
 
         assert str(excinfo.value) == 'AnotherInterface.field expects type "String" ' \
-                                     'but AnotherObject.field provides type "String!".'
+                                     'but AnotherObject.field provides type "[String]".'
+
+    def test_accepts_an_object_with_a_subset_non_null_interface_field_type(self):
+        AnotherInterface = GraphQLInterfaceType(
+            name='AnotherInterface',
+            resolve_type=_none,
+            fields={
+                'field': GraphQLField(GraphQLString)
+            }
+        )
+        AnotherObject = GraphQLObjectType(
+            name='AnotherObject',
+            interfaces=[AnotherInterface],
+            fields={
+                'field': GraphQLField(GraphQLNonNull(GraphQLString))
+            }
+        )
+
+        assert schema_with_field_type(AnotherObject)
+
+    def test_rejects_a_object_with_a_superset_nullable_interface_field_type(self):
+        AnotherInterface = GraphQLInterfaceType(
+            name='AnotherInterface',
+            resolve_type=_none,
+            fields={
+                'field': GraphQLField(GraphQLNonNull(GraphQLString))
+            }
+        )
+        AnotherObject = GraphQLObjectType(
+            name='AnotherObject',
+            interfaces=[AnotherInterface],
+            fields={
+                'field': GraphQLField(GraphQLString)
+
+            }
+        )
+
+        with raises(AssertionError) as excinfo:
+            schema_with_field_type(AnotherObject)
+
+        assert str(excinfo.value) == 'AnotherInterface.field expects type "String!" but ' \
+                                     'AnotherObject.field provides type "String".'