topics+authors-reimplemented-cache

resolvers/author.py

@@ -1,25 +1,196 @@
 import asyncio
 import time
+from typing import Optional
 
-from sqlalchemy import desc, select, text
+from sqlalchemy import select, text
 
 from cache.cache import (
     cache_author,
+    cached_query,
     get_cached_author,
     get_cached_author_by_user_id,
     get_cached_author_followers,
     get_cached_follower_authors,
     get_cached_follower_topics,
+    invalidate_cache_by_prefix,
 )
 from orm.author import Author
-from orm.shout import ShoutAuthor, ShoutTopic
-from orm.topic import Topic
 from resolvers.stat import get_with_stat
 from services.auth import login_required
 from services.db import local_session
+from services.redis import redis
 from services.schema import mutation, query
 from utils.logger import root_logger as logger
 
+DEFAULT_COMMUNITIES = [1]
+
+
+# Вспомогательная функция для получения всех авторов без статистики
+async def get_all_authors():
+    """
+    Получает всех авторов без статистики.
+    Используется для случаев, когда нужен полный список авторов без дополнительной информации.
+
+    Returns:
+        list: Список всех авторов без статистики
+    """
+    cache_key = "authors:all:basic"
+
+    # Функция для получения всех авторов из БД
+    async def fetch_all_authors():
+        logger.debug("Получаем список всех авторов из БД и кешируем результат")
+
+        with local_session() as session:
+            # Запрос на получение базовой информации об авторах
+            authors_query = select(Author).where(Author.deleted_at.is_(None))
+            authors = session.execute(authors_query).scalars().all()
+
+            # Преобразуем авторов в словари
+            return [author.dict() for author in authors]
+
+    # Используем универсальную функцию для кеширования запросов
+    return await cached_query(cache_key, fetch_all_authors)
+
+
+# Вспомогательная функция для получения авторов со статистикой с пагинацией
+async def get_authors_with_stats(limit=50, offset=0, by: Optional[str] = None):
+    """
+    Получает авторов со статистикой с пагинацией.
+
+    Args:
+        limit: Максимальное количество возвращаемых авторов
+        offset: Смещение для пагинации
+        by: Опциональный параметр сортировки (new/active)
+
+    Returns:
+        list: Список авторов с их статистикой
+    """
+    # Формируем ключ кеша с помощью универсальной функции
+    cache_key = f"authors:stats:limit={limit}:offset={offset}"
+
+    # Функция для получения авторов из БД
+    async def fetch_authors_with_stats():
+        logger.debug(f"Выполняем запрос на получение авторов со статистикой: limit={limit}, offset={offset}, by={by}")
+
+        with local_session() as session:
+            # Базовый запрос для получения авторов
+            base_query = select(Author).where(Author.deleted_at.is_(None))
+
+            # Применяем сортировку
+            if by:
+                if isinstance(by, dict):
+                    # Обработка словаря параметров сортировки
+                    from sqlalchemy import asc, desc
+
+                    for field, direction in by.items():
+                        column = getattr(Author, field, None)
+                        if column:
+                            if direction.lower() == "desc":
+                                base_query = base_query.order_by(desc(column))
+                            else:
+                                base_query = base_query.order_by(column)
+                elif by == "new":
+                    base_query = base_query.order_by(desc(Author.created_at))
+                elif by == "active":
+                    base_query = base_query.order_by(desc(Author.last_seen))
+                else:
+                    # По умолчанию сортируем по времени создания
+                    base_query = base_query.order_by(desc(Author.created_at))
+            else:
+                base_query = base_query.order_by(desc(Author.created_at))
+
+            # Применяем лимит и смещение
+            base_query = base_query.limit(limit).offset(offset)
+
+            # Получаем авторов
+            authors = session.execute(base_query).scalars().all()
+            author_ids = [author.id for author in authors]
+
+            if not author_ids:
+                return []
+
+            # Оптимизированный запрос для получения статистики по публикациям для авторов
+            shouts_stats_query = f"""
+            SELECT sa.author, COUNT(DISTINCT s.id) as shouts_count
+            FROM shout_author sa
+            JOIN shout s ON sa.shout = s.id AND s.deleted_at IS NULL AND s.published_at IS NOT NULL
+            WHERE sa.author IN ({",".join(map(str, author_ids))})
+            GROUP BY sa.author
+            """
+            shouts_stats = {row[0]: row[1] for row in session.execute(text(shouts_stats_query))}
+
+            # Запрос на получение статистики по подписчикам для авторов
+            followers_stats_query = f"""
+            SELECT author, COUNT(DISTINCT follower) as followers_count
+            FROM author_follower
+            WHERE author IN ({",".join(map(str, author_ids))})
+            GROUP BY author
+            """
+            followers_stats = {row[0]: row[1] for row in session.execute(text(followers_stats_query))}
+
+            # Формируем результат с добавлением статистики
+            result = []
+            for author in authors:
+                author_dict = author.dict()
+                author_dict["stat"] = {
+                    "shouts": shouts_stats.get(author.id, 0),
+                    "followers": followers_stats.get(author.id, 0),
+                }
+                result.append(author_dict)
+
+                # Кешируем каждого автора отдельно для использования в других функциях
+                await cache_author(author_dict)
+
+            return result
+
+    # Используем универсальную функцию для кеширования запросов
+    return await cached_query(cache_key, fetch_authors_with_stats)
+
+
+# Функция для инвалидации кеша авторов
+async def invalidate_authors_cache(author_id=None):
+    """
+    Инвалидирует кеши авторов при изменении данных.
+
+    Args:
+        author_id: Опциональный ID автора для точечной инвалидации.
+               Если не указан, инвалидируются все кеши авторов.
+    """
+    if author_id:
+        # Точечная инвалидация конкретного автора
+        logger.debug(f"Инвалидация кеша для автора #{author_id}")
+        specific_keys = [
+            f"author:id:{author_id}",
+            f"author:followers:{author_id}",
+            f"author:follows-authors:{author_id}",
+            f"author:follows-topics:{author_id}",
+            f"author:follows-shouts:{author_id}",
+        ]
+
+        # Получаем user_id автора, если есть
+        with local_session() as session:
+            author = session.query(Author).filter(Author.id == author_id).first()
+            if author and author.user:
+                specific_keys.append(f"author:user:{author.user.strip()}")
+
+        # Удаляем конкретные ключи
+        for key in specific_keys:
+            try:
+                await redis.execute("DEL", key)
+                logger.debug(f"Удален ключ кеша {key}")
+            except Exception as e:
+                logger.error(f"Ошибка при удалении ключа {key}: {e}")
+
+        # Также ищем и удаляем ключи коллекций, содержащих данные об этом авторе
+        collection_keys = await redis.execute("KEYS", "authors:stats:*")
+        if collection_keys:
+            await redis.execute("DEL", *collection_keys)
+            logger.debug(f"Удалено {len(collection_keys)} коллекционных ключей авторов")
+    else:
+        # Общая инвалидация всех кешей авторов
+        logger.debug("Полная инвалидация кеша авторов")
+        await invalidate_cache_by_prefix("authors")
+
 
 @mutation.field("update_author")
 @login_required
