django-ninja-aio-crud 2.14.0__tar.gz → 2.15.0__tar.gz

{django_ninja_aio_crud-2.14.0 → django_ninja_aio_crud-2.15.0}/.github/workflows/docs.yml

@@ -27,6 +27,7 @@ on:
           - "2.12"
           - "2.13"
           - "2.14"
+          - "2.15"
       make_latest:
         description: 'Set as "latest" and default?'
         type: boolean
@@ -57,6 +58,7 @@ on:
           - "2.12"
           - "2.13"
           - "2.14"
+          - "2.15"
       delete_confirm:
         description: 'Confirm deletion of the selected version'
         type: boolean

{django_ninja_aio_crud-2.14.0 → django_ninja_aio_crud-2.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-ninja-aio-crud
-Version: 2.14.0
+Version: 2.15.0
 Summary: Django Ninja AIO CRUD - Rest Framework
 Author: Giuseppe Casillo
 Requires-Python: >=3.10, <3.15

{django_ninja_aio_crud-2.14.0 → django_ninja_aio_crud-2.15.0}/docs/api/models/model_serializer.md

@@ -419,12 +419,14 @@ Use `relations_as_id` to serialize relation fields as IDs instead of nested obje
 
 | Relation Type      | Output Type       | Example Value        |
 |--------------------|-------------------|----------------------|
-| Forward FK         | `int \| None`     | `5` or `null`        |
-| Forward O2O        | `int \| None`     | `3` or `null`        |
-| Reverse FK         | `list[int]`       | `[1, 2, 3]`          |
-| Reverse O2O        | `int \| None`     | `7` or `null`        |
-| M2M (forward)      | `list[int]`       | `[1, 2]`             |
-| M2M (reverse)      | `list[int]`       | `[4, 5, 6]`          |
+| Forward FK         | `PK_TYPE \| None` | `5` or `null`        |
+| Forward O2O        | `PK_TYPE \| None` | `3` or `null`        |
+| Reverse FK         | `list[PK_TYPE]`   | `[1, 2, 3]`          |
+| Reverse O2O        | `PK_TYPE \| None` | `7` or `null`        |
+| M2M (forward)      | `list[PK_TYPE]`   | `[1, 2]`             |
+| M2M (reverse)      | `list[PK_TYPE]`   | `[4, 5, 6]`          |
+
+**Note:** `PK_TYPE` is automatically detected from the related model's primary key field. Supported types include `int` (default), `UUID`, `str`, and any other Django primary key type.
 
 **Example:**
 
@@ -494,6 +496,56 @@ class Article(ModelSerializer):
 }
 ```
 
+**UUID Primary Key Example:**
+
+When models use UUID primary keys, the output type is automatically `UUID`:
+
+```python
+import uuid
+from django.db import models
+from ninja_aio.models import ModelSerializer
+
+class Author(ModelSerializer):
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    name = models.CharField(max_length=200)
+
+    class ReadSerializer:
+        fields = ["id", "name", "books"]
+        relations_as_id = ["books"]
+
+class Book(ModelSerializer):
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    title = models.CharField(max_length=200)
+    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name="books")
+
+    class ReadSerializer:
+        fields = ["id", "title", "author"]
+        relations_as_id = ["author"]
+```
+
+**Output (Author with UUID):**
+
+```json
+{
+  "id": "550e8400-e29b-41d4-a716-446655440000",
+  "name": "J.K. Rowling",
+  "books": [
+    "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+    "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
+  ]
+}
+```
+
+**Output (Book with UUID):**
+
+```json
+{
+  "id": "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+  "title": "Harry Potter",
+  "author": "550e8400-e29b-41d4-a716-446655440000"
+}
+```
+
 **Query Optimization Note:** When using `relations_as_id`, you should still use `select_related()` for forward relations and `prefetch_related()` for reverse/M2M relations to avoid N+1 queries:
 
 ```python

{django_ninja_aio_crud-2.14.0 → django_ninja_aio_crud-2.15.0}/docs/api/models/serializers.md

