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

{django_ninja_aio_crud-2.14.0 → django_ninja_aio_crud-2.15.1}/.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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-ninja-aio-crud
-Version: 2.14.0
+Version: 2.15.1
 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.1}/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.1}/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.1}/ninja_aio/__init__.py

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

{django_ninja_aio_crud-2.14.0 → django_ninja_aio_crud-2.15.1}/ninja_aio/auth.py

@@ -107,11 +107,6 @@ class AsyncJwtBearer(HttpBearer):
         """
         try:
             self.dcd = jwt.decode(token, self.jwt_public, algorithms=self.algorithms)
-        except ValueError:
-            # raise AuthError(", ".join(exc.args), 401)
-            return False
-
-        try:
             self.validate_claims(self.dcd.claims)
         except errors.JoseError:
             return False

{django_ninja_aio_crud-2.14.0 → django_ninja_aio_crud-2.15.1}/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:
@@ -290,9 +305,8 @@ class BaseSerializer:
         """
         # Auto-resolve ModelSerializer with readable fields
         if isinstance(rel_model, ModelSerializerMeta):
-            if rel_model.get_fields("read") or rel_model.get_custom_fields("read"):
-                return rel_model.generate_related_s()
-            return None
+            has_readable_fields = rel_model.get_fields("read") or rel_model.get_custom_fields("read")
+            return rel_model.generate_related_s() if has_readable_fields else None
 
         # Resolve from explicit serializer mapping
         rel_serializers = cls._get_relations_serializers() or {}
@@ -415,12 +429,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,15 +471,16 @@ 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):
-            if not (
-                rel_model.get_fields("read") or rel_model.get_custom_fields("read")
-            ):
-                return None
+        if isinstance(rel_model, ModelSerializerMeta) and not (
+            rel_model.get_fields("read") or rel_model.get_custom_fields("read")
+        ):
+            return None
 
         schema = cls._resolve_relation_schema(field_name, rel_model)
         if not schema:

{django_ninja_aio_crud-2.14.0 → django_ninja_aio_crud-2.15.1}/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.1}/tests/test_auth.py

@@ -138,12 +138,11 @@ class JwtAuthTests(TestCase):
                 return "should-not-happen"
 
         bearer = TB()
-        # The ValueError branch at 110-112 is for when jwt.decode raises ValueError
-        # Mock jwt.decode to raise ValueError to test that branch
+
         import unittest.mock as mock
 
         with mock.patch("ninja_aio.auth.jwt.decode") as mock_decode:
-            mock_decode.side_effect = ValueError("invalid token")
+            mock_decode.side_effect = errors.JoseError("invalid token")
             result = async_to_sync(bearer.authenticate)(HttpRequest(), "fake-token")
             self.assertFalse(result)