fix: handle lazy connection type (#3941)

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: rcybulski1122012

RELEASE.md

@@ -0,0 +1,3 @@
+Release type: patch
+
+This release adds support for lazy types in ConnectionExtension.

strawberry/relay/fields.py

@@ -261,7 +261,12 @@ def apply(self, field: StrawberryField) -> None:
         if isinstance(f_type, StrawberryOptional):
             f_type = f_type.of_type
 
+        if isinstance(f_type, LazyType):
+            f_type = f_type.resolve_type()
+
         type_origin = get_origin(f_type) if is_generic_alias(f_type) else f_type
+        if isinstance(type_origin, LazyType):
+            type_origin = type_origin.resolve_type()
 
         if not isinstance(type_origin, type) or not issubclass(type_origin, Connection):
             raise RelayWrongAnnotationError(field.name, cast("type", field.origin))

tests/relay/test_connection.py

@@ -1,14 +1,14 @@
 import sys
 from collections.abc import Iterable
-from typing import Any, Optional
+from typing import Annotated, Any, Optional
 from typing_extensions import Self
 
 import pytest
 
 import strawberry
 from strawberry.permission import BasePermission
-from strawberry.relay import Connection, Node
-from strawberry.relay.types import ListConnection
+from strawberry.relay import Connection, Node, PageInfo, to_base64
+from strawberry.relay.types import Edge, ListConnection
 from strawberry.schema.config import StrawberryConfig
 
 
@@ -25,7 +25,7 @@ def resolve_nodes(
 
 
 @strawberry.type
-class UserConnection(Connection[User]):
+class EmptyUserConnection(Connection[User]):
     @classmethod
     def resolve_connection(
         cls,
@@ -42,6 +42,33 @@ def resolve_connection(
         return None
 
 
+@strawberry.type
+class UserConnection(Connection[User]):
+    @classmethod
+    def resolve_connection(
+        cls,
+        nodes: Iterable[User],
+        *,
+        info: Any,
+        after: Optional[str] = None,
+        before: Optional[str] = None,
+        first: Optional[int] = None,
+        last: Optional[int] = None,
+        max_results: Optional[int] = None,
+        **kwargs: Any,
+    ) -> Optional[Self]:
+        user_node_id = to_base64(User, "1")
+        return cls(
+            page_info=PageInfo(
+                has_next_page=False,
+                has_previous_page=False,
+                start_cursor=None,
+                end_cursor=None,
+            ),
+            edges=[Edge(cursor=user_node_id, node=User(id=user_node_id))],
+        )
+
+
 class TestPermission(BasePermission):
     message = "Not allowed"
 
@@ -52,7 +79,7 @@ def has_permission(self, source, info, **kwargs: Any):
 def test_nullable_connection_with_optional():
     @strawberry.type
     class Query:
-        @strawberry.relay.connection(Optional[UserConnection])
+        @strawberry.relay.connection(Optional[EmptyUserConnection])
         def users(self) -> Optional[list[User]]:
             return None
 
@@ -74,14 +101,77 @@ def users(self) -> Optional[list[User]]:
     assert not result.errors
 
 
+def test_lazy_connection():
+    @strawberry.type
+    class Query:
+        @strawberry.relay.connection(
+            Optional[
+                Annotated[
+                    "UserConnection", strawberry.lazy("tests.relay.test_connection")
+                ]
+            ]
+        )
+        def users(self) -> Optional[list[User]]:
+            return None
+
+    schema = strawberry.Schema(query=Query)
+    query = """
+            query {
+                users {
+                    edges {
+                        node {
+                            name
+                        }
+                    }
+                }
+            }
+        """
+
+    result = schema.execute_sync(query)
+    assert result.data == {"users": {"edges": [{"node": {"name": "John"}}]}}
+    assert not result.errors
+
+
+def test_lazy_optional_connection():
+    @strawberry.type
+    class Query:
+        @strawberry.relay.connection(
+            Optional[
+                Annotated[
+                    "EmptyUserConnection",
+                    strawberry.lazy("tests.relay.test_connection"),
+                ]
+            ]
+        )
+        def users(self) -> Optional[list[User]]:
+            return None
+
+    schema = strawberry.Schema(query=Query)
+    query = """
+            query {
+                users {
+                    edges {
+                        node {
+                            name
+                        }
+                    }
+                }
+            }
+        """
+
+    result = schema.execute_sync(query)
+    assert result.data == {"users": None}
+    assert not result.errors
+
+
 @pytest.mark.skipif(
     sys.version_info < (3, 10),
     reason="pipe syntax for union is only available on python 3.10+",
 )
 def test_nullable_connection_with_pipe():
     @strawberry.type
     class Query:
-        @strawberry.relay.connection(UserConnection | None)
+        @strawberry.relay.connection(EmptyUserConnection | None)
         def users(self) -> list[User] | None:
             return None
 
@@ -107,7 +197,7 @@ def test_nullable_connection_with_permission():
     @strawberry.type
     class Query:
         @strawberry.relay.connection(
-            Optional[UserConnection], permission_classes=[TestPermission]
+            Optional[EmptyUserConnection], permission_classes=[TestPermission]
         )
         def users(self) -> Optional[list[User]]:  # pragma: no cover
             pytest.fail("Should not have been called...")