log key deletion and return data as a Response()

Signed-off-by: Grant Ramsay <seapagan@gmail.com>

Author: seapagan

fastapi_redis_cache/cache.py

@@ -11,6 +11,7 @@
 from fastapi import Response
 
 from fastapi_redis_cache.client import FastApiRedisCache
+from fastapi_redis_cache.enums import RedisEvent
 from fastapi_redis_cache.util import (
     ONE_DAY_IN_SECONDS,
     ONE_HOUR_IN_SECONDS,
@@ -69,6 +70,7 @@ async def inner_wrapper(
                 # if the redis client is not connected or request is not
                 # cacheable, no caching behavior is performed.
                 return await get_api_response_async(func, *args, **kwargs)
+
             key = redis_cache.get_cache_key(tag, func, *args, **kwargs)
             ttl, in_cache = redis_cache.check_cache(key)
             if in_cache:
@@ -150,29 +152,45 @@ async def inner_wrapper(
             **kwargs: Any,  # noqa: ANN401
         ) -> Any:  # noqa: ANN401
             """Invalidate all cached responses with the same tag."""
-            _headers = kwargs.get("request", None).headers
+            response = kwargs.get("response", None)
+            create_response_directly = not response
+
+            if create_response_directly:
+                response = Response()
+                if "content-length" in response.headers:
+                    del response.headers["content-length"]
 
             redis_cache = FastApiRedisCache()
             orig_response = await get_api_response_async(func, *args, **kwargs)
 
-            if not redis_cache.redis or not redis_cache.connected or not tag:
-                # we only want to invalidate the cache if the redis client is
-                # connected and a tag is provided.
-                return orig_response
-            if kwargs:
+            ignore_args = redis_cache.ignore_arg_types
+
+            if all([redis_cache.redis, redis_cache.connected, tag, kwargs]):
+                # remove any args that should not be used to generate the cache
+                # key.
+                filtered_kwargs = kwargs.copy()
+                for arg in ignore_args:
+                    filtered_kwargs.pop(arg, None)
                 search = "".join(
-                    [f"({key}={value})" for key, value in kwargs.items()]
+                    [
+                        f"({key}={value})"
+                        for key, value in filtered_kwargs.items()
+                    ]
                 )
                 tag_keys = redis_cache.get_tagged_keys(tag)
                 found_keys = [key for key in tag_keys if search.encode() in key]
                 for key in found_keys:
+                    redis_cache.log(
+                        RedisEvent.KEY_DELETED_FROM_CACHE, key=key.decode()
+                    )
                     redis_cache.redis.delete(key)
                     redis_cache.redis.srem(tag, key)
-            else:
-                # will fill this later, what to do if no kwargs are provided
-                pass
 
-            return orig_response
+            return Response(
+                content=serialize_json(orig_response),
+                media_type=JSON_MEDIA_TYPE,
+                headers=response.headers,
+            )
 
         return inner_wrapper
 

fastapi_redis_cache/client.py

@@ -205,7 +205,9 @@ def add_to_cache(self, key: str, value: Any, expire: int) -> bool:
             message = f"Object of type {type(value)} is not JSON-serializable"
             self.log(RedisEvent.FAILED_TO_CACHE_KEY, msg=message, key=key)
             return False
+
         cached = self.redis.set(name=key, value=response_data, ex=expire)
+
         if not cached:
             self.log(RedisEvent.FAILED_TO_CACHE_KEY, key=key, value=value)
             return False

fastapi_redis_cache/enums.py

@@ -21,3 +21,4 @@ class RedisEvent(IntEnum):
     KEY_ADDED_TO_CACHE = 4
     KEY_FOUND_IN_CACHE = 5
     FAILED_TO_CACHE_KEY = 6
+    KEY_DELETED_FROM_CACHE = 7

tests/live_test.py

@@ -99,7 +99,7 @@ def cache_invalid_type(request: Request, response: Response) -> logging.Logger:
 
 @app.get("/cache_with_args/{user}")
 @cache_one_hour(tag="user_tag")
-def cache_with_args(user: int, request: Request) -> dict[str, Union[bool, str]]:
+def cache_with_args(user: int) -> dict[str, Union[bool, str]]:
     """Have a varying cache key based on the user argument."""
     return {
         "success": True,
@@ -109,9 +109,7 @@ def cache_with_args(user: int, request: Request) -> dict[str, Union[bool, str]]:
 
 @app.put("/cache_with_args/{user}")
 @expires(tag="user_tag")
-def put_cache_with_args(
-    user: int, request: Request
-) -> dict[str, Union[bool, str]]:
+def put_cache_with_args(user: int) -> dict[str, Union[bool, str]]:
     """Put request to change data for a specific user."""
     return {
         "success": True,