fix: fix DuplicatedTypeName exception raised for nested generics (#3946)

Author: bellini666

RELEASE.md

@@ -0,0 +1,28 @@
+Release type: patch
+
+This release fixes an issue where `DuplicatedTypeName` exception would be raised
+for nested generics like in the example below:
+
+```python
+from typing import Generic, TypeVar
+
+import strawberry
+
+T = TypeVar("T")
+
+
+@strawberry.type
+class Wrapper(Generic[T]):
+    value: T
+
+
+@strawberry.type
+class Query:
+    a: Wrapper[Wrapper[int]]
+    b: Wrapper[Wrapper[int]]
+
+
+schema = strawberry.Schema(query=Query)
+```
+
+This piece of code and similar ones will now work correctly.

strawberry/schema/schema_converter.py

@@ -1003,43 +1003,11 @@ def validate_same_type_definition(
         first_type_definition = cached_type.definition
         second_type_definition = type_definition
 
-        # TODO: maybe move this on the StrawberryType class
-        if (
-            isinstance(first_type_definition, StrawberryObjectDefinition)
-            and isinstance(second_type_definition, StrawberryObjectDefinition)
-            and first_type_definition.concrete_of is not None
-            and first_type_definition.concrete_of == second_type_definition.concrete_of
-            and (
-                first_type_definition.type_var_map.keys()
-                == second_type_definition.type_var_map.keys()
-            )
+        if self.is_same_type_definition(
+            first_type_definition,
+            second_type_definition,
         ):
-            # manually compare type_var_maps while resolving any lazy types
-            # so that they're considered equal to the actual types they're referencing
-            equal = True
-            for type_var, type1 in first_type_definition.type_var_map.items():
-                type2 = second_type_definition.type_var_map[type_var]
-                # both lazy types are always resolved because two different lazy types
-                # may be referencing the same actual type
-                if isinstance(type1, LazyType):
-                    type1 = type1.resolve_type()  # noqa: PLW2901
-                elif isinstance(type1, StrawberryOptional) and isinstance(
-                    type1.of_type, LazyType
-                ):
-                    type1.of_type = type1.of_type.resolve_type()
-
-                if isinstance(type2, LazyType):
-                    type2 = type2.resolve_type()
-                elif isinstance(type2, StrawberryOptional) and isinstance(
-                    type2.of_type, LazyType
-                ):
-                    type2.of_type = type2.of_type.resolve_type()
-
-                if type1 != type2:
-                    equal = False
-                    break
-            if equal:
-                return
+            return
 
         if isinstance(second_type_definition, StrawberryObjectDefinition):
             first_origin = second_type_definition.origin
@@ -1057,5 +1025,63 @@ def validate_same_type_definition(
 
         raise DuplicatedTypeName(first_origin, second_origin, name)
 
+    def is_same_type_definition(
+        self,
+        first_type_definition: StrawberryObjectDefinition | StrawberryType,
+        second_type_definition: StrawberryObjectDefinition | StrawberryType,
+    ) -> bool:
+        # TODO: maybe move this on the StrawberryType class
+        if (
+            not isinstance(first_type_definition, StrawberryObjectDefinition)
+            or not isinstance(second_type_definition, StrawberryObjectDefinition)
+            or first_type_definition.concrete_of is None
+            or first_type_definition.concrete_of != second_type_definition.concrete_of
+            or (
+                first_type_definition.type_var_map.keys()
+                != second_type_definition.type_var_map.keys()
+            )
+        ):
+            return False
+
+        # manually compare type_var_maps while resolving any lazy types
+        # so that they're considered equal to the actual types they're referencing
+        for type_var, type1 in first_type_definition.type_var_map.items():
+            type2 = second_type_definition.type_var_map[type_var]
+
+            # both lazy types are always resolved because two different lazy types
+            # may be referencing the same actual type
+            if isinstance(type1, LazyType):
+                type1 = type1.resolve_type()  # noqa: PLW2901
+            elif isinstance(type1, StrawberryOptional) and isinstance(
+                type1.of_type, LazyType
+            ):
+                type1.of_type = type1.of_type.resolve_type()
+
+            if isinstance(type2, LazyType):
+                type2 = type2.resolve_type()
+            elif isinstance(type2, StrawberryOptional) and isinstance(
+                type2.of_type, LazyType
+            ):
+                type2.of_type = type2.of_type.resolve_type()
+
+            same_type = type1 == type2
+            # If both types have object definitions, we are handling a nested generic
+            # type like `Foo[Foo[int]]`, meaning we need to compare their type definitions
+            # as they will actually be different instances of the type
+            if (
+                not same_type
+                and has_object_definition(type1)
+                and has_object_definition(type2)
+            ):
+                same_type = self.is_same_type_definition(
+                    type1.__strawberry_definition__,
+                    type2.__strawberry_definition__,
+                )
+
+            if not same_type:
+                return False
+
+        return True
+
 
 __all__ = ["GraphQLCoreConverter"]

tests/schema/test_generics_nested.py

@@ -363,3 +363,36 @@ def users(self) -> Union[Connection[User], Fallback]:
             "edge": {"__typename": "UserEdge", "node": {"name": "Patrick"}},
         }
     }
+
+
+def test_does_not_raise_duplicated_type_error():
+    T = TypeVar("T")
+
+    @strawberry.type
+    class Wrapper(Generic[T]):
+        value: T
+
+    @strawberry.type
+    class Query:
+        a: Wrapper[Wrapper[int]]
+        b: Wrapper[Wrapper[int]]
+
+    schema = strawberry.Schema(query=Query)
+
+    expected_schema = textwrap.dedent(
+        """
+        type IntWrapper {
+          value: Int!
+        }
+
+        type IntWrapperWrapper {
+          value: IntWrapper!
+        }
+
+        type Query {
+          a: IntWrapperWrapper!
+          b: IntWrapperWrapper!
+        }
+    """
+    ).strip()
+    assert str(schema) == expected_schema