Merge pull request #52 from eadwinCode/injectable_guards

Make Guards Injectable

Author: eadwinCode

docs/basics/execution-context.md

@@ -236,3 +236,6 @@ class DogsController(ControllerBase):
         result.update(message='This action adds a new dog')
         return result
 ```
+
+!!! info
+    It's important to note that `ExecutionContext` becomes available when there is route handler found to handle the current request.

docs/overview/providers.md

@@ -128,6 +128,8 @@ There are different scope which defines different ways a service is instantiated
 Whenever a transient scoped provider is required, a new instance of the provider is created
 
 ```python
+# main.py
+
 from ellar.di import EllarInjector, transient_scope, injectable
 
 injector = EllarInjector(auto_bind=False)
@@ -141,17 +143,24 @@ injector.container.register(ATransientClass)
 # OR
 # injector.container.register_transient(ATransientClass)
 
-a_transient_instance_1 = injector.get(ATransientClass)
-a_transient_instance_2 = injector.get(ATransientClass)
+def validate_transient_scope():
+    a_transient_instance_1 = injector.get(ATransientClass)
+    a_transient_instance_2 = injector.get(ATransientClass)
+    
+    assert a_transient_instance_2 != a_transient_instance_1 # True
 
-assert a_transient_instance_2 != a_transient_instance_1 # True
+    
+if __name__ == "__main__":
+    validate_transient_scope()
 ```
 
 ### **`singleton_scope`**: 
 A singleton scoped provider is created once throughout the lifespan of the Container instance.
 
 For example:
 ```python
+# main.py
+
 from ellar.di import EllarInjector, singleton_scope, injectable
 
 injector = EllarInjector(auto_bind=False)
@@ -165,18 +174,25 @@ injector.container.register(ASingletonClass)
 # OR
 # injector.container.register_singleton(ASingletonClass)
 
-a_singleton_instance_1 = injector.get(ASingletonClass)
-a_singleton_instance_2 = injector.get(ASingletonClass)
+def validate_singleton_scope():
+    a_singleton_instance_1 = injector.get(ASingletonClass)
+    a_singleton_instance_2 = injector.get(ASingletonClass)
+
+    assert a_singleton_instance_2 == a_singleton_instance_1 # True
 
-assert a_singleton_instance_2 == a_singleton_instance_1 # True
+if __name__ == "__main__":
+    validate_singleton_scope()
 ```
 
 ### **`request_scope`**: 
 A request scoped provider is instantiated once during the scope of the request. And it's destroyed once the request is complete.
 It is important to note that `request_scope` behaves like a `singleton_scope` during HTTPConnection mode and behaves like a `transient_scope` outside HTTPConnection mode.
 
 ```python
-from ellar.di import EllarInjector, request_scope, injectable, RequestServiceProvider
+# main.py
+
+import uvicorn
+from ellar.di import EllarInjector, request_scope, injectable
 
 injector = EllarInjector(auto_bind=False)
 
@@ -187,16 +203,22 @@ class ARequestScopeClass:
 
 
 injector.container.register(ARequestScopeClass)
-request_injector = RequestServiceProvider(injector.container)
 
-request_instance_1 = request_injector.get(ARequestScopeClass)
-request_instance_2 = request_injector.get(ARequestScopeClass)
-assert request_instance_2 == request_instance_1
 
-request_instance_1 = injector.get(ARequestScopeClass)
-request_instance_2 = injector.get(ARequestScopeClass)
+async def scoped_request(scope, receive, send):
+    async with injector.create_asgi_args(scope, receive, send) as request_injector:
+        request_instance_1 = request_injector.get(ARequestScopeClass)
+        request_instance_2 = request_injector.get(ARequestScopeClass)
+        assert request_instance_2 == request_instance_1
+
+    request_instance_1 = injector.get(ARequestScopeClass)
+    request_instance_2 = injector.get(ARequestScopeClass)
+
+    assert request_instance_2 != request_instance_1
+
 
