Fixed ThrottlerModule configuration

Author: eadwinCode

ellar_throttler/module.py

@@ -1,15 +1,45 @@
+import typing as t
+
 from ellar.common import Module
-from ellar.core import ModuleBase
+from ellar.core import IExecutionContext
+from ellar.core.modules import DynamicModule, IModuleConfigure, ModuleBase
 from ellar.di import ProviderConfig
 
 from ellar_throttler.interfaces import IThrottlerStorage
-from ellar_throttler.throttler_service import CacheThrottlerStorageService
+from ellar_throttler.throttler_module_options import ThrottlerModuleOptions
+from ellar_throttler.throttler_service import ThrottlerStorageService
+
 
+@Module()
+class ThrottlerModule(ModuleBase, IModuleConfigure):
+    @classmethod
+    def module_configure(
+        cls,
+        ttl: int,
+        limit: int,
+        storage: t.Union[t.Type, t.Any] = None,
+        skip_if: t.Callable[[IExecutionContext], bool] = None,
+    ) -> DynamicModule:
+        if storage and isinstance(storage, IThrottlerStorage):
+            _provider = ProviderConfig(IThrottlerStorage, use_value=storage)
+        elif storage:
+            _provider = ProviderConfig(IThrottlerStorage, use_class=storage)
+        else:
+            _provider = ProviderConfig(
+                IThrottlerStorage, use_class=ThrottlerStorageService
+            )
 
-@Module(
-    providers=[
-        ProviderConfig(IThrottlerStorage, use_class=CacheThrottlerStorageService)
-    ]
-)
-class ThrottlerModule(ModuleBase):
-    pass
+        return DynamicModule(
+            cls,
+            providers=[
+                _provider,
+                ProviderConfig(
+                    ThrottlerModuleOptions,
+                    use_value=ThrottlerModuleOptions(
+                        limit=limit,
+                        ttl=ttl,
+                        skip_if=skip_if,  # type:ignore[arg-type]
+                    ),
+                ),
+            ],
+        )

ellar_throttler/throttler_guard.py

@@ -10,25 +10,35 @@
 from .constants import THROTTLER_LIMIT, THROTTLER_SKIP, THROTTLER_TTL
 from .exception import ThrottledException
 from .interfaces import IThrottlerStorage
+from .throttler_module_options import ThrottlerModuleOptions
 
 
 @injectable()
 class ThrottlerGuard(GuardCanActivate):
     header_prefix = "X-RateLimit"
 
     def __init__(
-        self, storage_service: IThrottlerStorage, reflector: Reflector
+        self,
+        storage_service: IThrottlerStorage,
+        reflector: Reflector,
+        options: ThrottlerModuleOptions,
     ) -> None:
         self.storage_service = storage_service
         self.reflector = reflector
+        self.options = options
 
     async def can_activate(self, context: IExecutionContext) -> bool:
         handler = context.get_handler()
         class_ref = context.get_class()
 
         # Return early if the current route should be skipped.
         # or self.options.skipIf?.(context)
-        if self.reflector.get_all_and_override(THROTTLER_SKIP, handler, class_ref):
+
+        if (
+            self.reflector.get_all_and_override(THROTTLER_SKIP, handler, class_ref)
+            or self.options.skip_if
+            and self.options.skip_if(context)
+        ):
             return True
 
         # Return early when we have no limit or ttl data.
@@ -40,8 +50,8 @@ async def can_activate(self, context: IExecutionContext) -> bool:
         )
 
         # Check if specific limits are set at class or route level, otherwise use global options.
-        limit = route_or_class_limit or 60  # or this.options.limit
-        ttl = route_or_class_ttl or 60  # or this.options.ttl
+        limit = route_or_class_limit or self.options.limit
+        ttl = route_or_class_ttl or self.options.ttl
         return await self.handle_request(context, limit, ttl)
 
     @classmethod

ellar_throttler/throttler_module_options.py

@@ -0,0 +1,17 @@
+import dataclasses
+import typing as t
+
+from ellar.core import IExecutionContext
+
+
+@dataclasses.dataclass
+class ThrottlerModuleOptions:
+    # The amount of requests that are allowed within the ttl's time window.
+    limit: int
+
+    #  The amount of seconds of how many requests are allowed within this time.
+    ttl: int
+
+    # A factory method to determine if throttling should be skipped.
+    # This can be based on the incoming context.
+    skip_if: t.Callable[[IExecutionContext], bool] = None  # type:ignore[assignment]

ellar_throttler/throttler_service.py

@@ -80,9 +80,8 @@ def storage(self) -> t.Any:
         return self._cache_service.get_backend()
 
     async def get_expiration_time(self, key: str) -> int:
-        result = await self._cache_service.get_async(f"{key}-ttl") or 60
-        assert result, "Value can not be none"
-        return math.floor(result - time.time())
+        result = await self._cache_service.get_async(f"{key}-ttl")
+        return math.floor(result - time.time()) if result else -1
 
     async def increment(self, key: str, ttl: int) -> ThrottlerStorageRecord:
         if not await self._cache_service.has_key_async(key):