Merge pull request #7 from freemindcore/feat/more-configuration

Feat/more configuration

Author: freemindcore

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.1.19
+current_version = 0.1.20
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<feat>\d+)\.(?P<patch>\d+)

easy/__init__.py

@@ -1,6 +1,6 @@
 """Django Easy API - Easy and Fast Django REST framework based on Django-ninja-extra"""
 
-__version__ = "0.1.19"
+__version__ = "0.1.20"
 
 from easy.main import EasyAPI
 

easy/controller/base.py

@@ -9,18 +9,27 @@
 
 class CrudAPIController(ControllerBase, CrudAPI, metaclass=CrudApiMetaclass):
     """
-    Base APIController for auto creating CRUD APIs
-
-    GET /{id}       - Retrieve a single Object
-    PUT /{id}               - Create a single Object
-    PATCH /{id}     - Update fields for an Object
-    DELETE /{id}    - Delete a single Object
-    GET /           - Retrieve multiple Object, paginated
-    GET /filter/?filters={filters_dict}
-                        - Filter Objects with django-orm filter dict, paginated
-    GET /filter_exclude/?filters={filters_dict}
-                        - Filter exclude Objects with Django-ORM filter dict, paginated
-
+    Base APIController for auto creating CRUD APIs, configurable via Meta class
+    APIs auto genrated:
+        Creat
+            PUT /{id}       - Create a single Object
+
+        Read
+            GET /{id}       - Retrieve a single Object
+            GET /           - Retrieve multiple Object, paginated, support filtering
+
+        Update
+            PATCH /{id}     - Update a single Object
+
+        Delete
+            DELETE /{id}    - Delete a single Object
+
+    Configuration:
+        model:              django model
+        model_fields:       fields to be included in Schema, default to "__all__"
+        model_exclude:      fields to be excluded in Schema
+        model_join:         retrieve all m2m/FK fields, default to True
+        model_recursive:    recursively retrieve FK models, defaul to False
     """
 
     ...

easy/controller/meta.py

@@ -2,7 +2,7 @@
 import logging
 import uuid
 from abc import ABCMeta
-from typing import Any, Optional, Tuple, Type, Union
+from typing import Any, List, Optional, Tuple, Type, Union
 
 from django.db import models
 from django.http import HttpRequest
@@ -27,6 +27,10 @@ def __init__(self, service=None):  # type: ignore
             self.service = service
         super().__init__(model=self.model)
 
+        # Critical to set Meta
+        if hasattr(self, "Meta"):
+            self.model.Meta = self.Meta  # type: ignore
+
     # Define Controller APIs for auto generation
     async def get_obj(self, request: HttpRequest, id: int) -> Any:
         """
@@ -65,24 +69,6 @@ async def get_objs(
             return await self.service.get_objs(maximum, **json.loads(filters))
         return await self.service.get_objs(maximum)
 
-    @paginate
-    async def filter_objs(
-        self, request: HttpRequest, filters: Union[str, bytes]
-    ) -> Any:
-        """
-        GET /filter/?filters={filters_dict}
-        Filter Objects with Django-ORM filter dict
-        """
-        return await self.service.filter_objs(**json.loads(filters))
-
-    @paginate
-    async def filter_exclude_objs(self, filters: Union[str, bytes]) -> Any:
-        """
-        GET /filter_exclude/?filters={filters_dict}
-        Filter exclude Objects with Django-ORM filter dict
-        """
-        return await self.service.filter_exclude_objs(**json.loads(filters))
-
     # async def bulk_create_objs(self, request):
     #     """
     #     POST /bulk_create
@@ -101,15 +87,18 @@ async def filter_exclude_objs(self, filters: Union[str, bytes]) -> Any:
 class CrudApiMetaclass(ABCMeta):
     def __new__(mcs, name: str, bases: Tuple[Type[Any], ...], attrs: dict) -> Any:
         # Get configs from Meta
-        temp_base: Type = type.__new__(type, "object", (), {})
         temp_cls: Type = super(CrudApiMetaclass, mcs).__new__(
-            mcs, name, (temp_base,), attrs
+            mcs, name, (object,), attrs
         )
         temp_opts: ModelOptions = ModelOptions(getattr(temp_cls, "Meta", None))
+        opts_model: Optional[Type[models.Model]] = temp_opts.model
         opts_fields_exclude: Optional[str] = temp_opts.model_exclude
         opts_fields: Optional[str] = temp_opts.model_fields
-        opts_model: Optional[Type[models.Model]] = temp_opts.model
         opts_recursive: Optional[bool] = temp_opts.model_recursive
