Added support for injector to be nested, dropped controller class key and added middleware support to controllers

Author: eadwinCode

ellar/app/factory.py

@@ -128,6 +128,7 @@ def _create_app(
             t.List[t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]]
         ] = None,
         config_module: t.Union[str, t.Dict, None] = None,
+        injector: t.Optional[EllarInjector] = None,
     ) -> App:
         def _get_config_kwargs() -> t.Dict:
             if config_module is None:
@@ -144,7 +145,7 @@ def _get_config_kwargs() -> t.Dict:
 
         config = Config(app_configured=True, **_get_config_kwargs())
 
-        injector = EllarInjector(auto_bind=config.INJECTOR_AUTO_BIND)
+        injector = EllarInjector(auto_bind=config.INJECTOR_AUTO_BIND, parent=injector)
         injector.container.register_instance(config, concrete_type=Config)
 
         service = EllarAppService(injector, config)
@@ -210,6 +211,7 @@ def create_app(
         ] = None,
         commands: t.Sequence[t.Union[click.Command, click.Group, t.Any]] = (),
         config_module: t.Union[str, t.Dict, None] = None,
+        injector: t.Optional[EllarInjector] = None,
     ) -> App:
         module = Module(
             controllers=controllers,
@@ -227,6 +229,7 @@ def create_app(
             module=app_factory_module,
             config_module=config_module,
             global_guards=global_guards,
+            injector=injector,
         )
         return t.cast(App, app)
 
@@ -237,10 +240,14 @@ def create_from_app_module(
         global_guards: t.Optional[
             t.List[t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]]
         ] = None,
+        injector: t.Optional[EllarInjector] = None,
         config_module: t.Union[str, t.Dict, None] = None,
     ) -> App:
         app = cls._create_app(
-            module, config_module=config_module, global_guards=global_guards
+            module,
+            config_module=config_module,
+            global_guards=global_guards,
+            injector=injector,
         )
 
         return t.cast(App, app)

ellar/common/constants.py

@@ -72,6 +72,7 @@ class CONTROLLER_METADATA(metaclass=AnnotationToValue):
     NAME: str
     INCLUDE_IN_SCHEMA: str
     PROCESSED: str
+    MIDDLEWARE: str
 
 
 sequence_types = (list, set, tuple)

ellar/common/decorators/controller.py

@@ -10,8 +10,11 @@
 from ellar.common.models import ControllerBase, ControllerType
 from ellar.di import RequestORTransientScope, injectable
 from ellar.reflect import REFLECT_TYPE, reflect
-from ellar.utils import get_type_of_base
 from injector import Scope
+from starlette.middleware import Middleware
+
+if t.TYPE_CHECKING:
+    from ellar.core.middleware.middleware import EllarMiddleware
 
 
 @t.no_type_check
@@ -20,6 +23,7 @@ def Controller(
     *,
     name: t.Optional[str] = None,
     include_in_schema: bool = True,
+    middleware: t.Optional[t.Sequence[t.Union[Middleware, "EllarMiddleware"]]] = None,
     scope: t.Optional[t.Union[t.Type[Scope], Scope]] = RequestORTransientScope,
 ) -> t.Union[t.Type[ControllerBase], t.Callable[..., t.Any], t.Any]:
     """
@@ -30,6 +34,7 @@ def Controller(
     :param name: route name prefix for url reversing, eg name:route_name default=''
     :param include_in_schema: include controller in OPENAPI schema
     :param scope: Controller Instance Lifetime scope
+    :param middleware: Controller Middlewares
     :return: t.Type[ControllerBase]
     """
     _prefix: t.Optional[t.Any] = prefix if prefix is not None else NOT_SET
@@ -42,7 +47,11 @@ def Controller(
         ), "Controller Prefix must start with '/'"
     # TODO: replace with a ControllerTypeDict and OpenAPITypeDict
     kwargs = AttributeDict(
-        path=_prefix, name=name, include_in_schema=include_in_schema, processed=False
+        path=_prefix,
+        name=name,
+        include_in_schema=include_in_schema,
+        processed=False,
+        middleware=middleware,
     )
 
     def _decorator(cls: t.Type) -> t.Type[ControllerBase]:
@@ -73,25 +82,26 @@ def _decorator(cls: t.Type) -> t.Type[ControllerBase]:
                 .replace("controller", "")
             )
 
