django-ninja-aio-crud 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

{django_ninja_aio_crud-0.4.0.dist-info → django_ninja_aio_crud-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-ninja-aio-crud
-Version: 0.4.0
+Version: 0.6.0
 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
@@ -153,6 +160,32 @@ class Foo(ModelSerializer):
     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").
+
+```python
+# models.py
+from django.db import models
+from ninja_aio.models import ModelSerializer
+
+
+class Foo(ModelSerializer):
+  name = models.CharField(max_length=30)
+  bar = models.CharField(max_length=30, default="")
+  active = models.BooleanField(default=False)
+
+  class ReadSerializer:
+    excludes = ["bar"]
+
+  class CreateSerializer:
+    fields = ["name"]
+    optionals = [("bar", str), ("active", bool)]
+
+  class UpdateSerializer:
+    excludes = ["id", "name"]
+    optionals = [[("bar", str), ("active", bool)]
+```
+
+
 ### APIViewSet
 
 - View class used to automatically generate CRUD views. in your views.py import APIViewSet and define your api using NinjaAIO class. NinjaAIO class uses built-in parser and renderer which use orjson for data serialization.
@@ -161,8 +194,6 @@ class Foo(ModelSerializer):
 # views.py
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 from .models import Foo
 
@@ -173,7 +204,7 @@ class FooAPI(APIViewSet):
   model = Foo
   api = api
 
-  
+
 FooAPI().add_views_to_route()
 ```
 
@@ -184,8 +215,6 @@ FooAPI().add_views_to_route()
 from ninja import Schema
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 from .models import Foo
 
@@ -211,6 +240,54 @@ class FooAPI(APIViewSet):
         return 200, {sum: data.n1 + data.n2}
 
 
+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
+from ninja_aio.views import APIViewSet
+
+from .models import Foo
+
+api = NinjaAIO()
+
+
+class FooAPI(APIViewSet):
+  model = Foo
+  api = api
+  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()
 ```
 
@@ -223,8 +300,6 @@ FooAPI().add_views_to_route()
 from ninja import Schema
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIView
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 api = NinjaAIO()
 
@@ -294,8 +369,6 @@ class Foo(ModelSerializer):
 # views.py
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 from .models import Foo, Bar
 
@@ -332,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
@@ -361,8 +434,6 @@ class CustomJWTBearer(AsyncJWTBearer):
 from ninja import Schema
 from ninja_aio import NinjaAIO
 from ninja_aio.views import APIViewSet, APIView
-from ninja_aio.parsers import ORJSONParser
-from ninja_aio.renders import ORJSONRender
 
 from .models import Foo
 

django_ninja_aio_crud-0.6.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+ninja_aio/__init__.py,sha256=-m_l3-9_2Q1-PvkjWqAfSmu2jt2ILNb490jT2yC4sbk,119
+ninja_aio/api.py,sha256=Fe6l3YCy7MW5TY4-Lbl80CFuK2NT2Y7tHfmqPk6Mqak,1735
+ninja_aio/auth.py,sha256=z9gniLIgT8SjRqhGN7ZI0AGHjsALwgU6eyr2m46fwFY,1389
+ninja_aio/exceptions.py,sha256=JGUvZyYevGnFYFk2JYnNqng1e9ilG8l325wA5YC1RUA,1364
+ninja_aio/models.py,sha256=ddV2QGzWSJzwZ4vt-AJ9rRdiQCVSEtl6Bj3mxroSiQE,15096
+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=b-KLPkNhfMXsTx4egfi-nKeuKqYEUOLXJFNt0fYariE,9027
+django_ninja_aio_crud-0.6.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+django_ninja_aio_crud-0.6.0.dist-info/METADATA,sha256=aRvvPaOFsyvqGwg_wCpoQJ0PiQJfo0obaBPlovRlXeA,13078
+django_ninja_aio_crud-0.6.0.dist-info/RECORD,,

ninja_aio/__init__.py

@@ -1,6 +1,6 @@
 """Django Ninja AIO CRUD - Rest Framework"""
 
-__version__ = "0.4.0"
+__version__ = "0.6.0"
 
 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,4 +1,6 @@
 from functools import partial
+
+from joserfc.errors import JoseError
 from ninja import NinjaAPI
 from django.http import HttpRequest, HttpResponse
 
@@ -11,11 +13,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 +34,20 @@ class AuthError(BaseException):
     pass
 
 
-def _default_serialize_error(
-    request: HttpRequest, exc: SerializeError, api: "NinjaAPI"
+def _default_error(
+    request: HttpRequest, exc: BaseException, api: type[NinjaAPI]
 ) -> HttpResponse:
     return api.create_response(request, exc.error, status=exc.status_code)
 
 
 def set_api_exception_handlers(api: type[NinjaAPI]) -> None:
-    api.add_exception_handler(
-        SerializeError, partial(_default_serialize_error, api=api)
+    api.add_exception_handler(BaseException, partial(_default_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,11 +1,11 @@
 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
-from django.http import HttpResponse, HttpRequest
+from django.http import HttpRequest
 from django.core.exceptions import ObjectDoesNotExist
 from django.db.models.fields.related_descriptors import (
     ReverseManyToOneDescriptor,
@@ -14,7 +14,7 @@ from django.db.models.fields.related_descriptors import (
 )
 
 from .exceptions import SerializeError
-from .types import S_TYPES, REL_TYPES, F_TYPES, ModelSerializerMeta
+from .types import S_TYPES, REL_TYPES, F_TYPES, SCHEMA_TYPES, ModelSerializerMeta
 
 
 class ModelUtil:
@@ -24,21 +24,51 @@ class ModelUtil:
     @property
     def serializable_fields(self):
         if isinstance(self.model, ModelSerializerMeta):
-            return self.model.ReadSerializer.fields
+            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_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]:
@@ -121,7 +151,7 @@ class ModelUtil:
         if isinstance(self.model, ModelSerializerMeta):
             await obj.custom_actions(customs)
             await obj.post_create()
-        return 201, await self.read_s(request, obj, obj_schema)
+        return await self.read_s(request, obj, obj_schema)
 
     async def read_s(
         self,
@@ -150,7 +180,7 @@ class ModelUtil:
     async def delete_s(self, request: HttpRequest, pk: int | str):
         obj = await self.get_object(request, pk)
         await obj.adelete()
-        return HttpResponse(status=204)
+        return None
 
 
 class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
@@ -160,15 +190,18 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
     class CreateSerializer:
         fields: list[str] = []
         customs: list[tuple[str, type, Any]] = []
-        optionals: list[str] = []
+        optionals: list[tuple[str, type]] = []
+        excludes: list[str] = []
 
     class ReadSerializer:
         fields: list[str] = []
+        excludes: list[str] = []
 
     class UpdateSerializer:
         fields: list[str] = []
         customs: list[tuple[str, type, Any]] = []
-        optionals: list[str] = []
+        optionals: list[tuple[str, type]] = []
+        excludes: list[str] = []
 
     @property
     def has_custom_fields_create(self):
@@ -195,24 +228,61 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
         return self.has_optional_fields_create or self.has_optional_fields_update
 
     @classmethod
-    def _get_special_fields(cls, s_type: type[S_TYPES], f_type: type[F_TYPES]):
-        try:
-            match s_type:
-                case "create":
-                    fields = getattr(cls.CreateSerializer, f_type)
-                case "update":
-                    fields = getattr(cls.UpdateSerializer, f_type)
-        except AttributeError:
-            return []
+    def _get_fields(cls, s_type: type[S_TYPES], f_type: type[F_TYPES]):
+        match s_type:
+            case "create":
+                fields = getattr(cls.CreateSerializer, f_type, [])
+            case "update":
+                fields = getattr(cls.UpdateSerializer, f_type, [])
+            case "read":
+                fields = getattr(cls.ReadSerializer, f_type, [])
         return fields
 
     @classmethod
     def _is_special_field(
         cls, s_type: type[S_TYPES], field: str, f_type: type[F_TYPES]
     ):
-        special_fields = cls._get_special_fields(s_type, f_type)
+        special_fields = cls._get_fields(s_type, f_type)
         return any(field in special_f for special_f in special_fields)
 
+    @classmethod
+    def _generate_model_schema(
+        cls,
+        schema_type: type[SCHEMA_TYPES],
+        depth: int = None,
+    ) -> Schema:
+        match schema_type:
+            case "In":
+                s_type = "create"
+            case "Patch":
+                s_type = "update"
+            case "Out":
+                fields, reverse_rels, excludes = cls.get_schema_out_data()
+                if not fields and not reverse_rels and not excludes:
+                    return None
+                return create_schema(
+                    model=cls,
+                    name=f"{cls._meta.model_name}SchemaOut",
+                    depth=depth,
+                    fields=fields,
+                    custom_fields=reverse_rels,
+                    exclude=excludes,
+                )
+        fields = cls.get_fields(s_type)
+        customs = cls.get_custom_fields(s_type) + cls.get_optional_fields(s_type)
+        excludes = cls.get_excluded_fields(s_type)
+        return (
+            create_schema(
+                model=cls,
+                name=f"{cls._meta.model_name}Schema{schema_type}",
+                fields=fields,
+                custom_fields=customs,
+                exclude=excludes,
+            )
+            if fields or customs or excludes
+            else None
+        )
+
     @classmethod
     def verbose_name_path_resolver(cls) -> str:
         return "-".join(cls._meta.verbose_name_plural.split(" "))
@@ -292,7 +362,7 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
     def get_schema_out_data(cls):
         fields = []
         reverse_rels = []
-        for f in cls.ReadSerializer.fields:
+        for f in cls.get_fields("read"):
             field_obj = getattr(cls, f)
             if isinstance(field_obj, ManyToManyDescriptor):
                 rel_obj: ModelSerializer = field_obj.field.related_model
@@ -312,7 +382,7 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
                 reverse_rels.append(rel_data)
                 continue
             fields.append(f)
-        return fields, reverse_rels
+        return fields, reverse_rels, cls.get_excluded_fields("read")
 
     @classmethod
     def is_custom(cls, field: str):
@@ -328,49 +398,31 @@ class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
 
     @classmethod
     def get_custom_fields(cls, s_type: type[S_TYPES]):
-        return cls._get_special_fields(s_type, "customs")
+        return cls._get_fields(s_type, "customs")
 
     @classmethod
     def get_optional_fields(cls, s_type: type[S_TYPES]):
         return [
             (field, field_type, None)
-            for field, field_type in cls._get_special_fields(s_type, "optionals")
+            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")
+
     @classmethod
     def generate_read_s(cls, depth: int = 1) -> Schema:
-        fields, reverse_rels = cls.get_schema_out_data()
-        customs = [custom for custom in reverse_rels]
-        return create_schema(
-            model=cls,
-            name=f"{cls._meta.model_name}SchemaOut",
-            depth=depth,
-            fields=fields,
-            custom_fields=customs,
-        )
+        return cls._generate_model_schema("Out", depth)
 
     @classmethod
     def generate_create_s(cls) -> Schema:
-        fields = getattr(cls.CreateSerializer, "fields", []) + [
-            field[0] for field in cls.get_optional_fields("create")
-        ]
-        customs = cls.get_custom_fields("create") + cls.get_optional_fields("create")
-        return create_schema(
-            model=cls,
-            name=f"{cls._meta.model_name}SchemaIn",
-            fields=fields,
-            custom_fields=customs,
-        )
+        return cls._generate_model_schema("In")
 
     @classmethod
     def generate_update_s(cls) -> Schema:
-        fields = getattr(cls.UpdateSerializer, "fields", []) + [
-            field[0] for field in cls.get_optional_fields("update")
-        ]
-        customs = cls.get_custom_fields("update") + cls.get_optional_fields("update")
-        return create_schema(
-            model=cls,
-            name=f"{cls._meta.model_name}SchemaPatch",
-            fields=fields,
-            custom_fields=customs,
-        )
+        return cls._generate_model_schema("Patch")

ninja_aio/types.py

@@ -2,10 +2,11 @@ from typing import Literal
 
 from django.db.models import Model
 
-S_TYPES = Literal["create", "update"]
+S_TYPES = Literal["read", "create", "update"]
 REL_TYPES = Literal["many", "one"]
-F_TYPES = Literal["customs", "optionals"]
-
+F_TYPES = Literal["fields", "customs", "optionals", "excludes"]
+SCHEMA_TYPES = Literal["In", "Out", "Patch"]
+VIEW_TYPES = Literal["list", "retrieve", "create", "update", "delete", "all"]
 
 class ModelSerializerType(type):
     def __repr__(self):

ninja_aio/views.py

@@ -1,14 +1,15 @@
 from typing import List
 
-from ninja import NinjaAPI, Router, Schema
+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
 from .schemas import GenericMessageSchema
-from .types import ModelSerializerMeta
+from .types import ModelSerializerMeta, VIEW_TYPES
 
 ERROR_CODES = frozenset({400, 401, 404, 428})
 
@@ -55,7 +56,6 @@ class APIView:
         async def some_method(request, *args, **kwargs):
             pass
         """
-        pass
 
     def add_views(self):
         self.views()
@@ -73,23 +73,63 @@ 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_update, self.schema_in = self.get_schemas()
+        self.schema_out, self.schema_in, self.schema_update = self.get_schemas()
+        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):
+        """
+        key: view type (create, list, retrieve, update, delete or all)
+        value: tuple with schema and view method
+        """
+        return {
+            "create": (self.schema_in, self.create_view),
+            "list": (self.schema_out, self.list_view),
+            "retrieve": (self.schema_out, self.retrieve_view),
+            "update": (self.schema_update, self.update_view),
+            "delete": (None, self.delete_view),
+        }
+
+    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_schemas(self):
         if isinstance(self.model, ModelSerializerMeta):
             return (
                 self.model.generate_read_s(),
-                self.model.generate_update_s(),
                 self.model.generate_create_s(),
+                self.model.generate_update_s(),
             )
-        return self.schema_out, self.schema_update, self.schema_in
+        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(
@@ -98,9 +138,10 @@ class APIViewSet:
             response={201: self.schema_out, self.error_codes: GenericMessageSchema},
         )
         async def create(request: HttpRequest, data: self.schema_in):
-            return await self.model_util.create_s(request, data, self.schema_out)
+            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):
         @self.router.get(
@@ -112,21 +153,22 @@ class APIViewSet:
             },
         )
         @paginate(self.pagination_class)
-        async def list(request: HttpRequest):
+        async def list(request: HttpRequest, filters: Query[self.filters_schema]):
             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()
-            print(rels)
             if len(rels) > 0:
                 qs = qs.prefetch_related(*rels)
+            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()
             ]
             return objs
 
-        list.__name__ = f"list_{self.model._meta.verbose_name_plural}"
+        list.__name__ = f"list_{self.model_util.verbose_name_view_resolver()}"
+        return list
 
     def retrieve_view(self):
         @self.router.get(
@@ -134,11 +176,12 @@ class APIViewSet:
             auth=self.auths,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        async def retrieve(request: HttpRequest, pk: int | str):
+        async def retrieve(request: HttpRequest, pk: Path[self.path_schema]):
             obj = await self.model_util.get_object(request, 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):
         @self.router.patch(
@@ -146,10 +189,13 @@ class APIViewSet:
             auth=self.auths,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
-        async def update(request: HttpRequest, data: self.schema_update, pk: int | str):
+        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)
 
-        update.__name__ = f"update_{self.model._meta.model_name}"
+        update.__name__ = f"update_{self.model_util.model_name}"
+        return update
 
     def delete_view(self):
         @self.router.delete(
@@ -157,10 +203,11 @@ class APIViewSet:
             auth=self.auths,
             response={204: None, self.error_codes: GenericMessageSchema},
         )
-        async def delete(request: HttpRequest, pk: int | str):
-            return await self.model_util.delete_s(request, pk)
+        async def delete(request: HttpRequest, pk: Path[self.path_schema]):
+            return 204, await self.model_util.delete_s(request, pk)
 
-        delete.__name__ = f"delete_{self.model._meta.model_name}"
+        delete.__name__ = f"delete_{self.model_util.model_name}"
+        return delete
 
     def views(self):
         """
@@ -194,14 +241,18 @@ class APIViewSet:
         async def some_method(request, *args, **kwargs):
             pass
         """
-        pass
 
     def add_views(self):
-        self.create_view()
-        self.list_view()
-        self.retrieve_view()
-        self.update_view()
-        self.delete_view()
+        if "all" in self.disable:
+            self.views()
+            return self.router
+
+        for views_type, (schema, view) in self._crud_views.items():
+            if views_type not in self.disable and (
+                schema is not None or views_type == "delete"
+            ):
+                view()
+
         self.views()
         return self.router
 

django_ninja_aio_crud-0.4.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-ninja_aio/__init__.py,sha256=GPvxFosuQ4fZ9LpbRClXqv8e7BecmVUtj2nvbJyalus,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=mIZofuGOsRATYQki7GIuz50OQWfMes41cvOOAAonQA0,13768
-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=ZhFqRDP5g2A2er3izx36QjrYJxL_jgusbH7w7mVHNrk,339
-ninja_aio/views.py,sha256=IT6rTCcjXcVYrCi4_uEwnGOGXeWlIB4ZuyXJp8Fsqqc,6971
-django_ninja_aio_crud-0.4.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-django_ninja_aio_crud-0.4.0.dist-info/METADATA,sha256=0yQr4CWufJ7ZtXuhpTOchKQ-yOzG7o-wTaymDV0Tqvc,10832
-django_ninja_aio_crud-0.4.0.dist-info/RECORD,,