+        opts_join: Optional[bool] = temp_opts.model_join
+        opts_sensitive_fields: Optional[
+            Union[str, List[str]]
+        ] = temp_opts.sensitive_fields
 
         base_cls_attrs = {
             "get_obj": http_get("/{id}", summary="Get a single object")(
@@ -121,14 +110,6 @@ def __new__(mcs, name: str, bases: Tuple[Type[Any], ...], attrs: dict) -> Any:
             "get_all": http_get("/", summary="Get multiple objects")(
                 copy_func(CrudAPI.get_objs)  # type: ignore
             ),
-            "filter_objs": http_get("/filter/", summary="Filter")(
-                copy_func(CrudAPI.filter_objs)  # type: ignore
-            ),
-            "filter_exclude_objs": http_get(
-                "/filter_exclude/", summary="Filter exclude"
-            )(
-                copy_func(CrudAPI.filter_exclude_objs)  # type: ignore
-            ),
         }
 
         if opts_model:
@@ -143,7 +124,6 @@ class Config:
                             model_fields = "__all__"
                         else:
                             model_fields = opts_fields if opts_fields else "__all__"
-                    model_recursive = opts_recursive
 
             async def add_obj(  # type: ignore
                 self, request: HttpRequest, data: DataSchema
@@ -163,7 +143,7 @@ async def patch_obj(  # type: ignore
             ) -> Any:
                 """
                 PATCH /{id}
-                Update a single field for a Object
+                Update a single object
                 """
                 if await self.service.patch_obj(id=id, payload=data.dict()):
                     return BaseApiResponse("Updated.")
@@ -195,21 +175,35 @@ async def patch_obj(  # type: ignore
             mcs, name, (new_base,), attrs
         )
 
-        new_cls.model = opts_model
-        new_cls.model_exclude = opts_fields_exclude
-        new_cls.model_fields = opts_fields
-        new_cls.model_recursive = opts_recursive
-
+        if opts_model:
+            setattr(opts_model.Meta, "model_exclude", opts_fields_exclude)
+            setattr(opts_model.Meta, "model_fields", opts_fields)
+            setattr(opts_model.Meta, "model_recursive", opts_recursive)
+            setattr(opts_model.Meta, "model_join", opts_join)
+            setattr(opts_model.Meta, "sensitive_fields", opts_sensitive_fields)
+            setattr(new_cls, "model", opts_model)
         return new_cls
 
 
 class ModelOptions:
     def __init__(self, options: object = None):
+        """
+        Configuration:
+            model:              django model
+            model_fields:       fields to be included in Schema, default to "__all__"
+            model_exclude:      fields to be excluded in Schema
+            model_join:         retrieve all m2m/FK fields, default to True
+            model_recursive:    recursively retrieve FK models, default to False
+        """
         self.model: Optional[Type[models.Model]] = getattr(options, "model", None)
         self.model_fields: Optional[Union[str]] = getattr(options, "model_fields", None)
         self.model_exclude: Optional[Union[str]] = getattr(
             options, "model_exclude", None
         )
+        self.model_join: Optional[Union[bool]] = getattr(options, "model_join", True)
         self.model_recursive: Optional[Union[bool]] = getattr(
             options, "model_recursive", False
         )
+        self.sensitive_fields: Optional[Union[str, List[str]]] = getattr(
+            options, "sensitive_fields", ["token", "password"]
+        )

easy/domain/orm.py

@@ -19,6 +19,14 @@ def __init__(self, model: Type[models.Model]):
             if isinstance(_field, models.ManyToManyField)
         )
 
+    # @property
+    # def model_join(self):
+    #     """If configured to retrieve m2m by join"""
+    #     if hasattr(self.model, "Meta"):
+    #         return getattr(self.model.Meta, "model_join", True)
+    #     else:
+    #         return True
+
     def _separate_payload(self, payload: Dict) -> Tuple[Dict, Dict]:
         m2m_fields = {}
         local_fields = {}
@@ -118,7 +126,7 @@ def _crud_get_objs_all(self, maximum: int = None, **filters: Any) -> Any:
         return qs
 
     def _crud_filter(self, **kwargs: Any) -> QuerySet:
-        return self.model.objects.filter(**kwargs)
+        return self.model.objects.filter(**kwargs)  # pragma: no cover
 
     def _crud_filter_exclude(self, **kwargs: Any) -> QuerySet:
         return self.model.objects.all().exclude(**kwargs)

easy/domain/serializers.py

@@ -72,9 +72,9 @@ def serialize_foreign_key(
     except Exception as exc:  # pragma: no cover
         logger.error(f"serialize_foreign_key error - {obj}", exc_info=exc)
         return {field.name: None}
+    if hasattr(obj, "Meta") and getattr(obj.Meta, "model_recursive", False):
+        return {field.name: serialize_model_instance(related_instance, referrers)}
     return {field.name: field_value}
-    # TODO: recursive
-    # return {field.name: serialize_model_instance(related_instance, referrers)}
 
 
 def serialize_many_relationship(
@@ -90,8 +90,10 @@ def serialize_many_relationship(
         for k, v in obj._prefetched_objects_cache.items():  # type: ignore
             field_name = k if hasattr(obj, k) else k + "_set"
             if v:
-                # TODO: configurable recursive for m2m output
-                out[field_name] = serialize_queryset(v, referrers + (obj,))
+                if hasattr(obj, "Meta") and getattr(obj.Meta, "model_join", True):
+                    out[field_name] = serialize_queryset(v, referrers + (obj,))
+                else:
+                    out[field_name] = [o.pk for o in v]
             else:
                 out[field_name] = []
     except Exception as exc:  # pragma: no cover
@@ -101,15 +103,21 @@ def serialize_many_relationship(
 
 def serialize_value_field(obj: models.Model, field: Any) -> Dict[Any, Any]:
     """Serializes regular 'jsonable' field (Char, Int, etc.) of Django model instance"""
-    # TODO: configurable sensitive fields
-    if field.name in ["password"]:
+    sensitive_list: List = [
+        "password",
+    ]
+    if hasattr(obj, "Meta"):
+        sensitive_fields = getattr(obj.Meta, "sensitive_fields", None)
+        if sensitive_fields:
+            sensitive_list.extend(sensitive_fields)
+        sensitive_list = list(set(sensitive_list))
+    if field.name in sensitive_list:
         return {}
     return {field.name: getattr(obj, field.name)}
 
 
 def serialize_django_native_data(data: Any) -> Any:
     out = data
-    # TODO: need to protect sensitive fields
     # Queryset
     if is_queryset(data):
         out = serialize_queryset(data)

easy/services/crud.py

@@ -29,8 +29,8 @@ async def del_obj(self, id: int) -> Any:
     async def add_obj(self, **payload: Any) -> Any:
         return await sync_to_async(self._crud_add_obj)(**payload)
 
-    async def filter_objs(self, **payload: Any) -> Any:
-        return await sync_to_async(self._crud_filter)(**payload)
+    # async def filter_objs(self, **payload: Any) -> Any:
+    #     return await sync_to_async(self._crud_filter)(**payload)
 
     async def filter_exclude_objs(self, **payload: Any) -> Any:
         return await sync_to_async(self._crud_filter_exclude)(**payload)

tests/demo_app/controllers.py

@@ -31,6 +31,39 @@ def __init__(self, service: EventService):
     class Meta:
         model = Event
         model_fields = "__all__"
+        model_join = True
+
+
+@api_controller("unittest", permissions=[BaseApiPermission])
+class RecursiveAPIController(AutoGenCrudAPIController):
+    """
+    For unit testings of no recursive configuration
+    """
+
+    class Meta:
+        model = Event
+        model_fields = "__all__"
+        model_join = True
+        model_recursive = True
+
+
+@api_controller("unittest", permissions=[BaseApiPermission])
+class AutoGenCrudNoJoinAPIController(CrudAPIController):
+    """
+    For unit testings of the following auto generated APIs:
+        get/create/patch/delete/filter/filter_exclude
+    """
+
+    def __init__(self, service: EventService):
+        super().__init__(service)
+        self.service = service
+
+    class Meta:
+        model = Event
+        model_fields = "__all__"
+        model_join = False
+        model_recursive = True
+        sensitive_fields = ["password", "sensitive_info"]
 
 
 @api_controller("unittest", permissions=[BaseApiPermission])

tests/demo_app/models.py

@@ -9,6 +9,7 @@ class Meta:
 
 class Category(TestBaseModel):
     title = models.CharField(max_length=100)
+    status = models.PositiveSmallIntegerField(default=1, null=True)
 
 
 class Client(TestBaseModel):
@@ -20,6 +21,7 @@ class Client(TestBaseModel):
 
 class Type(TestBaseModel):
     name = models.CharField(max_length=50, null=True)
+    status = models.PositiveSmallIntegerField(default=1, null=True)
 
 
 class Event(TestBaseModel):
@@ -41,5 +43,7 @@ class Event(TestBaseModel):
 
     type = models.ForeignKey(Type, on_delete=models.CASCADE, null=True)
 
+    sensitive_info = models.CharField(max_length=100, null=True)
+
     def __str__(self):
         return self.title