@@ -51,10 +222,30 @@ async def update_author(_, info, profile):
 
 
 @query.field("get_authors_all")
-def get_authors_all(_, _info):
-    with local_session() as session:
-        authors = session.query(Author).all()
-        return authors
+async def get_authors_all(_, _info):
+    """
+    Получает список всех авторов без статистики.
+
+    Returns:
+        list: Список всех авторов
+    """
+    return await get_all_authors()
+
+
+@query.field("get_authors_paginated")
+async def get_authors_paginated(_, _info, limit=50, offset=0, by=None):
+    """
+    Получает список авторов с пагинацией и статистикой.
+
+    Args:
+        limit: Максимальное количество возвращаемых авторов
+        offset: Смещение для пагинации
+        by: Параметр сортировки (new/active)
+
+    Returns:
+        list: Список авторов с их статистикой
+    """
+    return await get_authors_with_stats(limit, offset, by)
 
 
 @query.field("get_author")
@@ -105,145 +296,105 @@ async def get_author_id(_, _info, user: str):
                 asyncio.create_task(cache_author(author_dict))
                 return author_with_stat
     except Exception as exc:
-        import traceback
-
-        traceback.print_exc()
-        logger.error(exc)
+        logger.error(f"Error getting author: {exc}")
+    return None
 
 
 @query.field("load_authors_by")
 async def load_authors_by(_, _info, by, limit, offset):
