refactored route operation

Author: eadwinCode

ellar/common/__init__.py

@@ -37,13 +37,14 @@
     IExceptionMiddlewareService,
     IExecutionContext,
     IExecutionContextFactory,
+    IGuardsConsumer,
     IHostContext,
     IHostContextFactory,
     IHTTPConnectionContextFactory,
     IHTTPHostContext,
+    IInterceptorsConsumer,
     IModuleSetup,
     IModuleTemplateLoader,
-    InterceptorConsumer,
     IResponseModel,
     IWebSocketContextFactory,
     IWebSocketHostContext,
@@ -194,7 +195,8 @@
     "IModuleSetup",
     "IResponseModel",
     "IModuleTemplateLoader",
-    "InterceptorConsumer",
+    "IInterceptorsConsumer",
+    "IGuardsConsumer",
     "EllarInterceptor",
     "interceptors",
 ]

ellar/common/interfaces/__init__.py

@@ -9,7 +9,8 @@
     IWebSocketHostContext,
 )
 from .exceptions import IExceptionHandler, IExceptionMiddlewareService
-from .interceptor_consumer import InterceptorConsumer
+from .guard_consumer import IGuardsConsumer
+from .interceptor_consumer import IInterceptorsConsumer
 from .module import IModuleSetup
 from .response_model import IResponseModel
 from .templating import IModuleTemplateLoader
@@ -28,5 +29,6 @@
     "IModuleSetup",
     "IResponseModel",
     "IModuleTemplateLoader",
-    "InterceptorConsumer",
+    "IInterceptorsConsumer",
+    "IGuardsConsumer",
 ]

ellar/common/interfaces/guard_consumer.py

@@ -0,0 +1,15 @@
+import typing as t
+from abc import ABC, abstractmethod
+
+from .context import IExecutionContext
+
+if t.TYPE_CHECKING:  # pragma: no cover
+    from ellar.common.routing import RouteOperationBase
+
+
+class IGuardsConsumer(ABC):
+    @abstractmethod
+    async def execute(
+        self, context: IExecutionContext, route_operation: "RouteOperationBase"
+    ) -> t.Any:
+        """implementation goes here"""

ellar/common/interfaces/interceptor_consumer.py

@@ -7,7 +7,7 @@
     from ellar.common.routing import RouteOperationBase
 
 