-assert request_instance_2 != request_instance_1
+if __name__ == "__main__":
+    uvicorn.run("main:scoped_request", port=5000, log_level="info")
 
 ```
 
@@ -208,6 +230,8 @@ With `ProviderConfig`, we can register a `base_type` against a `concrete_type` O
 
 For example:
 ```python
+# main.py
+
 from ellar.common import Module
 from ellar.core import ModuleBase, Config
 from ellar.di import ProviderConfig, injectable, EllarInjector
@@ -244,15 +268,20 @@ class AModule(ModuleBase):
         self.ifoo_b = ifoo_b
 
 
-module_ref = create_module_ref_factor(
+def validate_provider_config():
+    module_ref = create_module_ref_factor(
     AModule, container=injector.container, config=Config(),
-)
-module_ref.run_module_register_services()
-a_module_instance: AModule = injector.get(AModule)
+    )
+    module_ref.run_module_register_services()
+    a_module_instance: AModule = injector.get(AModule)
+    
+    assert isinstance(a_module_instance.ifoo, AFooClass)
+    assert isinstance(a_module_instance.ifoo_b, AFooClass)
+    assert a_module_instance.ifoo_b == a_foo_instance
 
-assert isinstance(a_module_instance.ifoo, AFooClass)
-assert isinstance(a_module_instance.ifoo_b, AFooClass)
-assert a_module_instance.ifoo_b == a_foo_instance
+    
+if __name__ == "__main__":
+    validate_provider_config()
 ```
 In above example, we used `ProviderConfig` as a value type as in the case of `IFooB` type and 
 as a concrete type as in the case of `IFoo` type.
@@ -262,6 +291,8 @@ We can also achieve the same by overriding `register_providers` in any Module cl
 
 For example:
 ```python
+# main.py
+
 from ellar.common import Module
 from ellar.core import ModuleBase, Config
 from ellar.di import Container, EllarInjector, injectable, ProviderConfig
@@ -293,15 +324,20 @@ class AModule(ModuleBase):
         container.register(IFooB, a_foo_instance)
 
 
-module_ref = create_module_ref_factor(
+def validate_register_services():
+    module_ref = create_module_ref_factor(
     AModule, container=injector.container, config=Config(),
-)
-module_ref.run_module_register_services()
+    )
+    module_ref.run_module_register_services()
+    
+    ifoo_b = injector.get(IFooB)
+    ifoo = injector.get(IFoo)
+    
+    assert isinstance(ifoo_b, AFooClass)
+    assert isinstance(ifoo, AFooClass)
+    assert ifoo_b == a_foo_instance
 
-ifoo_b = injector.get(IFooB)
-ifoo = injector.get(IFoo)
+if __name__ == "__main__":
+    validate_register_services()
 
