Merge pull request #216 from python-ellar/authorized_refactor

fix: Policy Refactor

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,13 +120,15 @@ def _build_modules(
         return routes
 
     @classmethod
+    @t.no_type_check
     def _create_app(
         cls,
         module: t.Type[t.Union[ModuleBase, t.Any]],
         global_guards: t.Optional[
             t.List[t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]]
         ] = None,
         config_module: t.Union[str, t.Dict, None] = None,
+        injector: t.Optional[EllarInjector] = None,
     ) -> App:
         def _get_config_kwargs() -> t.Dict:
             if config_module is None:
@@ -141,45 +145,54 @@ def _get_config_kwargs() -> t.Dict:
 
         config = Config(app_configured=True, **_get_config_kwargs())
 
-        injector = EllarInjector(auto_bind=config.INJECTOR_AUTO_BIND)
+        injector = EllarInjector(auto_bind=config.INJECTOR_AUTO_BIND, parent=injector)
         injector.container.register_instance(config, concrete_type=Config)
 
         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
 
@@ -198,6 +211,7 @@ def create_app(
         ] = None,
         commands: t.Sequence[t.Union[click.Command, click.Group, t.Any]] = (),
         config_module: t.Union[str, t.Dict, None] = None,
+        injector: t.Optional[EllarInjector] = None,
     ) -> App:
         module = Module(
             controllers=controllers,
@@ -211,11 +225,13 @@ 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,
+            injector=injector,
         )
+        return t.cast(App, app)
 
     @classmethod
     def create_from_app_module(
@@ -224,8 +240,14 @@ def create_from_app_module(
         global_guards: t.Optional[
             t.List[t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]]
         ] = None,
+        injector: t.Optional[EllarInjector] = None,
         config_module: t.Union[str, t.Dict, None] = None,
     ) -> App:
-        return cls._create_app(
-            module, config_module=config_module, global_guards=global_guards
+        app = cls._create_app(
+            module,
+            config_module=config_module,
+            global_guards=global_guards,
+            injector=injector,
         )
+
+        return t.cast(App, app)

ellar/app/lifespan.py

@@ -1,7 +1,6 @@
 import typing as t
 from contextlib import asynccontextmanager
 
-from anyio import create_task_group
 from ellar.common import IApplicationShutdown, IApplicationStartup
 from ellar.common.logging import logger
 
@@ -57,17 +56,15 @@ async def run_all_shutdown_actions(self, app: "App") -> None:
 
     @asynccontextmanager
     async def lifespan(self, app: "App") -> t.AsyncIterator[t.Any]:
-        logger.debug("Executing Modules Startup Handlers")
-
         try:
-            async with create_task_group() as tg:
-                tg.start_soon(self.run_all_startup_actions, app)
+            logger.debug("Executing Modules Startup Handlers")
+            await self.run_all_startup_actions(app)
 
             async with self._lifespan_context(app) as ctx:  # type:ignore[attr-defined]
                 logger.info("Application is ready.")
                 yield ctx
         finally:
             logger.debug("Executing Modules Shutdown Handlers")
-            async with create_task_group() as tg:
-                tg.start_soon(self.run_all_shutdown_actions, app)
+            await self.run_all_shutdown_actions(app)
+
             logger.info("Application shutdown successfully.")

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/auth/__init__.py

@@ -3,10 +3,10 @@
 from .identity import UserIdentity
 from .interceptor import AuthorizationInterceptor
 from .policy import (
-    BasePolicyHandler,
-    BasePolicyHandlerWithRequirement,
-    RequiredClaimsPolicy,
-    RequiredRolePolicy,
+    ClaimsPolicy,
+    Policy,
+    PolicyWithRequirement,
+    RolePolicy,
 )
 from .services import AppIdentitySchemes, IdentityAuthenticationService
 
@@ -16,11 +16,11 @@
     "Authorize",
     "BaseAuthenticationHandler",
     "CheckPolicies",
-    "BasePolicyHandler",
-    "BasePolicyHandlerWithRequirement",
+    "Policy",
+    "PolicyWithRequirement",
     "UserIdentity",
-    "RequiredClaimsPolicy",
-    "RequiredRolePolicy",
+    "ClaimsPolicy",
+    "RolePolicy",
     "AppIdentitySchemes",
     "IdentityAuthenticationService",
     "AuthenticationRequired",

ellar/auth/interceptor.py

@@ -6,7 +6,7 @@
 from starlette import status
 
 from .constants import POLICY_KEYS
-from .policy import BasePolicyHandler, PolicyType
+from .policy import Policy, PolicyType
 
 
 @injectable
@@ -26,7 +26,7 @@ def get_route_handler_policy(
 
     def _get_policy_instance(
         self, context: IExecutionContext, policy: t.Union[t.Type, t.Any, str]
-    ) -> t.Union[BasePolicyHandler, t.Any]:
+    ) -> t.Union[Policy, t.Any]:
         if isinstance(policy, type):
             return context.get_service_provider().get(policy)
         return policy

ellar/auth/policy/__init__.py

@@ -1,16 +1,16 @@
 from .base import (
-    BasePolicyHandler,
-    BasePolicyHandlerWithRequirement,
     DefaultRequirementType,
+    Policy,
     PolicyType,
+    PolicyWithRequirement,
 )
-from .common import RequiredClaimsPolicy, RequiredRolePolicy
+from .common import ClaimsPolicy, RolePolicy
 
 __all__ = [
-    "BasePolicyHandler",
-    "BasePolicyHandlerWithRequirement",
+    "Policy",
+    "PolicyWithRequirement",
     "DefaultRequirementType",
     "PolicyType",
-    "RequiredClaimsPolicy",
-    "RequiredRolePolicy",
+    "ClaimsPolicy",
+    "RolePolicy",
 ]

ellar/auth/policy/base.py

@@ -9,7 +9,7 @@ class DefaultRequirementType(AttributeDict):
     """
     Stores Policy Requirement Arguments in `arg_[n]` value
     example:
-        class MyPolicyHandler(BasePolicyHandlerWithRequirement):
+        class MyPolicyHandler(PolicyWithRequirement):
             ...
 
         policy = MyPolicyHandler['req1', 'req2', 'req2']
@@ -26,40 +26,40 @@ def __init__(self, *args: t.Any) -> None:
 class _PolicyOperandMixin:
     @t.no_type_check
     def __and__(
-        cls: t.Union["BasePolicyHandler", t.Type["BasePolicyHandler"]],
-        other: t.Union["BasePolicyHandler", t.Type["BasePolicyHandler"]],
-    ) -> "BasePolicyHandler":
+        cls: t.Union["Policy", t.Type["Policy"]],
+        other: t.Union["Policy", t.Type["Policy"]],
+    ) -> "Policy":
         return _ANDPolicy(cls, other)
 
     @t.no_type_check
     def __or__(
-        cls: t.Union["BasePolicyHandler", t.Type["BasePolicyHandler"]],
-        other: t.Union["BasePolicyHandler", t.Type["BasePolicyHandler"]],
-    ) -> "BasePolicyHandler":
+        cls: t.Union["Policy", t.Type["Policy"]],
+        other: t.Union["Policy", t.Type["Policy"]],
+    ) -> "Policy":
         return _ORPolicy(cls, other)
 
     @t.no_type_check
     def __invert__(
-        cls: t.Union["BasePolicyHandler", t.Type["BasePolicyHandler"]],
-    ) -> "BasePolicyHandler":
+        cls: t.Union["Policy", t.Type["Policy"]],
+    ) -> "Policy":
         return _NOTPolicy(cls)
 
 
-class BasePolicyHandlerMetaclass(_PolicyOperandMixin, ABCMeta):
+class PolicyMetaclass(_PolicyOperandMixin, ABCMeta):
     pass
 
 
-class BasePolicyHandler(ABC, _PolicyOperandMixin, metaclass=BasePolicyHandlerMetaclass):
+class Policy(ABC, _PolicyOperandMixin, metaclass=PolicyMetaclass):
     @abstractmethod
     async def handle(self, context: IExecutionContext) -> bool:
         """Run Policy Actions and return true or false"""
 
 
-class BasePolicyHandlerWithRequirement(
-    BasePolicyHandler,
+class PolicyWithRequirement(
+    Policy,
     ABC,
 ):
-    __requirements__: t.Dict[int, "BasePolicyHandler"] = {}
+    __requirements__: t.Dict[int, "Policy"] = {}
 
     requirement_type: t.Type = DefaultRequirementType
 
@@ -68,7 +68,7 @@ class BasePolicyHandlerWithRequirement(
     async def handle(self, context: IExecutionContext, requirement: t.Any) -> bool:
         """Handle Policy Action"""
 
-    def __class_getitem__(cls, parameters: t.Any) -> "BasePolicyHandler":
+    def __class_getitem__(cls, parameters: t.Any) -> "Policy":
         _parameters = parameters if isinstance(parameters, tuple) else (parameters,)
         hash_id = hash(_parameters)
         if hash_id not in cls.__requirements__:
@@ -79,24 +79,24 @@ def __class_getitem__(cls, parameters: t.Any) -> "BasePolicyHandler":
 
 
 PolicyType = t.Union[
-    BasePolicyHandler,
-    t.Type[BasePolicyHandler],
-    BasePolicyHandlerWithRequirement,
-    t.Type[BasePolicyHandlerWithRequirement],
+    Policy,
+    t.Type[Policy],
+    PolicyWithRequirement,
+    t.Type[PolicyWithRequirement],
 ]
 
 
 class _OperandResolversMixin:
     def _get_policy_object(
         self, context: IExecutionContext, policy: PolicyType
-    ) -> t.Union[BasePolicyHandler, BasePolicyHandlerWithRequirement]:
+    ) -> t.Union[Policy, PolicyWithRequirement]:
         if isinstance(policy, type):
             # resolve instance from EllarInjector, we assume the policy hand been decorated with @injector decorator.
             return context.get_service_provider().get(policy)  # type: ignore[no-any-return]
         return policy
 
 
-class _ORPolicy(BasePolicyHandler, _OperandResolversMixin):
+class _ORPolicy(Policy, _OperandResolversMixin):
     def __init__(self, policy_1: PolicyType, policy_2: PolicyType) -> None:
         self._policy_1 = policy_1
         self._policy_2 = policy_2
@@ -111,7 +111,7 @@ async def handle(self, context: IExecutionContext) -> bool:
         return _policy_1_result or _policy_2_result
 
 
-class _NOTPolicy(BasePolicyHandler, _OperandResolversMixin):
+class _NOTPolicy(Policy, _OperandResolversMixin):
     def __init__(self, policy_1: PolicyType) -> None:
         self._policy_1 = policy_1
 
@@ -134,7 +134,7 @@ async def handle(self, context: IExecutionContext) -> bool:
         return _policy_1_result and _policy_2_result
 
 
-class _PolicyHandlerWithRequirement(BasePolicyHandler, _OperandResolversMixin):
+class _PolicyHandlerWithRequirement(Policy, _OperandResolversMixin):
     def __init__(self, policy_1: PolicyType, requirement: t.Any) -> None:
         self._policy_1 = policy_1
         self.requirement = requirement