-        for base in get_type_of_base(ControllerBase, _controller_type):
-            if reflect.has_metadata(CONTROLLER_WATERMARK, base) and hasattr(
-                cls, "__CONTROLLER_WATERMARK__"
-            ):
-                raise ImproperConfiguration(
-                    f"`@Controller` decorated classes does not support inheritance. \n"
-                    f"{_controller_type}"
-                )
-
-        if not reflect.has_metadata(
-            CONTROLLER_WATERMARK, _controller_type
-        ) and not hasattr(cls, "__CONTROLLER_WATERMARK__"):
-            reflect.define_metadata(CONTROLLER_WATERMARK, True, _controller_type)
-            # reflect_all_controller_type_routes(_controller_type)
-
-            injectable(scope or RequestORTransientScope)(cls)
-
-            for key in CONTROLLER_METADATA.keys:
-                reflect.define_metadata(key, kwargs[key], _controller_type)
+        # for base in get_type_of_base(ControllerBase, _controller_type):
+        #     if reflect.has_metadata(CONTROLLER_WATERMARK, base) and hasattr(
+        #         cls, "__CONTROLLER_WATERMARK__"
+        #     ):
+        #         raise ImproperConfiguration(
+        #             f"`@Controller` decorated classes does not support inheritance. \n"
+        #             f"{_controller_type}"
+        #         )
+
+        # if not reflect.has_metadata(
+        #     CONTROLLER_WATERMARK, _controller_type
+        # ) and not hasattr(cls, "__CONTROLLER_WATERMARK__"):
+
+        reflect.define_metadata(CONTROLLER_WATERMARK, True, _controller_type)
+        # reflect_all_controller_type_routes(_controller_type)
+
+        injectable(scope or RequestORTransientScope)(cls)
+
+        for key in CONTROLLER_METADATA.keys:
+            reflect.define_metadata(key, kwargs[key], _controller_type)
 
         if new_cls:
             # if we forced cls to inherit from ControllerBase, we need to block it from been processed

ellar/core/router_builders/controller.py

@@ -1,9 +1,7 @@
 import inspect
 import typing as t
