fix: Use lazy type to specialize Edge/Connection (#106)

Use a lazy type to properly resolve and specialize the `Edge`/`Connection`
types that are created from the model.

The reason we are using a subclass of `LazyType` is because the original
one expects a path to be passed to be used to import it later. We don't
have one here, but we do have a mapper containing all the created types
that can be retrieved later.

Fix #97

Author: bellini666

RELEASE.md

@@ -0,0 +1,4 @@
+Release type: patch
+
+Fix a regression from 0.4.0 which was [raising an issue](https://github.com/strawberry-graphql/strawberry-sqlalchemy/issues/97)
+when trying to create a connection from the model's relationships.

src/strawberry_sqlalchemy_mapper/mapper.py

@@ -73,6 +73,7 @@
 from strawberry import relay
 from strawberry.annotation import StrawberryAnnotation
 from strawberry.field import StrawberryField
+from strawberry.lazy_type import LazyType
 from strawberry.private import is_private
 from strawberry.scalars import JSON as StrawberryJSON
 from strawberry.type import WithStrawberryObjectDefinition, get_object_definition
@@ -112,6 +113,19 @@
 _IS_GENERATED_RESOLVER_KEY = "_is_generated_resolver"
 
 
+@dataclasses.dataclass(frozen=True)
+class StrawberrySQLAlchemyLazy(LazyType):
+    # We don't actually want `Optional` here but we can't use dataclasse's
+    # kw_only untul python 3.10, and we do have fields with default values
+    # in strawberry's LazyType
+    mapper: Optional["StrawberrySQLAlchemyMapper[Any]"] = None
+    module: str = "__not_used__"
+
+    def resolve_type(self) -> Type[Any]:
+        assert self.mapper is not None
+        return self.mapper.mapped_types[self.type_name]
+
+
 class WithStrawberrySQLAlchemyObjectDefinition(
     WithStrawberryObjectDefinition,
     Protocol,
@@ -282,11 +296,12 @@ def _edge_type_for(self, type_name: str) -> Type[Any]:
         """
         edge_name = f"{type_name}Edge"
         if edge_name not in self.edge_types:
+            lazy_type = StrawberrySQLAlchemyLazy(type_name=type_name, mapper=self)
             self.edge_types[edge_name] = edge_type = strawberry.type(
                 dataclasses.make_dataclass(
                     edge_name,
                     [],
-                    bases=(relay.Edge[type_name],),  # type: ignore[valid-type]
+                    bases=(relay.Edge[lazy_type],),  # type: ignore[valid-type]
                 )
             )
             setattr(edge_type, _GENERATED_FIELD_KEYS_KEY, ["node"])
@@ -300,13 +315,14 @@ def _connection_type_for(self, type_name: str) -> Type[Any]:
         connection_name = f"{type_name}Connection"
         if connection_name not in self.connection_types:
             edge_type = self._edge_type_for(type_name)
+            lazy_type = StrawberrySQLAlchemyLazy(type_name=type_name, mapper=self)
             self.connection_types[connection_name] = connection_type = strawberry.type(
                 dataclasses.make_dataclass(
                     connection_name,
                     [
                         ("edges", List[edge_type]),  # type: ignore[valid-type]
                     ],
-                    bases=(relay.ListConnection[type_name],),  # type: ignore[valid-type]
+                    bases=(relay.ListConnection[lazy_type],),  # type: ignore[valid-type]
                 )
             )
             setattr(connection_type, _GENERATED_FIELD_KEYS_KEY, ["edges"])

tests/test_mapper.py

@@ -1,7 +1,9 @@
 import enum
+import textwrap
 from typing import List, Optional
 
 import pytest
+import strawberry
 from sqlalchemy import JSON, Column, Enum, ForeignKey, Integer, String
 from sqlalchemy.dialects.postgresql.array import ARRAY
 from sqlalchemy.orm import relationship
@@ -279,3 +281,73 @@ class Employee:
     assert type(name.type) == StrawberryOptional
     id = next(iter(filter(lambda f: f.name == "department", employee_type_fields)))
     assert type(id.type) == StrawberryOptional
+
+
+def test_relationships_schema(employee_and_department_tables, mapper):
+    EmployeeModel, DepartmentModel = employee_and_department_tables
+
+    @mapper.type(EmployeeModel)
+    class Employee:
+        __exclude__ = ["password_hash"]
+
+    @mapper.type(DepartmentModel)
+    class Department:
+        pass
+
+    @strawberry.type
+    class Query:
+        @strawberry.field
+        def departments(self) -> Department:
+            ...
+
+    mapper.finalize()
+    schema = strawberry.Schema(query=Query)
+
+    expected = '''
+    type Department {
+      id: Int!
+      name: String!
+      employees: EmployeeConnection!
+    }
+
+    type Employee {
+      id: Int!
+      name: String!
+      departmentId: Int
+      department: Department
+    }
+
+    type EmployeeConnection {
+      """Pagination data for this connection"""
+      pageInfo: PageInfo!
+      edges: [EmployeeEdge!]!
+    }
+
+    type EmployeeEdge {
+      """A cursor for use in pagination"""
+      cursor: String!
+
+      """The item at the end of the edge"""
+      node: Employee!
+    }
+
+    """Information to aid in pagination."""
+    type PageInfo {
+      """When paginating forwards, are there more items?"""
+      hasNextPage: Boolean!
+
+      """When paginating backwards, are there more items?"""
+      hasPreviousPage: Boolean!
+
+      """When paginating backwards, the cursor to continue."""
+      startCursor: String
+
+      """When paginating forwards, the cursor to continue."""
+      endCursor: String
+    }
+
+    type Query {
+      departments: Department!
+    }
+    '''
+    assert str(schema) == textwrap.dedent(expected).strip()