invcache-fix

cache/cache.py

@@ -340,11 +340,40 @@ async def invalidate_shouts_cache(cache_keys: List[str]):
     for key in cache_keys:
         cache_key = f"shouts:{key}"
         try:
+            # Удаляем основной кэш
             await redis.execute("DEL", cache_key)
             logger.debug(f"Invalidated cache key: {cache_key}")
             
             # Добавляем ключ в список инвалидированных с TTL
             await redis.execute("SETEX", f"{cache_key}:invalidated", CACHE_TTL, "1")
             
+            # Если это кэш темы, инвалидируем также связанные ключи
+            if key.startswith("topic_"):
+                topic_id = key.split("_")[1]
+                related_keys = [
+                    f"topic:id:{topic_id}",
+                    f"topic:authors:{topic_id}",
+                    f"topic:followers:{topic_id}"
+                ]
+                for related_key in related_keys:
+                    await redis.execute("DEL", related_key)
+                    logger.debug(f"Invalidated related key: {related_key}")
+            
         except Exception as e:
             logger.error(f"Error invalidating cache key {cache_key}: {e}")
+
+
+async def cache_topic_shouts(topic_id: int, shouts: List[dict]):
+    """Кэширует список публикаций для темы"""
+    key = f"topic_shouts_{topic_id}"
+    payload = json.dumps(shouts, cls=CustomJSONEncoder)
+    await redis.execute("SETEX", key, CACHE_TTL, payload)
+
+
+async def get_cached_topic_shouts(topic_id: int) -> List[dict]:
+    """Получает кэшированный список публикаций для темы"""
+    key = f"topic_shouts_{topic_id}"
+    cached = await redis.execute("GET", key)
+    if cached:
+        return json.loads(cached)
+    return None

resolvers/editor.py

@@ -334,22 +334,36 @@ async def update_shout(_, info, shout_id: int, shout_input=None, publish=False):
                     try:
                         logger.info("Invalidating cache after shout update")
                         
-                        # Инвалидируем кэш для всех связанных выборок
+                        cache_keys = [
-                        await invalidate_shouts_cache([
                             "feed",  # лента
                             f"author_{author_id}",  # публикации автора
                             "random_top",  # случайные топовые
                             "unrated",  # неоцененные
-                        ])
+                        ]
-                        
+
-                        # Инвалидируем кэш для каждой связанной темы
+                        # Добавляем ключи для старых тем (до обновления)
                         for topic in shout_by_id.topics:
-                            await invalidate_shouts_cache([f"topic_{topic.id}"])
+                            cache_keys.append(f"topic_{topic.id}")
+                            cache_keys.append(f"topic_shouts_{topic.id}")
+                            
+                        # Добавляем ключи для новых тем (если есть в shout_input)
+                        if shout_input.get("topics"):
+                            for topic in shout_input["topics"]:
+                                if topic.get("id"):
+                                    cache_keys.append(f"topic_{topic.id}")
+                                    cache_keys.append(f"topic_shouts_{topic.id}")
+
+                        await invalidate_shouts_cache(cache_keys)
+                        
+                        # Обновляем кэш тем и авторов
+                        for topic in shout_by_id.topics:
+                            await cache_by_id(Topic, topic.id, cache_topic)
+                        for author in shout_by_id.authors:
+                            await cache_author(author.dict())
                             
                         logger.info("Cache invalidated successfully")
                     except Exception as cache_error:
                         logger.warning(f"Cache invalidation error: {cache_error}", exc_info=True)
-                        # Не возвращаем ошибку, так как это некритично
 
                     if not publish:
                         await notify_shout(shout_dict, "update")