Enabled all application middlewares to be configured through application config

Author: eadwinCode

ellar/auth/middleware/auth.py

@@ -2,6 +2,7 @@
 from ellar.common import AnonymousIdentity, IHostContextFactory
 from ellar.common.types import TReceive, TScope, TSend
 from ellar.core.conf import Config
+from ellar.core.middleware import Middleware as EllarMiddleware
 from ellar.di import EllarInjector
 from starlette.routing import compile_path
 from starlette.types import ASGIApp
@@ -45,3 +46,7 @@ def is_static(self, scope: TScope) -> bool:
         Check is the request is for a static file
         """
         return self._path_regex.match(scope["path"]) is not None
+
+
+# IdentityMiddleware Configuration
+identity_middleware = EllarMiddleware(IdentityMiddleware)

ellar/auth/middleware/session.py

@@ -1,5 +1,6 @@
 from ellar.auth.session import SessionServiceNullStrategy, SessionStrategy
 from ellar.core.conf import Config
+from ellar.core.middleware import Middleware as EllarMiddleware
 from starlette.datastructures import MutableHeaders
 from starlette.requests import HTTPConnection
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
@@ -9,7 +10,7 @@ class SessionMiddleware:
     def __init__(
         self, app: ASGIApp, session_strategy: SessionStrategy, config: Config
     ) -> None:
-        config.setdefault("SESSION_DISABLED", False)
+        config.set_defaults(SESSION_DISABLED=False)
         self.app = app
         self._session_strategy = session_strategy
         self._is_active = not isinstance(session_strategy, SessionServiceNullStrategy)
@@ -52,3 +53,7 @@ async def _send_wrapper(message: Message) -> None:
             await send(message)
 
         await self.app(scope, receive, _send_wrapper)
+
+
+# SessionMiddleware Configuration
+session_middleware = EllarMiddleware(SessionMiddleware)

ellar/core/middleware/__init__.py

@@ -1,17 +1,15 @@
-from starlette.middleware.cors import CORSMiddleware as CORSMiddleware
 from starlette.middleware.gzip import GZipMiddleware as GZipMiddleware
 from starlette.middleware.httpsredirect import (
     HTTPSRedirectMiddleware as HTTPSRedirectMiddleware,
 )
-from starlette.middleware.trustedhost import (
-    TrustedHostMiddleware as TrustedHostMiddleware,
-)
 from starlette.middleware.wsgi import WSGIMiddleware as WSGIMiddleware
 
+from .cors import CORSMiddleware
 from .errors import ServerErrorMiddleware
 from .exceptions import ExceptionMiddleware
 from .function import FunctionBasedMiddleware
 from .middleware import EllarMiddleware as Middleware
+from .trusted_host import TrustedHostMiddleware
 from .versioning import RequestVersioningMiddleware
 
 __all__ = [

ellar/core/middleware/cors.py

@@ -0,0 +1,23 @@
+from ellar.common.types import ASGIApp
+from ellar.core.conf import Config
+from starlette.middleware.cors import CORSMiddleware as BaseCORSMiddleware
+
+from .middleware import EllarMiddleware
+
+
+class CORSMiddleware(BaseCORSMiddleware):
+    def __init__(self, app: ASGIApp, config: Config) -> None:
+        super().__init__(
+            app,
+            allow_origins=config.CORS_ALLOW_ORIGINS,
+            allow_credentials=config.CORS_ALLOW_CREDENTIALS,
+            allow_methods=config.CORS_ALLOW_METHODS,
+            allow_headers=config.CORS_ALLOW_HEADERS,
+            allow_origin_regex=config.CORS_ALLOW_ORIGIN_REGEX,
+            expose_headers=config.CORS_EXPOSE_HEADERS,
+            max_age=config.CORS_MAX_AGE,
+        )
+
+
+# CORSMiddleware Configuration
+cors_middleware = EllarMiddleware(CORSMiddleware)

ellar/core/middleware/errors.py

@@ -1,35 +1,33 @@
-import typing as t
-
+from ellar.common import IExceptionMiddlewareService
 from ellar.common.constants import SCOPE_RESPONSE_STARTED
-from ellar.common.interfaces import IExceptionHandler, IHostContextFactory
+from ellar.common.interfaces import IHostContextFactory
 from ellar.common.responses import Response
 from ellar.common.types import ASGIApp, TMessage, TReceive, TScope, TSend
-from ellar.core.connection.http import Request
+from ellar.core import Config
+from ellar.core.connection import Request
 from ellar.di import EllarInjector
 from starlette.middleware.errors import (
     ServerErrorMiddleware as BaseServerErrorMiddleware,
 )
 from starlette.requests import Request as StarletteRequest
 from starlette.responses import JSONResponse
 
+from .middleware import EllarMiddleware
+
 
 class ServerErrorMiddleware(BaseServerErrorMiddleware):
     def __init__(
         self,
         app: ASGIApp,
-        *,
-        debug: bool,
+        config: Config,
+        exception_service: IExceptionMiddlewareService,
         injector: "EllarInjector",
-        handler: t.Optional["IExceptionHandler"] = None,
     ) -> None:
-        _handler = None
-        if handler:
-            self._500_error_handler = handler
-            _handler = self.error_handler
+        self._500_error_handler = exception_service.get_500_error_handler()
 
         super(ServerErrorMiddleware, self).__init__(
-            debug=debug,
-            handler=_handler,  # type:ignore[arg-type]
+            debug=config.DEBUG,
+            handler=self.error_handler if self._500_error_handler else None,
             app=app,
         )
         self.injector = injector
@@ -69,3 +67,7 @@ def error_response(self, request: StarletteRequest, exc: Exception) -> Response:
         return JSONResponse(
             {"detail": "Internal server error", "status_code": 500}, status_code=500
         )
+
+
+# ServerErrorMiddleware Configuration
+server_error_middleware = EllarMiddleware(ServerErrorMiddleware)

ellar/core/middleware/exceptions.py

@@ -1,25 +1,28 @@
 import typing as t
 
+from ellar.common import APIException, IExceptionMiddlewareService
 from ellar.common.interfaces import IHostContextFactory
 from ellar.common.types import ASGIApp, TMessage, TReceive, TScope, TSend
-from ellar.core.context import current_injector
-from ellar.core.exceptions import ExceptionMiddlewareService
+from ellar.core.conf import Config
+from ellar.core.exceptions.service import ExceptionMiddlewareService
+from ellar.core.execution_context import current_injector
 from starlette.exceptions import HTTPException
 
-if t.TYPE_CHECKING:  # pragma: no cover
-    pass
+from .middleware import EllarMiddleware
 
 
 class ExceptionMiddleware:
     def __init__(
         self,
         app: ASGIApp,
-        exception_middleware_service: ExceptionMiddlewareService,
-        debug: bool = False,
+        exception_middleware_service: IExceptionMiddlewareService,
+        config: Config,
     ) -> None:
         self.app = app
-        self.debug = debug
-        self._exception_middleware_service = exception_middleware_service
+        self.debug = config.DEBUG
+        self._exception_middleware_service: ExceptionMiddlewareService = t.cast(
+            ExceptionMiddlewareService, exception_middleware_service
+        )
 
     async def __call__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
         if scope["type"] not in ("http", "websocket"):
@@ -40,7 +43,7 @@ async def sender(message: TMessage) -> None:
         except Exception as exc:
             handler = None
 
-            if isinstance(exc, HTTPException):
+            if isinstance(exc, (HTTPException, APIException)):
                 handler = self._exception_middleware_service.lookup_status_code_exception_handler(
                     exc.status_code
                 )
@@ -69,3 +72,7 @@ async def sender(message: TMessage) -> None:
             elif context.get_type() == "websocket":
                 ws_context = context_factory.create_context(scope, receive, send)
                 await handler.catch(ws_context, exc)
+
+
+# ExceptionMiddleware Configuration
+exception_middleware = EllarMiddleware(ExceptionMiddleware)

ellar/core/middleware/function.py

@@ -1,8 +1,8 @@
 import typing as t
 
-from ellar.common.interfaces import IHostContext, IHostContextFactory
+from ellar.common.interfaces import IHostContext
 from ellar.common.types import ASGIApp, TReceive, TScope, TSend
-from ellar.core.connection import HTTPConnection
+from ellar.core.execution_context import current_connection
 from starlette.responses import Response
 
 AwaitableCallable = t.Callable[..., t.Awaitable]
@@ -57,18 +57,10 @@ async def __call__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
             await self.app(scope, receive, send)
             return
 
-        connection = HTTPConnection(scope, receive)
-
-        if not connection.service_provider:  # pragma: no cover
-            raise Exception("Service Provider is required")
-
-        context_factory = connection.service_provider.get(IHostContextFactory)
-        context = context_factory.create_context(scope, receive, send)
-
         async def call_next() -> None:
             await self.app(scope, receive, send)
 
-        response = await self.dispatch_function(context, call_next)
+        response = await self.dispatch_function(current_connection, call_next)
 
         if response and isinstance(response, Response):
             await response(scope, receive, send)

ellar/core/middleware/middleware.py

@@ -1,57 +1,58 @@
+import inspect
 import typing as t
 
 from ellar.common.interfaces import IEllarMiddleware
 from ellar.common.types import ASGIApp
-from ellar.core.context import current_injector
-from ellar.di import injectable
-from ellar.utils import build_init_kwargs
+from ellar.core.execution_context import current_injector
+from ellar.utils.importer import import_from_string
+from injector import _infer_injected_bindings
 from starlette.middleware import Middleware
 
 T = t.TypeVar("T")
 
 
 class EllarMiddleware(Middleware, IEllarMiddleware):
-    _provider_token: t.Optional[str]
-
     @t.no_type_check
     def __init__(
         self,
-        cls: t.Type[T],
-        provider_token: t.Optional[str] = None,
+        cls_or_import_string: t.Union[t.Type[T], str],
         **options: t.Any,
     ) -> None:
-        super().__init__(cls, **options)
-        injectable()(self.cls)
-        self.kwargs = build_init_kwargs(self.cls, self.kwargs)
-        self._provider_token = provider_token
-
-    def _register_middleware(self) -> None:
-        provider_token = self._provider_token
-        if provider_token:
-            module_data = next(
-                current_injector.tree_manager.find_module(
-                    lambda data: data.name == provider_token
-                )
-            )
-
-            if module_data and module_data.is_ready:
-                module_data.value.add_provider(self.cls, export=True)
-                return
+        super().__init__(cls_or_import_string, **options)
 
-        current_injector.tree_manager.get_root_module().add_provider(
-            self.cls, export=True
-        )
+    def _ensure_class(self) -> None:
+        if isinstance(self.cls, str):
+            self.cls = import_from_string(self.cls)
 
     def __iter__(self) -> t.Iterator[t.Any]:
+        self._ensure_class()
         as_tuple = (self, self.args, self.kwargs)
         return iter(as_tuple)
 
+    def create_object(self, **init_kwargs: t.Any) -> t.Any:
+        _result = dict(init_kwargs)
+
+        if hasattr(self.cls, "__init__"):
+            spec = inspect.signature(self.cls.__init__)
+            type_hints = _infer_injected_bindings(
+                self.cls.__init__, only_explicit_bindings=False
+            )
+
+            for k, annotation in type_hints.items():
+                parameter = spec.parameters.get(k)
+                if k in _result or (parameter and parameter.default is None):
+                    continue
+
+                _result[k] = current_injector.get(annotation)
+
+        return self.cls(**_result)
+
     @t.no_type_check
     def __call__(self, app: ASGIApp, *args: t.Any, **kwargs: t.Any) -> T:
-        self._register_middleware()
-        kwargs.update(app=app)
+        self._ensure_class()
+        # kwargs.update(app=app)
         try:
-            return current_injector.create_object(self.cls, additional_kwargs=kwargs)
+            return self.create_object(**kwargs, app=app)
         except TypeError:  # pragma: no cover
             # TODO: Fix future typing for lower python version.
-            return self.cls(*args, **kwargs)
+            return self.cls(*args, **kwargs, app=app)

ellar/core/middleware/trusted_host.py

@@ -0,0 +1,25 @@
+from ellar.common.types import ASGIApp
+from ellar.core.conf import Config
+from starlette.middleware.trustedhost import (
+    TrustedHostMiddleware as BaseTrustedHostMiddleware,
+)
+
+from .middleware import EllarMiddleware
+
+
+class TrustedHostMiddleware(BaseTrustedHostMiddleware):
+    def __init__(self, app: ASGIApp, config: Config) -> None:
+        self.config = config
+
+        allowed_hosts = config.ALLOWED_HOSTS
+
+        if config.DEBUG and allowed_hosts != ["*"]:
+            allowed_hosts = ["*"]
+
+        super().__init__(
+            app, allowed_hosts=allowed_hosts, www_redirect=self.config.REDIRECT_HOST
+        )
+
+
+# TrustedHostMiddleware Configuration
+trusted_host_middleware = EllarMiddleware(TrustedHostMiddleware)

ellar/core/middleware/versioning.py

@@ -6,24 +6,31 @@
 from ellar.core.versioning import BaseAPIVersioning, DefaultAPIVersioning
 from starlette.types import ASGIApp
 
+from .middleware import EllarMiddleware
+
 
 class RequestVersioningMiddleware:
-    def __init__(self, app: ASGIApp, *, debug: bool, config: "Config") -> None:
+    def __init__(self, app: ASGIApp, config: "Config") -> None:
         self.app = app
-        self.debug = debug
         self.config = config
 
     async def __call__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
         if scope["type"] not in ["http", "websocket"]:  # pragma: no cover
             await self.app(scope, receive, send)
             return
 
+        ## setup Versioning Resolvers
         scheme = (
             t.cast(BaseAPIVersioning, self.config.VERSIONING_SCHEME)
             or DefaultAPIVersioning()
         )
 
         version_scheme_resolver = scheme.get_version_resolver(scope)
         version_scheme_resolver.resolve()
+
         scope[SCOPE_API_VERSIONING_RESOLVER] = version_scheme_resolver
         await self.app(scope, receive, send)
+
+
+# RequestVersioningMiddleware Configuration
+versioning_middleware = EllarMiddleware(RequestVersioningMiddleware)