django-ninja-aio-crud 0.1.0__py3-none-any.whl

django_ninja_aio_crud-0.1.0.dist-info/METADATA

@@ -0,0 +1,273 @@
+Metadata-Version: 2.1
+Name: django-ninja-aio-crud
+Version: 0.1.0
+Summary: Django Ninja AIO CRUD - Rest Framework 
+Author: Giuseppe Casillo
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Framework :: Django
+Classifier: Framework :: AsyncIO
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Dist: django-ninja >=1.3.0
+Requires-Dist: joserfc >=1.0.0
+Requires-Dist: orjson >= 3.10.7
+Project-URL: Repository, https://github.com/caspel26/django-ninja-aio-crud
+
+# 🥷 django-ninja-aio-crud
+> [!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.
+
+## 📝 Instructions
+
+### 📚 Prerequisites
+- Install Python from the [official website](https://www.python.org/) (latest version) and ensure it is added to the system Path and environment variables.
+
+### 💻 Setup your environment
+- Create a virtual environment
+```bash
+python -m venv .venv
+```
+### ✅ Activate it
+- If you are from linux activate it with
+```bash
+. .venv/bin/activate
+```
+- If you are from windows activate it with
+```bash
+. .venv/Scripts/activate
+```
+
+### 📥 Install requirements
+```bash
+pip install django-ninja-aio
+```
+
+## 🚀 Usage
+
+> [!TIP]
+> If you find **django ninja aio crud** useful, consider :star: this project
+> and why not ... [Buy me a coffee](https://buymeacoffee.com/caspel26)
+
+### ModelSerializer
+- You can serialize your models using ModelSerializer and made them inherit from it. In your models.py import ModelSerializer
+```Python
+from ninja_aio.models import ModelSerializer
+
+
+class Foo(ModelSerializer):
+  name = mdoels.CharField()
+  bar = models.CharField()
+
+  class ReadSerializer:
+    fields = ["id", "name", "bar"]
+
+  class CreateSerializer:
+    fields = ["name", "bar"]
+
+  class UpdateSerializer:
+    fields = ["name", "bar"]
+```
+- ReadSerializer, CreateSerializer, UpdateSerializer are used to define which fields would be included in runtime schemas creation. You can also specify custom fields and handle their function by overriding custom_actions ModelSerializer's method(custom fields are only available for Create and Update serializers).
+```Python
+from ninja_aio.models import ModelSerializer
+
+
+class Foo(ModelSerializer):
+  name = mdoels.CharField()
+  bar = models.CharField()
+  active = models.BooleanField(default=False)
+
+  class ReadSerializer:
+    fields = ["id", "name", "bar"]
+
+  class CreateSerializer:
+    customs = [("force_activation", bool, False)]
+    fields = ["name", "bar"]
+
+  class UpdateSerializer:
+    fields = ["name", "bar"]
+
+  async def custom_actions(self, payload: dict[str, Any]):
+      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
+      self.active = True
+      await self.asave()
+```
+- post create method is a custom method that comes out to handle actions which will be excuted after that the object is created. It can be used, indeed, for example to handle custom fields' actions.
+
+
+### APIViewSet
+- View class used to automatically generate CRUD views. in your views.py import APIViewSet and define your api using NinjaAPI class. As Parser and Render of the API you must use ninja_aio built-in classes which will serialize data using orjson.
+```Python
+from ninja import NinjAPI
+from ninja_aio.views import APIViewSet
+from ninja_aio.parsers import ORJSONParser
+from ninja_aio.renders import ORJSONRender
+
+from .models import Foo
+
+api = NinjaAPI(renderer=ORJSONRenderer(), parser=ORJSONParser())
+
+
+class FooAPI(APIViewSet):
+  model = Foo
+  api = api
+
+  
+FooAPI().add_views_to_route()
+```
+- and that's it, your model CRUD will be automatically created. You can also add custom views to CRUD overriding the built-in method "views".
+```Python
+from ninja import NinjAPI, Schema
+from ninja_aio.views import APIViewSet
+from ninja_aio.parsers import ORJSONParser
+from ninja_aio.renders import ORJSONRender
+
+from .models import Foo
+
+api = NinjaAPI(renderer=ORJSONRenderer(), parser=ORJSONParser())
+
+
+class ExampleSchemaOut(Schema):
+  sum: float
+
+
+class ExampleSchemaIn(Schema):
+  n1: float
+  n2: float
+
+
+class FooAPI(APIViewSet):
+  model = Foo
+  api = api
+
+  def views(self):
+    @self.router.post("numbers-sum/", response={200: ExampleSchemaOut)
+    async def sum(request: HttpRequest, data: ExampleSchemaIn):
+        return 200, {sum: data.n1 + data.n2}
+
+
+FooAPI().add_views_to_route()
+```
+
+### APIView
+- View class to code generic views class based. In your views.py import APIView class.
+```Python
+from ninja import NinjAPI, Schema
+from ninja_aio.views import APIView
+from ninja_aio.parsers import ORJSONParser
+from ninja_aio.renders import ORJSONRender
+
+api = NinjaAPI(renderer=ORJSONRenderer(), parser=ORJSONParser())
+
+
+class ExampleSchemaOut(Schema):
+  sum: float
+
+
+class ExampleSchemaIn(Schema):
+  n1: float
+  n2: float
+
+
+class SumView(APIView):
+  api = api
+  api_router_path = "numbers-sum/"
+  router_tag = "Sum"
+
+  def views(self):
+    @self.router.post(self.api_router_path, response={200: ExampleSchemaOut)
+    async def sum(request: HttpRequest, data: ExampleSchemaIn):
+        return 200, {sum: data.n1 + data.n2}
+
+
+SumView().add_views_to_route()
+```
+
+## 🔒 Authentication
+### 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.  
+```Python
+from ninja_aio.auth import AsyncJWTBearer
+from django.conf import settings
+from django.http import HttpRequest
+
+from .models import Foo
+
+
+class CustomJWTBearer(AsyncJWTBearer):
+    jwt_public = settings.JWT_PUBLIC
+    claims = {"foo_id": {"essential": True}}
+
+    async def auth_handler(self, request: HttpRequest):
+      try:
+        request.user = await Foo.objects.aget(id=self.dcd.claims["foo_id"])
+      except Foo.DoesNotExist:
+        return None
+      return request.user
+```
+- Then add it to views.
+```Python
+from ninja import NinjAPI, Schema
+from ninja_aio.views import APIViewSet, APIView
+from ninja_aio.parsers import ORJSONParser
+from ninja_aio.renders import ORJSONRender
+
+from .models import Foo
+
+api = NinjaAPI(renderer=ORJSONRenderer(), parser=ORJSONParser())
+
+
+class FooAPI(APIViewSet):
+  model = Foo
+  api = api
+  auths = CustomJWTBearer()
+
+
+class ExampleSchemaOut(Schema):
+  sum: float
+
+
+class ExampleSchemaIn(Schema):
+  n1: float
+  n2: float
+
+
+class SumView(APIView):
+  api = api
+  api_router_path = "numbers-sum/"
+  router_tag = "Sum"
+  auths = CustomJWTBearer()
+
+  def views(self):
+    @self.router.post(self.api_router_path, response={200: ExampleSchemaOut}, auth=self.auths)
+    async def sum(request: HttpRequest, data: ExampleSchemaIn):
+        return 200, {sum: data.n1 + data.n2}
+
+
+FooAPI().add_views_to_route()
+SumView().add_views_to_route()
+```
+
+## 📌 Notes
+- Feel free to contribute and improve the program. 🛠️
+

django_ninja_aio_crud-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+ninja_aio/__init__.py,sha256=b8kPWi0QdIvtWqqVRGTPL-1Nnwvlnf-FNDPVUvZOq8s,69
+ninja_aio/auth.py,sha256=hGgiblvffpHmmakjaxdNT3G0tq39-Bvc5oLNqjn4qd8,1300
+ninja_aio/exceptions.py,sha256=PPNr1CdC7M7Kx1MtiBGuR4hATYQqEuvxCRU6uSG7rgM,543
+ninja_aio/models.py,sha256=G6AOtGNtaiQNZ1nG6rxv-xNRzZmSgbrNYwQjXmNeFmo,10710
+ninja_aio/parsers.py,sha256=e_4lGCPV7zs-HTqtdJTc8yQD2KPAn9njbL8nF_Mmgkc,153
+ninja_aio/renders.py,sha256=uADkEyHQr4yet2h9j89Zjr9AbIElWCiLVk5HoqLSm10,1453
+ninja_aio/schemas.py,sha256=EgRkfhnzZqwGvdBmqlZixMtMcoD1ZxV_qzJ3fmaAy20,113
+ninja_aio/views.py,sha256=pEtc0ovXvymfKJRtthd8cAps2RetTr9gzn-Xmxs763o,6126
+django_ninja_aio_crud-0.1.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+django_ninja_aio_crud-0.1.0.dist-info/METADATA,sha256=atQGOc7SRwQLalwhnT65yJCqdAIiqTQXyyIpz05WH0s,8031
+django_ninja_aio_crud-0.1.0.dist-info/RECORD,,

django_ninja_aio_crud-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ninja_aio/__init__.py

@@ -0,0 +1,3 @@
+""" Django Ninja AIO CRUD - Rest Framework """
+
+__version__ = "0.1.0"

ninja_aio/auth.py

@@ -0,0 +1,50 @@
+from joserfc import jwt, jwk, errors
+from django.http.request import HttpRequest
+from ninja.security.http import HttpBearer
+
+from .exceptions import AuthError
+
+
+
+class AsyncJwtBearer(HttpBearer):
+    jwt_public: jwk.RSAKey
+    claims: dict[str, dict]
+    algorithms: list[str] = ["RS256"]
+
+    @classmethod
+    def get_claims(cls):
+        return jwt.JWTClaimsRegistry(**cls.claims)
+
+    def validate_claims(self, claims: jwt.Claims):
+        jwt_claims = self.get_claims()
+
+        try:
+            jwt_claims.validate(claims)
+        except (
+            errors.InvalidClaimError,
+            errors.MissingClaimError,
+            errors.ExpiredTokenError,
+        ):
+            raise AuthError()
+
+    async def auth_handler(self, request: HttpRequest):
+        """
+        Override this method to make your own authentication
+        """
+        pass
+
+    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
+
+        try:
+            self.validate_claims(self.dcd.claims)
+        except AuthError:
+            return None
+
+        return await self.auth_handler(request)

ninja_aio/exceptions.py

@@ -0,0 +1,24 @@
+class BaseException(Exception):
+    error: str | dict = ""
+    status_code: int = 400
+
+    def __init__(
+        self,
+        error: str | dict = None,
+        status_code: int | None = None,
+        is_critical: bool = False,
+    ) -> None:
+        self.error = error or self.error
+        self.status_code = status_code or self.status_code
+        self.is_critical = is_critical
+
+    def get_error(self):
+        return self.error, self.status_code
+
+
+class SerializeError(BaseException):
+    pass
+
+
+class AuthError(BaseException):
+    pass

ninja_aio/models.py

@@ -0,0 +1,305 @@
+import base64
+from typing import Any, Literal
+
+from ninja.schema import Schema
+from ninja.orm import create_schema
+
+from django.db import models
+from django.http import HttpResponse, HttpRequest
+from django.core.exceptions import ObjectDoesNotExist
+from django.db.models.fields.related import OneToOneRel
+from django.db.models.fields.related_descriptors import (
+    ReverseManyToOneDescriptor,
+    ReverseOneToOneDescriptor,
+)
+
+from .exceptions import SerializeError
+
+S_TYPES = Literal["create", "update"]
+REL_TYPES = Literal["many", "one"]
+
+
+class ModelSerializer(models.Model):
+    class Meta:
+        abstract = True
+
+    class CreateSerializer:
+        fields: list[str] = []
+        customs: list[tuple[str, type, Any]] = []
+
+    class ReadSerializer:
+        fields: list[str] = []
+
+    class UpdateSerializer:
+        fields: list[str] = []
+        customs: list[tuple[str, type, Any]] = []
+
+    @property
+    def has_custom_fields_create(self):
+        return hasattr(self.CreateSerializer, "customs")
+
+    @property
+    def has_custom_fields_update(self):
+        return hasattr(self.UpdateSerializer, "customs")
+
+    @property
+    def has_custom_fields(self):
+        return self.has_custom_fields_create or self.has_custom_fields_update
+
+    def has_changed(self, field: str) -> bool:
+        """
+        Check if a model field has changed
+        """
+        if not self.pk:
+            return False
+        old_value = (
+            self.__class__._default_manager.filter(pk=self.pk)
+            .values(field)
+            .get()[field]
+        )
+        return getattr(self, field) != old_value
+
+    @classmethod
+    async def queryset_request(cls, request: HttpRequest):
+        """
+        Override this method to return a filtered queryset based
+        on the request received
+        """
+        return cls.objects.select_related().all()
+
+    async def post_create(self) -> None:
+        """
+        Override this method to execute code after the object
+        has been created
+        """
+        pass
+
+    async def custom_actions(self, payload: dict[str, Any]):
+        """
+        Override this method to execute custom actions based on
+        custom given fields. It could be useful for post create method.
+        """
+        pass
+
+    @classmethod
+    def get_reverse_relations(cls):
+        reverse_rels = []
+        for f in cls.ReadSerializer.fields:
+            field_obj = getattr(cls, f)
+            if isinstance(field_obj, ReverseManyToOneDescriptor):
+                reverse_rels.append(field_obj.field.__dict__.get("_related_name"))
+            if isinstance(field_obj, ReverseOneToOneDescriptor):
+                reverse_rels.append(
+                    list(field_obj.__dict__.values())[0].__dict__.get("related_name")
+                )
+        return reverse_rels
+
+    @classmethod
+    def get_reverse_relation_schema(
+        cls, obj: type["ModelSerializer"], rel_type: type[REL_TYPES], field: str
+    ):
+        for index, rel_f in enumerate(obj.ReadSerializer.fields):
+            if rel_f == cls._meta.model_name:
+                obj.ReadSerializer.fields.pop(index)
+                break
+        rel_schema = obj.generate_read_s(depth=0)
+        if rel_type == "many":
+            rel_schema = list[rel_schema]
+        rel_data = (
+            field,
+            rel_schema | None,
+            None,
+        )
+        obj.ReadSerializer.fields.append(cls._meta.model_name)
+        return rel_data
+
+    @classmethod
+    def get_schema_out_data(cls):
+        fields = []
+        reverse_rels = []
+        for f in cls.ReadSerializer.fields:
+            field_obj = getattr(cls, f)
+            if isinstance(field_obj, ReverseManyToOneDescriptor):
+                rel_obj: ModelSerializer = field_obj.field.__dict__.get("model")
+                rel_data = cls.get_reverse_relation_schema(rel_obj, "many", f)
+                reverse_rels.append(rel_data)
+                continue
+            if isinstance(field_obj, ReverseOneToOneDescriptor):
+                rel_obj: ModelSerializer = list(field_obj.__dict__.values())[
+                    0
+                ].__dict__.get("related_model")
+                rel_data = cls.get_reverse_relation_schema(rel_obj, "one", f)
+                reverse_rels.append(rel_data)
+                continue
+            fields.append(f)
+        return fields, reverse_rels
+
+    @classmethod
+    def is_custom(cls, field: str):
+        customs = cls.get_custom_fields("create") or []
+        customs.extend(cls.get_custom_fields("update") or [])
+        return any(field in custom_f for custom_f in customs)
+
+    @classmethod
+    async def parse_input_data(cls, request: HttpRequest, data: Schema):
+        payload = data.model_dump()
+        customs = {k: v for k, v in payload.items() if cls.is_custom(k)}
+        for k, v in payload.items():
+            if cls.is_custom(k):
+                continue
+            field_obj = getattr(cls, k).field
+            if isinstance(field_obj, models.BinaryField):
+                if not v.endswith(b"=="):
+                    v = v + b"=="
+                payload |= {k: base64.b64decode(v)}
+            if isinstance(field_obj, models.ForeignKey):
+                try:
+                    rel: ModelSerializer = await field_obj.related_model.get_object(
+                        request, v
+                    )
+                except ObjectDoesNotExist:
+                    raise SerializeError({k: "not found"}, 404)
+                payload |= {k: rel}
+        new_payload = {k: v for k, v in payload.items() if k not in customs}
+        return new_payload, customs
+
+    @classmethod
+    async def parse_output_data(cls, request: HttpRequest, data: Schema):
+        olds_k: list[dict] = []
+        payload = data.model_dump()
+        for k, v in payload.items():
+            try:
+                field_obj = getattr(cls, k).field
+            except AttributeError:
+                field_obj = getattr(cls, k).related
+            if isinstance(v, dict) and (
+                isinstance(field_obj, models.ForeignKey)
+                or isinstance(field_obj, OneToOneRel)
+            ):
+                rel: ModelSerializer = await field_obj.related_model.get_object(
+                    request, list(v.values())[0]
+                )
+                if isinstance(field_obj, models.ForeignKey):
+                    for rel_k, rel_v in v.items():
+                        field_rel_obj = getattr(rel, rel_k)
+                        if isinstance(field_rel_obj, models.ForeignKey):
+                            olds_k.append({rel_k: rel_v})
+                    for obj in olds_k:
+                        for old_k, old_v in obj.items():
+                            v.pop(old_k)
+                            v |= {f"{old_k}_id": old_v}
+                    olds_k = []
+                payload |= {k: rel}
+        return payload
+
+    @classmethod
+    def get_custom_fields(cls, s_type: type[S_TYPES]):
+        try:
+            match s_type:
+                case "create":
+                    customs = cls.CreateSerializer.customs
+                case "update":
+                    customs = cls.UpdateSerializer.customs
+        except AttributeError:
+            return None
+        return customs
+
+    @classmethod
+    def get_optional_fields(cls, s_type: type[S_TYPES]) -> list[str] | None:
+        try:
+            match s_type:
+                case "create":
+                    optionals = cls.CreateSerializer.optionals
+                case "update":
+                    optionals = cls.UpdateSerializer.optionals
+        except AttributeError:
+            return None
+        return optionals
+
+    @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,
+        )
+
+    @classmethod
+    def generate_create_s(cls) -> Schema:
+        return create_schema(
+            model=cls,
+            name=f"{cls._meta.model_name}SchemaIn",
+            fields=cls.CreateSerializer.fields,
+            optional_fields=cls.get_optional_fields("create"),
+            custom_fields=cls.get_custom_fields("create"),
+        )
+
+    @classmethod
+    def generate_update_s(cls) -> Schema:
+        return create_schema(
+            model=cls,
+            name=f"{cls._meta.model_name}SchemaPatch",
+            fields=cls.UpdateSerializer.fields,
+            optional_fields=cls.get_optional_fields("update"),
+            custom_fields=cls.get_custom_fields("update"),
+        )
+
+    @classmethod
+    async def get_object(cls, request: HttpRequest, pk: int | str):
+        q = {cls._meta.pk.attname: pk}
+        try:
+            obj = (
+                await (await cls.queryset_request(request))
+                .prefetch_related(*cls.get_reverse_relations())
+                .aget(**q)
+            )
+        except ObjectDoesNotExist:
+            raise SerializeError({cls._meta.model_name: "not found"}, 404)
+        return obj
+
+    @classmethod
+    async def create_s(cls, request: HttpRequest, data: Schema):
+        try:
+            payload, customs = await cls.parse_input_data(request, data)
+            pk = (await cls.objects.acreate(**payload)).pk
+            obj = await cls.get_object(request, pk)
+        except SerializeError as e:
+            return e.status_code, e.error
+        payload |= customs
+        await obj.custom_actions(payload)
+        await obj.post_create()
+        return await cls.read_s(request, obj)
+
+    @classmethod
+    async def read_s(cls, request: HttpRequest, obj: type["ModelSerializer"]):
+        schema = cls.generate_read_s().from_orm(obj)
+        return await cls.parse_output_data(request, schema)
+
+    @classmethod
+    async def update_s(cls, request: HttpRequest, data: Schema, pk: int | str):
+        try:
+            obj = await cls.get_object(request, pk)
+        except SerializeError as e:
+            return e.status_code, e.error
+
+        payload, customs = await cls.parse_input_data(request, data)
+        for k, v in payload.items():
+            if v is not None:
+                setattr(obj, k, v)
+        payload |= customs
+        await obj.custom_actions(payload)
+        await obj.asave()
+        return await cls.read_s(request, obj)
+
+    @classmethod
+    async def delete_s(cls, request: HttpRequest, pk: int | str):
+        try:
+            obj = await cls.get_object(request, pk)
+        except SerializeError as e:
+            return e.status_code, e.error
+        await obj.adelete()
+        return HttpResponse(status=204)

ninja_aio/parsers.py

@@ -0,0 +1,7 @@
+import orjson
+from ninja.parser import Parser
+
+
+class ORJSONParser(Parser):
+    def parse_body(self, request):
+        return orjson.loads(request.body)

ninja_aio/renders.py

@@ -0,0 +1,43 @@
+import base64
+
+import orjson
+from django.http import HttpRequest
+from ninja.renderers import BaseRenderer
+
+
+class ORJSONRenderer(BaseRenderer):
+    media_type = "application/json"
+
+    def render(self, request: HttpRequest, data: dict | list, *, response_status):
+        if isinstance(data, list):
+            return orjson.dumps(self.render_list(data))
+        return orjson.dumps(self.render_dict(data))
+
+    @classmethod
+    def render_list(cls, data: list[dict]) -> list[dict]:
+        return [cls.parse_data(d) for d in data]
+
+    @classmethod
+    def render_dict(cls, data: dict):
+        return cls.parse_data(data)
+
+    @classmethod
+    def parse_data(cls, data: dict):
+        for k, v in data.items():
+            if isinstance(v, bytes):
+                data |= {k: base64.b64encode(v).decode()}
+            if isinstance(v, dict):
+                for k_rel, v_rel in v.items():
+                    if not isinstance(v_rel, bytes):
+                        continue
+                    v |= {k_rel: base64.b64encode(v_rel).decode()}
+                data |= {k: v}
+            if isinstance(v, list):
+                index_rel = 0
+                for f_rel in v:
+                    for k_rel, v_rel in f_rel.items():
+                        if isinstance(v_rel, bytes):
+                            v[index_rel] |= {k_rel: base64.b64encode(v_rel).decode()}
+                    index_rel += 1
+                data |= {k: v}
+        return data

ninja_aio/schemas.py

@@ -0,0 +1,5 @@
+from pydantic import RootModel
+
+
+class GenericMessageSchema(RootModel[dict[str, str]]):
+    root: dict[str, str]

ninja_aio/views.py

@@ -0,0 +1,194 @@
+from typing import List
+
+from ninja import NinjaAPI, Router
+from ninja.constants import NOT_SET
+from django.http import HttpRequest
+
+from .models import ModelSerializer
+from .schemas import GenericMessageSchema
+from .exceptions import SerializeError
+
+ERROR_CODES = frozenset({400, 401, 404, 428})
+
+
+class APIView:
+    api: NinjaAPI
+    router_tag: str
+    api_route_path: str
+    auths: list | None = NOT_SET
+
+    def __init__(self) -> None:
+        self.router = Router(tags=[self.router_tag])
+        self.error_codes = ERROR_CODES
+
+    def views(self):
+        """
+        Override this method to add your custom views. For example:
+        @self.router.get(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        You can add multilple views just doing:
+
+        @self.router.get(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        @self.router.post(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        If you provided a list of auths you can chose which of your views
+        should be authenticated:
+
+        AUTHENTICATED VIEW:
+
+        @self.router.get(some_path, response=some_schema, auth=self.auths)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        NOT AUTHENTICATED VIEW:
+
+        @self.router.post(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+        """
+        pass
+
+    def add_views(self):
+        self.views()
+        return self.router
+
+    def add_views_to_route(self):
+        return self.api.add_router(f"{self.api_route_path}/", self.add_views())
+
+
+class APIViewSet:
+    model: ModelSerializer
+    api: NinjaAPI
+    auths: list | None = NOT_SET
+
+    def __init__(self) -> None:
+        self.router = Router(tags=[self.model._meta.model_name.capitalize()])
+        self.schema_in = self.model.generate_create_s()
+        self.schema_out = self.model.generate_read_s()
+        self.schema_update = self.model.generate_update_s()
+        self.path = "/"
+        self.path_retrieve = f"{self.model._meta.pk.attname}/"
+        self.error_codes = ERROR_CODES
+
+    def create_view(self):
+        @self.router.post(
+            self.path,
+            auth=self.auths,
+            response={200: self.schema_out, self.error_codes: GenericMessageSchema},
+        )
+        async def create(request: HttpRequest, data: self.schema_in):
+            return await self.model.create_s(request, data)
+
+        create.__name__ = f"create_{self.model._meta.model_name}"
+
+    def list_view(self):
+        @self.router.get(
+            self.path,
+            auth=self.auths,
+            response={
+                200: List[self.schema_out],
+                self.error_codes: GenericMessageSchema,
+            },
+        )
+        async def list(request: HttpRequest):
+            qs = await self.model.queryset_request(request)
+            rels = self.model.get_reverse_relations()
+            if len(rels) > 0:
+                qs = qs.prefetch_related(*rels)
+            objs = [await self.model.read_s(request, obj) async for obj in qs.all()]
+            return objs
+
+        list.__name__ = f"list_{self.model._meta.verbose_name_plural}"
+
+    def retrieve_view(self):
+        @self.router.get(
+            self.path_retrieve,
+            auth=self.auths,
+            response={200: self.schema_out, self.error_codes: GenericMessageSchema},
+        )
+        async def retrieve(request: HttpRequest, pk: int | str):
+            try:
+                obj = await self.model.get_object(request, pk)
+            except SerializeError as e:
+                return e.status_code, e.error
+            return await self.model.read_s(request, obj)
+
+        retrieve.__name__ = f"retrieve_{self.model._meta.model_name}"
+
+    def update_view(self):
+        @self.router.patch(
+            self.path_retrieve,
+            auth=self.auths,
+            response={200: self.schema_out, self.error_codes: GenericMessageSchema},
+        )
+        async def update(request: HttpRequest, data: self.schema_update, pk: int | str):
+            return await self.model.update_s(request, data, pk)
+
+        update.__name__ = f"update_{self.model._meta.model_name}"
+
+    def delete_view(self):
+        @self.router.delete(
+            self.path_retrieve,
+            auth=self.auths,
+            response={204: None, self.error_codes: GenericMessageSchema},
+        )
+        async def delete(request: HttpRequest, pk: int | str):
+            return await self.model.delete_s(request, pk)
+
+        delete.__name__ = f"delete_{self.model._meta.model_name}"
+
+    def views(self):
+        """
+        Override this method to add your custom views. For example:
+        @self.router.get(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        You can add multilple views just doing:
+
+        @self.router.get(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        @self.router.post(some_path, response=some_schema)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        If you provided a list of auths you can chose which of your views
+        should be authenticated:
+
+        AUTHENTICATED VIEW:
+
+        @self.router.get(some_path, response=some_schema, auth=self.auths)
+        async def some_method(request, *args, **kwargs):
+            pass
+
+        NOT AUTHENTICATED VIEW:
+
+        @self.router.post(some_path, response=some_schema)
+        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()
+        self.views()
+        return self.router
+
+    def add_views_to_route(self):
+        return self.api.add_router(
+            f"{self.model._meta.verbose_name_plural}/",
+            self.add_views(),
+        )