@@ -429,12 +429,14 @@ Use `relations_as_id` in Meta to serialize relation fields as IDs instead of nes
 
 | Relation Type      | Output Type       | Example Value        |
 |--------------------|-------------------|----------------------|
-| Forward FK         | `int \| None`     | `5` or `null`        |
-| Forward O2O        | `int \| None`     | `3` or `null`        |
-| Reverse FK         | `list[int]`       | `[1, 2, 3]`          |
-| Reverse O2O        | `int \| None`     | `7` or `null`        |
-| M2M (forward)      | `list[int]`       | `[1, 2]`             |
-| M2M (reverse)      | `list[int]`       | `[4, 5, 6]`          |
+| Forward FK         | `PK_TYPE \| None` | `5` or `null`        |
+| Forward O2O        | `PK_TYPE \| None` | `3` or `null`        |
+| Reverse FK         | `list[PK_TYPE]`   | `[1, 2, 3]`          |
+| Reverse O2O        | `PK_TYPE \| None` | `7` or `null`        |
+| M2M (forward)      | `list[PK_TYPE]`   | `[1, 2]`             |
+| M2M (reverse)      | `list[PK_TYPE]`   | `[4, 5, 6]`          |
+
+**Note:** `PK_TYPE` is automatically detected from the related model's primary key field. Supported types include `int` (default), `UUID`, `str`, and any other Django primary key type.
 
 **Example:**
 
