feat: add configurations - model_join (default to True), sensitive_fields, model_recursive (default to False)

Author: freemindcore

easy/controller/base.py

@@ -9,13 +9,27 @@
 
 class CrudAPIController(ControllerBase, CrudAPI, metaclass=CrudApiMetaclass):
     """
-    Base APIController for auto creating CRUD APIs
+    Base APIController for auto creating CRUD APIs, configurable via Meta class
+    APIs auto genrated:
+        Creat
+            PUT /{id}       - Create a single Object
 
-    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
+        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:
         """
@@ -83,15 +87,18 @@ async def get_objs(
 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")(
@@ -117,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
@@ -137,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.")
@@ -169,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

tests/demo_app/test_async_auto_crud_apis.py

@@ -7,8 +7,10 @@
 
 from tests.demo_app.controllers import (
     AutoGenCrudAPIController,
+    AutoGenCrudNoJoinAPIController,
     AutoGenCrudSomeFieldsAPIController,
     EventSchema,
+    RecursiveAPIController,
 )
 from tests.demo_app.models import Category, Client, Event, Type
 
@@ -56,6 +58,21 @@ async def test_crud_default_get_all(self, transactional_db, easy_api_client):
         event_schema = json.loads(EventSchema.from_orm(event).json())
         assert event_schema["start_date"] == data[0]["start_date"]
 
+        # Recursive = False
+        client = easy_api_client(RecursiveAPIController)
+        response = await client.get(
+            "/", query=dict(maximum=100, filters=json.dumps(dict(id__gte=1)))
+        )
+        assert response.status_code == 200
+
+        data = response.json().get("data")
+        assert data[0]["title"] == "AsyncAdminAPIEvent_get_all"
+        assert data[0]["type"]["id"] == type.id
+        assert data[0]["category"]["status"] == 1
+
+        # Back to AutoGenCrudAPIController
+        client = easy_api_client(AutoGenCrudAPIController)
+
         response = await client.get(
             "/",
             query=dict(
@@ -179,12 +196,17 @@ async def test_crud_default_patch(self, transactional_db, easy_api_client):
             name="Client F for Unit Testings", key="F"
         )
 
+        category = await sync_to_async(Category.objects.create)(
+            title="Category for Unit Testings", status=2
+        )
+
         new_data = dict(
             id=event.pk,
             title=f"{object_data['title']}_patch",
             start_date=str((datetime.now() + timedelta(days=10)).date()),
             end_date=str((datetime.now() + timedelta(days=20)).date()),
             owner=[client_e.pk, client_f.pk],
+            category=category.pk,
         )
 
         response = await client.patch(
@@ -205,10 +227,27 @@ async def test_crud_default_patch(self, transactional_db, easy_api_client):
             f"/{event.pk}",
         )
         assert response.status_code == 200
-        assert response.json().get("data")["title"] == "AsyncAdminAPIEvent_patch"
-        assert response.json().get("data")["start_date"] == str(
-            (datetime.now() + timedelta(days=10)).date()
-        )
-        assert response.json().get("data")["end_date"] == str(
-            (datetime.now() + timedelta(days=20)).date()
+        data = response.json().get("data")
+        print("======> Auto join - data/ data owner /data lead_owner")
+        print(data)
+        assert len(data["owner"]) == 2
+        assert len(data["lead_owner"]) == 0
+        assert data["owner"][0]["name"] == "Client E for Unit Testings"
+        assert data["owner"][1]["name"] == "Client F for Unit Testings"
+
+        assert data["title"] == "AsyncAdminAPIEvent_patch"
+        assert data["start_date"] == str((datetime.now() + timedelta(days=10)).date())
+        assert data["end_date"] == str((datetime.now() + timedelta(days=20)).date())
+
+        client = easy_api_client(AutoGenCrudNoJoinAPIController)
+
+        # No auto join
+        response = await client.get(
+            f"/{event.pk}",
         )
+        assert response.status_code == 200
+        print("======> data/ data owner /data lead_owner")
+        data = response.json().get("data")
+        print(data)
+        print(data["owner"])
+        assert data["owner"] == [8, 9]