-class InterceptorConsumer(ABC):
+class IInterceptorsConsumer(ABC):
     @abstractmethod
     async def execute(
         self, context: IExecutionContext, route_operation: "RouteOperationBase"

ellar/common/routing/base.py

@@ -5,21 +5,21 @@
 
 from ellar.common.constants import (
     CONTROLLER_CLASS_KEY,
-    GUARDS_KEY,
     SCOPE_API_VERSIONING_RESOLVER,
     SCOPE_SERVICE_PROVIDER,
     VERSIONING_KEY,
 )
 from ellar.common.interfaces import (
     IExecutionContext,
     IExecutionContextFactory,
-    InterceptorConsumer,
+    IGuardsConsumer,
+    IInterceptorsConsumer,
 )
-from ellar.common.models import GuardCanActivate
 from ellar.common.types import TReceive, TScope, TSend
 from ellar.reflect import reflect
 
 if t.TYPE_CHECKING:  # pragma: no cover
+    from ellar.common import ControllerBase
     from ellar.core.versioning.resolver import BaseAPIVersioningResolver
     from ellar.di import EllarInjector
 
@@ -30,10 +30,17 @@
 
 
 class RouteOperationBase:
-    path: str
-    endpoint: t.Callable
     methods: t.Set[str]
 
+    def __init__(self, endpoint: t.Callable) -> None:
+        self.endpoint = endpoint
+        _controller_type: t.Type = reflect.get_metadata(  # type: ignore[assignment]
+            CONTROLLER_CLASS_KEY, self.endpoint
+        )
+        self._controller_type: t.Union[t.Type, t.Type["ControllerBase"]] = t.cast(
+            t.Union[t.Type, t.Type["ControllerBase"]], _controller_type
+        )
+
     @t.no_type_check
     def __call__(
         self, context: IExecutionContext, *args: t.Any, **kwargs: t.Any
@@ -44,55 +51,32 @@ def __call__(
     def _load_model(self) -> None:
         """compute route models"""
 
-    @t.no_type_check
-    async def run_route_guards(self, context: IExecutionContext) -> None:
-        app = context.get_app()
-        reflector = app.reflector
-
-        targets = [self.endpoint, self.get_control_type()]
-
-        _guards: t.Optional[
-            t.List[t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]]
-        ] = reflector.get_all_and_override(GUARDS_KEY, *targets)
-
-        if not _guards:
-            _guards = app.get_guards()
-
-        if _guards:
-            for guard in _guards:
-                if isinstance(guard, type):
-                    guard = context.get_service_provider().get(guard)
-
-                result = await guard.can_activate(context)
-                if not result:
-                    guard.raise_exception()
-
     async def app(self, scope: TScope, receive: TReceive, send: TSend) -> None:
         service_provider: "EllarInjector" = scope[SCOPE_SERVICE_PROVIDER]
 
         execution_context_factory = service_provider.get(IExecutionContextFactory)
         context = execution_context_factory.create_context(
             operation=self, scope=scope, receive=receive, send=send
         )
-        interceptor_consumer = service_provider.get(InterceptorConsumer)
+        interceptor_consumer = service_provider.get(IInterceptorsConsumer)
+        guard_consumer = service_provider.get(IGuardsConsumer)
 
-        await self.run_route_guards(context=context)
-        # await self._handle_request(context=context)
+        await guard_consumer.execute(context, self)
         await interceptor_consumer.execute(context, self)
 
-    def get_control_type(self) -> t.Type:
+    def get_controller_type(self) -> t.Type:
         """
         For operation under a controller, `get_control_type` and `get_class` will return the same result
         For operation under ModuleRouter, this will return a unique type created for the router for tracking some properties
         :return: a type that wraps the operation
         """
-        if not hasattr(self, "_control_type"):
+        if not self._controller_type:
             _control_type = reflect.get_metadata(CONTROLLER_CLASS_KEY, self.endpoint)
             if _control_type is None:
                 raise Exception("Operation must have a single control type.")
-            self._control_type = t.cast(t.Type, _control_type)
+            self._controller_type = t.cast(t.Type, _control_type)
 
-        return self._control_type
+        return self._controller_type
 
     @abstractmethod
     async def handle_request(self, *, context: IExecutionContext) -> t.Any:
@@ -108,9 +92,10 @@ def get_allowed_version(self) -> t.Set[t.Union[int, float, str]]:
         versions = reflect.get_metadata(VERSIONING_KEY, self.endpoint) or set()
         if not versions:
             versions = (
-                reflect.get_metadata(VERSIONING_KEY, self.get_control_type()) or set()
+                reflect.get_metadata(VERSIONING_KEY, self.get_controller_type())
+                or set()
             )
-        return t.cast(t.Set[t.Union[int, float, str]], versions)
+        return versions
 
     @classmethod
     def get_methods(cls, methods: t.Optional[t.List[str]] = None) -> t.Set[str]:

ellar/common/routing/controller/base.py

@@ -6,10 +6,10 @@
 
 class ControllerRouteOperationBase:
     endpoint: t.Callable
-    get_control_type: t.Callable
+    get_controller_type: t.Callable
 
     def _get_controller_instance(self, ctx: IExecutionContext) -> ControllerBase:
-        controller_type: t.Optional[t.Type[ControllerBase]] = self.get_control_type()
+        controller_type: t.Optional[t.Type[ControllerBase]] = self.get_controller_type()
 
         service_provider = ctx.get_service_provider()
 

ellar/common/routing/route.py

@@ -45,6 +45,7 @@ def __init__(
         name: t.Optional[str] = None,
         include_in_schema: bool = True,
     ) -> None:
+        super().__init__(endpoint=endpoint)
         self._is_coroutine = inspect.iscoroutinefunction(endpoint)
         self._defined_responses: t.Dict[int, t.Type] = dict(response)
 
@@ -53,7 +54,6 @@ def __init__(
         self.path_regex, self.path_format, self.param_convertors = compile_path(
             self.path
         )
-        self.endpoint = endpoint  # type: ignore
 
         self.name = get_name(endpoint) if name is None else name
         self.include_in_schema = include_in_schema

ellar/common/routing/route_collections.py

@@ -4,17 +4,8 @@
 
 from starlette.routing import BaseRoute, Host, Mount
 
-from ellar.common.constants import CONTROLLER_CLASS_KEY
-from ellar.common.helper import (
-    generate_controller_operation_unique_id,
-    get_unique_control_type,
-)
+from ellar.common.helper import generate_controller_operation_unique_id
 from ellar.common.logger import logger
-from ellar.reflect import reflect
-
-from .base import RouteOperationBase
-from .route import RouteOperation
-from .websocket.route import WebsocketRouteOperation
 
 
 class RouteCollection(t.Sequence[BaseRoute]):
@@ -59,21 +50,12 @@ def sort_routes(self) -> None:
             key=lambda e: e.host if isinstance(e, Host) else e.path  # type: ignore
         )
 
-    def _add_operation(
-        self, operation: t.Union[RouteOperation, WebsocketRouteOperation, BaseRoute]
-    ) -> None:
+    def _add_operation(self, operation: t.Union[BaseRoute]) -> None:
 
         if not isinstance(operation, BaseRoute):
             logger.warning("Tried Adding an operation that is not supported.")
             return
 
-        if isinstance(operation, RouteOperationBase) and not reflect.has_metadata(
-            CONTROLLER_CLASS_KEY, operation.endpoint
-        ):
-            reflect.define_metadata(
-                CONTROLLER_CLASS_KEY, get_unique_control_type(), operation.endpoint
-            )
-
         _methods = getattr(operation, "methods", {"WS"})
         _versioning = list(
             operation.get_allowed_version()  # type: ignore

ellar/common/routing/websocket/route.py

@@ -45,6 +45,7 @@ def __init__(
         extra_handler_type: t.Optional[t.Type[WebSocketExtraHandler]] = None,
         **handlers_kwargs: t.Any,
     ) -> None:
+        super().__init__(endpoint=endpoint)
         assert path.startswith("/"), "Routed paths must start with '/'"
         self._handlers_kwargs: t.Dict[str, t.Any] = dict(
             encoding=encoding,
@@ -62,7 +63,6 @@ def __init__(
         self.path_regex, self.path_format, self.param_convertors = compile_path(
             self.path
         )
-        self.endpoint = endpoint  # type: ignore
         self.name = get_name(endpoint) if name is None else name
 
         self.endpoint_parameter_model: WebsocketEndpointArgsModel = NOT_SET

ellar/core/context/factory.py

@@ -76,7 +76,7 @@ def create_context(
             receive=receive,
             send=send,
             operation_handler=operation.endpoint,
-            operation_handler_type=operation.get_control_type(),
+            operation_handler_type=operation.get_controller_type(),
             reflector=self.reflector,
         )