Added operation cache decorator and registered cache service to core app services

Author: eadwinCode

ellar/cache/__init__.py

@@ -0,0 +1,5 @@
+from .interface import ICacheService
+from .model import BaseCacheBackend
+from .service import CacheService
+
+__all__ = ["CacheService", "ICacheService", "BaseCacheBackend"]

ellar/common/__init__.py

@@ -3,6 +3,7 @@
 from ellar.core.params.params import Param, ParamTypes
 from ellar.core.routing import ModuleRouter
 
+from .cache import cache
 from .decorators import (
     Controller,
     Module,
@@ -54,6 +55,7 @@
 
 __all__ = [
     "command",
+    "cache",
     "ModuleRouter",
     "render",
     "Module",

ellar/common/cache.py

@@ -0,0 +1,144 @@
+import typing as t
+from functools import wraps
+
+from ellar.cache.interface import ICacheService
+from ellar.core import IExecutionContext
+from ellar.core.params import ExtraEndpointArg
+from ellar.helper import is_async_callable
+
+from .decorators.extra_args import extra_args
+from .routing.params import Context, Provide
+
+
+class CacheDecorator:
+    __slots__ = (
+        "_is_async",
+        "_key_prefix",
+        "_version",
+        "_backend",
+        "_func",
+        "_timeout",
+        "_cache_service_arg",
+        "_context_arg",
+        "_make_key_callback",
+    )
+
+    def __init__(
+        self,
+        func: t.Callable,
+        timeout: int,
+        *,
+        key_prefix: str = "",
+        version: str = None,
+        backend: str = "default",
+        make_key_callback: t.Callable[[IExecutionContext, str], str] = None,
+    ) -> None:
+        self._is_async = is_async_callable(func)
+        self._key_prefix = key_prefix
+        self._version = version
+        self._backend = backend
+        self._func = func
+        self._timeout = timeout
+
+        # create extra args
+        self._cache_service_arg = ExtraEndpointArg(
+            name="cache_service", annotation=ICacheService, default_value=Provide()  # type: ignore
+        )
+        self._context_arg = ExtraEndpointArg(
+            name="route_context", annotation=IExecutionContext, default_value=Context()  # type: ignore
+        )
+        # apply extra_args to endpoint
+        extra_args(self._cache_service_arg, self._context_arg)(func)
+        self._make_key_callback: t.Callable[[IExecutionContext, str], str] = (
+            make_key_callback or self.route_cache_make_key
+        )
+
+    def _get_key(self, **input_kwargs: t.Any) -> str:
+        context: IExecutionContext = self._context_arg.resolve(input_kwargs)
+        return self._make_key_callback(context, self._key_prefix or "")
+
+    def get_decorator_wrapper(self) -> t.Callable:
+        if self._is_async:
+            return self.get_async_cache_wrapper()
+        return self.get_cache_wrapper()
+
+    def route_cache_make_key(
+        self, context: IExecutionContext, key_prefix: str = ""
+    ) -> str:
+        """Defaults key generator for caching view"""
+        connection = context.switch_to_http_connection()
+        return f"{connection.get_client().url}:{key_prefix or 'view'}"
+
+    def get_async_cache_wrapper(self) -> t.Callable:
+        """Gets endpoint asynchronous wrapper function"""
+
+        @wraps(self._func)
+        async def _async_wrapper(*args: t.Any, **kwargs: t.Any) -> t.Any:
+            cache_service: ICacheService = self._cache_service_arg.resolve(kwargs)
+
+            key = self._get_key(**kwargs)
+
+            cached_value = await cache_service.get_async(
+                key, self._version, backend=self._backend
+            )
+            if cached_value:
+                return cached_value
+
+            response = await self._func(*args, **kwargs)
+            await cache_service.set_async(
+                key,
+                response,
+                timeout=self._timeout,
+                version=self._version,
+                backend=self._backend,
+            )
+            return response
+
+        return _async_wrapper
+
+    def get_cache_wrapper(self) -> t.Callable:
+        """Gets endpoint synchronous wrapper function"""
+
+        @wraps(self._func)
+        def _wrapper(*args: t.Any, **kwargs: t.Any) -> t.Any:
+            cache_service: ICacheService = self._cache_service_arg.resolve(kwargs)
+
+            key = self._get_key(**kwargs)
+
+            cached_value = cache_service.get(key, self._version, backend=self._backend)
+            if cached_value:
+                return cached_value
+
+            response = self._func(*args, **kwargs)
+            cache_service.set(
+                key,
+                response,
+                timeout=self._timeout,
+                version=self._version,
+                backend=self._backend,
+            )
+            return response
+
+        return _wrapper
+
+
+def cache(
+    timeout: int,
+    *,
+    key_prefix: str = "",
+    version: str = None,
+    backend: str = "default",
+    make_key_callback: t.Callable[[IExecutionContext, str], str] = None,
+) -> t.Callable:
+    def _wraps(func: t.Callable) -> t.Callable:
+        cache_decorator = CacheDecorator(
+            func,
+            timeout,
+            key_prefix=key_prefix,
+            version=version,
+            backend=backend,
+            make_key_callback=make_key_callback,
+        )
+        return cache_decorator.get_decorator_wrapper()
+
+    return _wraps

ellar/core/factory.py

@@ -97,9 +97,9 @@ def _create_app(
 
         config = Config(app_configured=True, config_module=config_module)
         injector = EllarInjector(auto_bind=config.INJECTOR_AUTO_BIND)
-
-        CoreServiceRegistration(injector).register_all()
         injector.container.register_instance(config, concrete_type=Config)
+        CoreServiceRegistration(injector, config).register_all()
+
         cls._build_modules(app_module=module, injector=injector, config=config)
 
         shutdown_event = config.ON_REQUEST_STARTUP

ellar/core/services.py

@@ -1,6 +1,10 @@
+import typing as t
+
+from ellar.cache import BaseCacheBackend, CacheService, ICacheService
 from ellar.di import EllarInjector
 from ellar.services.reflector import Reflector
 
+from .conf import Config
 from .context import (
     ExecutionContextFactory,
     HostContextFactory,
@@ -17,10 +21,11 @@
 class CoreServiceRegistration:
     """Create Binding for all application service"""
 
-    __slots__ = ("injector",)
+    __slots__ = ("injector", "config")
 
-    def __init__(self, injector: EllarInjector) -> None:
+    def __init__(self, injector: EllarInjector, config: Config) -> None:
         self.injector = injector
+        self.config = config
 
     def register_all(self) -> None:
         self.injector.container.register(
@@ -39,5 +44,9 @@ def register_all(self) -> None:
         self.injector.container.register_scoped(
             IWebSocketContextFactory, WebSocketContextFactory
         )
-
+        cache_service = CacheService(
+            t.cast(t.Dict[str, BaseCacheBackend], dict(self.config.CACHES))
+        )
         self.injector.container.register_instance(Reflector())
+        self.injector.container.register_instance(cache_service)
+        self.injector.container.register(ICacheService, cache_service)