Merge pull request #6 from eadwinCode/module_overall

Module Decorator overhaul to reflect meta data

Author: eadwinCode

ellar/common/__init__.py

@@ -1,14 +1,13 @@
 from ellar.core.params.params import Param, ParamTypes
 from ellar.core.routing import ModuleRouter
 
-from .decorators.application import on_app_init, on_app_started
 from .decorators.base import set_meta
 from .decorators.controller import Controller
 from .decorators.exception import exception_handler
 from .decorators.guards import guards
 from .decorators.html import Render, template_filter, template_global
 from .decorators.middleware import middleware
-from .decorators.modules import ApplicationModule, Module
+from .decorators.modules import Module
 from .decorators.openapi import openapi
 from .decorators.request import on_shutdown, on_startup
 from .decorators.serializer import serializer_filter
@@ -49,7 +48,6 @@
     "ParamTypes",
     "set_meta",
     "Controller",
-    "ApplicationModule",
     "openapi",
     "version",
     "Delete",
@@ -77,10 +75,8 @@
     "middleware",
     "exception_handler",
     "serializer_filter",
-    "on_app_init",
     "on_shutdown",
     "on_startup",
-    "on_app_started",
     "template_filter",
     "template_global",
 ]

ellar/common/decorators/__init__.py

@@ -1,11 +1,10 @@
-from .application import on_app_init, on_app_started  # noqa
 from .base import set_meta  # noqa
 from .controller import Controller  # noqa
 from .exception import exception_handler  # noqa
 from .guards import guards  # noqa
 from .html import Render, template_filter, template_global  # noqa
 from .middleware import middleware  # noqa
-from .modules import ApplicationModule, Module  # noqa
+from .modules import Module  # noqa
 from .openapi import openapi  # noqa
 from .request import on_shutdown, on_startup  # noqa
 from .serializer import serializer_filter  # noqa

ellar/common/decorators/application.py

@@ -2,38 +2,19 @@
 from functools import partial
 
 from ellar.constants import NOT_SET
-from ellar.core.operation_meta import OperationMeta
+from ellar.reflect import reflect
 
 
-def _operation_wrapper(
-    meta_key: str, meta_value: t.Any, target: t.Union[t.Callable, t.Any]
-) -> t.Union[t.Callable, t.Any]:
-    _meta = getattr(target, "_meta", OperationMeta())
-    _meta_values: t.Any = [meta_value]
-    existing = _meta.get(meta_key)
-    if existing:
-        if isinstance(existing, (list, tuple)):
-            _meta_values.extend(existing)
-            if isinstance(existing, tuple):
-                _meta_values = tuple(_meta_values)
-        elif isinstance(existing, set):
-            _meta_values.extend(existing)
-            _meta_values = set(_meta_values)
-        elif isinstance(existing, dict):
-            _meta_values = dict(meta_value)
-            _meta_values.update(existing)
-    else:
-        _meta_values = meta_value
-    _meta.update({meta_key: _meta_values})
-    setattr(target, "_meta", _meta)
-    return target
-
-
-def set_meta(meta_key: t.Any, meta_value: t.Optional[t.Any] = NOT_SET) -> t.Callable:
+def set_meta(
+    meta_key: t.Any,
+    meta_value: t.Optional[t.Any] = NOT_SET,
+    default_value: t.Any = None,
+) -> t.Callable:
     if meta_value is NOT_SET:
         return partial(set_meta, meta_key)
 
     def _decorator(target: t.Union[t.Callable, t.Any]) -> t.Union[t.Callable, t.Any]:
-        return _operation_wrapper(meta_key, meta_value, target)
+        reflect.define_metadata(meta_key, meta_value, target, default_value)
+        return target
 
     return _decorator

ellar/common/decorators/base.py

@@ -1,15 +1,52 @@
+import inspect
 import typing as t
+from abc import ABC
 
-from ellar.core.routing.controller import ControllerDecorator
+from ellar.compatible import AttributeDict
+from ellar.constants import (
+    CONTROLLER_CLASS_KEY,
+    CONTROLLER_METADATA,
+    CONTROLLER_WATERMARK,
+    NOT_SET,
+    OPERATION_ENDPOINT_KEY,
+    OPERATION_HANDLER_KEY,
+)
+from ellar.core import ControllerBase
+from ellar.core.controller import ControllerType
+from ellar.di import RequestScope, injectable
+from ellar.exceptions import ImproperConfiguration
+from ellar.reflect import reflect
 
