Moving Fastapi into protocol

[dev0Guy]

Hi,
I've talked on this advantage in previous discussion.
Here is mapping of all usage of FastAPI in the project. When we'll understand all of the instance usage we'll be able to replace those with python Protocol and use other web-framework as server engine.

nest/common/route_resolver.py

   class RoutesResolver:
       def __init__(self, container, app_ref: FastAPI):
          ....
8.        self.app_ref = app_ref

       def register_route(self, controller):
          router: APIRouter = controller.get_router()
17.       self.app_ref.include_router(router)

nest/core/pynest_application.py

   class PyNestApp(PyNestApplicationContext):
      def __init__(self, container: PyNestContainer, http_server: FastAPI):
          ....
31.       self.http_server = http_server

       def use(self, middleware: type, **options: Any) -> "PyNestApp":
          ....
48.       self.http_server.add_middleware(middleware, **options)

       def get_server(self) -> FastAPI:
          ....
58.       return self.http_server

nest/core/pynest_factory.py

   class PyNestFactory(AbstractPyNestFactory):
      def _create_server(**kwargs) -> FastAPI:
          ....
49.       return FastAPI(**kwargs)

nest/core/decorators/class_based_view.py

      def class_based_view(router: APIRouter, cls: Type[T]) -> Type[T]:
          ....
39.       for route in router.routes
40.       if isinstance(route, (Route, WebSocketRoute))
          ....
44.       router.routes.remove(route)
          ....
46.       cbv_router.routes.append(route)
47.       router.include_router(cbv_router)

      def _update_cbv_route_endpoint_signature(
          cls: Type[Any], route: Union[Route, WebSocketRoute] # of starlette.routing
      ) -> None:
          ....
103.      old_endpoint = route.endpoint
          ....
107.      new_first_parameter = old_first_parameter.replace(default=Depends(cls))
          ....
113.      setattr(route.endpoint, "__signature__", new_signature)

nest/core/decorators/controller.py

      def Controller(prefix: Optional[str] = None, tag: Optional[str] = None):
          ....
27.       router = APIRouter(tags=[tag] if tag else None)

      def add_routes(cls: Type, router: APIRouter, route_prefix: str) -> None:
          ....
95.       add_route_to_router(router, method_function)

      def add_route_to_router(router: APIRouter, method_function: callable) -> None:
          route_kwargs = {
                 "path": method_function.__route_path__,
                 "endpoint": method_function,
                 "methods": [method_function.__http_method__.value],
                  **method_function.__kwargs__,
          }

          if hasattr(method_function, "status_code"):
             route_kwargs["status_code"] = method_function.status_code

             router.add_api_route(**route_kwargs)

nest/core/decorators/database.py

      def db_request_handler(func):
          ....
38.       return HTTPException(status_code=500, detail=str(e))

Now we can talk about possible protocol to replace and decouple the application.

[dev0Guy]

Protocol we need:

from typing import Protocol, Self, Callable, Any, Optional, Union, Set, List


# Should look all the usage of def get_server(self) and add them into the protocol for example on_event
class HttpServer(Protocol):
    def __init__(self, **kwargs) -> None: ... # In the future can add common kwargs (extract them outside)
    def add_middleware(self, middleware, **options) -> None: ... # middleware by the http server
    def include_router(self, router: Router, prefix: str,  tags: list, **options) -> None: ...
    def add_api_route(self, router: Router, path: str,  endpoint: Callable[...,  Any], methods: Optional[Union[Set[str], List[str]]] )


class Router(Protocol):
    routes: List['Route'] # Route is dynamic variable in http server ,in fastapi case WebRoute, Route
    endpoint: Callable[...,  Any]
   
    def __init__(self, tags: List[str]) -> None: ....