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

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

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

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

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

{django_ninja_aio_crud-2.15.0 → django_ninja_aio_crud-2.16.0}/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.15.0 → django_ninja_aio_crud-2.16.0}/ninja_aio/helpers/api.py

@@ -359,6 +359,7 @@ class ManyToManyAPI:
         filters_schema,
         append_slash: bool,
         verbose_name_plural: str,
+        decorators: list,
     ):
         @self.router.get(
             self._get_api_path(rel_path, append_slash=append_slash),
@@ -373,6 +374,7 @@ class ManyToManyAPI:
         @decorate_view(
             unique_view(f"get_{self.related_model_util.model_name}_{rel_path}"),
             paginate(self.pagination_class),
+            *decorators,
         )
         async def get_related(
             request: HttpRequest,
@@ -407,6 +409,7 @@ class ManyToManyAPI:
         m2m_add: bool,
         m2m_remove: bool,
         verbose_name_plural: str,
+        decorators: list,
     ):
         action, schema_in = self._resolve_action_schema(m2m_add, m2m_remove)
         plural = verbose_name_plural
@@ -422,7 +425,10 @@ class ManyToManyAPI:
             summary=summary,
             description=summary,
         )
-        @unique_view(f"manage_{self.related_model_util.model_name}_{rel_path}")
+        @decorate_view(
+            unique_view(f"manage_{self.related_model_util.model_name}_{rel_path}"),
+            *decorators,
+        )
         async def manage_related(
             request: HttpRequest,
             pk: Path[self.path_schema],  # type: ignore
@@ -483,6 +489,8 @@ class ManyToManyAPI:
             relation.verbose_name_plural
             or rel_util.model._meta.verbose_name_plural.capitalize()
         )
+        get_decorators = relation.get_decorators or []
+        post_decorators = relation.post_decorators or []
 
         if m2m_get:
             self._register_get_relation_view(
@@ -494,6 +502,7 @@ class ManyToManyAPI:
                 filters_schema=filters_schema,
                 append_slash=append_slash,
                 verbose_name_plural=verbose_name_plural,
+                decorators=get_decorators,
             )
 
         if m2m_add or m2m_remove:
@@ -505,6 +514,7 @@ class ManyToManyAPI:
                 m2m_add=m2m_add,
                 m2m_remove=m2m_remove,
                 verbose_name_plural=verbose_name_plural,
+                decorators=post_decorators,
             )
 
     def _add_views(self):

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

@@ -305,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 {}
@@ -478,11 +477,10 @@ class BaseSerializer:
             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.15.0 → django_ninja_aio_crud-2.16.0}/ninja_aio/schemas/helpers.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Type
+from typing import Callable, List, Optional, Type
 
 from ninja import Schema
 from ninja_aio.types import ModelSerializerMeta, SerializerMeta
@@ -46,7 +46,11 @@ class M2MRelationSchema(BaseModel):
             Whether to append a trailing slash to the generated GET endpoint path. Defaults to False for backward compatibility.
         verbose_name_plural (str | None):
             Optional human-readable plural name for the related model, used in documentation and responses.
-            
+        get_decorators (List | None):
+            Optional list of decorators to apply to the GET endpoint.
+        post_decorators (List | None):
+            Optional list of decorators to apply to the POST (add/remove) endpoints.
+
     Validation:
         - If `model` is not a ModelSerializerMeta, `related_schema` is required.
         - When `model` is a ModelSerializerMeta and `related_schema` is not provided, it will be
@@ -72,6 +76,8 @@ class M2MRelationSchema(BaseModel):
     serializer_class: Optional[SerializerMeta] = None
     append_slash: bool = False
     verbose_name_plural: Optional[str] = None
+    get_decorators: Optional[List[Callable]] = []
+    post_decorators: Optional[List[Callable]] = []
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 

{django_ninja_aio_crud-2.15.0 → django_ninja_aio_crud-2.16.0}/tests/helpers/test_many_to_many_api.py

@@ -280,3 +280,158 @@ class M2MRelationSchemaValidationTestCase(TestCase):
             serializer_class=TestModelReverseManyToManySerializer,
         )
         self.assertEqual(schema.related_schema, CustomSchema)
