refactored operation creation and building

Author: eadwinCode

ellar/common/constants.py

@@ -54,6 +54,7 @@
 ROUTE_OPENAPI_PARAMETERS = "ROUTE_OPENAPI_PARAMETERS"
 
 OPERATION_ENDPOINT_KEY = "OPERATION_ENDPOINT"
+ROUTE_OPERATION_PARAMETERS = "__ROUTE_OPERATION_PARAMETERS__"
 ROUTE_INTERCEPTORS = "ROUTE_INTERCEPTORS"
 CONTROLLER_OPERATION_HANDLER_KEY = "CONTROLLER_OPERATION_HANDLER"
 CONTROLLER_CLASS_KEY = "CONTROLLER_CLASS_KEY"

ellar/common/decorators/controller.py

@@ -1,7 +1,6 @@
 import inspect
 import typing as t
 from abc import ABC
-from types import FunctionType
 
 from ellar.common.compatible import AttributeDict
 from ellar.common.constants import (
@@ -11,21 +10,26 @@
     CONTROLLER_WATERMARK,
     NOT_SET,
     OPERATION_ENDPOINT_KEY,
+    ROUTE_OPERATION_PARAMETERS,
 )
 from ellar.common.exceptions import ImproperConfiguration
+from ellar.common.logger import logger
 from ellar.common.models import ControllerBase, ControllerType
-from ellar.common.routing.controller import ControllerRouteOperationBase
 from ellar.di import RequestScope, injectable
 from ellar.reflect import REFLECT_TYPE, reflect
 
+from ..routing.controller import (
+    ControllerRouteOperation,
+    ControllerWebsocketRouteOperation,
+)
+from ..routing.schema import RouteParameters, WsRouteParameters
+
 
 def get_route_functions(
     cls: t.Type,
-) -> t.Iterable[t.Union[t.Callable, ControllerRouteOperationBase]]:
+) -> t.Iterable[t.Callable]:
     for method in cls.__dict__.values():
-        if hasattr(method, OPERATION_ENDPOINT_KEY) or isinstance(
-            method, ControllerRouteOperationBase
-        ):
+        if hasattr(method, OPERATION_ENDPOINT_KEY):
             yield method
 
 
@@ -35,20 +39,30 @@ def reflect_all_controller_type_routes(cls: t.Type[ControllerBase]) -> None:
     for base_cls in reversed(bases):
         if base_cls not in [ABC, ControllerBase, object]:
             for item in get_route_functions(base_cls):
-                operation = item
-                if callable(item) and type(item) == FunctionType:
-                    operation = reflect.get_metadata(  # type: ignore
-                        CONTROLLER_OPERATION_HANDLER_KEY, item
-                    )
-                endpoint_func = operation.endpoint  # type:ignore
-                if reflect.has_metadata(CONTROLLER_CLASS_KEY, endpoint_func):
+                if reflect.has_metadata(CONTROLLER_CLASS_KEY, item):
                     raise Exception(
                         f"{cls.__name__} Controller route tried to be processed more than once."
-                        f"\n-RouteFunction - {endpoint_func}."
+                        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, cls, item)
+
+                parameter = item.__dict__[ROUTE_OPERATION_PARAMETERS]
+                operation: t.Union[
+                    ControllerRouteOperation, ControllerWebsocketRouteOperation
+                ]
+                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
+
+                del item.__dict__[ROUTE_OPERATION_PARAMETERS]
 
-                reflect.define_metadata(CONTROLLER_CLASS_KEY, cls, endpoint_func)
                 reflect.define_metadata(
                     CONTROLLER_OPERATION_HANDLER_KEY,
                     [operation],

ellar/common/routing/mount.py

@@ -9,15 +9,14 @@
     CONTROLLER_CLASS_KEY,
     GUARDS_KEY,
     NOT_SET,
-    OPERATION_ENDPOINT_KEY,
     VERSIONING_KEY,
 )
 from ellar.common.helper import get_unique_control_type
 from ellar.common.models import GuardCanActivate
 from ellar.common.types import TReceive, TScope, TSend
 from ellar.reflect import reflect
 