-    logger.debug(f"loading authors by {by}")
-    authors_query = select(Author)
+    """
+    Загружает авторов по заданному критерию с пагинацией.
 
-    if by.get("slug"):
-        authors_query = authors_query.filter(Author.slug.ilike(f"%{by['slug']}%"))
-    elif by.get("name"):
-        authors_query = authors_query.filter(Author.name.ilike(f"%{by['name']}%"))
-    elif by.get("topic"):
-        authors_query = (
-            authors_query.join(ShoutAuthor)  # Первое соединение ShoutAuthor
-            .join(ShoutTopic, ShoutAuthor.shout == ShoutTopic.shout)
-            .join(Topic, ShoutTopic.topic == Topic.id)
-            .filter(Topic.slug == str(by["topic"]))
-        )
+    Args:
+        by: Критерий сортировки авторов (new/active)
+        limit: Максимальное количество возвращаемых авторов
+        offset: Смещение для пагинации
 
-    if by.get("last_seen"):  # в unix time
-        before = int(time.time()) - by["last_seen"]
-        authors_query = authors_query.filter(Author.last_seen > before)
-    elif by.get("created_at"):  # в unix time
-        before = int(time.time()) - by["created_at"]
-        authors_query = authors_query.filter(Author.created_at > before)
-
-    authors_query = authors_query.limit(limit).offset(offset)
-
-    with local_session() as session:
-        authors_nostat = session.execute(authors_query).all()
-        authors = []
-        for a in authors_nostat:
-            if isinstance(a, Author):
-                author_dict = await get_cached_author(a.id, get_with_stat)
-                if author_dict and isinstance(author_dict.get("shouts"), int):
-                    authors.append(author_dict)
-
-    # order
-    order = by.get("order")
-    if order in ["shouts", "followers"]:
-        authors_query = authors_query.order_by(desc(text(f"{order}_stat")))
-
-    # group by
-    authors = get_with_stat(authors_query)
-    return authors or []
+    Returns:
+        list: Список авторов с учетом критерия
+    """
+    # Используем оптимизированную функцию для получения авторов
+    return await get_authors_with_stats(limit, offset, by)
 
 
 def get_author_id_from(slug="", user=None, author_id=None):
-    if not slug and not user and not author_id:
-        raise ValueError("One of slug, user, or author_id must be provided")
-
-    author_query = select(Author.id)
-    if user:
-        author_query = author_query.filter(Author.user == user)
-    elif slug:
-        author_query = author_query.filter(Author.slug == slug)
-    elif author_id:
-        author_query = author_query.filter(Author.id == author_id)
-
-    with local_session() as session:
-        author_id_result = session.execute(author_query).first()
-        author_id = author_id_result[0] if author_id_result else None
-
-    if not author_id:
-        raise ValueError("Author not found")
-
+    try:
+        author_id = None
+        if author_id:
+            return author_id
+        with local_session() as session:
+            author = None
+            if slug:
+                author = session.query(Author).filter(Author.slug == slug).first()
+                if author:
+                    author_id = author.id
+                    return author_id
+            if user:
+                author = session.query(Author).filter(Author.user == user).first()
+                if author:
+                    author_id = author.id
+    except Exception as exc:
+        logger.error(exc)
     return author_id
 
 
 @query.field("get_author_follows")
 async def get_author_follows(_, _info, slug="", user=None, author_id=0):
-    try:
-        author_id = get_author_id_from(slug, user, author_id)
+    logger.debug(f"getting follows for @{slug}")
+    author_id = get_author_id_from(slug=slug, user=user, author_id=author_id)
+    if not author_id:
+        return {}
 
-        if bool(author_id):
-            logger.debug(f"getting {author_id} follows authors")
-            authors = await get_cached_follower_authors(author_id)
-            topics = await get_cached_follower_topics(author_id)
-        return {
-            "topics": topics,
-            "authors": authors,
-            "communities": [{"id": 1, "name": "Дискурс", "slug": "discours", "pic": ""}],
-        }
-    except Exception:
-        import traceback
+    followed_authors = await get_cached_follower_authors(author_id)
+    followed_topics = await get_cached_follower_topics(author_id)
 
