Skip optimised check when returning generic types

RELEASE.md

@@ -0,0 +1,4 @@
+Release type: patch
+
+This release fixes a bug where returning a generic type from a field
+that was returning an interface would throw an error.

strawberry/schema/schema_converter.py

@@ -60,6 +60,7 @@
     StrawberryList,
     StrawberryOptional,
     StrawberryType,
+    get_object_definition,
     has_object_definition,
 )
 from strawberry.types.info import Info
@@ -435,11 +436,16 @@
                 obj: Any, info: GraphQLResolveInfo, abstract_type: GraphQLAbstractType
             ) -> Union[Awaitable[Optional[str]], str, None]:
                 if isinstance(obj, interface.origin):
-                    return obj.__strawberry_definition__.name
-                else:
-                    # Revert to calling is_type_of for cases where a direct subclass
-                    # of the interface is not returned (i.e. an ORM object)
-                    return default_type_resolver(obj, info, abstract_type)
+                    type_definition = get_object_definition(obj, strict=True)
+
+                    # TODO: we should find the correct type here from the
+                    # generic
+                    if not type_definition.is_generic:
+                        return obj.__strawberry_definition__.name
+
+                # Revert to calling is_type_of for cases where a direct subclass
+                # of the interface is not returned (i.e. an ORM object)
+                return default_type_resolver(obj, info, abstract_type)
 
             return resolve_type
 

tests/schema/test_generics.py

@@ -1180,3 +1180,48 @@ def foo(self) -> GenericObject[str]:
             "repr": "foo",
         }
     }
+
+
+def test_generic_interface_extra_types():
+    T = TypeVar("T")
+
+    @strawberry.interface
+    class Abstract:
+        x: str = ""
+
+    @strawberry.type
+    class Real(Generic[T], Abstract):
+        y: T
+
+    @strawberry.type
+    class Query:
+        @strawberry.field
+        def real(self) -> Abstract:
+            return Real[int](y=0)
+
+    schema = strawberry.Schema(Query, types=[Real[int]])
+
+    assert (
+        str(schema)
+        == textwrap.dedent(
+            """
+            interface Abstract {
+              x: String!
+            }
+
+            type IntReal implements Abstract {
+              x: String!
+              y: Int!
+            }
+
+            type Query {
+              real: Abstract!
+            }
+            """
+        ).strip()
+    )
+
+    query_result = schema.execute_sync("{ real { __typename x } }")
+
+    assert not query_result.errors
+    assert query_result.data == {"real": {"__typename": "IntReal", "x": ""}}