-assert isinstance(ifoo_b, AFooClass)
-assert isinstance(ifoo, AFooClass)
-assert ifoo_b == a_foo_instance
 ```

ellar/asgi_args.py

@@ -0,0 +1,19 @@
+import typing as t
+
+from ellar.types import TReceive, TScope, TSend
+
+if t.TYPE_CHECKING:  # pragma: no cover
+    from ellar.di.providers import Provider
+
+
+class ASGIArgs:
+    __slots__ = ("scope", "receive", "send", "context")
+
+    def __init__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
+        self.scope = scope
+        self.receive = receive
+        self.send = send
+        self.context: t.Dict[t.Type, "Provider"] = {}
+
+    def get_args(self) -> t.Tuple[TScope, TReceive, TSend]:
+        return self.scope, self.receive, self.send

ellar/constants.py

@@ -1,6 +1,7 @@
+import contextvars
 import logging
 from enum import Enum
-from typing import Any, Dict, List, no_type_check
+from typing import Any, Dict, List, Optional, no_type_check
 
 from pydantic.fields import (
     SHAPE_LIST,
@@ -10,6 +11,13 @@
     SHAPE_TUPLE_ELLIPSIS,
 )
 
+from .asgi_args import ASGIArgs
+
+ASGI_CONTEXT_VAR: contextvars.ContextVar[Optional[ASGIArgs]] = contextvars.ContextVar(
+    "ASGI-CONTEXT-VAR"
+)
+ASGI_CONTEXT_VAR.set(None)
+
 
 class _AnnotationToValue(type):
     keys: List[str]

ellar/core/connection/http.py

@@ -8,16 +8,16 @@
 from ellar.constants import SCOPE_SERVICE_PROVIDER
 
 if t.TYPE_CHECKING:  # pragma: no cover
-    from ellar.di.injector import RequestServiceProvider
+    from ellar.di import EllarInjector
 
 
 class HTTPConnection(StarletteHTTPConnection):
     @property
-    def service_provider(self) -> "RequestServiceProvider":
+    def service_provider(self) -> "EllarInjector":
         assert (
             SCOPE_SERVICE_PROVIDER in self.scope
         ), "RequestServiceProviderMiddleware must be installed to access request.service_provider"
-        return t.cast("RequestServiceProvider", self.scope[SCOPE_SERVICE_PROVIDER])
+        return t.cast("EllarInjector", self.scope[SCOPE_SERVICE_PROVIDER])
 
 
 class Request(StarletteRequest, HTTPConnection):

ellar/core/context/__init__.py

@@ -1,9 +1,12 @@
 from .exceptions import HostContextException
 from .execution import ExecutionContext
+from .factory import ExecutionContextFactory, HostContextFactory
 from .host import HostContext
 from .interface import (
     IExecutionContext,
+    IExecutionContextFactory,
     IHostContext,
+    IHostContextFactory,
     IHTTPHostContext,
     IWebSocketHostContext,
 )
@@ -16,4 +19,8 @@
     "IWebSocketHostContext",
     "HostContext",
     "HostContextException",
+    "IExecutionContextFactory",
+    "IHostContextFactory",
+    "ExecutionContextFactory",
+    "HostContextFactory",
 ]

ellar/core/context/execution.py

@@ -1,20 +1,16 @@
 import typing as t
 
 from ellar.compatible import cached_property
-from ellar.constants import CONTROLLER_CLASS_KEY, SCOPE_SERVICE_PROVIDER
+from ellar.constants import CONTROLLER_CLASS_KEY
 from ellar.di import injectable
-from ellar.di.providers import ModuleProvider
 from ellar.services.reflector import Reflector
 from ellar.types import TReceive, TScope, TSend
 
-from .exceptions import ExecutionContextException
 from .host import HostContext
 from .interface import IExecutionContext
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.controller import ControllerBase
-    from ellar.core.routing import RouteOperationBase
-    from ellar.di.injector import RequestServiceProvider
 
 
 @injectable()
@@ -49,33 +45,3 @@ def _get_class(self) -> t.Optional[t.Type["ControllerBase"]]:
 
     def get_class(self) -> t.Optional[t.Type["ControllerBase"]]:
         return self._get_class  # type: ignore
-
-    @classmethod
-    def create_context(
-        cls,
-        *,
-        scope: TScope,
-        receive: TReceive,
-        send: TSend,
-        operation: "RouteOperationBase",
-    ) -> IExecutionContext:
-        provider = ModuleProvider(
-            cls,
-            scope=scope,
-            receive=receive,
-            send=send,
-            operation_handler=operation.endpoint,
-        )
-        request_provider: "RequestServiceProvider" = t.cast(
-            "RequestServiceProvider", scope.get(SCOPE_SERVICE_PROVIDER)
-        )
-        if not request_provider:
-            raise ExecutionContextException(
-                "RequestServiceProvider is not configured. "
-                "Please ensure `RequestServiceProviderMiddleware` is registered."
-            )
-
-        request_provider.update_context(IExecutionContext, provider)
-        execution_context = request_provider.get(IExecutionContext)  # type: ignore
-
-        return execution_context