-        traceback.print_exc()
-        return {"error": "Author not found"}
+    # TODO: Get followed communities too
+    return {
+        "authors": followed_authors,
+        "topics": followed_topics,
+        "communities": DEFAULT_COMMUNITIES,
+        "shouts": [],
+    }
 
 
 @query.field("get_author_follows_topics")
 async def get_author_follows_topics(_, _info, slug="", user=None, author_id=None):
-    try:
-        follower_id = get_author_id_from(slug, user, author_id)
-        topics = await get_cached_follower_topics(follower_id)
-        return topics
-    except Exception:
-        import traceback
-
-        traceback.print_exc()
+    logger.debug(f"getting followed topics for @{slug}")
+    author_id = get_author_id_from(slug=slug, user=user, author_id=author_id)
+    if not author_id:
+        return []
+    followed_topics = await get_cached_follower_topics(author_id)
+    return followed_topics
 
 
 @query.field("get_author_follows_authors")
 async def get_author_follows_authors(_, _info, slug="", user=None, author_id=None):
-    try:
-        follower_id = get_author_id_from(slug, user, author_id)
-        return await get_cached_follower_authors(follower_id)
-    except Exception:
-        import traceback
-
-        traceback.print_exc()
+    logger.debug(f"getting followed authors for @{slug}")
+    author_id = get_author_id_from(slug=slug, user=user, author_id=author_id)
+    if not author_id:
+        return []
+    followed_authors = await get_cached_follower_authors(author_id)
+    return followed_authors
 
 
 def create_author(user_id: str, slug: str, name: str = ""):
+    author = Author()
+    author.user = user_id  # Связь с user_id из системы авторизации
+    author.slug = slug  # Идентификатор из системы авторизации
+    author.created_at = author.updated_at = int(time.time())
+    author.name = name or slug  # если не указано
+
     with local_session() as session:
-        try:
-            author = None
-            if user_id:
-                author = session.query(Author).filter(Author.user == user_id).first()
-            elif slug:
-                author = session.query(Author).filter(Author.slug == slug).first()
-            if not author:
-                new_author = Author(user=user_id, slug=slug, name=name)
-                session.add(new_author)
-                session.commit()
-                logger.info(f"author created by webhook {new_author.dict()}")
-        except Exception as exc:
-            logger.debug(exc)
+        session.add(author)
+        session.commit()
+        return author
 
 
 @query.field("get_author_followers")
 async def get_author_followers(_, _info, slug: str = "", user: str = "", author_id: int = 0):
-    logger.debug(f"getting followers for @{slug}")
+    logger.debug(f"getting followers for author @{slug} or ID:{author_id}")
     author_id = get_author_id_from(slug=slug, user=user, author_id=author_id)
-    followers = []
-    if author_id:
-        followers = await get_cached_author_followers(author_id)
+    if not author_id:
+        return []
+    followers = await get_cached_author_followers(author_id)
     return followers

resolvers/topic.py

@@ -1,18 +1,15 @@
-import time
-
-from sqlalchemy import func, select, text
+from sqlalchemy import desc, select, text
 
 from cache.cache import (
     cache_topic,
+    cached_query,
     get_cached_topic_authors,
     get_cached_topic_by_slug,
     get_cached_topic_followers,
-    redis_operation,
+    invalidate_cache_by_prefix,
 )
-from cache.memorycache import cache_region
 from orm.author import Author
-from orm.shout import Shout, ShoutTopic
-from orm.topic import Topic, TopicFollower
+from orm.topic import Topic
 from resolvers.stat import get_with_stat
 from services.auth import login_required
 from services.db import local_session