-from .operation_definitions import OperationDefinitions, TOperation, TWebsocketOperation
+from .operation_definitions import OperationDefinitions
 from .route import RouteOperation
 from .route_collections import RouteCollection
 from .schema import RouteParameters, WsRouteParameters
@@ -146,33 +145,32 @@ def __init__(
         reflect.define_metadata(
             VERSIONING_KEY, set(version or []), self.get_control_type()
         )
+        self._pre_build_routes: t.List[t.Union[RouteParameters, WsRouteParameters]] = []
 
-    def _get_operation(self, route_parameter: RouteParameters) -> TOperation:
-        _operation_class = self._get_http_operations_class(route_parameter.endpoint)
-        _operation = _operation_class(**route_parameter.dict())
-        setattr(route_parameter.endpoint, OPERATION_ENDPOINT_KEY, True)
-        self._set_other_router_attributes(_operation)
-        return _operation
-
-    def _get_ws_operation(
-        self, ws_route_parameters: WsRouteParameters
-    ) -> TWebsocketOperation:
-        _ws_operation_class = self._get_ws_operations_class(
-            ws_route_parameters.endpoint
-        )
-        _operation = _ws_operation_class(**ws_route_parameters.dict())
-        setattr(ws_route_parameters.endpoint, OPERATION_ENDPOINT_KEY, True)
-        self._set_other_router_attributes(_operation)
-        return _operation
-
-    def _set_other_router_attributes(
-        self, operation: t.Union[TWebsocketOperation, TOperation]
-    ) -> None:
-        if not reflect.has_metadata(CONTROLLER_CLASS_KEY, operation.endpoint):
+    def get_pre_build_routes(
+        self,
+    ) -> t.List[t.Union[RouteParameters, WsRouteParameters]]:
+        return self._pre_build_routes
+
+    def clear_pre_build_routes(self) -> None:
+        self._pre_build_routes.clear()
+
+    def _get_operation(self, route_parameter: RouteParameters) -> t.Callable:
+        endpoint = super()._get_operation(route_parameter)
+        self._pre_build_routes.append(route_parameter)
+        self._set_other_router_attributes(endpoint)
+        return endpoint
+
+    def _get_ws_operation(self, ws_route_parameters: WsRouteParameters) -> t.Callable:
+        endpoint = super()._get_ws_operation(ws_route_parameters)
+        self._pre_build_routes.append(ws_route_parameters)
+        self._set_other_router_attributes(endpoint)
+        return endpoint
+
+    def _set_other_router_attributes(self, operation_handler: t.Callable) -> None:
+        if not reflect.has_metadata(CONTROLLER_CLASS_KEY, operation_handler):
             # this is need to happen before adding operation to router else we lose ability to
             # get extra information about operation that is set on the router.
             reflect.define_metadata(
-                CONTROLLER_CLASS_KEY, self.get_control_type(), operation.endpoint
+                CONTROLLER_CLASS_KEY, self.get_control_type(), operation_handler
             )
-
-        self.app.routes.append(operation)  # type:ignore

ellar/common/routing/operation_definitions.py

@@ -4,7 +4,6 @@
 from types import FunctionType
 
 from ellar.common.constants import (
-    CONTROLLER_OPERATION_HANDLER_KEY,
     DELETE,
     GET,
     HEAD,
@@ -13,22 +12,11 @@
     PATCH,
     POST,
     PUT,
+    ROUTE_OPERATION_PARAMETERS,
     TRACE,
 )
-from ellar.common.helper import class_base_function_regex
-from ellar.common.types import TCallable
-from ellar.reflect import reflect
 
-from .controller.route import ControllerRouteOperation
-from .controller.websocket.route import ControllerWebsocketRouteOperation
-from .route import RouteOperation
 from .schema import RouteParameters, WsRouteParameters
-from .websocket import WebsocketRouteOperation
-
-TOperation = t.Union[RouteOperation, ControllerRouteOperation]
-TWebsocketOperation = t.Union[
-    WebsocketRouteOperation, ControllerWebsocketRouteOperation
-]
 
 
 def _websocket_connection_attributes(func: t.Callable) -> t.Callable:
@@ -43,11 +31,11 @@ def _wrap(connect_handler: t.Callable) -> t.Callable:
                     "Invalid type. Please make sure you passed the websocket handler."
                 )
 
