django-ninja-aio-crud 0.5.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

{django_ninja_aio_crud-0.5.0.dist-info → django_ninja_aio_crud-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-ninja-aio-crud
-Version: 0.5.0
+Version: 0.6.1
 Summary: Django Ninja AIO CRUD - Rest Framework
 Author: Giuseppe Casillo
 Requires-Python: >=3.10
@@ -25,9 +25,16 @@ Classifier: Topic :: Internet :: WWW/HTTP
 Requires-Dist: django-ninja >=1.3.0
 Requires-Dist: joserfc >=1.0.0
 Requires-Dist: orjson >= 3.10.7
+Requires-Dist: coverage ; extra == "test"
 Project-URL: Repository, https://github.com/caspel26/django-ninja-aio-crud
+Provides-Extra: test
 
 # 🥷 django-ninja-aio-crud
+![Test](https://github.com/caspel26/django-ninja-aio-crud/actions/workflows/coverage.yml/badge.svg)
+[![codecov](https://codecov.io/gh/caspel26/django-ninja-aio-crud/graph/badge.svg?token=DZ5WDT3S20)](https://codecov.io/gh/caspel26/django-ninja-aio-crud)
+[![PyPI - Version](https://img.shields.io/pypi/v/django-ninja-aio-crud?color=g&logo=pypi&logoColor=white)](https://pypi.org/project/django-ninja-aio-crud/)
+[![PyPI - License](https://img.shields.io/pypi/l/django-ninja-aio-crud)](https://github.com/caspel26/django-ninja-aio-crud/blob/main/LICENSE)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 > [!NOTE]
 > Django ninja aio crud framework is based on **<a href="https://django-ninja.dev/">Django Ninja framework</a>**. It comes out with built-in views and models which are able to make automatic async CRUD operations and codes views class based making the developers' life easier and the code cleaner.
 
@@ -120,7 +127,7 @@ class Foo(ModelSerializer):
       if not payload.get("force_activation"):
           return
       setattr(self, "force_activation", True)
-  
+
   async def post_create(self) -> None:
       if not hasattr(self, "force_activation") or not getattr(self, "force_activation"):
           return
@@ -150,7 +157,7 @@ class Foo(ModelSerializer):
     optionals = [("bar", str), ("active", bool)]
 
   class UpdateSerializer:
-    optionals = [[("bar", str), ("active", bool)]
+    optionals = [("bar", str), ("active", bool)]
 ```
 
 - Instead of declaring your fields maybe you want to exclude some of them. Declaring "excludes" attribute into serializers will exclude the given fields. (You can declare only one between "fields" and "excludes").
@@ -175,7 +182,7 @@ class Foo(ModelSerializer):
 
   class UpdateSerializer:
     excludes = ["id", "name"]
-    optionals = [[("bar", str), ("active", bool)]
+    optionals = [("bar", str), ("active", bool)]
 ```
 
 
@@ -197,7 +204,7 @@ class FooAPI(APIViewSet):
   model = Foo
   api = api
 
-  
+
 FooAPI().add_views_to_route()
 ```
 
@@ -238,6 +245,10 @@ FooAPI().add_views_to_route()
 
 - You can also choose to disable any operation from crud by declaring "disbale" attribute. You can give "all" to disable every crud operation except for additional views.
 
+> [!TIP]
+> You can exclude by default an endpoint without declaring the serializer.
+> For example if you don't want to give update method to a CRUD just do not declare UpdateSerializer into model.
+
 ```python
 # views.py
 from ninja_aio import NinjaAIO
@@ -254,6 +265,29 @@ class FooAPI(APIViewSet):
   disable = ["retrieve", "update"]
 
 
+FooAPI().add_views_to_route()
+```
+For the list endpoint you can also set query params and handle them. They will be also visible into swagger.
+
+```python
+# views.py
+from ninja_aio import NinjaAIO
+from ninja_aio.views import APIViewSet
+
+from .models import Foo
+
+api = NinjaAIO()
+
+
+class FooAPI(APIViewSet):
+  model = Foo
+  api = api
+  query_params = {"name": (str, None), "active": (bool, None)}
+
+  async def query_params_handler(self, queryset, filters):
+      return queryset.filter(**{k: v for k, v in filters.items() if v is not None})
+
+
 FooAPI().add_views_to_route()
 ```
 
@@ -371,7 +405,7 @@ BarAPI().add_views_to_route()
 
 ### Jwt
 
-- AsyncJWTBearer built-in class is an authenticator class which use joserfc module. It cames out with authenticate method which validate given claims. Override auth handler method to write your own authentication method. Default algorithms used is RS256. a jwt Token istance is set as class atribute so you can use it by self.dcd.  
+- AsyncJWTBearer built-in class is an authenticator class which use joserfc module. It cames out with authenticate method which validate given claims. Override auth handler method to write your own authentication method. Default algorithms used is RS256. a jwt Token istance is set as class atribute so you can use it by self.dcd.
 
 ```python
 from ninja_aio.auth import AsyncJWTBearer

django_ninja_aio_crud-0.6.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+ninja_aio/__init__.py,sha256=VSJ4PO3jZ-Z_NF8y2IrjsTc6MSqxlJ_b7TtAvZW4f28,119
+ninja_aio/api.py,sha256=Fe6l3YCy7MW5TY4-Lbl80CFuK2NT2Y7tHfmqPk6Mqak,1735
+ninja_aio/auth.py,sha256=z9gniLIgT8SjRqhGN7ZI0AGHjsALwgU6eyr2m46fwFY,1389
+ninja_aio/exceptions.py,sha256=Lg0nUJe6kWEf0qvXpQ9FqQ8sCFBFH-lP4xovvY-YfiY,1922
+ninja_aio/models.py,sha256=lplwxtZKweoppJEi0ERPSHRtsq5UwQaGK3NtR_I-FBw,15213
+ninja_aio/parsers.py,sha256=e_4lGCPV7zs-HTqtdJTc8yQD2KPAn9njbL8nF_Mmgkc,153
+ninja_aio/renders.py,sha256=mHeKNJtmDhZmgFpS9B6SPn5uZFcyVXrsoMhr149LeW8,1555
+ninja_aio/schemas.py,sha256=EgRkfhnzZqwGvdBmqlZixMtMcoD1ZxV_qzJ3fmaAy20,113
+ninja_aio/types.py,sha256=EHznS-6KWLwSX5hLeXbAi7qHWla09_rGeQraiLpH-aY,491
+ninja_aio/views.py,sha256=z820mKzfbvh9SZ4cALQVKMfc64kx74t8xWGWaUBzHfs,9270
+django_ninja_aio_crud-0.6.1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+django_ninja_aio_crud-0.6.1.dist-info/METADATA,sha256=4nH4p3l9UUIUGilQ4C_fDM1Uv-WiF6FveqrG25JosQk,13076
+django_ninja_aio_crud-0.6.1.dist-info/RECORD,,

ninja_aio/__init__.py

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

ninja_aio/auth.py

@@ -2,7 +2,7 @@ from joserfc import jwt, jwk, errors
 from django.http.request import HttpRequest
 from ninja.security.http import HttpBearer
 
-from .exceptions import AuthError
+from .exceptions import AuthError, parse_jose_error
 
 
 class AsyncJwtBearer(HttpBearer):
@@ -23,8 +23,8 @@ class AsyncJwtBearer(HttpBearer):
             errors.InvalidClaimError,
             errors.MissingClaimError,
             errors.ExpiredTokenError,
-        ):
-            raise AuthError()
+        ) as exc:
+            raise AuthError(**parse_jose_error(exc), status_code=401)
 
     async def auth_handler(self, request: HttpRequest):
         """
@@ -35,15 +35,11 @@ class AsyncJwtBearer(HttpBearer):
     async def authenticate(self, request: HttpRequest, token: str):
         try:
             self.dcd = jwt.decode(token, self.jwt_public, algorithms=self.algorithms)
-        except (
-            errors.BadSignatureError,
-            ValueError,
-        ):
-            return None
+        except errors.BadSignatureError as exc:
+            raise AuthError(**parse_jose_error(exc), status_code=401)
+        except ValueError as exc:
+            raise AuthError(", ".join(exc.args), 401)
 
-        try:
-            self.validate_claims(self.dcd.claims)
-        except AuthError:
-            return None
+        self.validate_claims(self.dcd.claims)
 
         return await self.auth_handler(request)

ninja_aio/exceptions.py

@@ -1,6 +1,9 @@
 from functools import partial
+
+from joserfc.errors import JoseError
 from ninja import NinjaAPI
 from django.http import HttpRequest, HttpResponse
+from pydantic import ValidationError
 
 
 class BaseException(Exception):
@@ -11,11 +14,14 @@ class BaseException(Exception):
         self,
         error: str | dict = None,
         status_code: int | None = None,
-        is_critical: bool = False,
+        details: str | None = None,
     ) -> None:
-        self.error = error or self.error
+        if isinstance(error, str):
+            self.error = {"error": error}
+        if isinstance(error, dict):
+            self.error = error
+        self.error |= {"details": details} if details else {}
         self.status_code = status_code or self.status_code
-        self.is_critical = is_critical
 
     def get_error(self):
         return self.error, self.status_code
@@ -29,13 +35,35 @@ class AuthError(BaseException):
     pass
 
 
-def _default_serialize_error(
-    request: HttpRequest, exc: SerializeError, api: "NinjaAPI"
+class PydanticValidationError(BaseException):
+    def __init__(self, details=None):
+        super().__init__("Validation Error", 400, details)
+
+
+def _default_error(
+    request: HttpRequest, exc: BaseException, api: type[NinjaAPI]
 ) -> HttpResponse:
     return api.create_response(request, exc.error, status=exc.status_code)
 
 
+def _pydantic_validation_error(
+    request: HttpRequest, exc: ValidationError, api: type[NinjaAPI]
+) -> HttpResponse:
+    error = PydanticValidationError(exc.errors(include_input=False))
+    return api.create_response(request, error.error, status=error.status_code)
+
+
 def set_api_exception_handlers(api: type[NinjaAPI]) -> None:
+    api.add_exception_handler(BaseException, partial(_default_error, api=api))
     api.add_exception_handler(
-        SerializeError, partial(_default_serialize_error, api=api)
+        ValidationError, partial(_pydantic_validation_error, api=api)
+    )
+
+
+def parse_jose_error(jose_exc: JoseError) -> dict:
+    error_msg = {"error": jose_exc.error}
+    return (
+        error_msg | {"details": jose_exc.description}
+        if jose_exc.description
+        else error_msg
     )

ninja_aio/models.py

@@ -1,7 +1,7 @@
 import base64
 from typing import Any
 
-from ninja.schema import Schema
+from ninja import Schema
 from ninja.orm import create_schema
 
 from django.db import models
@@ -27,21 +27,48 @@ class ModelUtil:
             return self.model.get_fields("read")
         return [field.name for field in self.model._meta.get_fields()]
 
+    @property
+    def model_name(self) -> str:
+        return self.model._meta.model_name
+
+    @property
+    def model_pk_name(self) -> str:
+        return self.model._meta.pk.attname
+
+    @property
+    def model_verbose_name_plural(self) -> str:
+        return self.model._meta.verbose_name_plural
+
     def verbose_name_path_resolver(self) -> str:
-        return "-".join(self.model._meta.verbose_name_plural.split(" "))
+        return "-".join(self.model_verbose_name_plural.split(" "))
 
     def verbose_name_view_resolver(self) -> str:
-        return self.model._meta.verbose_name_plural.replace(" ", "")
+        return self.model_verbose_name_plural.replace(" ", "")
+
+    async def get_object(
+        self,
+        request: HttpRequest,
+        pk: int | str = None,
+        filters: dict = None,
+        getters: dict = None,
+    ):
+        get_q = {self.model_pk_name: pk} if pk is not None else {}
+        if getters:
+            get_q |= getters
 
-    async def get_object(self, request: HttpRequest, pk: int | str):
-        q = {self.model._meta.pk.attname: pk}
         obj_qs = self.model.objects.select_related()
         if isinstance(self.model, ModelSerializerMeta):
             obj_qs = await self.model.queryset_request(request)
+
+        obj_qs = obj_qs.prefetch_related(*self.get_reverse_relations())
+        if filters:
+            obj_qs = obj_qs.filter(**filters)
+
         try:
-            obj = await obj_qs.prefetch_related(*self.get_reverse_relations()).aget(**q)
+            obj = await obj_qs.aget(**get_q)
         except ObjectDoesNotExist:
-            raise SerializeError({self.model._meta.model_name: "not found"}, 404)
+            raise SerializeError({self.model_name: "not found"}, 404)
+
         return obj
 
     def get_reverse_relations(self) -> list[str]:
@@ -242,8 +269,11 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
                     exclude=excludes,
                 )
         fields = cls.get_fields(s_type)
-        customs = cls.get_custom_fields(s_type) + cls.get_optional_fields(s_type)
+        optionals = cls.get_optional_fields(s_type)
+        customs = cls.get_custom_fields(s_type) + optionals
         excludes = cls.get_excluded_fields(s_type)
+        if not fields and not excludes:
+            fields = [f[0] for f in optionals]
         return (
             create_schema(
                 model=cls,
@@ -379,11 +409,11 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
             (field, field_type, None)
             for field, field_type in cls._get_fields(s_type, "optionals")
         ]
-    
+
     @classmethod
     def get_excluded_fields(cls, s_type: type[S_TYPES]):
         return cls._get_fields(s_type, "excludes")
-    
+
     @classmethod
     def get_fields(cls, s_type: type[S_TYPES]):
         return cls._get_fields(s_type, "fields")

ninja_aio/views.py

@@ -1,10 +1,10 @@
 from typing import List
 
-from ninja import NinjaAPI, Router, Schema, Path
+from ninja import NinjaAPI, Router, Schema, Path, Query
 from ninja.constants import NOT_SET
 from ninja.pagination import paginate, AsyncPaginationBase, PageNumberPagination
 from django.http import HttpRequest
-from django.db.models import Model
+from django.db.models import Model, QuerySet
 from pydantic import create_model
 
 from .models import ModelSerializer, ModelUtil
@@ -73,16 +73,19 @@ class APIViewSet:
     schema_update: Schema | None = None
     auths: list | None = NOT_SET
     pagination_class: type[AsyncPaginationBase] = PageNumberPagination
+    query_params: dict[str, tuple[type, ...]] = {}
     disable: list[type[VIEW_TYPES]] = []
 
     def __init__(self) -> None:
-        self.router = Router(tags=[self.model._meta.model_name.capitalize()])
-        self.path = "/"
-        self.path_retrieve = f"{{{self.model._meta.pk.attname}}}/"
         self.error_codes = ERROR_CODES
         self.model_util = ModelUtil(self.model)
         self.schema_out, self.schema_in, self.schema_update = self.get_schemas()
-        self.path_schema = self._create_path_schema()
+        self.path_schema = self._generate_path_schema()
+        self.filters_schema = self._generate_filters_schema()
+        self.router_tag = self.model_util.model_name.capitalize()
+        self.router = Router(tags=[self.router_tag])
+        self.path = "/"
+        self.path_retrieve = f"{{{self.model_util.model_pk_name}}}/"
 
     @property
     def _crud_views(self):
@@ -98,11 +101,19 @@ class APIViewSet:
             "delete": (None, self.delete_view),
         }
 
-    def _create_path_schema(self):
-        fields = {
-            self.model._meta.pk.attname: (str | int , ...),
-        }
-        return create_model(f"{self.model._meta.model_name}PathSchema", **fields)
+    def _generate_schema(self, fields: dict, name: str) -> Schema:
+        return create_model(f"{self.model_util.model_name}{name}", **fields)
+
+    def _generate_path_schema(self):
+        return self._generate_schema(
+            {self.model_util.model_pk_name: (int | str, ...)}, "PathSchema"
+        )
+
+    def _generate_filters_schema(self):
+        return self._generate_schema(self.query_params, "FiltersSchema")
+
+    def _get_pk(self, data: Schema):
+        return data.model_dump()[self.model_util.model_pk_name]
 
     def get_schemas(self):
         if isinstance(self.model, ModelSerializerMeta):
@@ -113,6 +124,16 @@ class APIViewSet:
             )
         return self.schema_out, self.schema_in, self.schema_update
 
+    async def query_params_handler(
+        self, queryset: QuerySet[ModelSerializer], filters: dict
+    ):
+        """
+        Override this method to handle request query params making queries to the database
+        based on filters or any other logic. This method should return a queryset. filters
+        are given already dumped by the schema.
+        """
+        return queryset
+
     def create_view(self):
         @self.router.post(
             self.path,
@@ -122,7 +143,7 @@ class APIViewSet:
         async def create(request: HttpRequest, data: self.schema_in):
             return 201, await self.model_util.create_s(request, data, self.schema_out)
 
-        create.__name__ = f"create_{self.model._meta.model_name}"
+        create.__name__ = f"create_{self.model_util.model_name}"
         return create
 
     def list_view(self):
@@ -135,13 +156,17 @@ class APIViewSet:
             },
         )
         @paginate(self.pagination_class)
-        async def list(request: HttpRequest):
+        async def list(
+            request: HttpRequest, filters: Query[self.filters_schema] = None
+        ):
             qs = self.model.objects.select_related()
             if isinstance(self.model, ModelSerializerMeta):
                 qs = await self.model.queryset_request(request)
             rels = self.model_util.get_reverse_relations()
             if len(rels) > 0:
                 qs = qs.prefetch_related(*rels)
+            if filters is not None:
+                qs = await self.query_params_handler(qs, filters.model_dump())
             objs = [
                 await self.model_util.read_s(request, obj, self.schema_out)
                 async for obj in qs.all()
@@ -158,10 +183,10 @@ class APIViewSet:
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
         async def retrieve(request: HttpRequest, pk: Path[self.path_schema]):
-            obj = await self.model_util.get_object(request, pk)
+            obj = await self.model_util.get_object(request, self._get_pk(pk))
             return await self.model_util.read_s(request, obj, self.schema_out)
 
-        retrieve.__name__ = f"retrieve_{self.model._meta.model_name}"
+        retrieve.__name__ = f"retrieve_{self.model_util.model_name}"
         return retrieve
 
     def update_view(self):
@@ -170,10 +195,14 @@ class APIViewSet:
             auth=self.auths,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        async def update(request: HttpRequest, data: self.schema_update, pk: Path[self.path_schema]):
-            return await self.model_util.update_s(request, data, pk, self.schema_out)
+        async def update(
+            request: HttpRequest, data: self.schema_update, pk: Path[self.path_schema]
+        ):
+            return await self.model_util.update_s(
+                request, data, self._get_pk(pk), self.schema_out
+            )
 
-        update.__name__ = f"update_{self.model._meta.model_name}"
+        update.__name__ = f"update_{self.model_util.model_name}"
         return update
 
     def delete_view(self):
@@ -183,9 +212,9 @@ class APIViewSet:
             response={204: None, self.error_codes: GenericMessageSchema},
         )
         async def delete(request: HttpRequest, pk: Path[self.path_schema]):
-            return 204, await self.model_util.delete_s(request, pk)
+            return 204, await self.model_util.delete_s(request, self._get_pk(pk))
 
-        delete.__name__ = f"delete_{self.model._meta.model_name}"
+        delete.__name__ = f"delete_{self.model_util.model_name}"
         return delete
 
     def views(self):

django_ninja_aio_crud-0.5.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-ninja_aio/__init__.py,sha256=ZragxlHPdmlSQb8pX6GdLzlHSdO-6qs4EelxyzrSMGw,119
-ninja_aio/api.py,sha256=Fe6l3YCy7MW5TY4-Lbl80CFuK2NT2Y7tHfmqPk6Mqak,1735
-ninja_aio/auth.py,sha256=3Pr8llYoCN59ZH3J_2qWmzjXxsy-rpQzXrVfwLfY25Q,1299
-ninja_aio/exceptions.py,sha256=LP9GZpDk1fYMRRgGHSAstcCvgu5uSDLg8PPDANlZGTs,1008
-ninja_aio/models.py,sha256=wCEQfzU3Q96rMwbkqBMjuaPipILRoX2eorId1hfsiR4,14569
-ninja_aio/parsers.py,sha256=e_4lGCPV7zs-HTqtdJTc8yQD2KPAn9njbL8nF_Mmgkc,153
-ninja_aio/renders.py,sha256=mHeKNJtmDhZmgFpS9B6SPn5uZFcyVXrsoMhr149LeW8,1555
-ninja_aio/schemas.py,sha256=EgRkfhnzZqwGvdBmqlZixMtMcoD1ZxV_qzJ3fmaAy20,113
-ninja_aio/types.py,sha256=EHznS-6KWLwSX5hLeXbAi7qHWla09_rGeQraiLpH-aY,491
-ninja_aio/views.py,sha256=p0wWVMw1TRtdCSHKfIWHPINGn3rkGWFPsRwMyg4HUOs,8121
-django_ninja_aio_crud-0.5.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-django_ninja_aio_crud-0.5.0.dist-info/METADATA,sha256=FdZKHgHjgaZqqrv9BNB801Q1lHjSlYaMFUA-cBA_SQs,11573
-django_ninja_aio_crud-0.5.0.dist-info/RECORD,,