@@ -30,42 +27,26 @@ async def get_all_topics():
     Returns:
         list: Список всех тем без статистики
     """
-    # Пытаемся получить данные из кеша
-    cached_topics = await redis_operation("GET", "topics:all:basic")
+    cache_key = "topics:all:basic"
 
-    if cached_topics:
-        logger.debug("Используем кешированные базовые данные о темах из Redis")
-        try:
-            import json
+    # Функция для получения всех тем из БД
+    async def fetch_all_topics():
+        logger.debug("Получаем список всех тем из БД и кешируем результат")
 
-            return json.loads(cached_topics)
-        except Exception as e:
-            logger.error(f"Ошибка при десериализации тем из Redis: {e}")
+        with local_session() as session:
+            # Запрос на получение базовой информации о темах
+            topics_query = select(Topic)
+            topics = session.execute(topics_query).scalars().all()
 
-    # Если в кеше нет данных, выполняем запрос в БД
-    logger.debug("Получаем список всех тем из БД и кешируем результат")
+            # Преобразуем темы в словари
+            return [topic.dict() for topic in topics]
 
-    with local_session() as session:
-        # Запрос на получение базовой информации о темах
-        topics_query = select(Topic)
-        topics = session.execute(topics_query).scalars().all()
-
-        # Преобразуем темы в словари
-        result = [topic.dict() for topic in topics]
-
-    # Кешируем результат в Redis без TTL (будет обновляться только при изменениях)
-    try:
-        import json
-
-        await redis_operation("SET", "topics:all:basic", json.dumps(result))
-    except Exception as e:
-        logger.error(f"Ошибка при кешировании тем в Redis: {e}")
-
-    return result
+    # Используем универсальную функцию для кеширования запросов
+    return await cached_query(cache_key, fetch_all_topics)
 
 
 # Вспомогательная функция для получения тем со статистикой с пагинацией
-async def get_topics_with_stats(limit=100, offset=0, community_id=None):
+async def get_topics_with_stats(limit=100, offset=0, community_id=None, by=None):
     """
     Получает темы со статистикой с пагинацией.
 
@@ -73,105 +54,140 @@ async def get_topics_with_stats(limit=100, offset=0, community_id=None):
         limit: Максимальное количество возвращаемых тем
         offset: Смещение для пагинации
         community_id: Опциональный ID сообщества для фильтрации