-            _item: t.Optional[WebsocketRouteOperation] = reflect.get_metadata(
-                CONTROLLER_OPERATION_HANDLER_KEY, websocket_handler
+            _item: t.Optional[WsRouteParameters] = getattr(
+                websocket_handler, ROUTE_OPERATION_PARAMETERS, None
             )
 
-            if not _item or not isinstance(_item, WebsocketRouteOperation):
+            if not _item or not isinstance(_item, WsRouteParameters):
                 raise Exception(
                     "Invalid type. Please make sure you passed the websocket handler."
                 )
@@ -74,41 +62,43 @@ def _wrap(connect_handler: t.Callable) -> t.Callable:
 class OperationDefinitions:
     __slots__ = ()
 
-    def _get_http_operations_class(self, func: t.Callable) -> t.Type[TOperation]:
-        if class_base_function_regex.match(repr(func)):
-            return ControllerRouteOperation
-        return RouteOperation
-
-    def _get_ws_operations_class(self, func: t.Callable) -> t.Type[TWebsocketOperation]:
-        if class_base_function_regex.match(repr(func)):
-            return ControllerWebsocketRouteOperation
-        return WebsocketRouteOperation
-
-    def _get_operation(self, route_parameter: RouteParameters) -> TOperation:
-        _operation_class = self._get_http_operations_class(route_parameter.endpoint)
-        _operation = _operation_class(**route_parameter.dict())
+    # def _get_http_operations_class(self, func: t.Callable) -> t.Type[TOperation]:
+    #     if class_base_function_regex.match(repr(func)):
+    #         return ControllerRouteOperation
+    #     return RouteOperation
+    #
+    # def _get_ws_operations_class(self, func: t.Callable) -> t.Type[TWebsocketOperation]:
+    #     if class_base_function_regex.match(repr(func)):
+    #         return ControllerWebsocketRouteOperation
+    #     return WebsocketRouteOperation
+
+    def _get_operation(self, route_parameter: RouteParameters) -> t.Callable:
         setattr(route_parameter.endpoint, OPERATION_ENDPOINT_KEY, True)
-        return _operation
-
-    def _get_ws_operation(
-        self, ws_route_parameters: WsRouteParameters
-    ) -> TWebsocketOperation:
-        _ws_operation_class = self._get_ws_operations_class(
-            ws_route_parameters.endpoint
-        )
-        _operation = _ws_operation_class(**ws_route_parameters.dict())
+        setattr(route_parameter.endpoint, ROUTE_OPERATION_PARAMETERS, route_parameter)
+        return route_parameter.endpoint
+
+    def _get_ws_operation(self, ws_route_parameters: WsRouteParameters) -> t.Callable:
+        # _ws_operation_class = self._get_ws_operations_class(
+        #     ws_route_parameters.endpoint
+        # )
+        # _operation = _ws_operation_class(**ws_route_parameters.dict())
         setattr(ws_route_parameters.endpoint, OPERATION_ENDPOINT_KEY, True)
-        return _operation
+        setattr(
+            ws_route_parameters.endpoint,
+            ROUTE_OPERATION_PARAMETERS,
+            ws_route_parameters,
+        )
+        return ws_route_parameters.endpoint
 
     def _get_decorator_or_operation(
         self, path: t.Union[str, t.Callable], endpoint_parameter_partial: t.Callable
-    ) -> t.Callable[[TCallable], t.Union[TOperation, TCallable]]:
+    ) -> t.Callable:
         if callable(path):
             route_parameter = endpoint_parameter_partial(endpoint=path, path="/")
             self._get_operation(route_parameter=route_parameter)
             return path
 
-        def _decorator(endpoint_handler: TCallable) -> TCallable:
+        def _decorator(endpoint_handler: t.Callable) -> t.Callable:
             _route_parameter = endpoint_parameter_partial(
                 endpoint=endpoint_handler, path=path
             )
