django-ninja-aio-crud 2.9.0__tar.gz → 2.10.1__tar.gz

{django_ninja_aio_crud-2.9.0 → django_ninja_aio_crud-2.10.1}/.github/workflows/docs.yml

@@ -21,6 +21,8 @@ on:
           - "2.6.1"
           - "2.7.0"
           - "2.8"
+          - "2.9"
+          - "2.10"
       make_latest:
         description: 'Set as "latest" and default?'
         type: boolean
@@ -45,6 +47,8 @@ on:
           - "2.6.1"
           - "2.7.0"
           - "2.8"
+          - "2.9"
+          - "2.10"
       delete_confirm:
         description: 'Confirm deletion of the selected version'
         type: boolean

{django_ninja_aio_crud-2.9.0 → django_ninja_aio_crud-2.10.1}/PKG-INFO

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

{django_ninja_aio_crud-2.9.0 → django_ninja_aio_crud-2.10.1}/docs/api/views/mixins.md

@@ -140,6 +140,49 @@ class EventViewSet(LessEqualDateFilterViewSetMixin, APIViewSet):
     query_params = {"created_at": (datetime, None)}
 ```
 
+## RelationFilterViewSetMixin
+
+Filters by related model fields using configurable `RelationFilterSchema` entries.
+
+- Behavior: Maps query parameters to Django ORM lookups on related models.
+- Configuration: Define `relations_filters` as a list of `RelationFilterSchema` objects.
+- Query params are automatically registered from `relations_filters`.
+
+Each `RelationFilterSchema` requires:
+
+- `query_param`: The API query parameter name exposed to clients.
+- `query_filter`: The Django ORM lookup path (e.g., `author__id`, `category__name__icontains`).
+- `filter_type`: Tuple of `(type, default)` for schema generation (e.g., `(int, None)`).
+
+Example:
+
+```python
+from ninja_aio.views.mixins import RelationFilterViewSetMixin
+from ninja_aio.views.api import APIViewSet
+from ninja_aio.schemas import RelationFilterSchema
+
+class BookViewSet(RelationFilterViewSetMixin, APIViewSet):
+    model = models.Book
+    api = api
+    relations_filters = [
+        RelationFilterSchema(
+            query_param="author",
+            query_filter="author__id",
+            filter_type=(int, None),
+        ),
+        RelationFilterSchema(
+            query_param="category_name",
+            query_filter="category__name__icontains",
+            filter_type=(str, None),
+        ),
+    ]
+```
+
+This enables:
+
+- `GET /books?author=5` → `queryset.filter(author__id=5)`
+- `GET /books?category_name=fiction` → `queryset.filter(category__name__icontains="fiction")`
+
 ## Tips
 
 - Align `query_params` types with expected filter values; prefer Pydantic `date`/`datetime` for date filters so values implement `isoformat`.

{django_ninja_aio_crud-2.9.0 → django_ninja_aio_crud-2.10.1}/ninja_aio/__init__.py

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

{django_ninja_aio_crud-2.9.0 → django_ninja_aio_crud-2.10.1}/ninja_aio/schemas/__init__.py

@@ -5,6 +5,7 @@ from .api import (
     M2MAddSchemaIn,
     M2MRemoveSchemaIn,
     M2MSchemaIn,
+    RelationFilterSchema,
 )
 from .helpers import M2MRelationSchema, QuerySchema, ModelQuerySetSchema, ObjectQuerySchema, ObjectsQuerySchema
 
@@ -20,4 +21,5 @@ __all__ = [
     "ModelQuerySetSchema",
     "ObjectQuerySchema",
     "ObjectsQuerySchema",
+    "RelationFilterSchema",
 ]

django_ninja_aio_crud-2.10.1/ninja_aio/schemas/api.py

@@ -0,0 +1,43 @@
+from typing import Any
+
+from ninja import Schema
+
+
+class M2MDetailSchema(Schema):
+    count: int
+    details: list[str]
+
+
+class M2MSchemaOut(Schema):
+    errors: M2MDetailSchema
+    results: M2MDetailSchema
+
+
+class M2MAddSchemaIn(Schema):
+    add: list = []
+
+
+class M2MRemoveSchemaIn(Schema):
+    remove: list = []
+
+
+class M2MSchemaIn(Schema):
+    add: list = []
+    remove: list = []
+
+
+class RelationFilterSchema(Schema):
+    """
+    Schema for configuring relation-based filters in RelationFilterViewSetMixin.
+
+    Attributes:
+        filter_type: A tuple of (type, default_value) used to generate the query parameter
+            field in the filters schema. Example: (int, None) for optional integer filter.
+        query_param: The name of the query parameter exposed in the API endpoint.
+            This is what clients will use in requests (e.g., ?author_id=5).
+        query_filter: The Django ORM lookup to apply (e.g., "author__id", "category__slug").
+    """
+
+    filter_type: tuple[type, Any]
+    query_param: str
+    query_filter: str

{django_ninja_aio_crud-2.9.0 → django_ninja_aio_crud-2.10.1}/ninja_aio/views/api.py

@@ -311,6 +311,9 @@ class APIViewSet(API):
             "delete": (None, self.delete_view),
         }
 
+    def _check_relations_filters(self, filter: str):
+        return filter in getattr(self, "relations_filters_fields", [])
+
     def _auth_view(self, view_type: str):
         """
         Resolve auth for a specific HTTP verb; falls back to self.auth if NOT_SET.

{django_ninja_aio_crud-2.9.0 → django_ninja_aio_crud-2.10.1}/ninja_aio/views/mixins.py

@@ -1,4 +1,5 @@
 from ninja_aio.views.api import APIViewSet
+from ninja_aio.schemas import RelationFilterSchema
 
 
 class IcontainsFilterViewSetMixin(APIViewSet):
@@ -55,7 +56,7 @@ class IcontainsFilterViewSetMixin(APIViewSet):
             **{
                 f"{key}__icontains": value
                 for key, value in filters.items()
-                if isinstance(value, str)
+                if isinstance(value, str) and not self._check_relations_filters(key)
             }
         )
 
@@ -94,7 +95,11 @@ class BooleanFilterViewSetMixin(APIViewSet):
         """
         base_qs = await super().query_params_handler(queryset, filters)
         return base_qs.filter(
-            **{key: value for key, value in filters.items() if isinstance(value, bool)}
+            **{
+                key: value
+                for key, value in filters.items()
+                if isinstance(value, bool) and not self._check_relations_filters(key)
+            }
         )
 
 
@@ -136,6 +141,7 @@ class NumericFilterViewSetMixin(APIViewSet):
                 key: value
                 for key, value in filters.items()
                 if isinstance(value, (int, float))
+                and not self._check_relations_filters(key)
             }
         )
 
@@ -178,6 +184,7 @@ class DateFilterViewSetMixin(APIViewSet):
                 f"{key}{self._compare_attr}": value
                 for key, value in filters.items()
                 if hasattr(value, "isoformat")
+                and not self._check_relations_filters(key)
             }
         )
 
@@ -273,3 +280,69 @@ class LessEqualDateFilterViewSetMixin(DateFilterViewSetMixin):
     """
 
     _compare_attr = "__lte"
+
+
+class RelationFilterViewSetMixin(APIViewSet):
+    """
+    Mixin providing filtering for related fields in Django QuerySets.
+
+    This mixin applies filters on related fields based on configured RelationFilterSchema
+    entries. Each entry maps a query parameter name to a Django ORM lookup path.
+
+    Attributes:
+        relations_filters: List of RelationFilterSchema defining the relation filters.
+            Each schema specifies:
+            - query_param: The API query parameter name (e.g., "author_id")
+            - query_filter: The Django ORM lookup (e.g., "author__id")
+            - filter_type: Tuple of (type, default) for schema generation
+
+    Example:
+        class BookViewSet(RelationFilterViewSetMixin, APIViewSet):
+            relations_filters = [
+                RelationFilterSchema(
+                    query_param="author_id",
+                    query_filter="author__id",
+                    filter_type=(int, None),
+                ),
+                RelationFilterSchema(
+                    query_param="category_slug",
+                    query_filter="category__slug",
+                    filter_type=(str, None),
+                ),
+            ]
+
+        # GET /books?author_id=5 -> queryset.filter(author__id=5)
+        # GET /books?category_slug=fiction -> queryset.filter(category__slug="fiction")
+
+    Notes:
+        - Filter values that are None or falsy are skipped.
+        - This mixin automatically registers query_params from relations_filters.
+    """
+
+    relations_filters: list[RelationFilterSchema] = []
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls.query_params = {
+            **cls.query_params,
+            **{
+                rel_filter.query_param: rel_filter.filter_type
+                for rel_filter in cls.relations_filters
+            },
+        }
+
+    @property
+    def relations_filters_fields(self):
+        return [rel_filter.query_param for rel_filter in self.relations_filters]
+
+    async def query_params_handler(self, queryset, filters):
+        """
+        Apply relation filters to the queryset based on configured relations_filters.
+        """
+        base_qs = await super().query_params_handler(queryset, filters)
+        rel_filters = {}
+        for rel_filter in self.relations_filters:
+            value = filters.get(rel_filter.query_param)
+            if value is not None:
+                rel_filters[rel_filter.query_filter] = value
+        return base_qs.filter(**rel_filters) if rel_filters else base_qs

{django_ninja_aio_crud-2.9.0 → django_ninja_aio_crud-2.10.1}/tests/core/test_renderer_parser.py

@@ -48,3 +48,28 @@ class ORJSONRendererParserTestCase(TestCase):
             [base64.b64encode(b"a").decode(), base64.b64encode(b"b").decode()],
         )
         self.assertEqual(decoded["plain"], "value")
+
+    def test_renderer_non_dict_data(self):
+        """Test that renderer handles non-dict data (covers lines 23-24)."""
+        # When data is not a dict, it triggers the AttributeError branch
+        # and falls back to self.dumps(data)
+        non_dict_data = "plain string"
+        rendered = self.renderer.render(DummyRequest(), non_dict_data, response_status=200)
+        decoded = orjson.loads(rendered)
+        self.assertEqual(decoded, "plain string")
+
+    def test_renderer_list_data(self):
+        """Test that renderer handles list data directly."""
+        # A list doesn't have .items() method
+        list_data = [1, 2, 3]
+        rendered = self.renderer.render(DummyRequest(), list_data, response_status=200)
+        decoded = orjson.loads(rendered)
+        self.assertEqual(decoded, [1, 2, 3])
+
+    def test_renderer_primitive_data(self):
+        """Test that renderer handles primitive data."""
+        # An integer doesn't have .items() method
+        int_data = 42
+        rendered = self.renderer.render(DummyRequest(), int_data, response_status=200)
+        decoded = orjson.loads(rendered)
+        self.assertEqual(decoded, 42)

django_ninja_aio_crud-2.10.1/tests/models/test_model_util.py

@@ -0,0 +1,152 @@
+from django.test import tag, TestCase
+from unittest import mock
+
+from ninja.errors import ConfigError
+from ninja_aio.models import ModelUtil
+from tests.test_app import models, schema
+from tests.generics.models import Tests
+
+
+class BaseTests:
+    class ModelUtilTestCaseBase(Tests.GenericModelUtilTestCase):
+        @property
+        def create_data(self):
+            return {"name": "test", "description": "test"}
+
+        @property
+        def parsed_input_data(self):
+            return {"payload": self.create_data}
+
+        @property
+        def read_data(self):
+            return {"id": 1, "name": "test", "description": "test"}
+
+        @property
+        def additional_getters(self):
+            return {"description": "test"}
+
+        @property
+        def additional_filters(self):
+            return {"name": "test"}
+
+    @tag("model_util_model_serializer")
+    class ModelUtilModelSerializerTestCase(ModelUtilTestCaseBase):
+        @property
+        def serializable_fields(self):
+            return self.model.ReadSerializer.fields
+
+    @tag("model_util_model")
+    class ModelUtilModelBaseTestCase(ModelUtilTestCaseBase):
+        @property
+        def serializable_fields(self):
+            return ["id", "name", "description"]
+
+
+@tag("model_util_model_serializer_base")
+class ModelUtilModelSerializerBaseTestCase(BaseTests.ModelUtilModelSerializerTestCase):
+    model = models.TestModelSerializer
+
+    @property
+    def model_verbose_name_path(self):
+        return "test-model-serializers"
+
+    @property
+    def model_verbose_name_view(self):
+        return "testmodelserializers"
+
+
+@tag("model_util_model_base")
+class ModelUtilModelBaseTestCase(BaseTests.ModelUtilModelBaseTestCase):
+    model = models.TestModel
+    schema_in = schema.TestModelSchemaIn
+    schema_out = schema.TestModelSchemaOut
+    schema_patch = schema.TestModelSchemaPatch
+
+    @property
+    def model_verbose_name_path(self):
+        return "test-models"
+
+    @property
+    def model_verbose_name_view(self):
+        return "testmodels"
+
+
+@tag("model_util_config_error")
+class ModelUtilConfigErrorTestCase(TestCase):
+    """Test ModelUtil ConfigError edge cases (covers lines 113-115)."""
+
+    def test_model_util_raises_config_error_for_model_serializer_with_serializer_class(
+        self,
+    ):
+        """Test that ModelUtil raises ConfigError when both model is ModelSerializer and serializer_class is provided."""
+        from tests.test_app.serializers import TestModelForeignKeySerializer
+
+        with self.assertRaises(ConfigError) as ctx:
+            ModelUtil(
+                models.TestModelSerializer,
+                serializer_class=TestModelForeignKeySerializer,
+            )
+
+        self.assertIn(
+            "cannot accept both model and serializer_class", str(ctx.exception)
+        )
+
+
+@tag("model_util_pk_field_type")
+class ModelUtilPkFieldTypeTestCase(TestCase):
+    """Test ModelUtil pk_field_type error handling (covers lines 152-158)."""
+
+    def test_pk_field_type_raises_config_error_for_unknown_type(self):
+        """Test that pk_field_type raises ConfigError for unknown field types."""
+        from ninja.orm import fields
+
+        # Create a mock model with an unknown pk field type
+        mock_pk_field = mock.Mock()
+        mock_pk_field.get_internal_type.return_value = "UnknownFieldType"
+
+        mock_meta = mock.Mock()
+        mock_meta.pk = mock_pk_field
+
+        mock_model = mock.Mock()
+        mock_model._meta = mock_meta
+
+        util = ModelUtil(mock_model)
+
+        # Temporarily remove the key if it exists to ensure KeyError
+        original_types = fields.TYPES.copy()
+        fields.TYPES.pop("UnknownFieldType", None)
+
+        try:
+            with self.assertRaises(ConfigError) as ctx:
+                _ = util.pk_field_type
+
+            self.assertIn("Do not know how to convert", str(ctx.exception))
+            self.assertIn("UnknownFieldType", str(ctx.exception))
+        finally:
+            # Restore original types
+            fields.TYPES.update(original_types)
+
+
+@tag("model_util_objects_query_default")
+class ModelUtilObjectsQueryDefaultTestCase(TestCase):
+    """Test ModelUtil get_objects with default ObjectsQuerySchema (covers line 351)."""
+
+    async def test_get_objects_with_none_query_data_uses_default(self):
+        """Test that get_objects uses default ObjectsQuerySchema when query_data is None."""
+        # Create a test object
+        obj = await models.TestModel.objects.acreate(name="test", description="desc")
+
+        util = ModelUtil(models.TestModel)
+
+        # Create a mock request
+        request = mock.Mock()
+
+        # Call get_objects with query_data=None (will use default ObjectsQuerySchema)
+        qs = await util.get_objects(request, query_data=None)
+
+        # Should return a queryset
+        count = await qs.acount()
+        self.assertGreaterEqual(count, 1)
+
+        # Cleanup
+        await obj.adelete()

{django_ninja_aio_crud-2.9.0 → django_ninja_aio_crud-2.10.1}/tests/test_app/serializers.py

@@ -29,3 +29,19 @@ class TestModelReverseForeignKeySerializer(serializers.Serializer):
         relations_serializers = {
             "test_model_foreign_keys": TestModelForeignKeySerializer,
         }
+
+
+class TestModelOneToOneSerializer(serializers.Serializer):
+    """Serializer for TestModelOneToOne to test ForwardOneToOneDescriptor coverage."""
+
+    class Meta:
+        model = models.TestModelOneToOne
+        schema_in = serializers.SchemaModelConfig(
+            fields=["name", "description", "test_model"]
+        )
+        schema_out = serializers.SchemaModelConfig(
+            fields=["id", "name", "description", "test_model"]
+        )
+        schema_update = serializers.SchemaModelConfig(
+            optionals=[("name", str), ("description", str)]
+        )

{django_ninja_aio_crud-2.9.0 → django_ninja_aio_crud-2.10.1}/tests/test_app/views.py

@@ -1,5 +1,6 @@
 import datetime
 from ninja_aio.views import mixins
+from ninja_aio.schemas import RelationFilterSchema
 
 from tests.generics.views import GenericAPIViewSet
 from tests.test_app import models, schema, serializers
@@ -153,3 +154,27 @@ class TestModelForeignKeySerializerAPI(GenericAPIViewSet):
 class TestModelReverseForeignKeySerializerAPI(GenericAPIViewSet):
     model = models.TestModelReverseForeignKey
     serializer_class = serializers.TestModelReverseForeignKeySerializer
+
+
+# ==========================================================
+#                  RELATION FILTER MIXIN APIS
+# ==========================================================
+
+
+class TestModelSerializerForeignKeyRelationFilterAPI(
+    GenericAPIViewSet,
+    mixins.RelationFilterViewSetMixin,
+):
+    model = models.TestModelSerializerForeignKey
+    relations_filters = [
+        RelationFilterSchema(
+            query_param="test_model_serializer",
+            query_filter="test_model_serializer__id",
+            filter_type=(int, None),
+        ),
+        RelationFilterSchema(
+            query_param="test_model_serializer_name",
+            query_filter="test_model_serializer__name__icontains",
+            filter_type=(str, None),
+        ),
+    ]

{django_ninja_aio_crud-2.9.0 → django_ninja_aio_crud-2.10.1}/tests/test_auth.py

@@ -122,3 +122,54 @@ class JwtAuthTests(TestCase):
         bearer = TBWrongAud()
         result = async_to_sync(bearer.authenticate)(HttpRequest(), token)
         self.assertFalse(result)
+
+    def test_async_bearer_authenticate_invalid_token_returns_false(self):
+        """Test that a malformed/invalid token returns False (covers lines 110-112)."""
+        pub = self.public_jwk
+
+        class TB(AsyncJwtBearer):
+            jwt_public = pub
+            claims = {
+                "iss": {"value": "test-issuer"},
+                "aud": {"value": "test-audience"},
+            }
+
+            async def auth_handler(self, request):
+                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")
+            result = async_to_sync(bearer.authenticate)(HttpRequest(), "fake-token")
+            self.assertFalse(result)
+
+    def test_async_bearer_base_auth_handler_returns_none(self):
+        """Test that the base auth_handler returns None (covers line 101)."""
+        pub = self.public_jwk
+
+        class TB(AsyncJwtBearer):
+            jwt_public = pub
+            claims = {
+                "iss": {"value": "test-issuer"},
+                "aud": {"value": "test-audience"},
+            }
+            # Don't override auth_handler, use base implementation
+
+        token = encode_jwt({"sub": "42"}, duration=60)
+        bearer = TB()
+        result = async_to_sync(bearer.authenticate)(HttpRequest(), token)
+        # Base auth_handler returns None (pass statement)
+        self.assertIsNone(result)
+
+    def test_validate_mandatory_claims_skips_preset_claims(self):
+        """Test that validate_mandatory_claims skips claims already present (covers line 137)."""
+        # Pre-set both mandatory claims
+        claims = {"iss": "custom-issuer", "aud": "custom-audience"}
+        result = validate_mandatory_claims(claims)
+        # Should keep the pre-set values, not override with settings
+        self.assertEqual(result["iss"], "custom-issuer")
+        self.assertEqual(result["aud"], "custom-audience")

{django_ninja_aio_crud-2.9.0 → django_ninja_aio_crud-2.10.1}/tests/test_query_util.py

@@ -1,6 +1,7 @@
 from unittest import mock
 from django.test import TestCase, tag
 from tests.test_app import models as app_models
+from ninja_aio.helpers.query import ScopeNamespace
 
 
 @tag("query_util_dedicated")
@@ -93,3 +94,24 @@ class QueryUtilDedicatedTestCase(TestCase):
             _ = util_simple.apply_queryset_optimizations(qs, util_simple.SCOPES.READ)
             m_sel.assert_not_called()
             m_pref.assert_not_called()
+
+
+@tag("scope_namespace")
+class ScopeNamespaceTestCase(TestCase):
+    """Tests for ScopeNamespace class (covers line 17 - __iter__)."""
+
+    def test_scope_namespace_iter(self):
+        """Test that ScopeNamespace is iterable (covers line 17)."""
+        namespace = ScopeNamespace(READ="read", WRITE="write", CUSTOM="custom")
+        # Test iteration
+        values = list(namespace)
+        self.assertEqual(len(values), 3)
+        self.assertIn("read", values)
+        self.assertIn("write", values)
+        self.assertIn("custom", values)
+
+    def test_scope_namespace_attributes(self):
+        """Test that ScopeNamespace sets attributes correctly."""
+        namespace = ScopeNamespace(FOO="foo", BAR="bar")
+        self.assertEqual(namespace.FOO, "foo")
+        self.assertEqual(namespace.BAR, "bar")