+        by: Опциональный параметр сортировки
 
     Returns:
         list: Список тем с их статистикой
     """
-    # Формируем ключ кеша с учетом параметров
-    cache_key = f"topics:stats:limit={limit}:offset={offset}"
-    if community_id:
-        cache_key += f":community={community_id}"
+    # Формируем ключ кеша с помощью универсальной функции
+    cache_key = f"topics:stats:limit={limit}:offset={offset}:community_id={community_id}"
 
-    # Пытаемся получить данные из кеша
-    cached_topics = await redis_operation("GET", cache_key)
+    # Функция для получения тем из БД
+    async def fetch_topics_with_stats():
+        logger.debug(f"Выполняем запрос на получение тем со статистикой: limit={limit}, offset={offset}")
 
-    if cached_topics:
-        logger.debug(f"Используем кешированные данные о темах из Redis: {cache_key}")
-        try:
-            import json
+        with local_session() as session:
+            # Базовый запрос для получения тем
+            base_query = select(Topic)
 
-            return json.loads(cached_topics)
-        except Exception as e:
-            logger.error(f"Ошибка при десериализации тем из Redis: {e}")
+            # Добавляем фильтр по сообществу, если указан
+            if community_id:
+                base_query = base_query.where(Topic.community == community_id)
 
-    # Если в кеше нет данных, выполняем оптимизированный запрос
-    logger.debug(f"Выполняем запрос на получение тем со статистикой: limit={limit}, offset={offset}")
+            # Применяем сортировку на основе параметра by
+            if by:
+                if isinstance(by, dict):
+                    # Обработка словаря параметров сортировки
+                    for field, direction in by.items():
+                        column = getattr(Topic, field, None)
+                        if column:
+                            if direction.lower() == "desc":
+                                base_query = base_query.order_by(desc(column))
+                            else:
+                                base_query = base_query.order_by(column)
+                elif by == "popular":
+                    # Сортировка по популярности (количеству публикаций)
+                    # Примечание: это требует дополнительного запроса или подзапроса
+                    base_query = base_query.order_by(
+                        desc(Topic.id)
+                    )  # Временно, нужно заменить на proper implementation
+                else:
+                    # По умолчанию сортируем по ID в обратном порядке
+                    base_query = base_query.order_by(desc(Topic.id))
+            else:
+                # По умолчанию сортируем по ID в обратном порядке
+                base_query = base_query.order_by(desc(Topic.id))
 
-    with local_session() as session:
-        # Базовый запрос для получения тем
-        base_query = select(Topic)
+            # Применяем лимит и смещение
+            base_query = base_query.limit(limit).offset(offset)
 
-        # Добавляем фильтр по сообществу, если указан
-        if community_id:
-            base_query = base_query.where(Topic.community == community_id)
+            # Получаем темы
+            topics = session.execute(base_query).scalars().all()
+            topic_ids = [topic.id for topic in topics]
 
-        # Применяем лимит и смещение
-        base_query = base_query.limit(limit).offset(offset)
+            if not topic_ids:
+                return []
 
-        # Получаем темы
-        topics = session.execute(base_query).scalars().all()
-        topic_ids = [topic.id for topic in topics]
+            # Запрос на получение статистики по публикациям для выбранных тем
+            shouts_stats_query = f"""
+            SELECT st.topic, COUNT(DISTINCT s.id) as shouts_count
+            FROM shout_topic st
+            JOIN shout s ON st.shout = s.id AND s.deleted_at IS NULL
+            WHERE st.topic IN ({",".join(map(str, topic_ids))})
+            GROUP BY st.topic
+            """
+            shouts_stats = {row[0]: row[1] for row in session.execute(text(shouts_stats_query))}
 
-        if not topic_ids:
-            return []
+            # Запрос на получение статистики по подписчикам для выбранных тем
+            followers_stats_query = f"""
+            SELECT topic, COUNT(DISTINCT follower) as followers_count
+            FROM topic_followers
+            WHERE topic IN ({",".join(map(str, topic_ids))})
+            GROUP BY topic
+            """
+            followers_stats = {row[0]: row[1] for row in session.execute(text(followers_stats_query))}
 
-        # Запрос на получение статистики по публикациям для выбранных тем
-        shouts_stats_query = f"""
-        SELECT st.topic, COUNT(DISTINCT s.id) as shouts_count
-        FROM shout_topic st
-        JOIN shout s ON st.shout = s.id AND s.deleted_at IS NULL
-        WHERE st.topic IN ({",".join(map(str, topic_ids))})
-        GROUP BY st.topic
-        """
-        shouts_stats = {row[0]: row[1] for row in session.execute(text(shouts_stats_query))}
+            # Формируем результат с добавлением статистики
+            result = []
+            for topic in topics:
+                topic_dict = topic.dict()
+                topic_dict["stat"] = {
+                    "shouts": shouts_stats.get(topic.id, 0),
+                    "followers": followers_stats.get(topic.id, 0),
+                }
+                result.append(topic_dict)
 
-        # Запрос на получение статистики по подписчикам для выбранных тем
-        followers_stats_query = f"""
-        SELECT topic, COUNT(DISTINCT follower) as followers_count
-        FROM topic_followers
-        WHERE topic IN ({",".join(map(str, topic_ids))})
-        GROUP BY topic
-        """
-        followers_stats = {row[0]: row[1] for row in session.execute(text(followers_stats_query))}
+                # Кешируем каждую тему отдельно для использования в других функциях
+                await cache_topic(topic_dict)
 
-        # Формируем результат с добавлением статистики
-        result = []
-        for topic in topics:
-            topic_dict = topic.dict()
-            topic_dict["stat"] = {
-                "shouts": shouts_stats.get(topic.id, 0),
-                "followers": followers_stats.get(topic.id, 0),
-            }
-            result.append(topic_dict)
+            return result
 
-            # Кешируем каждую тему отдельно для использования в других функциях
-            await cache_topic(topic_dict)
-
-    # Кешируем полный результат в Redis без TTL (будет обновляться только при изменениях)
-    try:
-        import json
-
-        await redis_operation("SET", cache_key, json.dumps(result))
-    except Exception as e:
-        logger.error(f"Ошибка при кешировании тем в Redis: {e}")
-
-    return result
+    # Используем универсальную функцию для кеширования запросов
+    return await cached_query(cache_key, fetch_topics_with_stats)
 
 
 # Функция для инвалидации кеша тем
-async def invalidate_topics_cache():
+async def invalidate_topics_cache(topic_id=None):
     """
