fix: Correctly handle field implicitly generated for ForeignKey relationships (#6)

Author: provinzkraut

README.md

@@ -153,6 +153,27 @@ This can be mitigated by:
    and [`prefetch_related`](https://docs.djangoproject.com/en/5.2/ref/models/querysets/#prefetch-related)
    to ensure relationships are fully loaded
 
+## Foreign keys
+
+When defining a `ForeignKey` field, Django will implicitly generate another field on the
+model with an `_id` suffix, to store the actual foreign key value. The DTO will include
+these implicit fields.
+
+```python
+class Author(models.Model):
+    name = models.CharField(max_length=100)
+
+class Book(models.Model):
+    name = models.CharField(max_length=100)
+    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name="books")
+```
+
+In this example, the DTO for `Book` includes the field definitions
+- `id: int`
+- `name: str`
+- `author_id: int`
+- `author: Author`
+
 
 ## Serialization / validation of 3rd party field types
 

litestar_django/dto.py

@@ -174,7 +174,10 @@ def get_field_default(
         if isinstance(field, ForeignObjectRel):
             if isinstance(field, ManyToOneRel):
                 return Empty, list
-            return Empty, None
+            return None, None
+
+        if isinstance(field, ForeignKey) and field.null:
+            return None, None
 
         if isinstance(field, ManyToManyField):
             return Empty, list
@@ -189,6 +192,35 @@ def get_field_default(
 
         return default, default_factory
 
+    @classmethod
+    def get_model_fields(
+        cls, model_type: type[T]
+    ) -> Generator[tuple[str, AnyField], None, None]:
+        for field in model_type._meta.get_fields():
+            yield field.name, field
+            if isinstance(field, ForeignKey):
+                # if it's a fk, also include the implicitly generated '_id' fields
+                # generated by django
+                for fk_tuple in field.related_fields:
+                    # 'attname' is the name of the '_id' field on the referring model
+                    name = fk_tuple[0].attname
+                    # there is no concrete, distinct field for the '_id' attribute;
+                    # it's the same as the 'ForeignKey' field on the type. on the
+                    # concrete class, these fields are 'ForwardManyToOneDescriptor' for
+                    # the explicitly defined 'ForeignKey' field, and a
+                    # 'ForeignKeyDeferredAttribute' for the implicitly created '_id'
+                    # field.
+                    # we need a concrete field to infer the type though, so we construct
+                    # it from the type of the related primary key field
+                    related_field = fk_tuple[1]
+                    id_field = type(related_field)(
+                        name=name,
+                        null=field.null,
+                        validators=related_field.validators,
+                        default=None if field.null else NOT_PROVIDED,
+                    )
+                    yield name, id_field
+
     @classmethod
     def generate_field_definitions(
         cls, model_type: Type[T]
@@ -198,9 +230,7 @@ def generate_field_definitions(
             field_type_map = {**_FIELD_TYPE_MAP, **cls.custom_field_types}
 
         field: AnyField
-        for field in model_type._meta.get_fields():
-            name = field.name
-
+        for name, field in cls.get_model_fields(model_type):
             if field.hidden:
                 dto_field = DTOField("private")
             elif not field.editable:
@@ -210,6 +240,9 @@ def generate_field_definitions(
 
             if field.is_relation and field.related_model:
                 related = field.related_model
+                # all relationships are 'read-only', because Django does not support
+                # inline creation of related objects
+                dto_field = DTOField("read-only")
                 if isinstance(field, (ForeignKey, OneToOneField)):
                     field_type: Any = related
                 elif isinstance(field, ManyToManyField) or getattr(

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "litestar-django"
-version = "0.2.0"
+version = "0.2.1"
 description = "Django model support for Litestar"
 readme = "README.md"
 license = { text = "MIT" }

tests/some_app/app/models.py

@@ -144,7 +144,17 @@ class Genre(models.Model):
     name = models.CharField(max_length=50)
 
 
+class Tag(models.Model):
+    name = models.CharField(max_length=100)
+
+
 class Book(models.Model):
     name = models.CharField(max_length=100)
     author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name="books")
+    nullable_tag = models.ForeignKey(
+        Tag,
+        on_delete=models.CASCADE,
+        null=True,
+        related_name="books",
+    )
     genres = models.ManyToManyField(Genre, related_name="books")

tests/test_dto_field_definitions.py

@@ -21,6 +21,7 @@
     StdEnum,
     LabelledEnum,
     ModelInvalidRegexValidator,
+    Tag,
 )
 
 # django extract these from SQLite on 5.1 and above
@@ -532,6 +533,56 @@ def test_relationship_to_one() -> None:
             name="author",
             kwarg_definition=KwargDefinition(title="author"),
         ),
+        dto_field=DTOField("read-only"),
+    )
+
+    assert field_defs["author_id"] == DTOFieldDefinition.from_field_definition(
+        model_name="Book",
+        default_factory=None,
+        field_definition=FieldDefinition.from_annotation(
+            int,
+            name="author_id",
+            kwarg_definition=KwargDefinition(
+                title="author_id",
+                # min/max int values set by django
+                lt=MAX_INT_VALUE,
+                gt=MIN_INT_VALUE,
+            ),
+        ),
+        dto_field=DTOField(),
+    )
+
+
+def test_relationship_to_one_nullable() -> None:
+    dto_type = DjangoModelDTO[Book]
+    field_defs = {f.name: f for f in dto_type.generate_field_definitions(Book)}
+
+    assert field_defs["nullable_tag"] == DTOFieldDefinition.from_field_definition(
+        model_name="Book",
+        default_factory=None,
+        field_definition=FieldDefinition.from_annotation(
+            Optional[Tag],
+            name="nullable_tag",
+            default=None,
+            kwarg_definition=KwargDefinition(title="nullable tag"),
+        ),
+        dto_field=DTOField("read-only"),
+    )
+
+    assert field_defs["nullable_tag_id"] == DTOFieldDefinition.from_field_definition(
+        model_name="Book",
+        default_factory=None,
+        field_definition=FieldDefinition.from_annotation(
+            Optional[int],
+            name="nullable_tag_id",
+            default=None,
+            kwarg_definition=KwargDefinition(
+                title="nullable_tag_id",
+                # no limit values if the field is nullable
+                lt=None,
+                gt=None,
+            ),
+        ),
         dto_field=DTOField(),
     )
 
@@ -566,7 +617,7 @@ def test_relationship_to_many() -> None:
             name="genres",
             kwarg_definition=KwargDefinition(title="genres"),
         ),
-        dto_field=DTOField(),
+        dto_field=DTOField("read-only"),
     )
 
 

tests/test_dto_integration.py

@@ -110,7 +110,8 @@ def test_serialize_to_many() -> None:
     def handler() -> list[Book]:
         # need to prefetch here, so we don't accidentally perform lazy-loading during
         # the transfer process
-        return list(Book.objects.prefetch_related("author", "genres").all())
+        data = list(Book.objects.prefetch_related("author", "genres").all())
+        return data
 
     with create_test_client(
         [handler], raise_server_exceptions=True, debug=True
@@ -121,13 +122,19 @@ def handler() -> list[Book]:
             {
                 "id": book_a.id,
                 "name": "book_a",
+                "author_id": author.id,
                 "author": {"id": author.id, "name": "Someone"},
+                "nullable_tag_id": None,
+                "nullable_tag": None,
                 "genres": [{"id": genre_a.id, "name": "genre_a"}],
             },
             {
                 "id": book_b.id,
                 "name": "book_b",
+                "author_id": author.id,
                 "author": {"id": author.id, "name": "Someone"},
+                "nullable_tag_id": None,
+                "nullable_tag": None,
                 "genres": [
                     {"id": genre_a.id, "name": "genre_a"},
                     {"id": genre_b.id, "name": "genre_b"},
@@ -136,7 +143,10 @@ def handler() -> list[Book]:
             {
                 "id": book_c.id,
                 "name": "book_c",
+                "author_id": author.id,
                 "author": {"id": author.id, "name": "Someone"},
+                "nullable_tag_id": None,
+                "nullable_tag": None,
                 "genres": [],
             },
         ]
@@ -147,8 +157,10 @@ def test_validate() -> None:
     @post(
         "/",
         sync_to_thread=True,
-        dto=DjangoModelDTO[Annotated[Author, DTOConfig(exclude={"id", "books"})]],
-        return_dto=DjangoModelDTO[Author],
+        dto=DjangoModelDTO[Annotated[Author, DTOConfig(include={"name"})]],
+        return_dto=DjangoModelDTO[
+            Annotated[Author, DTOConfig(include={"id", "name", "books"})]
+        ],
     )
     def handler(data: Author) -> Author:
         data.save()