@@ -509,6 +511,40 @@ class ArticleSerializer(serializers.Serializer):
 }
 ```
 
+**UUID Primary Key Example:**
+
+When related models use UUID primary keys, the output type is automatically `UUID`:
+
+```python
+import uuid
+from django.db import models
+
+class Author(models.Model):
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    name = models.CharField(max_length=200)
+
+class AuthorSerializer(serializers.Serializer):
+    class Meta:
+        model = Author
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "name", "books"]
+        )
+        relations_as_id = ["books"]
+```
+
+**Output (Author with UUID):**
+
+```json
+{
+  "id": "550e8400-e29b-41d4-a716-446655440000",
+  "name": "J.K. Rowling",
+  "books": [
+    "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+    "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
+  ]
+}
+```
+
 **Combining with relations_serializers:**
 
 You can use both `relations_as_id` and `relations_serializers` in the same serializer. Fields in `relations_as_id` take precedence:

{django_ninja_aio_crud-2.14.0 → django_ninja_aio_crud-2.15.0}/ninja_aio/__init__.py

@@ -1,6 +1,6 @@
 """Django Ninja AIO CRUD - Rest Framework"""
 
-__version__ = "2.14.0"
+__version__ = "2.15.0"
 
 from .api import NinjaAIO
 

{django_ninja_aio_crud-2.14.0 → django_ninja_aio_crud-2.15.0}/ninja_aio/models/serializers.py

@@ -46,8 +46,23 @@ def _extract_pk(v: Any) -> Any:
     return v
 
 
-# Annotated type for extracting PK from model instances during serialization
-PkFromModel = Annotated[int, BeforeValidator(_extract_pk)]
+class PkFromModel:
+    """Subscriptable type for extracting PK from model instances during serialization.
+
+    Usage:
+        PkFromModel[int]   -> for integer PKs
+        PkFromModel[str]   -> for string PKs
+        PkFromModel[UUID]  -> for UUID PKs
+        PkFromModel        -> defaults to int (backwards compatible)
+    """
+
+    _default = Annotated[int, BeforeValidator(_extract_pk)]
+
+    def __class_getitem__(cls, pk_type: type) -> type:
+        return Annotated[pk_type, BeforeValidator(_extract_pk)]
+
+    def __new__(cls):
+        return cls._default
 
 
 class BaseSerializer:
@@ -415,12 +430,14 @@ class BaseSerializer:
 
         # Handle relations_as_id for reverse relations
         if field_name in relations_as_id:
+            from ninja_aio.models.utils import ModelUtil
+            pk_field_type = ModelUtil(rel_model).pk_field_type
             if many:
                 # For many relations, use PkFromModel to extract PKs from model instances
-                return (field_name, list[PkFromModel], Field(default_factory=list))
+                return (field_name, list[PkFromModel[pk_field_type]], Field(default_factory=list))
             else:
                 # For single reverse relations (ReverseOneToOne), extract pk
-                return (field_name, PkFromModel | None, None)
+                return (field_name, PkFromModel[pk_field_type] | None, None)
 
         schema = cls._resolve_relation_schema(field_name, rel_model)
         if not schema:
@@ -455,8 +472,10 @@ class BaseSerializer:
 
         # Handle relations_as_id: serialize as the raw FK ID
         if field_name in relations_as_id:
+            from ninja_aio.models.utils import ModelUtil
+            pk_field_type = ModelUtil(rel_model).pk_field_type
             # Use PkFromModel to extract pk from the related instance during serialization
-            return (field_name, PkFromModel | None, None)
+            return (field_name, PkFromModel[pk_field_type] | None, None)
 
         # Special case: ModelSerializer with no readable fields should be skipped entirely
         if isinstance(rel_model, ModelSerializerMeta):

{django_ninja_aio_crud-2.14.0 → django_ninja_aio_crud-2.15.0}/tests/test_app/models.py

@@ -1,3 +1,5 @@
+import uuid
+
 from ninja_aio.models import ModelSerializer
 from django.db import models
 
@@ -298,3 +300,179 @@ class ArticleAsId(BaseTestModelSerializer):
     class ReadSerializer:
         fields = ["id", "name", "description", "tags_as_id"]
         relations_as_id = ["tags_as_id"]
+
+
+# ==========================================================
+#          RELATIONS AS ID WITH UUID PK TEST MODELS
+# ==========================================================
+
+
+class BaseUUIDTestModel(ModelSerializer):
+    """Base model with UUID primary key."""
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    name = models.CharField(max_length=255)
+
+    class Meta:
+        abstract = True
+
+    class ReadSerializer:
+        fields = ["id", "name"]
+
+
+class AuthorUUID(BaseUUIDTestModel):
+    """Author model with UUID PK for testing relations_as_id on reverse FK."""
+
+    class ReadSerializer:
+        fields = ["id", "name", "books_uuid"]
+        relations_as_id = ["books_uuid"]
+
+
+class BookUUID(BaseUUIDTestModel):
+    """Book model with UUID PK for testing relations_as_id on forward FK."""
+
+    author_uuid = models.ForeignKey(
+        AuthorUUID,
+        on_delete=models.CASCADE,
+        related_name="books_uuid",
+        null=True,
+        blank=True,
+    )
+
+    class ReadSerializer:
+        fields = ["id", "name", "author_uuid"]
+        relations_as_id = ["author_uuid"]
+
+
+class ProfileUUID(BaseUUIDTestModel):
+    """Profile model with UUID PK for testing relations_as_id on reverse O2O."""
+
+    class ReadSerializer:
+        fields = ["id", "name", "user_uuid"]
+        relations_as_id = ["user_uuid"]
+
+
+class UserUUID(BaseUUIDTestModel):
+    """User model with UUID PK for testing relations_as_id on forward O2O."""
+
+    profile_uuid = models.OneToOneField(
+        ProfileUUID,
+        on_delete=models.CASCADE,
+        related_name="user_uuid",
+        null=True,
+        blank=True,
+    )
+
+    class ReadSerializer:
+        fields = ["id", "name", "profile_uuid"]
+        relations_as_id = ["profile_uuid"]
+
+
+class TagUUID(BaseUUIDTestModel):
+    """Tag model with UUID PK for testing relations_as_id on reverse M2M."""
+
+    class ReadSerializer:
+        fields = ["id", "name", "articles_uuid"]
+        relations_as_id = ["articles_uuid"]
+
+
+class ArticleUUID(BaseUUIDTestModel):
+    """Article model with UUID PK for testing relations_as_id on forward M2M."""
+
+    tags_uuid = models.ManyToManyField(
+        TagUUID,
+        related_name="articles_uuid",
+        blank=True,
+    )
+
+    class ReadSerializer:
+        fields = ["id", "name", "tags_uuid"]
+        relations_as_id = ["tags_uuid"]
+
+
+# ==========================================================
+#        RELATIONS AS ID WITH STRING PK TEST MODELS
+# ==========================================================
+
+
+class BaseStringPKTestModel(ModelSerializer):
+    """Base model with string (CharField) primary key."""
+
+    id = models.CharField(primary_key=True, max_length=50)
+    name = models.CharField(max_length=255)
+
+    class Meta:
+        abstract = True
+
+    class ReadSerializer:
+        fields = ["id", "name"]
+
+
+class AuthorStringPK(BaseStringPKTestModel):
+    """Author model with string PK for testing relations_as_id on reverse FK."""
+
+    class ReadSerializer:
+        fields = ["id", "name", "books_str"]
+        relations_as_id = ["books_str"]
+
+
+class BookStringPK(BaseStringPKTestModel):
+    """Book model with string PK for testing relations_as_id on forward FK."""
+
+    author_str = models.ForeignKey(
+        AuthorStringPK,
+        on_delete=models.CASCADE,
+        related_name="books_str",
+        null=True,
+        blank=True,
+    )
+
+    class ReadSerializer:
+        fields = ["id", "name", "author_str"]
+        relations_as_id = ["author_str"]
+
+
+class ProfileStringPK(BaseStringPKTestModel):
+    """Profile model with string PK for testing relations_as_id on reverse O2O."""
+
+    class ReadSerializer:
+        fields = ["id", "name", "user_str"]
+        relations_as_id = ["user_str"]
+
+
+class UserStringPK(BaseStringPKTestModel):
+    """User model with string PK for testing relations_as_id on forward O2O."""
+
+    profile_str = models.OneToOneField(
+        ProfileStringPK,
+        on_delete=models.CASCADE,
+        related_name="user_str",
+        null=True,
+        blank=True,
+    )
+
+    class ReadSerializer:
+        fields = ["id", "name", "profile_str"]
+        relations_as_id = ["profile_str"]
+
+
+class TagStringPK(BaseStringPKTestModel):
+    """Tag model with string PK for testing relations_as_id on reverse M2M."""
+
+    class ReadSerializer:
+        fields = ["id", "name", "articles_str"]
+        relations_as_id = ["articles_str"]
+
+
+class ArticleStringPK(BaseStringPKTestModel):
+    """Article model with string PK for testing relations_as_id on forward M2M."""
+
+    tags_str = models.ManyToManyField(
+        TagStringPK,
+        related_name="articles_str",
+        blank=True,
+    )
+
+    class ReadSerializer:
+        fields = ["id", "name", "tags_str"]
+        relations_as_id = ["tags_str"]

{django_ninja_aio_crud-2.14.0 → django_ninja_aio_crud-2.15.0}/tests/test_serializers.py

@@ -911,3 +911,443 @@ class RelationsAsIdIntegrationTestCase(TestCase):
         self.assertIsInstance(result.articles_as_id, list)
         self.assertEqual(len(result.articles_as_id), 1)
         self.assertIn(self.article.pk, result.articles_as_id)
+
+
+@tag("serializers", "relations_as_id", "uuid_pk")
+class RelationsAsIdUUIDModelSerializerTestCase(TestCase):
+    """Test cases for relations_as_id with UUID primary keys."""
+
+    def setUp(self):
+        warnings.simplefilter("ignore", UserWarning)
+
+    def test_forward_fk_uuid_relations_as_id_schema(self):
+        """Test forward FK field with UUID PK in relations_as_id generates UUID type."""
+        from tests.test_app.models import BookUUID
+        from uuid import UUID
+
+        schema = BookUUID.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("author_uuid", schema.model_fields)
+
+        field_info = schema.model_fields["author_uuid"]
+        self.assertTrue(
+            field_info.annotation is not None,
+            "author_uuid field should have a type annotation",
+        )
+
+    def test_reverse_fk_uuid_relations_as_id_schema(self):
+        """Test reverse FK field with UUID PK in relations_as_id generates list[UUID] type."""
+        from tests.test_app.models import AuthorUUID
+        from uuid import UUID
+
+        schema = AuthorUUID.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("books_uuid", schema.model_fields)
+
+        field_info = schema.model_fields["books_uuid"]
+        self.assertTrue(
+            field_info.annotation is not None,
+            "books_uuid field should have a type annotation",
+        )
+
+    def test_forward_o2o_uuid_relations_as_id_schema(self):
+        """Test forward O2O field with UUID PK in relations_as_id generates UUID type."""
+        from tests.test_app.models import UserUUID
+
+        schema = UserUUID.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("profile_uuid", schema.model_fields)
+
+        field_info = schema.model_fields["profile_uuid"]
+        self.assertTrue(
+            field_info.annotation is not None,
+            "profile_uuid field should have a type annotation",
+        )
+
+    def test_reverse_o2o_uuid_relations_as_id_schema(self):
+        """Test reverse O2O field with UUID PK in relations_as_id generates UUID type."""
+        from tests.test_app.models import ProfileUUID
+
+        schema = ProfileUUID.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("user_uuid", schema.model_fields)
+
+        field_info = schema.model_fields["user_uuid"]
+        self.assertTrue(
+            field_info.annotation is not None,
+            "user_uuid field should have a type annotation",
+        )
+
+    def test_forward_m2m_uuid_relations_as_id_schema(self):
+        """Test forward M2M field with UUID PK in relations_as_id generates list[UUID] type."""
+        from tests.test_app.models import ArticleUUID
+
+        schema = ArticleUUID.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("tags_uuid", schema.model_fields)
+
+        field_info = schema.model_fields["tags_uuid"]
+        self.assertTrue(
+            field_info.annotation is not None,
+            "tags_uuid field should have a type annotation",
+        )
+
+    def test_reverse_m2m_uuid_relations_as_id_schema(self):
+        """Test reverse M2M field with UUID PK in relations_as_id generates list[UUID] type."""
+        from tests.test_app.models import TagUUID
+
+        schema = TagUUID.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("articles_uuid", schema.model_fields)
+
+        field_info = schema.model_fields["articles_uuid"]
+        self.assertTrue(
+            field_info.annotation is not None,
+            "articles_uuid field should have a type annotation",
+        )
+
+
+@tag("serializers", "relations_as_id", "uuid_pk", "integration")
+class RelationsAsIdUUIDIntegrationTestCase(TestCase):
+    """Integration tests for relations_as_id with UUID primary keys and actual data serialization."""
+
+    @classmethod
+    def setUpTestData(cls):
+        from tests.test_app.models import (
+            AuthorUUID,
+            BookUUID,
+            ProfileUUID,
+            UserUUID,
+            TagUUID,
+            ArticleUUID,
+        )
+
+        # Create test data for FK relations with UUID PKs
+        cls.author = AuthorUUID.objects.create(name="UUID Author 1")
+        cls.book1 = BookUUID.objects.create(name="UUID Book 1", author_uuid=cls.author)
+        cls.book2 = BookUUID.objects.create(name="UUID Book 2", author_uuid=cls.author)
+        cls.book_no_author = BookUUID.objects.create(name="UUID Book 3", author_uuid=None)
+
+        # Create test data for O2O relations with UUID PKs
+        cls.profile = ProfileUUID.objects.create(name="UUID Profile 1")
+        cls.user = UserUUID.objects.create(name="UUID User 1", profile_uuid=cls.profile)
+
+        # Create test data for M2M relations with UUID PKs
+        cls.tag1 = TagUUID.objects.create(name="UUID Tag 1")
+        cls.tag2 = TagUUID.objects.create(name="UUID Tag 2")
+        cls.article = ArticleUUID.objects.create(name="UUID Article 1")
+        cls.article.tags_uuid.add(cls.tag1, cls.tag2)
+
+    def setUp(self):
+        warnings.simplefilter("ignore", UserWarning)
+
+    def test_forward_fk_uuid_serialization(self):
+        """Test forward FK field with UUID PK serializes as UUID."""
+        from tests.test_app.models import BookUUID
+        from uuid import UUID
+
+        schema = BookUUID.generate_read_s()
+        result = schema.from_orm(self.book1)
+
+        self.assertIsInstance(result.author_uuid, UUID)
+        self.assertEqual(result.author_uuid, self.author.pk)
+
+    def test_forward_fk_uuid_null_serialization(self):
+        """Test forward FK field with UUID PK and null value serializes as None."""
+        from tests.test_app.models import BookUUID
+
+        schema = BookUUID.generate_read_s()
+        result = schema.from_orm(self.book_no_author)
+
+        self.assertIsNone(result.author_uuid)
+
+    def test_reverse_fk_uuid_serialization(self):
+        """Test reverse FK field with UUID PK serializes as list of UUIDs."""
+        from tests.test_app.models import AuthorUUID
+        from uuid import UUID
+
+        author = AuthorUUID.objects.prefetch_related("books_uuid").get(pk=self.author.pk)
+
+        schema = AuthorUUID.generate_read_s()
+        result = schema.from_orm(author)
+
+        self.assertIsInstance(result.books_uuid, list)
+        self.assertEqual(len(result.books_uuid), 2)
+        for book_id in result.books_uuid:
+            self.assertIsInstance(book_id, UUID)
+        self.assertIn(self.book1.pk, result.books_uuid)
+        self.assertIn(self.book2.pk, result.books_uuid)
+
+    def test_forward_o2o_uuid_serialization(self):
+        """Test forward O2O field with UUID PK serializes as UUID."""
+        from tests.test_app.models import UserUUID
+        from uuid import UUID
+
+        schema = UserUUID.generate_read_s()
+        result = schema.from_orm(self.user)
+
+        self.assertIsInstance(result.profile_uuid, UUID)
+        self.assertEqual(result.profile_uuid, self.profile.pk)
+
+    def test_reverse_o2o_uuid_serialization(self):
+        """Test reverse O2O field with UUID PK serializes as UUID."""
+        from tests.test_app.models import ProfileUUID
+        from uuid import UUID
+
+        profile = ProfileUUID.objects.select_related("user_uuid").get(pk=self.profile.pk)
+
+        schema = ProfileUUID.generate_read_s()
+        result = schema.from_orm(profile)
+
+        self.assertIsInstance(result.user_uuid, UUID)
+        self.assertEqual(result.user_uuid, self.user.pk)
+
+    def test_forward_m2m_uuid_serialization(self):
+        """Test forward M2M field with UUID PK serializes as list of UUIDs."""
+        from tests.test_app.models import ArticleUUID
+        from uuid import UUID
+
+        article = ArticleUUID.objects.prefetch_related("tags_uuid").get(pk=self.article.pk)
+
+        schema = ArticleUUID.generate_read_s()
+        result = schema.from_orm(article)
+
+        self.assertIsInstance(result.tags_uuid, list)
+        self.assertEqual(len(result.tags_uuid), 2)
+        for tag_id in result.tags_uuid:
+            self.assertIsInstance(tag_id, UUID)
+        self.assertIn(self.tag1.pk, result.tags_uuid)
+        self.assertIn(self.tag2.pk, result.tags_uuid)
+
+    def test_reverse_m2m_uuid_serialization(self):
+        """Test reverse M2M field with UUID PK serializes as list of UUIDs."""
+        from tests.test_app.models import TagUUID
+        from uuid import UUID
+
+        tag = TagUUID.objects.prefetch_related("articles_uuid").get(pk=self.tag1.pk)
+
+        schema = TagUUID.generate_read_s()
+        result = schema.from_orm(tag)
+
+        self.assertIsInstance(result.articles_uuid, list)
+        self.assertEqual(len(result.articles_uuid), 1)
+        self.assertIsInstance(result.articles_uuid[0], UUID)
+        self.assertIn(self.article.pk, result.articles_uuid)
+
+
+@tag("serializers", "relations_as_id", "string_pk")
+class RelationsAsIdStringPKModelSerializerTestCase(TestCase):
+    """Test cases for relations_as_id with string (CharField) primary keys."""
+
+    def setUp(self):
+        warnings.simplefilter("ignore", UserWarning)
+
+    def test_forward_fk_string_relations_as_id_schema(self):
+        """Test forward FK field with string PK in relations_as_id generates str type."""
+        from tests.test_app.models import BookStringPK
+
+        schema = BookStringPK.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("author_str", schema.model_fields)
+
+        field_info = schema.model_fields["author_str"]
+        self.assertTrue(
+            field_info.annotation is not None,
+            "author_str field should have a type annotation",
+        )
+
+    def test_reverse_fk_string_relations_as_id_schema(self):
+        """Test reverse FK field with string PK in relations_as_id generates list[str] type."""
+        from tests.test_app.models import AuthorStringPK
+
+        schema = AuthorStringPK.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("books_str", schema.model_fields)
+
+        field_info = schema.model_fields["books_str"]
+        self.assertTrue(
+            field_info.annotation is not None,
+            "books_str field should have a type annotation",
+        )
+
+    def test_forward_o2o_string_relations_as_id_schema(self):
+        """Test forward O2O field with string PK in relations_as_id generates str type."""
+        from tests.test_app.models import UserStringPK
+
+        schema = UserStringPK.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("profile_str", schema.model_fields)
+
+        field_info = schema.model_fields["profile_str"]
+        self.assertTrue(
+            field_info.annotation is not None,
+            "profile_str field should have a type annotation",
+        )
+
+    def test_reverse_o2o_string_relations_as_id_schema(self):
+        """Test reverse O2O field with string PK in relations_as_id generates str type."""
+        from tests.test_app.models import ProfileStringPK
+
+        schema = ProfileStringPK.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("user_str", schema.model_fields)
+
+        field_info = schema.model_fields["user_str"]
+        self.assertTrue(
+            field_info.annotation is not None,
+            "user_str field should have a type annotation",
+        )
+
+    def test_forward_m2m_string_relations_as_id_schema(self):
+        """Test forward M2M field with string PK in relations_as_id generates list[str] type."""
+        from tests.test_app.models import ArticleStringPK
+
+        schema = ArticleStringPK.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("tags_str", schema.model_fields)
+
+        field_info = schema.model_fields["tags_str"]
+        self.assertTrue(
+            field_info.annotation is not None,
+            "tags_str field should have a type annotation",
+        )
+
+    def test_reverse_m2m_string_relations_as_id_schema(self):
+        """Test reverse M2M field with string PK in relations_as_id generates list[str] type."""
+        from tests.test_app.models import TagStringPK
+
+        schema = TagStringPK.generate_read_s()
+        self.assertIsNotNone(schema)
+        self.assertIn("articles_str", schema.model_fields)
+
+        field_info = schema.model_fields["articles_str"]
+        self.assertTrue(
+            field_info.annotation is not None,
+            "articles_str field should have a type annotation",
+        )
+
+
+@tag("serializers", "relations_as_id", "string_pk", "integration")
+class RelationsAsIdStringPKIntegrationTestCase(TestCase):
+    """Integration tests for relations_as_id with string primary keys and actual data serialization."""
+
+    @classmethod
+    def setUpTestData(cls):
+        from tests.test_app.models import (
+            AuthorStringPK,
+            BookStringPK,
+            ProfileStringPK,
+            UserStringPK,
+            TagStringPK,
+            ArticleStringPK,
+        )
+
+        # Create test data for FK relations with string PKs
+        cls.author = AuthorStringPK.objects.create(id="author-001", name="String Author 1")
+        cls.book1 = BookStringPK.objects.create(id="book-001", name="String Book 1", author_str=cls.author)
+        cls.book2 = BookStringPK.objects.create(id="book-002", name="String Book 2", author_str=cls.author)
+        cls.book_no_author = BookStringPK.objects.create(id="book-003", name="String Book 3", author_str=None)
+
+        # Create test data for O2O relations with string PKs
+        cls.profile = ProfileStringPK.objects.create(id="profile-001", name="String Profile 1")
+        cls.user = UserStringPK.objects.create(id="user-001", name="String User 1", profile_str=cls.profile)
+
+        # Create test data for M2M relations with string PKs
+        cls.tag1 = TagStringPK.objects.create(id="tag-001", name="String Tag 1")
+        cls.tag2 = TagStringPK.objects.create(id="tag-002", name="String Tag 2")
+        cls.article = ArticleStringPK.objects.create(id="article-001", name="String Article 1")
+        cls.article.tags_str.add(cls.tag1, cls.tag2)
+
+    def setUp(self):
+        warnings.simplefilter("ignore", UserWarning)
+
+    def test_forward_fk_string_serialization(self):
+        """Test forward FK field with string PK serializes as str."""
+        from tests.test_app.models import BookStringPK
+
+        schema = BookStringPK.generate_read_s()
+        result = schema.from_orm(self.book1)
+
+        self.assertIsInstance(result.author_str, str)
+        self.assertEqual(result.author_str, self.author.pk)
+        self.assertEqual(result.author_str, "author-001")
+
+    def test_forward_fk_string_null_serialization(self):
+        """Test forward FK field with string PK and null value serializes as None."""
+        from tests.test_app.models import BookStringPK
+
+        schema = BookStringPK.generate_read_s()
+        result = schema.from_orm(self.book_no_author)
+
+        self.assertIsNone(result.author_str)
+
+    def test_reverse_fk_string_serialization(self):
+        """Test reverse FK field with string PK serializes as list of strs."""
+        from tests.test_app.models import AuthorStringPK
+
+        author = AuthorStringPK.objects.prefetch_related("books_str").get(pk=self.author.pk)
+
+        schema = AuthorStringPK.generate_read_s()
+        result = schema.from_orm(author)
+
+        self.assertIsInstance(result.books_str, list)
+        self.assertEqual(len(result.books_str), 2)
+        for book_id in result.books_str:
+            self.assertIsInstance(book_id, str)
+        self.assertIn(self.book1.pk, result.books_str)
+        self.assertIn(self.book2.pk, result.books_str)
+
+    def test_forward_o2o_string_serialization(self):
+        """Test forward O2O field with string PK serializes as str."""
+        from tests.test_app.models import UserStringPK
+
+        schema = UserStringPK.generate_read_s()
+        result = schema.from_orm(self.user)
+
+        self.assertIsInstance(result.profile_str, str)
+        self.assertEqual(result.profile_str, self.profile.pk)
+        self.assertEqual(result.profile_str, "profile-001")
+
+    def test_reverse_o2o_string_serialization(self):
+        """Test reverse O2O field with string PK serializes as str."""
+        from tests.test_app.models import ProfileStringPK
+
+        profile = ProfileStringPK.objects.select_related("user_str").get(pk=self.profile.pk)
+
+        schema = ProfileStringPK.generate_read_s()
+        result = schema.from_orm(profile)
+
+        self.assertIsInstance(result.user_str, str)
+        self.assertEqual(result.user_str, self.user.pk)
+        self.assertEqual(result.user_str, "user-001")
+
+    def test_forward_m2m_string_serialization(self):
+        """Test forward M2M field with string PK serializes as list of strs."""
+        from tests.test_app.models import ArticleStringPK
+
+        article = ArticleStringPK.objects.prefetch_related("tags_str").get(pk=self.article.pk)
+
+        schema = ArticleStringPK.generate_read_s()
+        result = schema.from_orm(article)
+
+        self.assertIsInstance(result.tags_str, list)
+        self.assertEqual(len(result.tags_str), 2)
+        for tag_id in result.tags_str:
+            self.assertIsInstance(tag_id, str)
+        self.assertIn(self.tag1.pk, result.tags_str)
+        self.assertIn(self.tag2.pk, result.tags_str)
+
+    def test_reverse_m2m_string_serialization(self):
+        """Test reverse M2M field with string PK serializes as list of strs."""
+        from tests.test_app.models import TagStringPK
+
+        tag = TagStringPK.objects.prefetch_related("articles_str").get(pk=self.tag1.pk)
+
+        schema = TagStringPK.generate_read_s()
+        result = schema.from_orm(tag)
+
+        self.assertIsInstance(result.articles_str, list)
+        self.assertEqual(len(result.articles_str), 1)
+        self.assertIsInstance(result.articles_str[0], str)
+        self.assertIn(self.article.pk, result.articles_str)
+        self.assertEqual(result.articles_str[0], "article-001")