-    Инвалидирует все кеши тем при изменении данных.
+    Инвалидирует кеши тем при изменении данных.
+
+    Args:
+        topic_id: Опциональный ID темы для точечной инвалидации.
+               Если не указан, инвалидируются все кеши тем.
     """
-    logger.debug("Инвалидация кеша тем")
+    if topic_id:
+        # Точечная инвалидация конкретной темы
+        logger.debug(f"Инвалидация кеша для темы #{topic_id}")
+        specific_keys = [
+            f"topic:id:{topic_id}",
+            f"topic:authors:{topic_id}",
+            f"topic:followers:{topic_id}",
+            f"topic_shouts_{topic_id}",
+        ]
 
-    # Получаем все ключи, начинающиеся с "topics:"
-    topic_keys = await redis.execute("KEYS", "topics:*")
+        # Получаем slug темы, если есть
+        with local_session() as session:
+            topic = session.query(Topic).filter(Topic.id == topic_id).first()
+            if topic and topic.slug:
+                specific_keys.append(f"topic:slug:{topic.slug}")
 
-    if topic_keys:
-        # Удаляем все найденные ключи
-        await redis.execute("DEL", *topic_keys)
-        logger.debug(f"Удалено {len(topic_keys)} ключей кеша тем")
+        # Удаляем конкретные ключи
+        for key in specific_keys:
+            try:
+                await redis.execute("DEL", key)
+                logger.debug(f"Удален ключ кеша {key}")
+            except Exception as e:
+                logger.error(f"Ошибка при удалении ключа {key}: {e}")
+
+        # Также ищем и удаляем ключи коллекций, содержащих данные об этой теме
+        collection_keys = await redis.execute("KEYS", "topics:stats:*")
+        if collection_keys:
+            await redis.execute("DEL", *collection_keys)
+            logger.debug(f"Удалено {len(collection_keys)} коллекционных ключей тем")
+    else:
+        # Общая инвалидация всех кешей тем
+        logger.debug("Полная инвалидация кеша тем")
+        await invalidate_cache_by_prefix("topics")
 
 
 # Запрос на получение всех тем
@@ -188,23 +204,24 @@ async def get_topics_all(_, _info):
 
 # Запрос на получение тем с пагинацией и статистикой
 @query.field("get_topics_paginated")
-async def get_topics_paginated(_, _info, limit=100, offset=0):
+async def get_topics_paginated(_, _info, limit=100, offset=0, by=None):
     """
     Получает список тем с пагинацией и статистикой.
 
     Args:
         limit: Максимальное количество возвращаемых тем
         offset: Смещение для пагинации
+        by: Опциональные параметры сортировки
 
     Returns:
         list: Список тем с их статистикой
     """
-    return await get_topics_with_stats(limit, offset)
+    return await get_topics_with_stats(limit, offset, None, by)
 
 
 # Запрос на получение тем по сообществу
 @query.field("get_topics_by_community")
-async def get_topics_by_community(_, _info, community_id: int, limit=100, offset=0):
+async def get_topics_by_community(_, _info, community_id: int, limit=100, offset=0, by=None):
     """
     Получает список тем, принадлежащих указанному сообществу с пагинацией и статистикой.
 
@@ -212,11 +229,12 @@ async def get_topics_by_community(_, _info, community_id: int, limit=100, offset
         community_id: ID сообщества
         limit: Максимальное количество возвращаемых тем
         offset: Смещение для пагинации
+        by: Опциональные параметры сортировки
 
     Returns:
         list: Список тем с их статистикой
     """
-    return await get_topics_with_stats(limit, offset, community_id)
+    return await get_topics_with_stats(limit, offset, community_id, by)
 
 
 # Запрос на получение тем по автору
@@ -268,14 +286,18 @@ async def update_topic(_, _info, topic_input):
         if not topic:
             return {"error": "topic not found"}
         else:
+            old_slug = topic.slug
             Topic.update(topic, topic_input)
             session.add(topic)
             session.commit()
 
-            # Инвалидируем кеш всех тем и конкретной темы
-            await invalidate_topics_cache()
-            await redis.execute("DEL", f"topic:slug:{slug}")
-            await redis.execute("DEL", f"topic:id:{topic.id}")
+            # Инвалидируем кеш только для этой конкретной темы
+            await invalidate_topics_cache(topic.id)
+
+            # Если slug изменился, удаляем старый ключ
+            if old_slug != topic.slug:
+                await redis.execute("DEL", f"topic:slug:{old_slug}")
+                logger.debug(f"Удален ключ кеша для старого slug: {old_slug}")
 
             return {"topic": topic}