-if t.TYPE_CHECKING:
+if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.guard import GuardCanActivate
 
 
+def get_route_functions(cls: t.Type) -> t.Iterable[t.Callable]:
+    for method in cls.__dict__.values():
+        if hasattr(method, OPERATION_ENDPOINT_KEY):
+            yield method
+
+
+def reflect_all_controller_type_routes(cls: t.Type[ControllerBase]) -> None:
+    bases = inspect.getmro(cls)
+
+    for base_cls in reversed(bases):
+        if base_cls not in [ABC, ControllerBase, object]:
+            for item in get_route_functions(base_cls):
+                operation = reflect.get_metadata(OPERATION_HANDLER_KEY, item)
+                reflect.define_metadata(CONTROLLER_CLASS_KEY, cls, item)
+                reflect.define_metadata(
+                    OPERATION_HANDLER_KEY,
+                    operation,
+                    cls,
+                    default_value=[],
+                )
+
+
 @t.overload
 def Controller(
     prefix: t.Optional[str] = None,
-) -> ControllerDecorator:  # pragma: no cover
+) -> t.Union[t.Type[ControllerBase], t.Callable[..., t.Any], t.Any]:  # pragma: no cover
     ...
 
 
@@ -26,7 +63,8 @@ def Controller(
     guards: t.Optional[
         t.List[t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]]
     ] = None,
-) -> ControllerDecorator:  # pragma: no cover
+    include_in_schema: bool = True,
+) -> t.Union[t.Type[ControllerBase], t.Callable[..., t.Any], t.Any]:  # pragma: no cover
     ...
 
 
@@ -42,21 +80,66 @@ def Controller(
     guards: t.Optional[
         t.List[t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]]
     ] = None,
-) -> t.Union[ControllerDecorator, t.Callable]:
-    if isinstance(prefix, type):
-        return ControllerDecorator("")(prefix)
+    include_in_schema: bool = True,
+) -> t.Union[t.Type[ControllerBase], t.Callable[..., t.Any], t.Any]:
+    _prefix: t.Optional[t.Any] = prefix or NOT_SET
+    if prefix and isinstance(prefix, type):
+        _prefix = NOT_SET
+
+    if _prefix is not NOT_SET:
+        assert _prefix == "" or str(_prefix).startswith(
+            "/"
+        ), "Controller Prefix must start with '/'"
 
-    def _decorator(cls: t.Type) -> ControllerDecorator:
-        _controller = ControllerDecorator(
-            prefix=prefix,
+    kwargs = AttributeDict(
+        openapi=AttributeDict(
             tag=tag,
             description=description,
             external_doc_description=external_doc_description,
             external_doc_url=external_doc_url,
-            name=name,
-            version=version,
-            guards=guards,
-        )
-        return _controller(cls)
+        ),
+        path=_prefix,
+        name=name,
+        version=set([version] if isinstance(version, str) else version),
+        guards=guards or [],
+        include_in_schema=include_in_schema,
+    )
+
+    def _decorator(cls: t.Type) -> t.Type[ControllerBase]:
+        if not isinstance(cls, type):
+            raise ImproperConfiguration(f"Controller is a class decorator - {cls}")
+
+        if type(cls) is not ControllerType:
+            # We force the cls to inherit from `ControllerBase` by creating another type.
+            cls = type(cls.__name__, (cls, ControllerBase), {})
+
+        _controller_type = t.cast(t.Type[ControllerBase], cls)
+
+        _tag = _controller_type.controller_class_name()
+
+        if not kwargs.openapi.tag:  # type: ignore
+            kwargs.openapi.tag = _tag  # type: ignore
+
+        if kwargs["path"] is NOT_SET:
+            kwargs["path"] = f"/{_tag}"
+
+        if not kwargs["name"]:
+            kwargs["name"] = (
+                str(_controller_type.controller_class_name())
+                .lower()
+                .replace("controller", "")
+            )
+
+        if not reflect.get_metadata(CONTROLLER_WATERMARK, _controller_type):
+            reflect.define_metadata(CONTROLLER_WATERMARK, True, _controller_type)
+            reflect_all_controller_type_routes(_controller_type)
+            injectable(RequestScope)(cls)
+
+            for key in CONTROLLER_METADATA.keys:
+                reflect.define_metadata(key, kwargs[key], _controller_type)
+
+        return _controller_type
 
+    if callable(prefix):
+        return _decorator(prefix)
     return _decorator

ellar/common/decorators/controller.py

@@ -4,11 +4,11 @@
 
 from .base import set_meta
 
-if t.TYPE_CHECKING:
+if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.guard import GuardCanActivate
 
 
 def guards(
     *_guards: t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]
 ) -> t.Callable:
-    return set_meta(GUARDS_KEY, _guards)
+    return set_meta(GUARDS_KEY, _guards, default_value=[])