@@ -126,7 +116,7 @@ def get(
         response: t.Union[
             t.Dict[int, t.Type], t.List[t.Tuple[int, t.Type]], t.Type, t.Any
         ] = None,
-    ) -> t.Callable[[TCallable], t.Union[TOperation, TCallable]]:
+    ) -> t.Callable:
         methods = [GET]
         endpoint_parameter_partial = partial(
             RouteParameters,
@@ -146,7 +136,7 @@ def post(
         response: t.Union[
             t.Dict[int, t.Type], t.List[t.Tuple[int, t.Type]], t.Type, t.Any
         ] = None,
-    ) -> t.Callable[[TCallable], t.Union[TOperation, TCallable]]:
+    ) -> t.Callable:
         methods = [POST]
         endpoint_parameter_partial = partial(
             RouteParameters,
@@ -166,7 +156,7 @@ def put(
         response: t.Union[
             t.Dict[int, t.Type], t.List[t.Tuple[int, t.Type]], t.Type, t.Any
         ] = None,
-    ) -> t.Callable[[TCallable], t.Union[TOperation, TCallable]]:
+    ) -> t.Callable:
         methods = [PUT]
         endpoint_parameter_partial = partial(
             RouteParameters,
@@ -186,7 +176,7 @@ def patch(
         response: t.Union[
             t.Dict[int, t.Type], t.List[t.Tuple[int, t.Type]], t.Type, t.Any
         ] = None,
-    ) -> t.Callable[[TCallable], t.Union[TOperation, TCallable]]:
+    ) -> t.Callable:
         methods = [PATCH]
         endpoint_parameter_partial = partial(
             RouteParameters,
@@ -206,7 +196,7 @@ def delete(
         response: t.Union[
             t.Dict[int, t.Type], t.List[t.Tuple[int, t.Type]], t.Type, t.Any
         ] = None,
-    ) -> t.Callable[[TCallable], t.Union[TOperation, TCallable]]:
+    ) -> t.Callable:
         methods = [DELETE]
         endpoint_parameter_partial = partial(
             RouteParameters,
@@ -226,7 +216,7 @@ def head(
         response: t.Union[
             t.Dict[int, t.Type], t.List[t.Tuple[int, t.Type]], t.Type, t.Any
         ] = None,
-    ) -> t.Callable[[TCallable], t.Union[TOperation, TCallable]]:
+    ) -> t.Callable:
         methods = [HEAD]
         endpoint_parameter_partial = partial(
             RouteParameters,
@@ -246,7 +236,7 @@ def options(
         response: t.Union[
             t.Dict[int, t.Type], t.List[t.Tuple[int, t.Type]], t.Type, t.Any
         ] = None,
-    ) -> t.Callable[[TCallable], t.Union[TOperation, TCallable]]:
+    ) -> t.Callable:
         methods = [OPTIONS]
         endpoint_parameter_partial = partial(
             RouteParameters,
@@ -266,7 +256,7 @@ def trace(
         response: t.Union[
             t.Dict[int, t.Type], t.List[t.Tuple[int, t.Type]], t.Type, t.Any
         ] = None,
-    ) -> t.Callable[[TCallable], t.Union[TOperation, TCallable]]:
+    ) -> t.Callable:
         methods = [TRACE]
         endpoint_parameter_partial = partial(
             RouteParameters,
@@ -287,8 +277,8 @@ def http_route(
         response: t.Union[
             t.Dict[int, t.Type], t.List[t.Tuple[int, t.Type]], t.Type, t.Any
         ] = None,
-    ) -> t.Callable[[TCallable], t.Union[TOperation, TCallable]]:
-        def _decorator(endpoint_handler: TCallable) -> TCallable:
+    ) -> t.Callable:
+        def _decorator(endpoint_handler: t.Callable) -> t.Callable:
             endpoint_parameter = RouteParameters(
                 name=name,
                 path=path,
@@ -311,10 +301,10 @@ def ws_route(
         encoding: t.Optional[str] = "json",
         use_extra_handler: bool = False,
         extra_handler_type: t.Optional[t.Type] = None,
-    ) -> t.Callable[[TCallable], t.Union[TCallable, TWebsocketOperation]]:
+    ) -> t.Callable:
         def _decorator(
-            endpoint_handler: TCallable,
-        ) -> t.Union[TCallable, TWebsocketOperation]:
+            endpoint_handler: t.Callable,
+        ) -> t.Callable:
             endpoint_parameter = WsRouteParameters(
                 name=name,
                 path=path,