feat: Added middleware support to EllarMount and ApplicationContext available on App boostrapping

Author: eadwinCode

Makefile

@@ -23,6 +23,9 @@ lint:fmt ## Run code linters
 	ruff check ellar tests samples
 	mypy ellar
 
+ruff-fix: ## Run Ruff fixer
+	ruff check ellar tests samples --fix --unsafe-fixes
+
 fmt format:clean ## Run code formatters
 	ruff format ellar tests samples
 	ruff check --fix ellar tests samples

ellar/app/factory.py

@@ -10,9 +10,11 @@
 from ellar.core.modules import ModuleRefBase
 from ellar.di import EllarInjector, ProviderConfig
 from ellar.reflect import reflect
-from ellar.utils import get_unique_type
+from ellar.threading.sync_worker import execute_async_context_manager
+from ellar.utils import get_name, get_unique_type
 from starlette.routing import BaseRoute, Host, Mount
 
+from .context import ApplicationContext
 from .main import App
 from .services import EllarAppService
 
@@ -118,6 +120,7 @@ def _build_modules(
         return routes
 
     @classmethod
+    @t.no_type_check
     def _create_app(
         cls,
         module: t.Type[t.Union[ModuleBase, t.Any]],
@@ -147,39 +150,48 @@ def _get_config_kwargs() -> t.Dict:
         service = EllarAppService(injector, config)
         service.register_core_services()
 
-        routes = cls._build_modules(app_module=module, injector=injector, config=config)
-
-        app = App(
-            routes=routes,
-            config=config,
-            injector=injector,
-            lifespan=config.DEFAULT_LIFESPAN_HANDLER,
-            global_guards=global_guards,
-        )
-
-        for module_config in reversed(list(injector.get_app_dependent_modules())):
-            if injector.get_module(module_config.module):  # pragma: no cover
-                continue
+        with execute_async_context_manager(ApplicationContext(injector)) as context:
+            routes = cls._build_modules(
+                app_module=module, injector=injector, config=config
+            )
 
-            module_ref = module_config.configure_with_factory(
-                config, injector.container
+            app = App(
+                routes=routes,
+                config=config,
+                injector=injector,
+                lifespan=config.DEFAULT_LIFESPAN_HANDLER,
+                global_guards=global_guards,
             )
+            # tag application instance by ApplicationModule name
+            context.injector.container.register_instance(app, App, tag=get_name(module))
+
+            for module_config in reversed(
+                list(context.injector.get_app_dependent_modules())
+            ):
+                if context.injector.get_module(
+                    module_config.module
+                ):  # pragma: no cover
+                    continue
+
+                module_ref = module_config.configure_with_factory(
+                    config, context.injector.container
+                )
 
-            assert isinstance(
-                module_ref, ModuleRefBase
-            ), f"{module_config.module} is not properly configured."
+                assert isinstance(
+                    module_ref, ModuleRefBase
+                ), f"{module_config.module} is not properly configured."
 
-            injector.add_module(module_ref)
-            app.router.extend(module_ref.routes)
+                context.injector.add_module(module_ref)
+                app.router.extend(module_ref.routes)
 
-        # app.setup_jinja_environment
-        app.setup_jinja_environment()
+            # app.setup_jinja_environment
+            app.setup_jinja_environment()
 
-        for module, module_ref in app.injector.get_modules().items():
-            module_ref.run_module_register_services()
+            for module, module_ref in context.injector.get_modules().items():
+                module_ref.run_module_register_services()
 
-            if issubclass(module, IApplicationReady):
-                app.injector.get(module).on_ready(app)
+                if issubclass(module, IApplicationReady):
+                    context.injector.get(module).on_ready(app)
 
         return app
 
@@ -211,11 +223,12 @@ def create_app(
         )
         app_factory_module = get_unique_type()
         module(app_factory_module)
-        return cls._create_app(
+        app = cls._create_app(
             module=app_factory_module,
             config_module=config_module,
             global_guards=global_guards,
         )
+        return t.cast(App, app)
 
     @classmethod
     def create_from_app_module(
@@ -226,6 +239,8 @@ def create_from_app_module(
         ] = None,
         config_module: t.Union[str, t.Dict, None] = None,
     ) -> App:
-        return cls._create_app(
+        app = cls._create_app(
             module, config_module=config_module, global_guards=global_guards
         )
+
+        return t.cast(App, app)

ellar/app/main.py

@@ -201,8 +201,8 @@ def build_middleware_stack(self) -> ASGIApp:
         )
 
         app = self.router
-        for item in reversed(middleware):
-            app = item(app=app, injector=self.injector)
+        for cls, args, kwargs in reversed(middleware):
+            app = cls(app, *args, **kwargs, ellar_injector=self.injector)
         return app
 
     def application_context(self) -> ApplicationContext:

ellar/core/middleware/middleware.py

@@ -16,11 +16,21 @@ def __init__(self, cls: t.Type[T], **options: t.Any) -> None:
         injectable()(self.cls)
         self.kwargs = build_init_kwargs(self.cls, self.kwargs)
 
+    def __iter__(self) -> t.Iterator[t.Any]:
+        as_tuple = (self, self.args, self.kwargs)
+        return iter(as_tuple)
+
     @t.no_type_check
-    def __call__(self, app: ASGIApp, injector: EllarInjector) -> T:
-        self.kwargs.update(app=app)
+    def __call__(self, app: ASGIApp, *args: t.Any, **kwargs: t.Any) -> T:
+        from ellar.app.context import current_injector
+
+        kwargs.update(app=app)
+        if "ellar_injector" in kwargs:
+            injector: EllarInjector = kwargs.pop("ellar_injector")
+        else:
+            injector = current_injector
         try:
-            return injector.create_object(self.cls, additional_kwargs=self.kwargs)
+            return injector.create_object(self.cls, additional_kwargs=kwargs)
         except TypeError:  # pragma: no cover
             # TODO: Fix future typing for lower python version.
-            return self.cls(**self.kwargs)
+            return self.cls(*args, **kwargs)

ellar/core/routing/mount.py

@@ -32,11 +32,18 @@ def __init__(
         middleware: t.Optional[t.Sequence[Middleware]] = None,
     ) -> None:
         super(EllarMount, self).__init__(
-            path=path, name=name, app=app, routes=[], middleware=middleware
+            path=path, name=name, app=app, routes=[], middleware=[]
         )
         self.include_in_schema = include_in_schema
         self._current_found_route_key = f"{uuid.uuid4().hex:4}_EllarMountRoute"
         self._control_type = control_type
+        self._middleware_stack = self.build_middleware_stack(middleware or [])
+
+    def build_middleware_stack(self, middleware: t.Sequence[Middleware]) -> ASGIApp:
+        app = self._app_handler
+        for cls, args, kwargs in reversed(middleware):
+            app = cls(app, *args, **kwargs)
+        return app
 
     def get_control_type(self) -> t.Optional[t.Type[t.Any]]:
         return self._control_type
@@ -75,7 +82,7 @@ def matches(self, scope: TScope) -> t.Tuple[Match, TScope]:
 
         return Match.NONE, {}
 
-    async def handle(self, scope: TScope, receive: TReceive, send: TSend) -> None:
+    async def _app_handler(self, scope: TScope, receive: TReceive, send: TSend) -> None:
         request_logger.debug(
             f"Executing Matched URL Handler, path={scope['path']} - '{self.__class__.__name__}'"
         )
@@ -87,6 +94,9 @@ async def handle(self, scope: TScope, receive: TReceive, send: TSend) -> None:
             mount_router = t.cast(Router, self.app)
             await mount_router.default(scope, receive, send)
 
+    async def handle(self, scope: TScope, receive: TReceive, send: TSend) -> None:
+        await self._middleware_stack(scope, receive, send)
+
 
 def router_default_decorator(func: ASGIApp) -> ASGIApp:
     @functools.wraps(func)

tests/test_controller/test_module_router.py

@@ -1,12 +1,21 @@
 import pytest
-from ellar.common import ModuleRouter
+from ellar.common import IHostContext, ModuleRouter
+from ellar.core import Request
+from ellar.core.middleware import FunctionBasedMiddleware, Middleware
 from ellar.core.router_builders import ModuleRouterBuilder
+from ellar.testing import Test
 
 from .sample import router
 
 another_router = ModuleRouter("/prefix/another", name="arouter")
 
 
+async def callable_middleware(ctx: IHostContext, call_next):
+    scope, _, _ = ctx.get_args()
+    scope["callable_middleware"] = "Functional Middleware executed successfully"
+    await call_next()
+
+
 @another_router.get("/sample")
 def some_example():
     return {"message": "okay"}
@@ -68,3 +77,20 @@ def some_route():
     reversed_path = mount.url_path_for(f"{mount.name}:{mount.routes[0].name}")
     path = mount.path_format.replace("/{path}", mount.routes[0].path)
     assert reversed_path == path
+
+
+def test_module_router_callable_middleware():
+    router_ = ModuleRouter(
+        "",
+        middleware=[Middleware(FunctionBasedMiddleware, dispatch=callable_middleware)],
+    )
+
+    @router_.get
+    async def some_route(req: Request):
+        return {"message": req.scope["callable_middleware"]}
+
+    tm = Test.create_test_module(routers=[router_])
+    res = tm.get_test_client().get("")
+
+    assert res.status_code == 200
+    assert res.json() == {"message": "Functional Middleware executed successfully"}