Improve support for type inheritance from other mapped types

README.md

@@ -152,6 +152,46 @@ query {
 """
 ```
 
+### Type Inheritance
+
+You can inherit fields from other mapped types using standard Python class inheritance.
+
+- Fields from the parent type (e.g., ApiA) are inherited by the child (e.g., ApiB).
+
+- The `__exclude__` setting applies to inherited fields.
+
+- If both SQLAlchemy models define the same field name, the field from the model inside `.type(...)` takes precedence.
+
+- Declaring a field manually in the mapped type overrides everything else.
+
+```python
+class ModelA(base):
+    __tablename__ = "a"
+
+    id = Column(String, primary_key=True)
+    common_field = Column(String(50))
+
+
+class ModelB(base):
+    __tablename__ = "b"
+
+    id = Column(String, primary_key=True)
+    common_field = Column(Integer)  # Conflicting field
+    extra_field = Column(String(50))
+
+
+@mapper.type(ModelA)
+class ApiA:
+    __exclude__ = ["id"]  # This field will be excluded in ApiA (and its children)
+
+
+@mapper.type(ModelB)
+class ApiB(ApiA):
+    # Inherits fields from ApiA, except "id"
+    # "common_field" will come from ModelB, not ModelA, so it will be a Integer
+    # "extra_field" will be overridden and will be a float now instead of the String type declared in ModelB:
+    extra_field: float = strawberry.field(name="extraField")
+```
 ## Limitations
 
 ### Supported Types

RELEASE.md

@@ -0,0 +1,93 @@
+Release type: patch
+
+This release improves how types inherit fields from other mapped types using `@mapper.type(...)`.
+You can now safely inherit from another mapped type, and the resulting GraphQL type will include all expected fields with predictable conflict resolution.
+
+Some examples:
+
+- Basic Inheritance:
+
+```python
+@mapper.type(ModelA)
+class ApiA:
+    pass
+
+
+@mapper.type(ModelB)
+class ApiB(ApiA):
+    # ApiB inherits all fields declared in ApiA
+    pass
+```
+
+
+- The `__exclude__` option continues working:
+
+```python
+@mapper.type(ModelA)
+class ApiA:
+    __exclude__ = ["relationshipB_id"]
+
+
+@mapper.type(ModelB)
+class ApiB(ApiA):
+    # ApiB will have all fields declared in ApiA, except "relationshipB_id"
+    pass
+```
+
+- If two SQLAlchemy models define fields with the same name, the field from the model inside `.type(...)` takes precedence:
+
+```python
+class ModelA(base):
+    __tablename__ = "a"
+
+    id = Column(String, primary_key=True)
+    example_field = Column(String(50))
+
+
+class ModelB(base):
+    __tablename__ = "b"
+
+    id = Column(String, primary_key=True)
+    example_field = Column(Integer, autoincrement=True)
+
+
+@mapper.type(ModelA)
+class ApiA:
+    # example_field will be a String
+    pass
+
+
+@mapper.type(ModelB)
+class ApiB(ApiA):
+    # example_field will be taken from ModelB and will be an Integer
+    pass
+```
+
+
+- If a field is explicitly declared in the mapped type, it will override any inherited or model-based definition:
+
+```python
+class ModelA(base):
+    __tablename__ = "a"
+
+    id = Column(String, primary_key=True)
+    example_field = Column(String(50))
+
+
+class ModelB(base):
+    __tablename__ = "b"
+
+    id = Column(String, primary_key=True)
+    example_field = Column(Integer, autoincrement=True)
+
+
+@mapper.type(ModelA)
+class ApiA:
+    pass
+
+
+@mapper.type(ModelB)
+class ApiB(ApiA):
+    # example_field will be a Float
+    example_field: float = strawberry.field(name="exampleField")
+```

src/strawberry_sqlalchemy_mapper/mapper.py

@@ -27,10 +27,12 @@
     Protocol,
     Sequence,
     Set,
+    Tuple,
     Type,
     TypeVar,
     Union,
     cast,
+    get_type_hints,
     overload,
 )
 from typing_extensions import Self
@@ -651,27 +653,47 @@ class Employee:
         ```
         """
 
+        def _get_generated_field_keys(type_, old_annotations) -> Tuple[List[str], Dict[str, Any]]:
+            old_annotations = old_annotations.copy()
+            generated_field_keys = set()
+
+            for key in dir(type_):
+                val = getattr(type_, key)
+                if getattr(val, _IS_GENERATED_RESOLVER_KEY, False):
+                    setattr(type_, key, field(resolver=val))
+                    generated_field_keys.add(key)
+
+            # Checks for an original type annotation, useful in resolving inheritance-related types
+            if original_type := getattr(type_, _ORIGINAL_TYPE_KEY, None):
+                for key in dir(original_type):
+                    if key.startswith("__") and key.endswith("__"):
+                        continue
+
+                    val = getattr(original_type, key)
+                    if getattr(val, _IS_GENERATED_RESOLVER_KEY, False):
+                        setattr(type_, key, field(resolver=val))
+                        generated_field_keys.add(key)
+                        try:
+                            annotations = get_type_hints(original_type)
+                        except Exception:
+                            annotations = original_type.__annotations__
+
+                        if key in annotations:
+                            old_annotations[key] = annotations[key]
+
+            return list(generated_field_keys), old_annotations
+
         def convert(type_: Any) -> Any:
             old_annotations = getattr(type_, "__annotations__", {})
             type_.__annotations__ = {k: v for k, v in old_annotations.items() if is_private(v)}
             mapper: Mapper = cast("Mapper", inspect(model))
-            generated_field_keys = []
 
             excluded_keys = getattr(type_, "__exclude__", [])
             list_keys = getattr(type_, "__use_list__", [])
 
-            # if the type inherits from another mapped type, then it may have
-            # generated resolvers. These will be treated by dataclasses as having
-            # a default value, which will likely cause issues because of keys
-            # that don't have default values. To fix this, we wrap them in
-            # `strawberry.field()` (like when they were originally made), so
-            # dataclasses will ignore them.
-            # TODO: Potentially raise/fix this issue upstream
-            for key in dir(type_):
-                val = getattr(type_, key)
-                if getattr(val, _IS_GENERATED_RESOLVER_KEY, False):
-                    setattr(type_, key, field(resolver=val))
-                    generated_field_keys.append(key)
+            generated_field_keys, old_annotations = _get_generated_field_keys(
+                type_, old_annotations
+            )
 
             self._handle_columns(mapper, type_, excluded_keys, generated_field_keys)
             relationship: RelationshipProperty
@@ -798,7 +820,15 @@ def convert(type_: Any) -> Any:
             # because the pre-existing fields might have default values,
             # which will cause the mapped fields to fail
             # (because they may not have default values)
-            type_.__annotations__.update(old_annotations)
+
+            # For Python versions <= 3.9, only update annotations that don't already exist
+            # because this versions handle inherance differently
+            if sys.version_info[:2] <= (3, 9):
+                for k, v in old_annotations.items():
+                    if k not in type_.__annotations__:
+                        type_.__annotations__[k] = v
+            else:
+                type_.__annotations__.update(old_annotations)
 
             if make_interface:
                 mapped_type = strawberry.interface(type_)