-from abc import ABC
 
 from ellar.common.constants import (
-    CONTROLLER_CLASS_KEY,
     CONTROLLER_METADATA,
     CONTROLLER_OPERATION_HANDLER_KEY,
     CONTROLLER_WATERMARK,
@@ -31,63 +29,51 @@ def _get_route_functions(
         cls,
         klass: t.Type,
     ) -> t.Iterable[t.Callable]:
-        for method in klass.__dict__.values():
+        for _method_name, method in inspect.getmembers(
+            klass, predicate=inspect.isfunction
+        ):
             if hasattr(method, OPERATION_ENDPOINT_KEY):
                 yield method
 
     @classmethod
     def _process_controller_routes(
         cls, controller: t.Type[ControllerBase]
     ) -> t.Sequence[BaseRoute]:
-        bases = inspect.getmro(controller)
         res = []
 
         if reflect.get_metadata(CONTROLLER_METADATA.PROCESSED, controller):
             return (
                 reflect.get_metadata(CONTROLLER_OPERATION_HANDLER_KEY, controller) or []
             )
 
-        for base_cls in reversed(bases):
-            if base_cls not in [ABC, ControllerBase, object]:
-                for item in cls._get_route_functions(base_cls):
-                    if reflect.has_metadata(CONTROLLER_CLASS_KEY, item):
-                        raise Exception(
-                            f"{controller.__name__} Controller route tried to be processed more than once."
-                            f"\n-RouteFunction - {item}."
-                            f"\n-Controller route function can not be reused once its under a `@Controller` decorator."
-                        )
-
-                    reflect.define_metadata(CONTROLLER_CLASS_KEY, controller, item)
-
-                    parameters = item.__dict__[ROUTE_OPERATION_PARAMETERS]
-                    operation: t.Union[
-                        ControllerRouteOperation, ControllerWebsocketRouteOperation
-                    ]
-
-                    if not isinstance(parameters, list):
-                        parameters = [parameters]
-
-                    for parameter in parameters:
-                        if isinstance(parameter, RouteParameters):
-                            operation = ControllerRouteOperation(**parameter.dict())
-                        elif isinstance(parameter, WsRouteParameters):
-                            operation = ControllerWebsocketRouteOperation(
-                                **parameter.dict()
-                            )
-                        else:  # pragma: no cover
-                            logger.warning(
-                                f"Parameter type is not recognized. {type(parameter) if not isinstance(parameter, type) else parameter}"
-                            )
-                            continue
-
-                        reflect.define_metadata(
-                            CONTROLLER_OPERATION_HANDLER_KEY,
-                            [operation],
-                            controller,
-                        )
-                        res.append(operation)
-
-                    del item.__dict__[ROUTE_OPERATION_PARAMETERS]
+        for item in cls._get_route_functions(controller):
+            parameters = item.__dict__[ROUTE_OPERATION_PARAMETERS]
+            operation: t.Union[
+                ControllerRouteOperation, ControllerWebsocketRouteOperation
+            ]
+
+            if not isinstance(parameters, list):
+                parameters = [parameters]
+
+            for parameter in parameters:
+                if isinstance(parameter, RouteParameters):
+                    operation = ControllerRouteOperation(controller, **parameter.dict())
+                elif isinstance(parameter, WsRouteParameters):
+                    operation = ControllerWebsocketRouteOperation(
+                        controller, **parameter.dict()
+                    )
+                else:  # pragma: no cover
+                    logger.warning(
+                        f"Parameter type is not recognized. {type(parameter) if not isinstance(parameter, type) else parameter}"
+                    )
+                    continue
+
+                reflect.define_metadata(
+                    CONTROLLER_OPERATION_HANDLER_KEY,
+                    [operation],
+                    controller,
+                )
+                res.append(operation)
         reflect.define_metadata(CONTROLLER_METADATA.PROCESSED, True, controller)
         return res
 
@@ -103,6 +89,12 @@ def build(
         include_in_schema = reflect.get_metadata_or_raise_exception(
             CONTROLLER_METADATA.INCLUDE_IN_SCHEMA, controller_type
         )
+
+        middleware = reflect.get_metadata(
+            CONTROLLER_METADATA.MIDDLEWARE, controller_type
+        )
+
+        kwargs.setdefault("middleware", middleware)
         router = EllarMount(
             app=app,
             path=reflect.get_metadata_or_raise_exception(

ellar/core/routing/base.py

@@ -31,14 +31,13 @@
 
 class RouteOperationBase:
     methods: t.Set[str]
+    _controller_type: t.Optional[t.Union[t.Type, t.Type["ControllerBase"]]] = None
 
     def __init__(self, endpoint: t.Callable) -> None:
         self.endpoint = endpoint
-
-        self._controller_type = None
         _controller_type: t.Type = self.get_controller_type()
 
-        self._controller_type: t.Union[t.Type, t.Type["ControllerBase"]] = t.cast(  # type:ignore[no-redef]
+        self._controller_type: t.Union[t.Type, t.Type["ControllerBase"]] = t.cast(
             t.Union[t.Type, t.Type["ControllerBase"]], _controller_type
         )
 
@@ -86,7 +85,7 @@ def get_controller_type(self) -> t.Type:
             _controller_type = reflect.get_metadata(CONTROLLER_CLASS_KEY, self.endpoint)
             if _controller_type is None or not isinstance(_controller_type, type):
                 raise Exception("Operation must have a single control type.")
-            self._controller_type = t.cast(t.Type, _controller_type)
+            return t.cast(t.Type, _controller_type)
 
         return self._controller_type
 

ellar/core/routing/controller/base.py

@@ -6,12 +6,20 @@
 
 
 class ControllerRouteOperationBase:
+    _controller_type: t.Optional[t.Type["ControllerBase"]] = None
     endpoint: t.Callable
     get_controller_type: t.Callable
 
+    def __init__(
+        self, controller_type: t.Type[ControllerBase], *args: t.Any, **kwargs: t.Any
+    ) -> None:
+        self._controller_type = controller_type
+
+        super().__init__(*args, **kwargs)
+
     def _get_controller_instance(self, ctx: IExecutionContext) -> ControllerBase:
         request_logger.debug("Getting Controller Instance")
-        controller_type: t.Optional[t.Type[ControllerBase]] = self.get_controller_type()
+        controller_type: t.Type[ControllerBase] = self.get_controller_type()
 
         service_provider = ctx.get_service_provider()
 

ellar/openapi/route_doc_models.py

@@ -3,7 +3,6 @@
 
 from ellar.common.compatible import cached_property
 from ellar.common.constants import (
-    CONTROLLER_CLASS_KEY,
     GUARDS_KEY,
     METHODS_WITH_BODY,
     REF_PREFIX,
@@ -246,7 +245,7 @@ def get_openapi_operation_metadata(self, method: str) -> t.Dict[str, t.Any]:
                 methods=method,
                 controller=None
                 if ignore_controller
-                else reflector.get(CONTROLLER_CLASS_KEY, self.route.endpoint),
+                else self.route.get_controller_type(),
             )
         )
         if self.deprecated:

tests/test_controller/test_controller_decorator.py

@@ -1,7 +1,6 @@
 import pytest
 from ellar.common import Controller, ControllerBase, get, http_route, ws_route
 from ellar.common.constants import (
-    CONTROLLER_CLASS_KEY,
     CONTROLLER_OPERATION_HANDLER_KEY,
 )
 from ellar.core.router_builders import ControllerRouterBuilder
@@ -52,7 +51,7 @@ def test_controller_routes_has_controller_type():
     assert routes
 
     for route in routes:
-        controller_type = reflect.get_metadata(CONTROLLER_CLASS_KEY, route.endpoint)
+        controller_type = route.get_controller_type()
         assert controller_type == SampleController