+
+
+# Decorator tracking for tests
+_decorator_calls = {"get": 0, "post": 0}
+
+
+def track_get_decorator(func):
+    """Decorator that tracks GET endpoint calls."""
+    from functools import wraps
+
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        _decorator_calls["get"] += 1
+        return await func(*args, **kwargs)
+
+    return wrapper
+
+
+def track_post_decorator(func):
+    """Decorator that tracks POST endpoint calls."""
+    from functools import wraps
+
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        _decorator_calls["post"] += 1
+        return await func(*args, **kwargs)
+
+    return wrapper
+
+
+class TestM2MWithDecoratorsViewSet(GenericAPIViewSet):
+    """ViewSet using M2M relations with custom decorators."""
+
+    model = models.TestModelSerializerManyToMany
+    m2m_relations = [
+        M2MRelationSchema(
+            model=models.TestModelSerializerReverseManyToMany,
+            related_name="test_model_serializers",
+            filters={"name": (str, "")},
+            get_decorators=[track_get_decorator],
+            post_decorators=[track_post_decorator],
+            append_slash=True,
+        )
+    ]
+
+    def test_model_serializers_query_params_handler(self, queryset, filters):
+        name_filter = filters.get("name")
+        if name_filter:
+            queryset = queryset.filter(name=name_filter)
+        return queryset
+
+
+@tag("many_to_many_api", "decorators")
+class M2MRelationSchemaDecoratorsTestCase(Tests.BaseManyToManyAPITestCase):
+    """Test M2M API with custom decorators applied to GET and POST endpoints."""
+
+    viewset_class = TestM2MWithDecoratorsViewSet
+    related_model = models.TestModelSerializerReverseManyToMany
+    related_name = "test_model_serializers"
+    api_namespace = "m2m_decorators_test"
+    related_names = ["dec_a", "dec_b", "dec_c"]
+
+    def setUp(self):
+        super().setUp()
+        # Reset decorator call counts before each test
+        _decorator_calls["get"] = 0
+        _decorator_calls["post"] = 0
+
+    async def test_get_decorator_is_applied(self):
+        """Test that get_decorators are applied to the GET endpoint."""
+        # First add some related objects
+        await self._add_related()
+        initial_get_count = _decorator_calls["get"]
+
+        # Call the GET endpoint
+        await self.get_view(request=self.request.get(), pk=self.path_schema)
+
+        # Verify the get decorator was called
+        self.assertEqual(
+            _decorator_calls["get"],
+            initial_get_count + 1,
+            "GET decorator should have been called once",
+        )
+
+    async def test_post_decorator_is_applied(self):
+        """Test that post_decorators are applied to the POST endpoint."""
+        initial_post_count = _decorator_calls["post"]
+
+        # Call the POST endpoint to add related objects
+        await self._add_related()
+
+        # Verify the post decorator was called
+        self.assertEqual(
+            _decorator_calls["post"],
+            initial_post_count + 1,
+            "POST decorator should have been called once",
+        )
+
+    async def test_decorators_independent(self):
+        """Test that GET and POST decorators are applied independently."""
+        # Reset counts
+        _decorator_calls["get"] = 0
+        _decorator_calls["post"] = 0
+
+        # Call POST endpoint
+        await self._add_related()
+        self.assertEqual(_decorator_calls["post"], 1)
+        self.assertEqual(_decorator_calls["get"], 0)
+
+        # Call GET endpoint
+        await self.get_view(request=self.request.get(), pk=self.path_schema)
+        self.assertEqual(_decorator_calls["post"], 1)  # Still 1
+        self.assertEqual(_decorator_calls["get"], 1)
+
+
+@tag("many_to_many_api", "decorators", "schema")
+class M2MRelationSchemaDecoratorsFieldTestCase(TestCase):
+    """Test cases for M2MRelationSchema decorator fields."""
+
+    def test_decorators_default_to_empty_list(self):
+        """Test that decorators default to empty lists."""
+        schema = M2MRelationSchema(
+            model=models.TestModelSerializerReverseManyToMany,
+            related_name="test_model_serializers",
+        )
+        self.assertEqual(schema.get_decorators, [])
+        self.assertEqual(schema.post_decorators, [])
+
+    def test_decorators_accept_list_of_callables(self):
+        """Test that decorators accept a list of callables."""
+
+        def custom_decorator(func):
+            return func
+
+        schema = M2MRelationSchema(
+            model=models.TestModelSerializerReverseManyToMany,
+            related_name="test_model_serializers",
+            get_decorators=[custom_decorator],
+            post_decorators=[custom_decorator, custom_decorator],
+        )
+        self.assertEqual(len(schema.get_decorators), 1)
+        self.assertEqual(len(schema.post_decorators), 2)
+        self.assertEqual(schema.get_decorators[0], custom_decorator)
+
+    def test_decorators_can_be_none(self):
+        """Test that decorators can explicitly be set to None."""
+        schema = M2MRelationSchema(
+            model=models.TestModelSerializerReverseManyToMany,
+            related_name="test_model_serializers",
+            get_decorators=None,
+            post_decorators=None,
+        )
+        # None values should be accepted
+        self.assertIsNone(schema.get_decorators)
+        self.assertIsNone(schema.post_decorators)

{django_ninja_aio_crud-2.15.0 → django_ninja_aio_crud-2.16.0}/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)
 

{django_ninja_aio_crud-2.15.0 → django_ninja_aio_crud-2.16.0}/tests/views/test_viewset.py

@@ -890,7 +890,7 @@ class DetailSchemaModelSerializerTestCase(TestCase):
         """Test that get_schemas returns a 4-tuple with detail schema."""
         result = self.viewset.get_schemas()
         self.assertEqual(len(result), 4)
-        schema_out, schema_detail, schema_in, schema_update = result
+        schema_out, schema_detail, _, _ = result
         self.assertIsNotNone(schema_out)
         self.assertIsNotNone(schema_detail)