debug: force rebuild core stag branch

:

.gitea/workflows/main.yml

@@ -29,7 +29,16 @@ jobs:
         if: github.ref == 'refs/heads/dev'
         uses: dokku/github-action@master
         with:
-          branch: 'dev'
+          branch: 'main'
           force: true
           git_remote_url: 'ssh://dokku@v2.discours.io:22/core'
           ssh_private_key: ${{ secrets.SSH_PRIVATE_KEY }}
+
+      - name: Push to dokku for staging branch
+        if: github.ref == 'refs/heads/staging'
+        uses: dokku/github-action@master
+        with:
+          branch: 'dev'
+          git_remote_url: 'ssh://dokku@staging.discours.io:22/core'
+          ssh_private_key: ${{ secrets.SSH_PRIVATE_KEY }}
+          git_push_flags: '--force'

.gitignore

@@ -128,6 +128,9 @@ dmypy.json
 .idea
 temp.*
 
+# Debug
+DEBUG.log
+
 discours.key
 discours.crt
 discours.pem
@@ -161,4 +164,5 @@ views.json
 *.key
 *.crt
 *cache.json
-.cursor
+.cursor
+.devcontainer/

CHANGELOG.md

@@ -1,3 +1,44 @@
+#### [0.4.20] - 2025-05-03
+- Исправлена ошибка в классе `CacheRevalidationManager`: добавлена инициализация атрибута `_redis`
+- Улучшена обработка соединения с Redis в менеджере ревалидации кэша:
+  - Автоматическое восстановление соединения в случае его потери
+  - Проверка соединения перед выполнением операций с кэшем
+  - Дополнительное логирование для упрощения диагностики проблем
+- Исправлен резолвер `unpublish_shout`:
+  - Корректное формирование синтетического поля `publication` с `published_at: null`
+  - Возвращение полноценного словаря с данными вместо объекта модели
+  - Улучшена загрузка связанных данных (авторы, темы) для правильного формирования ответа
+
+#### [0.4.19] - 2025-04-14
+- dropped `Shout.description` and `Draft.description` to be UX-generated
+- use redis to init views counters after migrator
+
+#### [0.4.18] - 2025-04-10
+- Fixed `Topic.stat.authors` and `Topic.stat.comments`
+- Fixed unique constraint violation for empty slug values:
+  - Modified `update_draft` resolver to handle empty slug values
+  - Modified `create_draft` resolver to prevent empty slug values
+  - Added validation to prevent inserting or updating drafts with empty slug
+  - Fixed database error "duplicate key value violates unique constraint draft_slug_key"
+
+#### [0.4.17] - 2025-03-26
+- Fixed `'Reaction' object is not subscriptable` error in hierarchical comments:
+  - Modified `get_reactions_with_stat()` to convert Reaction objects to dictionaries
+  - Added default values for limit/offset parameters
+  - Fixed `load_first_replies()` implementation with proper parameter passing
+  - Added doctest with example usage
+  - Limited child comments to 100 per parent for performance
+
+#### [0.4.16] - 2025-03-22
+- Added hierarchical comments pagination:
+  - Created new GraphQL query `load_comments_branch` for efficient loading of hierarchical comments
+  - Ability to load root comments with their first N replies
+  - Added pagination for both root and child comments
+  - Using existing `comments_count` field in `Stat` type to display number of replies
+  - Added special `first_replies` field to store first replies to a comment
+  - Optimized SQL queries for efficient loading of comment hierarchies
+  - Implemented flexible comment sorting system (by time, rating)
+
 #### [0.4.15] - 2025-03-22
 - Upgraded caching system described `docs/caching.md`
 - Module `cache/memorycache.py` removed
@@ -31,8 +72,7 @@
   - Implemented persistent Redis caching for author queries without TTL (invalidated only on changes)
   - Optimized author retrieval with separate endpoints:
     - `get_authors_all` - returns all non-deleted authors without statistics
-    - `get_authors_paginated` - returns authors with statistics and pagination support
+    - `load_authors_by` - optimized to use caching and efficient sorting and pagination
-    - `load_authors_by` - optimized to use caching and efficient sorting
   - Improved SQL queries with optimized JOIN conditions and efficient filtering
   - Added pre-aggregation of statistics (shouts count, followers count) in single efficient queries
   - Implemented robust cache invalidation on author updates
@@ -44,7 +84,6 @@
   - Implemented persistent Redis caching for topic queries (no TTL, invalidated only on changes)
   - Optimized topic retrieval with separate endpoints for different use cases:
     - `get_topics_all` - returns all topics without statistics for lightweight listing
-    - `get_topics_paginated` - returns topics with statistics and pagination support
     - `get_topics_by_community` - adds pagination and optimized filtering by community
   - Added SQLAlchemy-managed indexes directly in ORM models for automatic schema maintenance
   - Created `sync_indexes()` function for automatic index synchronization during app startup
@@ -142,7 +181,7 @@
 #### [0.4.4]
 - `followers_stat` removed for shout
 - sqlite3 support added
-- `rating_stat` and `commented_stat` fixes
+- `rating_stat` and `comments_count` fixes
 
 #### [0.4.3]
 - cache reimplemented

Dockerfile

@@ -3,6 +3,7 @@ FROM python:slim
 RUN apt-get update && apt-get install -y \
     postgresql-client \
     curl \
+    build-essential \
     && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app

app/resolvers/draft.py

@@ -0,0 +1 @@
+ 

cache/cache.py

@@ -545,8 +545,9 @@ async def get_cached_data(key: str) -> Optional[Any]:
     try:
         cached_data = await redis.execute("GET", key)
         if cached_data:
-            logger.debug(f"Данные получены из кеша по ключу {key}")
+            loaded = orjson.loads(cached_data)
-            return orjson.loads(cached_data)
+            logger.debug(f"Данные получены из кеша по ключу {key}: {len(loaded)}")
+            return loaded
         return None
     except Exception as e:
         logger.error(f"Ошибка при получении данных из кеша: {e}")

cache/revalidator.py

@@ -8,6 +8,7 @@ from cache.cache import (
     invalidate_cache_by_prefix,
 )
 from resolvers.stat import get_with_stat
+from services.redis import redis
 from utils.logger import root_logger as logger
 
 CACHE_REVALIDATION_INTERVAL = 300  # 5 minutes
@@ -21,9 +22,19 @@ class CacheRevalidationManager:
         self.lock = asyncio.Lock()
         self.running = True
         self.MAX_BATCH_SIZE = 10  # Максимальное количество элементов для поштучной обработки
+        self._redis = redis  # Добавлена инициализация _redis для доступа к Redis-клиенту
 
     async def start(self):
         """Запуск фонового воркера для ревалидации кэша."""
+        # Проверяем, что у нас есть соединение с Redis
+        if not self._redis._client:
+            logger.warning("Redis connection not established. Waiting for connection...")
+            try:
+                await self._redis.connect()
+                logger.info("Redis connection established for revalidation manager")
+            except Exception as e:
+                logger.error(f"Failed to connect to Redis: {e}")
+                
         self.task = asyncio.create_task(self.revalidate_cache())
 
     async def revalidate_cache(self):
@@ -39,6 +50,10 @@ class CacheRevalidationManager:
 
     async def process_revalidation(self):
         """Обновление кэша для всех сущностей, требующих ревалидации."""
+        # Проверяем соединение с Redis
+        if not self._redis._client:
+            return  # Выходим из метода, если не удалось подключиться
+                
         async with self.lock:
             # Ревалидация кэша авторов
             if self.items_to_revalidate["authors"]:

docs/caching.md

@@ -147,16 +147,32 @@ await invalidate_topics_cache(456)
 
 ```python
 class CacheRevalidationManager:
-    # ...
+    def __init__(self, interval=CACHE_REVALIDATION_INTERVAL):
-    async def process_revalidation(self):
         # ...
+        self._redis = redis  # Прямая ссылка на сервис Redis
+        
+    async def start(self):
+        # Проверка и установка соединения с Redis
+        # ...
+        
+    async def process_revalidation(self):
+        # Обработка элементов для ревалидации
+        # ...
+        
     def mark_for_revalidation(self, entity_id, entity_type):
+        # Добавляет сущность в очередь на ревалидацию
         # ...
 ```
 
 Менеджер ревалидации работает как асинхронный фоновый процесс, который периодически (по умолчанию каждые 5 минут) проверяет наличие сущностей для ревалидации.
 
-Особенности реализации:
+**Взаимодействие с Redis:**
+- CacheRevalidationManager хранит прямую ссылку на сервис Redis через атрибут `_redis`
+- При запуске проверяется наличие соединения с Redis и при необходимости устанавливается новое
+- Включена автоматическая проверка соединения перед каждой операцией ревалидации
+- Система самостоятельно восстанавливает соединение при его потере
+
+**Особенности реализации:**
 - Для авторов и тем используется поштучная ревалидация каждой записи
 - Для шаутов и реакций используется батчевая обработка, с порогом в 10 элементов
 - При достижении порога система переключается на инвалидацию коллекций вместо поштучной обработки

docs/comments-pagination.md

@@ -0,0 +1,165 @@
+# Пагинация комментариев
+
+## Обзор
+
+Реализована система пагинации комментариев по веткам, которая позволяет эффективно загружать и отображать вложенные ветки обсуждений. Основные преимущества:
+
+1. Загрузка только необходимых комментариев, а не всего дерева
+2. Снижение нагрузки на сервер и клиент
+3. Возможность эффективной навигации по большим обсуждениям
+4. Предзагрузка первых N ответов для улучшения UX
+
+## API для иерархической загрузки комментариев
+
+### GraphQL запрос `load_comments_branch`
+
+```graphql
+query LoadCommentsBranch(
+  $shout: Int!,
+  $parentId: Int,
+  $limit: Int,
+  $offset: Int,
+  $sort: ReactionSort,
+  $childrenLimit: Int,
+  $childrenOffset: Int
+) {
+  load_comments_branch(
+    shout: $shout,
+    parent_id: $parentId,
+    limit: $limit,
+    offset: $offset,
+    sort: $sort,
+    children_limit: $childrenLimit,
+    children_offset: $childrenOffset
+  ) {
+    id
+    body
+    created_at
+    created_by {
+      id
+      name
+      slug
+      pic
+    }
+    kind
+    reply_to
+    stat {
+      rating
+      comments_count
+    }
+    first_replies {
+      id
+      body
+      created_at
+      created_by {
+        id
+        name
+        slug
+        pic
+      }
+      kind
+      reply_to
+      stat {
+        rating
+        comments_count
+      }
+    }
+  }
+}
+```
+
+### Параметры запроса
+
+| Параметр | Тип | По умолчанию | Описание |
+|----------|-----|--------------|----------|
+| shout | Int! | - | ID статьи, к которой относятся комментарии |
+| parent_id | Int | null | ID родительского комментария. Если null, загружаются корневые комментарии |
+| limit | Int | 10 | Максимальное количество комментариев для загрузки |
+| offset | Int | 0 | Смещение для пагинации |
+| sort | ReactionSort | newest | Порядок сортировки: newest, oldest, like |
+| children_limit | Int | 3 | Максимальное количество дочерних комментариев для каждого родительского |
+| children_offset | Int | 0 | Смещение для пагинации дочерних комментариев |
+
+### Поля в ответе
+
+Каждый комментарий содержит следующие основные поля:
+
+- `id`: ID комментария
+- `body`: Текст комментария
+- `created_at`: Время создания
+- `created_by`: Информация об авторе
+- `kind`: Тип реакции (COMMENT)
+- `reply_to`: ID родительского комментария (null для корневых)
+- `first_replies`: Первые N дочерних комментариев
+- `stat`: Статистика комментария, включающая:
+  - `comments_count`: Количество ответов на комментарий
+  - `rating`: Рейтинг комментария
+
+## Примеры использования
+
+### Загрузка корневых комментариев с первыми ответами
+
+```javascript
+const { data } = await client.query({
+  query: LOAD_COMMENTS_BRANCH,
+  variables: {
+    shout: 222,
+    limit: 10,
+    offset: 0,
+    sort: "newest",
+    childrenLimit: 3
+  }
+});
+```
+
+### Загрузка ответов на конкретный комментарий
+
+```javascript
+const { data } = await client.query({
+  query: LOAD_COMMENTS_BRANCH,
+  variables: {
+    shout: 222,
+    parentId: 123, // ID комментария, для которого загружаем ответы
+    limit: 10,
+    offset: 0,
+    sort: "oldest" // Сортируем ответы от старых к новым
+  }
+});
+```
+
+### Пагинация дочерних комментариев
+
+Для загрузки дополнительных ответов на комментарий:
+
+```javascript
+const { data } = await client.query({
+  query: LOAD_COMMENTS_BRANCH,
+  variables: {
+    shout: 222,
+    parentId: 123,
+    limit: 10,
+    offset: 0,
+    childrenLimit: 5,
+    childrenOffset: 3 // Пропускаем первые 3 комментария (уже загруженные)
+  }
+});
+```
+
+## Рекомендации по клиентской реализации
+
+1. Для эффективной работы со сложными ветками обсуждений рекомендуется:
+
+   - Сначала загружать только корневые комментарии с первыми N ответами
+   - При наличии дополнительных ответов (когда `stat.comments_count > first_replies.length`) 
+     добавить кнопку "Показать все ответы"
+   - При нажатии на кнопку загружать дополнительные ответы с помощью запроса с указанным `parentId`
+
+2. Для сортировки:
+   - По умолчанию использовать `newest` для отображения свежих обсуждений
+   - Предусмотреть переключатель сортировки для всего дерева комментариев
+   - При изменении сортировки перезагружать данные с новым параметром `sort`
+
+3. Для улучшения производительности:
+   - Кешировать результаты запросов на клиенте
+   - Использовать оптимистичные обновления при добавлении/редактировании комментариев
+   - При необходимости загружать комментарии порциями (ленивая загрузка) 

docs/features.md

@@ -34,4 +34,15 @@
 - Поддерживаемые методы: GET, POST, OPTIONS
 - Настроена поддержка credentials
 - Разрешенные заголовки: Authorization, Content-Type, X-Requested-With, DNT, Cache-Control
-- Настроено кэширование preflight-ответов на 20 дней (1728000 секунд)
+- Настроено кэширование preflight-ответов на 20 дней (1728000 секунд)
+
+## Пагинация комментариев по веткам
+
+- Эффективная загрузка комментариев с учетом их иерархической структуры
+- Отдельный запрос `load_comments_branch` для оптимизированной загрузки ветки комментариев
+- Возможность загрузки корневых комментариев статьи с первыми ответами на них
+- Гибкая пагинация как для корневых, так и для дочерних комментариев
+- Использование поля `stat.comments_count` для отображения количества ответов на комментарий
+- Добавление специального поля `first_replies` для хранения первых ответов на комментарий
+- Поддержка различных методов сортировки (новые, старые, популярные)
+- Оптимизированные SQL запросы для минимизации нагрузки на базу данных

main.py

@@ -17,7 +17,8 @@ from cache.revalidator import revalidation_manager
 from services.exception import ExceptionHandlerMiddleware
 from services.redis import redis
 from services.schema import create_all_tables, resolvers
-from services.search import search_service
+#from services.search import search_service
+from services.search import search_service, initialize_search_index
 from services.viewed import ViewedStorage
 from services.webhook import WebhookEndpoint, create_webhook_endpoint
 from settings import DEV_SERVER_PID_FILE_NAME, MODE
@@ -34,24 +35,67 @@ async def start():
                 f.write(str(os.getpid()))
     print(f"[main] process started in {MODE} mode")
 
+async def check_search_service():
+    """Check if search service is available and log result"""
+    info = await search_service.info()
+    if info.get("status") in ["error", "unavailable"]:
+        print(f"[WARNING] Search service unavailable: {info.get('message', 'unknown reason')}")
+    else:
+        print(f"[INFO] Search service is available: {info}")
 
+
+# indexing DB data
+# async def indexing():
+#     from services.db import fetch_all_shouts
+#     all_shouts = await fetch_all_shouts()
+#     await initialize_search_index(all_shouts)
 async def lifespan(_app):
     try:
+        print("[lifespan] Starting application initialization")
         create_all_tables()
         await asyncio.gather(
             redis.connect(),
             precache_data(),
             ViewedStorage.init(),
             create_webhook_endpoint(),
-            search_service.info(),
+            check_search_service(),
             start(),
             revalidation_manager.start(),
         )
+        print("[lifespan] Basic initialization complete")
+
+        # Add a delay before starting the intensive search indexing
+        print("[lifespan] Waiting for system stabilization before search indexing...")
+        await asyncio.sleep(10)  # 10-second delay to let the system stabilize
+
+        # Start search indexing as a background task with lower priority
+        asyncio.create_task(initialize_search_index_background())
+
         yield
     finally:
+        print("[lifespan] Shutting down application services")
         tasks = [redis.disconnect(), ViewedStorage.stop(), revalidation_manager.stop()]
         await asyncio.gather(*tasks, return_exceptions=True)
+        print("[lifespan] Shutdown complete")
 
+# Initialize search index in the background
+async def initialize_search_index_background():
+    """Run search indexing as a background task with low priority"""
+    try:
+        print("[search] Starting background search indexing process")
+        from services.db import fetch_all_shouts
+        
+        # Get total count first (optional)
+        all_shouts = await fetch_all_shouts()
+        total_count = len(all_shouts) if all_shouts else 0
+        print(f"[search] Fetched {total_count} shouts for background indexing")
+        
+        # Start the indexing process with the fetched shouts
+        print("[search] Beginning background search index initialization...")
+        await initialize_search_index(all_shouts)
+        print("[search] Background search index initialization complete")
+    except Exception as e:
+        print(f"[search] Error in background search indexing: {str(e)}")
 
 # Создаем экземпляр GraphQL
 graphql_app = GraphQL(schema, debug=True)

orm/draft.py

@@ -6,6 +6,7 @@ from sqlalchemy.orm import relationship
 from orm.author import Author
 from orm.topic import Topic
 from services.db import Base
+from orm.shout import Shout
 
 
 class DraftTopic(Base):
@@ -26,11 +27,14 @@ class DraftAuthor(Base):
     caption = Column(String, nullable=True, default="")
 
 
+
 class Draft(Base):
     __tablename__ = "draft"
     # required
     created_at: int = Column(Integer, nullable=False, default=lambda: int(time.time()))
-    created_by: int = Column(ForeignKey("author.id"), nullable=False)
+    # Колонки для связей с автором
+    created_by: int = Column("created_by", ForeignKey("author.id"), nullable=False)
+    community: int = Column("community", ForeignKey("community.id"), nullable=False, default=1)
 
     # optional
     layout: str = Column(String, nullable=True, default="article")
@@ -38,7 +42,6 @@ class Draft(Base):
     title: str = Column(String, nullable=True)
     subtitle: str | None = Column(String, nullable=True)
     lead: str | None = Column(String, nullable=True)
-    description: str | None = Column(String, nullable=True)
     body: str = Column(String, nullable=False, comment="Body")
     media: dict | None = Column(JSON, nullable=True)
     cover: str | None = Column(String, nullable=True, comment="Cover image url")
@@ -49,7 +52,55 @@ class Draft(Base):
     # auto
     updated_at: int | None = Column(Integer, nullable=True, index=True)
     deleted_at: int | None = Column(Integer, nullable=True, index=True)
-    updated_by: int | None = Column(ForeignKey("author.id"), nullable=True)
+    updated_by: int | None = Column("updated_by", ForeignKey("author.id"), nullable=True)
-    deleted_by: int | None = Column(ForeignKey("author.id"), nullable=True)
+    deleted_by: int | None = Column("deleted_by", ForeignKey("author.id"), nullable=True)
-    authors = relationship(Author, secondary="draft_author")
+    
-    topics = relationship(Topic, secondary="draft_topic")
+    # --- Relationships --- 
+    # Только many-to-many связи через вспомогательные таблицы
+    authors = relationship(Author, secondary="draft_author", lazy="select")
+    topics = relationship(Topic, secondary="draft_topic", lazy="select")
+    
+    # Связь с Community (если нужна как объект, а не ID)
+    # community = relationship("Community", foreign_keys=[community_id], lazy="joined")
+    # Пока оставляем community_id как ID
+
+    # Связь с публикацией (один-к-одному или один-к-нулю)
+    # Загружается через joinedload в резолвере
+    publication = relationship(
+        "Shout", 
+        primaryjoin="Draft.id == Shout.draft", 
+        foreign_keys="Shout.draft", 
+        uselist=False, 
+        lazy="noload", # Не грузим по умолчанию, только через options
+        viewonly=True # Указываем, что это связь только для чтения
+    )
+
+    def dict(self):
+        """
+        Сериализует объект Draft в словарь.
+        Гарантирует, что поля topics и authors всегда будут списками.
+        """
+        return {
+            "id": self.id,
+            "created_at": self.created_at,
+            "created_by": self.created_by,
+            "community": self.community,
+            "layout": self.layout,
+            "slug": self.slug,
+            "title": self.title,
+            "subtitle": self.subtitle,
+            "lead": self.lead,
+            "body": self.body,
+            "media": self.media or [],
+            "cover": self.cover,
+            "cover_caption": self.cover_caption,
+            "lang": self.lang,
+            "seo": self.seo,
+            "updated_at": self.updated_at,
+            "deleted_at": self.deleted_at,
+            "updated_by": self.updated_by,
+            "deleted_by": self.deleted_by,
+            # Гарантируем, что topics и authors всегда будут списками
+            "topics": [topic.dict() for topic in (self.topics or [])],
+            "authors": [author.dict() for author in (self.authors or [])]
+        }

orm/shout.py

@@ -71,6 +71,34 @@ class ShoutAuthor(Base):
 class Shout(Base):
     """
     Публикация в системе.
+
+    Attributes:
+        body (str)
+        slug (str)
+        cover (str) : "Cover image url"
+        cover_caption (str) : "Cover image alt caption"
+        lead (str) 
+        title (str)
+        subtitle (str)
+        layout (str)
+        media (dict)
+        authors (list[Author])
+        topics (list[Topic])
+        reactions (list[Reaction])
+        lang (str)
+        version_of (int)
+        oid (str)
+        seo (str) : JSON
+        draft (int)
+        created_at (int)
+        updated_at (int)
+        published_at (int)
+        featured_at (int)
+        deleted_at (int)
+        created_by (int)
+        updated_by (int)
+        deleted_by (int)
+        community (int)
     """
 
     __tablename__ = "shout"
@@ -91,7 +119,6 @@ class Shout(Base):
     cover: str | None = Column(String, nullable=True, comment="Cover image url")
     cover_caption: str | None = Column(String, nullable=True, comment="Cover image alt caption")
     lead: str | None = Column(String, nullable=True)
-    description: str | None = Column(String, nullable=True)
     title: str = Column(String, nullable=False)
     subtitle: str | None = Column(String, nullable=True)
     layout: str = Column(String, nullable=False, default="article")

requirements.txt

@@ -13,5 +13,10 @@ starlette
 gql
 ariadne
 granian
+
+# NLP and search
+httpx
+
 orjson
-pydantic
+pydantic
+trafilatura

resolvers/__init__.py

@@ -8,6 +8,7 @@ from resolvers.author import (  # search_authors,
     get_author_id,
     get_authors_all,
     load_authors_by,
+    load_authors_search,
     update_author,
 )
 from resolvers.community import get_communities_all, get_community
@@ -16,9 +17,11 @@ from resolvers.draft import (
     delete_draft,
     load_drafts,
     publish_draft,
-    unpublish_draft,
     update_draft,
 )
+from resolvers.editor import (
+    unpublish_shout,
+)
 from resolvers.feed import (
     load_shouts_coauthored,
     load_shouts_discussed,
@@ -37,6 +40,7 @@ from resolvers.reaction import (
     create_reaction,
     delete_reaction,
     load_comment_ratings,
+    load_comments_branch,
     load_reactions_by,
     load_shout_comments,
     load_shout_ratings,
@@ -70,6 +74,7 @@ __all__ = [
     "get_author_follows_authors",
     "get_authors_all",
     "load_authors_by",
+    "load_authors_search",
     "update_author",
     ## "search_authors",
     # community
@@ -107,6 +112,7 @@ __all__ = [
     "load_shout_comments",
     "load_shout_ratings",
     "load_comment_ratings",
+    "load_comments_branch",
     # notifier
     "load_notifications",
     "notifications_seen_thread",

resolvers/author.py

@@ -20,6 +20,7 @@ from services.auth import login_required
 from services.db import local_session
 from services.redis import redis
 from services.schema import mutation, query
+from services.search import search_service
 from utils.logger import root_logger as logger
 
 DEFAULT_COMMUNITIES = [1]
@@ -232,22 +233,6 @@ async def get_authors_all(_, _info):
     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")
 async def get_author(_, _info, slug="", author_id=0):
     author_dict = None
@@ -317,6 +302,46 @@ async def load_authors_by(_, _info, by, limit, offset):
     return await get_authors_with_stats(limit, offset, by)
 
 
+@query.field("load_authors_search")
+async def load_authors_search(_, info, text: str, limit: int = 10, offset: int = 0):
+    """
+    Resolver for searching authors by text. Works with txt-ai search endpony.
+    Args:
+        text: Search text
+        limit: Maximum number of authors to return
+        offset: Offset for pagination
+    Returns:
+        list: List of authors matching the search criteria
+    """
+    
+    # Get author IDs from search engine (already sorted by relevance)
+    search_results = await search_service.search_authors(text, limit, offset)
+
+    if not search_results:
+        return []
+
+    author_ids = [result.get("id") for result in search_results if result.get("id")]
+    if not author_ids:
+        return []
+
+    # Fetch full author objects from DB
+    with local_session() as session:
+        # Simple query to get authors by IDs - no need for stats here
+        authors_query = select(Author).filter(Author.id.in_(author_ids))
+        db_authors = session.execute(authors_query).scalars().all()
+    
+    if not db_authors:
+        return []
+
+    # Create a dictionary for quick lookup
+    authors_dict = {str(author.id): author for author in db_authors}
+    
+    # Keep the order from search results (maintains the relevance sorting)
+    ordered_authors = [authors_dict[author_id] for author_id in author_ids if author_id in authors_dict]
+
+    return ordered_authors
+
+
 def get_author_id_from(slug="", user=None, author_id=None):
     try:
         author_id = None

resolvers/draft.py

@@ -1,7 +1,6 @@
 import time
-from operator import or_
+import trafilatura
-
+from sqlalchemy.orm import joinedload
-from sqlalchemy.sql import and_
 
 from cache.cache import (
     cache_author,
@@ -11,7 +10,7 @@ from cache.cache import (
     invalidate_shouts_cache,
 )
 from orm.author import Author
-from orm.draft import Draft
+from orm.draft import Draft, DraftAuthor, DraftTopic
 from orm.shout import Shout, ShoutAuthor, ShoutTopic
 from orm.topic import Topic
 from services.auth import login_required
@@ -19,35 +18,70 @@ from services.db import local_session
 from services.notify import notify_shout
 from services.schema import mutation, query
 from services.search import search_service
+from utils.html_wrapper import wrap_html_fragment
 from utils.logger import root_logger as logger
 
-
 def create_shout_from_draft(session, draft, author_id):
+    """
+    Создаёт новый объект публикации (Shout) на основе черновика.
+
+    Args:
+        session: SQLAlchemy сессия (не используется, для совместимости)
+        draft (Draft): Объект черновика
+        author_id (int): ID автора публикации
+
+    Returns:
+        Shout: Новый объект публикации (не сохранённый в базе)
+
+    Пример:
+        >>> from orm.draft import Draft
+        >>> draft = Draft(id=1, title='Заголовок', body='Текст', slug='slug', created_by=1)
+        >>> shout = create_shout_from_draft(None, draft, 1)
+        >>> shout.title
+        'Заголовок'
+        >>> shout.body
+        'Текст'
+        >>> shout.created_by
+        1
+    """
     # Создаем новую публикацию
     shout = Shout(
-        body=draft.body,
+        body=draft.body or "",
         slug=draft.slug,
         cover=draft.cover,
         cover_caption=draft.cover_caption,
         lead=draft.lead,
-        description=draft.description,
+        title=draft.title or "",
-        title=draft.title,
         subtitle=draft.subtitle,
-        layout=draft.layout,
+        layout=draft.layout or "article",
-        media=draft.media,
+        media=draft.media or [],
-        lang=draft.lang,
+        lang=draft.lang or "ru",
         seo=draft.seo,
         created_by=author_id,
         community=draft.community,
         draft=draft.id,
         deleted_at=None,
     )
+    
+    # Инициализируем пустые массивы для связей
+    shout.topics = []
+    shout.authors = []
+    
     return shout
 
 
 @query.field("load_drafts")
 @login_required
 async def load_drafts(_, info):
+    """
+    Загружает все черновики, доступные текущему пользователю.
+    
+    Предварительно загружает связанные объекты (topics, authors, publication),
+    чтобы избежать ошибок с отсоединенными объектами при сериализации.
+    
+    Returns:
+        dict: Список черновиков или сообщение об ошибке
+    """
     user_id = info.context.get("user_id")
     author_dict = info.context.get("author", {})
     author_id = author_dict.get("id")
@@ -55,13 +89,44 @@ async def load_drafts(_, info):
     if not user_id or not author_id:
         return {"error": "User ID and author ID are required"}
 
-    with local_session() as session:
+    try:
-        drafts = (
+        with local_session() as session:
-            session.query(Draft)
+            # Предзагружаем authors, topics и связанную publication
-            .filter(or_(Draft.authors.any(Author.id == author_id), Draft.created_by == author_id))
+            drafts_query = (
-            .all()
+                session.query(Draft)
-        )
+                .options(
-    return {"drafts": drafts}
+                    joinedload(Draft.topics),
+                    joinedload(Draft.authors),
+                    joinedload(Draft.publication) # Загружаем связанную публикацию
+                )
+                .filter(Draft.authors.any(Author.id == author_id))
+            )
+            drafts = drafts_query.all()
+            
+            # Преобразуем объекты в словари, пока они в контексте сессии
+            drafts_data = []
+            for draft in drafts:
+                draft_dict = draft.dict()
+                # Всегда возвращаем массив для topics, даже если он пустой
+                draft_dict["topics"] = [topic.dict() for topic in (draft.topics or [])]
+                draft_dict["authors"] = [author.dict() for author in (draft.authors or [])]
+                
+                # Добавляем информацию о публикации, если она есть
+                if draft.publication:
+                    draft_dict["publication"] = {
+                        "id": draft.publication.id,
+                        "slug": draft.publication.slug,
+                        "published_at": draft.publication.published_at
+                    }
+                else:
+                     draft_dict["publication"] = None
+                     
+                drafts_data.append(draft_dict)
+                
+            return {"drafts": drafts_data}
+    except Exception as e:
+        logger.error(f"Failed to load drafts: {e}", exc_info=True)
+        return {"error": f"Failed to load drafts: {str(e)}"}
 
 
 @mutation.field("create_draft")
@@ -105,23 +170,40 @@ async def create_draft(_, info, draft_input):
     if "title" not in draft_input or not draft_input["title"]:
         draft_input["title"] = ""  # Пустая строка вместо NULL
 
+    # Проверяем slug - он должен быть или не пустым, или не передаваться вообще
+    if "slug" in draft_input and (draft_input["slug"] is None or draft_input["slug"] == ""):
+        # При создании черновика удаляем пустой slug из входных данных
+        del draft_input["slug"]
+
     try:
         with local_session() as session:
             # Remove id from input if present since it's auto-generated
             if "id" in draft_input:
                 del draft_input["id"]
-
+                
-            # Добавляем текущее время создания
+            # Добавляем текущее время создания и ID автора
             draft_input["created_at"] = int(time.time())
-
+            draft_input["created_by"] = author_id
-            draft = Draft(created_by=author_id, **draft_input)
+            draft = Draft(**draft_input)
             session.add(draft)
+            session.flush()
+            
+            # Добавляем создателя как автора
+            da = DraftAuthor(shout=draft.id, author=author_id)
+            session.add(da)
+            
             session.commit()
             return {"draft": draft}
     except Exception as e:
         logger.error(f"Failed to create draft: {e}", exc_info=True)
         return {"error": f"Failed to create draft: {str(e)}"}
 
+def generate_teaser(body, limit=300):
+    body_html = wrap_html_fragment(body)
+    body_text = trafilatura.extract(body_html, include_comments=False, include_tables=False)
+    body_teaser = ". ".join(body_text[:limit].split(". ")[:-1])
+    return body_teaser
+
 
 @mutation.field("update_draft")
 @login_required
@@ -130,7 +212,21 @@ async def update_draft(_, info, draft_id: int, draft_input):
 
     Args:
         draft_id: ID черновика для обновления
-        draft_input: Данные для обновления черновика
+        draft_input: Данные для обновления черновика согласно схеме DraftInput:
+            - layout: String
+            - author_ids: [Int!]
+            - topic_ids: [Int!]
+            - main_topic_id: Int
+            - media: [MediaItemInput]
+            - lead: String
+            - subtitle: String
+            - lang: String
+            - seo: String
+            - body: String
+            - title: String
+            - slug: String
+            - cover: String
+            - cover_caption: String
 
     Returns:
         dict: Обновленный черновик или сообщение об ошибке
@@ -142,15 +238,89 @@ async def update_draft(_, info, draft_id: int, draft_input):
     if not user_id or not author_id:
         return {"error": "Author ID are required"}
 
-    with local_session() as session:
+    try:
-        draft = session.query(Draft).filter(Draft.id == draft_id).first()
+        with local_session() as session:
-        if not draft:
+            draft = session.query(Draft).filter(Draft.id == draft_id).first()
-            return {"error": "Draft not found"}
+            if not draft:
+                return {"error": "Draft not found"}
 
-        Draft.update(draft, draft_input)
+            # Фильтруем входные данные, оставляя только разрешенные поля
-        draft.updated_at = int(time.time())
+            allowed_fields = {
-        session.commit()
+                "layout", "author_ids", "topic_ids", "main_topic_id", 
-        return {"draft": draft}
+                "media", "lead", "subtitle", "lang", "seo", "body", 
+                "title", "slug", "cover", "cover_caption"
+            }
+            filtered_input = {k: v for k, v in draft_input.items() if k in allowed_fields}
+
+            # Проверяем slug
+            if "slug" in filtered_input and not filtered_input["slug"]:
+                del filtered_input["slug"]
+
+            # Обновляем связи с авторами если переданы
+            if "author_ids" in filtered_input:
+                author_ids = filtered_input.pop("author_ids")
+                if author_ids:
+                    # Очищаем текущие связи
+                    session.query(DraftAuthor).filter(DraftAuthor.shout == draft_id).delete()
+                    # Добавляем новые связи
+                    for aid in author_ids:
+                        da = DraftAuthor(shout=draft_id, author=aid)
+                        session.add(da)
+
+            # Обновляем связи с темами если переданы
+            if "topic_ids" in filtered_input:
+                topic_ids = filtered_input.pop("topic_ids")
+                main_topic_id = filtered_input.pop("main_topic_id", None)
+                if topic_ids:
+                    # Очищаем текущие связи
+                    session.query(DraftTopic).filter(DraftTopic.shout == draft_id).delete()
+                    # Добавляем новые связи
+                    for tid in topic_ids:
+                        dt = DraftTopic(
+                            shout=draft_id, 
+                            topic=tid,
+                            main=(tid == main_topic_id) if main_topic_id else False
+                        )
+                        session.add(dt)
+
+            # Генерируем SEO если не предоставлено
+            if "seo" not in filtered_input and not draft.seo:
+                body_src = filtered_input.get("body", draft.body)
+                lead_src = filtered_input.get("lead", draft.lead)
+                body_html = wrap_html_fragment(body_src)
+                lead_html = wrap_html_fragment(lead_src)
+                
+                try:
+                    body_text = trafilatura.extract(body_html, include_comments=False, include_tables=False) if body_src else None
+                    lead_text = trafilatura.extract(lead_html, include_comments=False, include_tables=False) if lead_src else None
+                    
+                    body_teaser = generate_teaser(body_text, 300) if body_text else ""
+                    filtered_input["seo"] = lead_text if lead_text else body_teaser
+                except Exception as e:
+                    logger.warning(f"Failed to generate SEO for draft {draft_id}: {e}")
+
+            # Обновляем основные поля черновика
+            for key, value in filtered_input.items():
+                setattr(draft, key, value)
+
+            # Обновляем метаданные
+            draft.updated_at = int(time.time())
+            draft.updated_by = author_id
+
+            session.commit()
+            
+            # Преобразуем объект в словарь для ответа
+            draft_dict = draft.dict()
+            draft_dict["topics"] = [topic.dict() for topic in draft.topics]
+            draft_dict["authors"] = [author.dict() for author in draft.authors]
+            # Добавляем объект автора в updated_by
+            draft_dict["updated_by"] = author_dict
+            
+            return {"draft": draft_dict}
+
+    except Exception as e:
+        logger.error(f"Failed to update draft: {e}", exc_info=True)
+        return {"error": f"Failed to update draft: {str(e)}"}
 
 
 @mutation.field("delete_draft")
@@ -170,183 +340,136 @@ async def delete_draft(_, info, draft_id: int):
         return {"draft": draft}
 
 
+def validate_html_content(html_content: str) -> tuple[bool, str]:
+    """
+    Проверяет валидность HTML контента через trafilatura.
+    
+    Args:
+        html_content: HTML строка для проверки
+        
+    Returns:
+        tuple[bool, str]: (валидность, сообщение об ошибке)
+        
+    Example:
+        >>> is_valid, error = validate_html_content("<p>Valid HTML</p>")
+        >>> is_valid
+        True
+        >>> error
+        ''
+        >>> is_valid, error = validate_html_content("Invalid < HTML")
+        >>> is_valid
+        False
+        >>> 'Invalid HTML' in error
+        True
+    """
+    if not html_content or not html_content.strip():
+        return False, "Content is empty"
+        
+    try:
+        html_content = wrap_html_fragment(html_content)
+        extracted = trafilatura.extract(html_content)
+        if not extracted:
+            return False, "Invalid HTML structure or empty content"
+        return True, ""
+    except Exception as e:
+        logger.error(f"HTML validation error: {e}", exc_info=True)
+        return False, f"Invalid HTML content: {str(e)}"
+
+
 @mutation.field("publish_draft")
 @login_required
 async def publish_draft(_, info, draft_id: int):
-    user_id = info.context.get("user_id")
+    """
-    author_dict = info.context.get("author", {})
+    Публикует черновик, создавая новый Shout или обновляя существующий.
-    author_id = author_dict.get("id")
+    
-    if not user_id or not author_id:
-        return {"error": "User ID and author ID are required"}
-
-    with local_session() as session:
-        draft = session.query(Draft).filter(Draft.id == draft_id).first()
-        if not draft:
-            return {"error": "Draft not found"}
-        shout = create_shout_from_draft(session, draft, author_id)
-        session.add(shout)
-        session.commit()
-        return {"shout": shout, "draft": draft}
-
-
-@mutation.field("unpublish_draft")
-@login_required
-async def unpublish_draft(_, info, draft_id: int):
-    user_id = info.context.get("user_id")
-    author_dict = info.context.get("author", {})
-    author_id = author_dict.get("id")
-    if not user_id or not author_id:
-        return {"error": "User ID and author ID are required"}
-
-    with local_session() as session:
-        draft = session.query(Draft).filter(Draft.id == draft_id).first()
-        if not draft:
-            return {"error": "Draft not found"}
-        shout = session.query(Shout).filter(Shout.draft == draft.id).first()
-        if shout:
-            shout.published_at = None
-            session.commit()
-            return {"shout": shout, "draft": draft}
-        return {"error": "Failed to unpublish draft"}
-
-
-@mutation.field("publish_shout")
-@login_required
-async def publish_shout(_, info, shout_id: int):
-    """Publish draft as a shout or update existing shout.
-
     Args:
-        shout_id: ID существующей публикации или 0 для новой
+        draft_id (int): ID черновика для публикации
-        draft: Объект черновика (опционально)
+        
+    Returns:
+        dict: Результат публикации с shout или сообщением об ошибке
     """
     user_id = info.context.get("user_id")
     author_dict = info.context.get("author", {})
     author_id = author_dict.get("id")
-    now = int(time.time())
+
     if not user_id or not author_id:
-        return {"error": "User ID and author ID are required"}
+        return {"error": "Author ID is required"}
 
     try:
         with local_session() as session:
-            shout = session.query(Shout).filter(Shout.id == shout_id).first()
+            # Загружаем черновик со всеми связями
-            if not shout:
+            draft = (
-                return {"error": "Shout not found"}
+                session.query(Draft)
-            was_published = shout.published_at is not None
+                .options(
-            draft = session.query(Draft).where(Draft.id == shout.draft).first()
+                    joinedload(Draft.topics),
+                    joinedload(Draft.authors),
+                    joinedload(Draft.publication)
+                )
+                .filter(Draft.id == draft_id)
+                .first()
+            )
+
             if not draft:
                 return {"error": "Draft not found"}
-            # Находим черновик если не передан
 
-            if not shout:
+            # Проверка валидности HTML в body
-                shout = create_shout_from_draft(session, draft, author_id)
+            is_valid, error = validate_html_content(draft.body)
-            else:
+            if not is_valid:
+                return {"error": f"Cannot publish draft: {error}"}
+
+            # Проверяем, есть ли уже публикация для этого черновика
+            if draft.publication:
+                shout = draft.publication
                 # Обновляем существующую публикацию
-                shout.draft = draft.id
+                for field in ["body", "title", "subtitle", "lead", "cover", "cover_caption", "media", "lang", "seo"]:
-                shout.created_by = author_id
+                    if hasattr(draft, field):
-                shout.title = draft.title
+                        setattr(shout, field, getattr(draft, field))
-                shout.subtitle = draft.subtitle
+                shout.updated_at = int(time.time())
-                shout.body = draft.body
+                shout.updated_by = author_id
-                shout.cover = draft.cover
+            else:
-                shout.cover_caption = draft.cover_caption
+                # Создаем новую публикацию
-                shout.lead = draft.lead
+                shout = create_shout_from_draft(session, draft, author_id)
-                shout.description = draft.description
+                now = int(time.time())
-                shout.layout = draft.layout
+                shout.created_at = now
-                shout.media = draft.media
+                shout.published_at = now
-                shout.lang = draft.lang
+                session.add(shout)
-                shout.seo = draft.seo
+                session.flush()  # Получаем ID нового шаута
 
-                draft.updated_at = now
+            # Очищаем существующие связи
-                shout.updated_at = now
+            session.query(ShoutAuthor).filter(ShoutAuthor.shout == shout.id).delete()
+            session.query(ShoutTopic).filter(ShoutTopic.shout == shout.id).delete()
 
-                # Устанавливаем published_at только если была ранее снята с публикации
+            # Добавляем авторов
-                if not was_published:
+            for author in (draft.authors or []):
-                    shout.published_at = now
+                sa = ShoutAuthor(shout=shout.id, author=author.id)
-
-            # Обрабатываем связи с авторами
-            if (
-                not session.query(ShoutAuthor)
-                .filter(and_(ShoutAuthor.shout == shout.id, ShoutAuthor.author == author_id))
-                .first()
-            ):
-                sa = ShoutAuthor(shout=shout.id, author=author_id)
                 session.add(sa)
 
-            # Обрабатываем темы
+            # Добавляем темы
-            if draft.topics:
+            for topic in (draft.topics or []):
-                for topic in draft.topics:
+                st = ShoutTopic(
-                    st = ShoutTopic(
+                    topic=topic.id,
-                        topic=topic.id, shout=shout.id, main=topic.main if hasattr(topic, "main") else False
+                    shout=shout.id,
-                    )
+                    main=topic.main if hasattr(topic, "main") else False
-                    session.add(st)
+                )
-
+                session.add(st)
-            session.add(shout)
-            session.add(draft)
-            session.flush()
-
-            # Инвалидируем кэш только если это новая публикация или была снята с публикации
-            if not was_published:
-                cache_keys = ["feed", f"author_{author_id}", "random_top", "unrated"]
-
-                # Добавляем ключи для тем
-                for topic in shout.topics:
-                    cache_keys.append(f"topic_{topic.id}")
-                    cache_keys.append(f"topic_shouts_{topic.id}")
-                    await cache_by_id(Topic, topic.id, cache_topic)
-
-                # Инвалидируем кэш
-                await invalidate_shouts_cache(cache_keys)
-                await invalidate_shout_related_cache(shout, author_id)
-
-                # Обновляем кэш авторов
-                for author in shout.authors:
-                    await cache_by_id(Author, author.id, cache_author)
-
-                # Отправляем уведомление о публикации
-                await notify_shout(shout.dict(), "published")
-
-                # Обновляем поисковый индекс
-                search_service.index(shout)
-            else:
-                # Для уже опубликованных материалов просто отправляем уведомление об обновлении
-                await notify_shout(shout.dict(), "update")
 
             session.commit()
+
+            # Инвалидируем кеш
+            invalidate_shouts_cache()
+            invalidate_shout_related_cache(shout.id)
+
+            # Уведомляем о публикации
+            await notify_shout(shout.id)
+
+            # Обновляем поисковый индекс
+            search_service.index_shout(shout)
+
+            logger.info(f"Successfully published shout #{shout.id} from draft #{draft_id}")
+            logger.debug(f"Shout data: {shout.dict()}")
+
             return {"shout": shout}
 
     except Exception as e:
-        logger.error(f"Failed to publish shout: {e}", exc_info=True)
+        logger.error(f"Failed to publish draft {draft_id}: {e}", exc_info=True)
-        if "session" in locals():
+        return {"error": f"Failed to publish draft: {str(e)}"}
-            session.rollback()
-        return {"error": f"Failed to publish shout: {str(e)}"}
-
-
-@mutation.field("unpublish_shout")
-@login_required
-async def unpublish_shout(_, info, shout_id: int):
-    """Unpublish a shout.
-
-    Args:
-        shout_id: The ID of the shout to unpublish
-
-    Returns:
-        dict: The unpublished shout or an error message
-    """
-    author_dict = info.context.get("author", {})
-    author_id = author_dict.get("id")
-    if not author_id:
-        return {"error": "Author ID is required"}
-
-    shout = None
-    with local_session() as session:
-        try:
-            shout = session.query(Shout).filter(Shout.id == shout_id).first()
-            shout.published_at = None
-            session.commit()
-            invalidate_shout_related_cache(shout)
-            invalidate_shouts_cache()
-
-        except Exception:
-            session.rollback()
-            return {"error": "Failed to unpublish shout"}
-
-    return {"shout": shout}

resolvers/editor.py

@@ -1,8 +1,9 @@
 import time
 
 import orjson
+import trafilatura
 from sqlalchemy import and_, desc, select
-from sqlalchemy.orm import joinedload
+from sqlalchemy.orm import joinedload, selectinload
 from sqlalchemy.sql.functions import coalesce
 
 from cache.cache import (
@@ -12,6 +13,7 @@ from cache.cache import (
     invalidate_shouts_cache,
 )
 from orm.author import Author
+from orm.draft import Draft
 from orm.shout import Shout, ShoutAuthor, ShoutTopic
 from orm.topic import Topic
 from resolvers.follower import follow, unfollow
@@ -19,8 +21,9 @@ from resolvers.stat import get_with_stat
 from services.auth import login_required
 from services.db import local_session
 from services.notify import notify_shout
-from services.schema import query
+from services.schema import mutation, query
 from services.search import search_service
+from utils.html_wrapper import wrap_html_fragment
 from utils.logger import root_logger as logger
 
 
@@ -176,9 +179,18 @@ async def create_shout(_, info, inp):
 
                 logger.info(f"Creating shout with input: {inp}")
                 # Создаем публикацию без topics
+                body = inp.get("body", "")
+                lead = inp.get("lead", "")
+                body_html = wrap_html_fragment(body)
+                lead_html = wrap_html_fragment(lead)
+                body_text = trafilatura.extract(body_html)
+                lead_text = trafilatura.extract(lead_html)
+                seo = inp.get("seo", lead_text.strip() or body_text.strip()[:300].split(". ")[:-1].join(". "))
                 new_shout = Shout(
                     slug=slug,
-                    body=inp.get("body", ""),
+                    body=body,
+                    seo=seo,
+                    lead=lead,
                     layout=inp.get("layout", "article"),
                     title=inp.get("title", ""),
                     created_by=author_id,
@@ -380,7 +392,7 @@ def patch_topics(session, shout, topics_input):
 # @login_required
 async def update_shout(_, info, shout_id: int, shout_input=None, publish=False):
     logger.info(f"Starting update_shout with id={shout_id}, publish={publish}")
-    logger.debug(f"Full shout_input: {shout_input}")
+    logger.debug(f"Full shout_input: {shout_input}")  # DraftInput
 
     user_id = info.context.get("user_id")
     roles = info.context.get("roles", [])
@@ -637,39 +649,178 @@ def get_main_topic(topics):
     """Get the main topic from a list of ShoutTopic objects."""
     logger.info(f"Starting get_main_topic with {len(topics) if topics else 0} topics")
     logger.debug(
-        f"Topics data: {[(t.topic.slug if t.topic else 'no-topic', t.main) for t in topics] if topics else []}"
+        f"Topics data: {[(t.slug, getattr(t, 'main', False)) for t in topics] if topics else []}"
     )
 
     if not topics:
         logger.warning("No topics provided to get_main_topic")
         return {"id": 0, "title": "no topic", "slug": "notopic", "is_main": True}
 
-    # Find first main topic in original order
+    # Проверяем, является ли topics списком объектов ShoutTopic или Topic
-    main_topic_rel = next((st for st in topics if st.main), None)
+    if hasattr(topics[0], 'topic') and topics[0].topic:
-    logger.debug(
+        # Для ShoutTopic объектов (старый формат)
-        f"Found main topic relation: {main_topic_rel.topic.slug if main_topic_rel and main_topic_rel.topic else None}"
+        # Find first main topic in original order
-    )
+        main_topic_rel = next((st for st in topics if getattr(st, 'main', False)), None)
+        logger.debug(
+            f"Found main topic relation: {main_topic_rel.topic.slug if main_topic_rel and main_topic_rel.topic else None}"
+        )
 
-    if main_topic_rel and main_topic_rel.topic:
+        if main_topic_rel and main_topic_rel.topic:
-        result = {
+            result = {
-            "slug": main_topic_rel.topic.slug,
+                "slug": main_topic_rel.topic.slug,
-            "title": main_topic_rel.topic.title,
+                "title": main_topic_rel.topic.title,
-            "id": main_topic_rel.topic.id,
+                "id": main_topic_rel.topic.id,
-            "is_main": True,
+                "is_main": True,
-        }
+            }
-        logger.info(f"Returning main topic: {result}")
+            logger.info(f"Returning main topic: {result}")
-        return result
+            return result
 
-    # If no main found but topics exist, return first
+        # If no main found but topics exist, return first
-    if topics and topics[0].topic:
+        if topics and topics[0].topic:
-        logger.info(f"No main topic found, using first topic: {topics[0].topic.slug}")
+            logger.info(f"No main topic found, using first topic: {topics[0].topic.slug}")
-        result = {
+            result = {
-            "slug": topics[0].topic.slug,
+                "slug": topics[0].topic.slug,
-            "title": topics[0].topic.title,
+                "title": topics[0].topic.title,
-            "id": topics[0].topic.id,
+                "id": topics[0].topic.id,
-            "is_main": True,
+                "is_main": True,
-        }
+            }
-        return result
+            return result
+    else:
+        # Для Topic объектов (новый формат из selectinload)
+        # После смены на selectinload у нас просто список Topic объектов
+        if topics:
+            logger.info(f"Using first topic as main: {topics[0].slug}")
+            result = {
+                "slug": topics[0].slug,
+                "title": topics[0].title,
+                "id": topics[0].id,
+                "is_main": True,
+            }
+            return result
 
     logger.warning("No valid topics found, returning default")
     return {"slug": "notopic", "title": "no topic", "id": 0, "is_main": True}
+
+@mutation.field("unpublish_shout")
+@login_required
+async def unpublish_shout(_, info, shout_id: int):
+    """Снимает публикацию (shout) с публикации.
+
+    Предзагружает связанный черновик (draft) и его авторов/темы, чтобы избежать
+    ошибок при последующем доступе к ним в GraphQL.
+
+    Args:
+        shout_id: ID публикации для снятия с публикации
+
+    Returns:
+        dict: Снятая с публикации публикация или сообщение об ошибке
+    """
+    author_dict = info.context.get("author", {})
+    author_id = author_dict.get("id")
+    if not author_id:
+        # В идеале нужна проверка прав, имеет ли автор право снимать публикацию
+        return {"error": "Author ID is required"}
+
+    shout = None
+    with local_session() as session:
+        try:
+            # Загружаем Shout со всеми связями для правильного формирования ответа
+            shout = (
+                session.query(Shout)
+                .options(
+                    joinedload(Shout.authors),
+                    selectinload(Shout.topics)
+                )
+                .filter(Shout.id == shout_id)
+                .first()
+            )
+            
+            if not shout:
+                 logger.warning(f"Shout not found for unpublish: ID {shout_id}")
+                 return {"error": "Shout not found"} 
+            
+            # Если у публикации есть связанный черновик, загружаем его с relationships
+            if shout.draft:
+                # Отдельно загружаем черновик с его связями
+                draft = (
+                    session.query(Draft)
+                    .options(
+                        selectinload(Draft.authors),
+                        selectinload(Draft.topics)
+                    )
+                    .filter(Draft.id == shout.draft)
+                    .first()
+                )
+                
+                # Связываем черновик с публикацией вручную для доступа через API
+                if draft:
+                    shout.draft_obj = draft
+
+            # TODO: Добавить проверку прав доступа, если необходимо
+            # if author_id not in [a.id for a in shout.authors]: # Требует selectinload(Shout.authors) выше
+            #    logger.warning(f"Author {author_id} denied unpublishing shout {shout_id}")
+            #    return {"error": "Access denied"}
+
+            # Запоминаем старый slug и id для формирования поля publication
+            shout_slug = shout.slug
+            shout_id_for_publication = shout.id
+
+            # Снимаем с публикации (устанавливаем published_at в None)
+            shout.published_at = None
+            session.commit()
+            
+            # Формируем полноценный словарь для ответа
+            shout_dict = shout.dict()
+            
+            # Добавляем связанные данные
+            shout_dict["topics"] = (
+                [
+                    {"id": topic.id, "slug": topic.slug, "title": topic.title}
+                    for topic in shout.topics
+                ]
+                if shout.topics
+                else []
+            )
+            
+            # Добавляем main_topic 
+            shout_dict["main_topic"] = get_main_topic(shout.topics)
+            
+            # Добавляем авторов
+            shout_dict["authors"] = (
+                [
+                    {"id": author.id, "name": author.name, "slug": author.slug}
+                    for author in shout.authors
+                ]
+                if shout.authors
+                else []
+            )
+            
+            # Важно! Обновляем поле publication, отражая состояние "снят с публикации"
+            shout_dict["publication"] = {
+                "id": shout_id_for_publication,
+                "slug": shout_slug,
+                "published_at": None  # Ключевое изменение - устанавливаем published_at в None
+            }
+
+            # Инвалидация кэша
+            try:
+                cache_keys = [
+                    "feed",  # лента
+                    f"author_{author_id}",  # публикации автора
+                    "random_top",  # случайные топовые
+                    "unrated",  # неоцененные
+                ]
+                await invalidate_shout_related_cache(shout, author_id) 
+                await invalidate_shouts_cache(cache_keys)
+                logger.info(f"Cache invalidated after unpublishing shout {shout_id}")
+            except Exception as cache_err:
+                 logger.error(f"Failed to invalidate cache for unpublish shout {shout_id}: {cache_err}")
+
+        except Exception as e: 
+            session.rollback()
+            logger.error(f"Failed to unpublish shout {shout_id}: {e}", exc_info=True) 
+            return {"error": f"Failed to unpublish shout: {str(e)}"}
+
+    # Возвращаем сформированный словарь вместо объекта
+    logger.info(f"Shout {shout_id} unpublished successfully by author {author_id}")
+    return {"shout": shout_dict}

resolvers/reaction.py

@@ -67,30 +67,35 @@ def add_reaction_stat_columns(q):
     return q
 
 
-def get_reactions_with_stat(q, limit, offset):
+def get_reactions_with_stat(q, limit=10, offset=0):
     """
     Execute the reaction query and retrieve reactions with statistics.
 
     :param q: Query with reactions and statistics.
     :param limit: Number of reactions to load.
     :param offset: Pagination offset.
-    :return: List of reactions.
+    :return: List of reactions as dictionaries.
+
+    >>> get_reactions_with_stat(q, 10, 0)  # doctest: +SKIP
+    [{'id': 1, 'body': 'Текст комментария', 'stat': {'rating': 5, 'comments_count': 3}, ...}]
     """
     q = q.limit(limit).offset(offset)
     reactions = []
 
     with local_session() as session:
         result_rows = session.execute(q)
-        for reaction, author, shout, commented_stat, rating_stat in result_rows:
+        for reaction, author, shout, comments_count, rating_stat in result_rows:
             # Пропускаем реакции с отсутствующими shout или author
             if not shout or not author:
                 logger.error(f"Пропущена реакция из-за отсутствия shout или author: {reaction.dict()}")
                 continue
 
-            reaction.created_by = author.dict()
+            # Преобразуем Reaction в словарь для доступа по ключу
-            reaction.shout = shout.dict()
+            reaction_dict = reaction.dict()
-            reaction.stat = {"rating": rating_stat, "comments": commented_stat}
+            reaction_dict["created_by"] = author.dict()
-            reactions.append(reaction)
+            reaction_dict["shout"] = shout.dict()
+            reaction_dict["stat"] = {"rating": rating_stat, "comments_count": comments_count}
+            reactions.append(reaction_dict)
 
     return reactions
 
@@ -393,7 +398,7 @@ async def update_reaction(_, info, reaction):
 
             result = session.execute(reaction_query).unique().first()
             if result:
-                r, author, _shout, commented_stat, rating_stat = result
+                r, author, _shout, comments_count, rating_stat = result
                 if not r or not author:
                     return {"error": "Invalid reaction ID or unauthorized"}
 
@@ -408,7 +413,7 @@ async def update_reaction(_, info, reaction):
                 session.commit()
 
                 r.stat = {
-                    "commented": commented_stat,
+                    "comments_count": comments_count,
                     "rating": rating_stat,
                 }
 
@@ -482,12 +487,16 @@ def apply_reaction_filters(by, q):
     shout_slug = by.get("shout")
     if shout_slug:
         q = q.filter(Shout.slug == shout_slug)
+    
+    shout_id = by.get("shout_id")
+    if shout_id:
+        q = q.filter(Shout.id == shout_id)
 
     shouts = by.get("shouts")
     if shouts:
         q = q.filter(Shout.slug.in_(shouts))
 
-    created_by = by.get("created_by")
+    created_by = by.get("created_by", by.get("author_id"))
     if created_by:
         q = q.filter(Author.id == created_by)
 
@@ -612,24 +621,22 @@ async def load_shout_comments(_, info, shout: int, limit=50, offset=0):
 @query.field("load_comment_ratings")
 async def load_comment_ratings(_, info, comment: int, limit=50, offset=0):
     """
-    Load ratings for a specified comment with pagination and statistics.
+    Load ratings for a specified comment with pagination.
 
     :param info: GraphQL context info.
     :param comment: Comment ID.
     :param limit: Number of ratings to load.
     :param offset: Pagination offset.
-    :return: List of reactions.
+    :return: List of ratings.
     """
     q = query_reactions()
 
-    q = add_reaction_stat_columns(q)
-
     # Filter, group, sort, limit, offset
     q = q.filter(
         and_(
             Reaction.deleted_at.is_(None),
             Reaction.reply_to == comment,
-            Reaction.kind == ReactionKind.COMMENT.value,
+            Reaction.kind.in_(RATING_REACTIONS),
         )
     )
     q = q.group_by(Reaction.id, Author.id, Shout.id)
@@ -637,3 +644,187 @@ async def load_comment_ratings(_, info, comment: int, limit=50, offset=0):
 
     # Retrieve and return reactions
     return get_reactions_with_stat(q, limit, offset)
+
+
+@query.field("load_comments_branch")
+async def load_comments_branch(
+    _,
+    _info,
+    shout: int,
+    parent_id: int | None = None,
+    limit=10,
+    offset=0,
+    sort="newest",
+    children_limit=3,
+    children_offset=0,
+):
+    """
+    Загружает иерархические комментарии с возможностью пагинации корневых и дочерних.
+
+    :param info: GraphQL context info.
+    :param shout: ID статьи.
+    :param parent_id: ID родительского комментария (None для корневых).
+    :param limit: Количество комментариев для загрузки.
+    :param offset: Смещение для пагинации.
+    :param sort: Порядок сортировки ('newest', 'oldest', 'like').
+    :param children_limit: Максимальное количество дочерних комментариев.
+    :param children_offset: Смещение для дочерних комментариев.
+    :return: Список комментариев с дочерними.
+    """
+    # Создаем базовый запрос
+    q = query_reactions()
+    q = add_reaction_stat_columns(q)
+
+    # Фильтруем по статье и типу (комментарии)
+    q = q.filter(
+        and_(
+            Reaction.deleted_at.is_(None),
+            Reaction.shout == shout,
+            Reaction.kind == ReactionKind.COMMENT.value,
+        )
+    )
+
+    # Фильтруем по родительскому ID
+    if parent_id is None:
+        # Загружаем только корневые комментарии
+        q = q.filter(Reaction.reply_to.is_(None))
+    else:
+        # Загружаем только прямые ответы на указанный комментарий
+        q = q.filter(Reaction.reply_to == parent_id)
+
+    # Сортировка и группировка
+    q = q.group_by(Reaction.id, Author.id, Shout.id)
+
+    # Определяем сортировку
+    order_by_stmt = None
+    if sort.lower() == "oldest":
+        order_by_stmt = asc(Reaction.created_at)
+    elif sort.lower() == "like":
+        order_by_stmt = desc("rating_stat")
+    else:  # "newest" по умолчанию
+        order_by_stmt = desc(Reaction.created_at)
+
+    q = q.order_by(order_by_stmt)
+
+    # Выполняем запрос для получения комментариев
+    comments = get_reactions_with_stat(q, limit, offset)
+
+    # Если комментарии найдены, загружаем дочерние и количество ответов
+    if comments:
+        # Загружаем количество ответов для каждого комментария
+        await load_replies_count(comments)
+
+        # Загружаем дочерние комментарии
+        await load_first_replies(comments, children_limit, children_offset, sort)
+
+    return comments
+
+
+async def load_replies_count(comments):
+    """
+    Загружает количество ответов для списка комментариев и обновляет поле stat.comments_count.
+
+    :param comments: Список комментариев, для которых нужно загрузить количество ответов.
+    """
+    if not comments:
+        return
+
+    comment_ids = [comment["id"] for comment in comments]
+
+    # Запрос для подсчета количества ответов
+    q = (
+        select(Reaction.reply_to.label("parent_id"), func.count().label("count"))
+        .where(
+            and_(
+                Reaction.reply_to.in_(comment_ids),
+                Reaction.deleted_at.is_(None),
+                Reaction.kind == ReactionKind.COMMENT.value,
+            )
+        )
+        .group_by(Reaction.reply_to)
+    )
+
+    # Выполняем запрос
+    with local_session() as session:
+        result = session.execute(q).fetchall()
+
+    # Создаем словарь {parent_id: count}
+    replies_count = {row[0]: row[1] for row in result}
+
+    # Добавляем значения в комментарии
+    for comment in comments:
+        if "stat" not in comment:
+            comment["stat"] = {}
+
+        # Обновляем счетчик комментариев в stat
+        comment["stat"]["comments_count"] = replies_count.get(comment["id"], 0)
+
+
+async def load_first_replies(comments, limit, offset, sort="newest"):
+    """
+    Загружает первые N ответов для каждого комментария.
+
+    :param comments: Список комментариев, для которых нужно загрузить ответы.
+    :param limit: Максимальное количество ответов для каждого комментария.
+    :param offset: Смещение для пагинации дочерних комментариев.
+    :param sort: Порядок сортировки ответов.
+    """
+    if not comments or limit <= 0:
+        return
+
+    # Собираем ID комментариев
+    comment_ids = [comment["id"] for comment in comments]
+
+    # Базовый запрос для загрузки ответов
+    q = query_reactions()
+    q = add_reaction_stat_columns(q)
+
+    # Фильтрация: только ответы на указанные комментарии
+    q = q.filter(
+        and_(
+            Reaction.reply_to.in_(comment_ids),
+            Reaction.deleted_at.is_(None),
+            Reaction.kind == ReactionKind.COMMENT.value,
+        )
+    )
+
+    # Группировка
+    q = q.group_by(Reaction.id, Author.id, Shout.id)
+
+    # Определяем сортировку
+    order_by_stmt = None
+    if sort.lower() == "oldest":
+        order_by_stmt = asc(Reaction.created_at)
+    elif sort.lower() == "like":
+        order_by_stmt = desc("rating_stat")
+    else:  # "newest" по умолчанию
+        order_by_stmt = desc(Reaction.created_at)
+
+    q = q.order_by(order_by_stmt, Reaction.reply_to)
+
+    # Выполняем запрос - указываем limit для неограниченного количества ответов
+    # но не более 100 на родительский комментарий
+    replies = get_reactions_with_stat(q, limit=100, offset=0)
+
+    # Группируем ответы по родительским ID
+    replies_by_parent = {}
+    for reply in replies:
+        parent_id = reply.get("reply_to")
+        if parent_id not in replies_by_parent:
+            replies_by_parent[parent_id] = []
+        replies_by_parent[parent_id].append(reply)
+
+    # Добавляем ответы к соответствующим комментариям с учетом смещения и лимита
+    for comment in comments:
+        comment_id = comment["id"]
+        if comment_id in replies_by_parent:
+            parent_replies = replies_by_parent[comment_id]
+            # Применяем смещение и лимит
+            comment["first_replies"] = parent_replies[offset : offset + limit]
+        else:
+            comment["first_replies"] = []
+
+    # Загружаем количество ответов для дочерних комментариев
+    all_replies = [reply for replies in replies_by_parent.values() for reply in replies]
+    if all_replies:
+        await load_replies_count(all_replies)

resolvers/reader.py

@@ -10,7 +10,7 @@ from orm.shout import Shout, ShoutAuthor, ShoutTopic
 from orm.topic import Topic
 from services.db import json_array_builder, json_builder, local_session
 from services.schema import query
-from services.search import search_text
+from services.search import search_text, get_search_count
 from services.viewed import ViewedStorage
 from utils.logger import root_logger as logger
 
@@ -187,12 +187,10 @@ def get_shouts_with_links(info, q, limit=20, offset=0):
     """
     shouts = []
     try:
-        # logger.info(f"Starting get_shouts_with_links with limit={limit}, offset={offset}")
         q = q.limit(limit).offset(offset)
 
         with local_session() as session:
             shouts_result = session.execute(q).all()
-            # logger.info(f"Got {len(shouts_result) if shouts_result else 0} shouts from query")
 
             if not shouts_result:
                 logger.warning("No shouts found in query result")
@@ -203,7 +201,6 @@ def get_shouts_with_links(info, q, limit=20, offset=0):
                     shout = None
                     if hasattr(row, "Shout"):
                         shout = row.Shout
-                        # logger.debug(f"Processing shout#{shout.id} at index {idx}")
                     if shout:
                         shout_id = int(f"{shout.id}")
                         shout_dict = shout.dict()
@@ -225,26 +222,22 @@ def get_shouts_with_links(info, q, limit=20, offset=0):
                             elif isinstance(row.stat, dict):
                                 stat = row.stat
                             viewed = ViewedStorage.get_shout(shout_id=shout_id) or 0
-                            shout_dict["stat"] = {**stat, "viewed": viewed, "commented": stat.get("comments_count", 0)}
+                            shout_dict["stat"] = {**stat, "viewed": viewed}
 
                         # Обработка main_topic и topics
                         topics = None
                         if has_field(info, "topics") and hasattr(row, "topics"):
                             topics = orjson.loads(row.topics) if isinstance(row.topics, str) else row.topics
-                            # logger.debug(f"Shout#{shout_id} topics: {topics}")
                             shout_dict["topics"] = topics
 
                         if has_field(info, "main_topic"):
                             main_topic = None
                             if hasattr(row, "main_topic"):
-                                # logger.debug(f"Raw main_topic for shout#{shout_id}: {row.main_topic}")
                                 main_topic = (
                                     orjson.loads(row.main_topic) if isinstance(row.main_topic, str) else row.main_topic
                                 )
-                                # logger.debug(f"Parsed main_topic for shout#{shout_id}: {main_topic}")
 
                             if not main_topic and topics and len(topics) > 0:
-                                # logger.info(f"No main_topic found for shout#{shout_id}, using first topic from list")
                                 main_topic = {
                                     "id": topics[0]["id"],
                                     "title": topics[0]["title"],
@@ -252,10 +245,8 @@ def get_shouts_with_links(info, q, limit=20, offset=0):
                                     "is_main": True,
                                 }
                             elif not main_topic:
-                                logger.warning(f"No main_topic and no topics found for shout#{shout_id}")
                                 main_topic = {"id": 0, "title": "no topic", "slug": "notopic", "is_main": True}
                             shout_dict["main_topic"] = main_topic
-                            # logger.debug(f"Final main_topic for shout#{shout_id}: {main_topic}")
 
                         if has_field(info, "authors") and hasattr(row, "authors"):
                             shout_dict["authors"] = (
@@ -282,7 +273,6 @@ def get_shouts_with_links(info, q, limit=20, offset=0):
         logger.error(f"Fatal error in get_shouts_with_links: {e}", exc_info=True)
         raise
     finally:
-        logger.info(f"Returning {len(shouts)} shouts from get_shouts_with_links")
         return shouts
 
 
@@ -401,33 +391,49 @@ async def load_shouts_search(_, info, text, options):
     """
     limit = options.get("limit", 10)
     offset = options.get("offset", 0)
+    
     if isinstance(text, str) and len(text) > 2:
+        # Get search results with pagination
         results = await search_text(text, limit, offset)
-        scores = {}
+        
-        hits_ids = []
+        if not results:
-        for sr in results:
+            logger.info(f"No search results found for '{text}'")
-            shout_id = sr.get("id")
+            return []
-            if shout_id:
+        
-                shout_id = str(shout_id)
+        # Extract IDs in the order from the search engine
-                scores[shout_id] = sr.get("score")
+        hits_ids = [str(sr.get("id")) for sr in results if sr.get("id")]
-                hits_ids.append(shout_id)
 
-        q = (
+        # Query DB for only the IDs in the current page
-            query_with_stat(info)
+        q = query_with_stat(info)
-            if has_field(info, "stat")
-            else select(Shout).filter(and_(Shout.published_at.is_not(None), Shout.deleted_at.is_(None)))
-        )
         q = q.filter(Shout.id.in_(hits_ids))
-        q = apply_filters(q, options)
+        q = apply_filters(q, options.get("filters", {}))
-        q = apply_sorting(q, options)
+
-        shouts = get_shouts_with_links(info, q, limit, offset)
+        shouts = get_shouts_with_links(info, q, len(hits_ids), 0)
-        for shout in shouts:
+
-            shout.score = scores[f"{shout.id}"]
+        # Reorder shouts to match the order from hits_ids
-        shouts.sort(key=lambda x: x.score, reverse=True)
+        shouts_dict = {str(shout['id']): shout for shout in shouts}
-        return shouts
+        ordered_shouts = [shouts_dict[shout_id] for shout_id in hits_ids if shout_id in shouts_dict]
+
+        return ordered_shouts
     return []
 
 
+@query.field("get_search_results_count")
+async def get_search_results_count(_, info, text):
+    """
+    Returns the total count of search results for a search query.
+    
+    :param _: Root query object (unused)
+    :param info: GraphQL context information
+    :param text: Search query text
+    :return: Total count of results
+    """
+    if isinstance(text, str) and len(text) > 2:
+        count = await get_search_count(text)
+        return {"count": count}
+    return {"count": 0}
+
+
 @query.field("load_shouts_unrated")
 async def load_shouts_unrated(_, info, options):
     """

resolvers/topic.py

@@ -10,6 +10,7 @@ from cache.cache import (
 )
 from orm.author import Author
 from orm.topic import Topic
+from orm.reaction import ReactionKind
 from resolvers.stat import get_with_stat
 from services.auth import login_required
 from services.db import local_session
@@ -112,7 +113,7 @@ async def get_topics_with_stats(limit=100, offset=0, community_id=None, by=None)
             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
+            JOIN shout s ON st.shout = s.id AND s.deleted_at IS NULL AND s.published_at IS NOT NULL
             WHERE st.topic IN ({",".join(map(str, topic_ids))})
             GROUP BY st.topic
             """
@@ -121,12 +122,35 @@ async def get_topics_with_stats(limit=100, offset=0, community_id=None, by=None)
             # Запрос на получение статистики по подписчикам для выбранных тем
             followers_stats_query = f"""
             SELECT topic, COUNT(DISTINCT follower) as followers_count
-            FROM topic_followers
+            FROM topic_followers tf
             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))}
 
+            # Запрос на получение статистики авторов для выбранных тем
+            authors_stats_query = f"""
+            SELECT st.topic, COUNT(DISTINCT sa.author) as authors_count
+            FROM shout_topic st
+            JOIN shout s ON st.shout = s.id AND s.deleted_at IS NULL AND s.published_at IS NOT NULL
+            JOIN shout_author sa ON sa.shout = s.id
+            WHERE st.topic IN ({",".join(map(str, topic_ids))})
+            GROUP BY st.topic
+            """
+            authors_stats = {row[0]: row[1] for row in session.execute(text(authors_stats_query))}
+
+            # Запрос на получение статистики комментариев для выбранных тем
+            comments_stats_query = f"""
+            SELECT st.topic, COUNT(DISTINCT r.id) as comments_count
+            FROM shout_topic st
+            JOIN shout s ON st.shout = s.id AND s.deleted_at IS NULL AND s.published_at IS NOT NULL
+            JOIN reaction r ON r.shout = s.id AND r.kind = '{ReactionKind.COMMENT.value}' AND r.deleted_at IS NULL
+            JOIN author a ON r.created_by = a.id AND a.deleted_at IS NULL
+            WHERE st.topic IN ({",".join(map(str, topic_ids))})
+            GROUP BY st.topic
+            """
+            comments_stats = {row[0]: row[1] for row in session.execute(text(comments_stats_query))}
+
             # Формируем результат с добавлением статистики
             result = []
             for topic in topics:
@@ -134,6 +158,8 @@ async def get_topics_with_stats(limit=100, offset=0, community_id=None, by=None)
                 topic_dict["stat"] = {
                     "shouts": shouts_stats.get(topic.id, 0),
                     "followers": followers_stats.get(topic.id, 0),
+                    "authors": authors_stats.get(topic.id, 0),
+                    "comments": comments_stats.get(topic.id, 0),
                 }
                 result.append(topic_dict)
 
@@ -202,23 +228,6 @@ async def get_topics_all(_, _info):
     return await get_all_topics()
 
 
-# Запрос на получение тем с пагинацией и статистикой
-@query.field("get_topics_paginated")
-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, None, by)
-
-
 # Запрос на получение тем по сообществу
 @query.field("get_topics_by_community")
 async def get_topics_by_community(_, _info, community_id: int, limit=100, offset=0, by=None):

schema/input.graphql

@@ -33,7 +33,6 @@ input DraftInput {
   main_topic_id: Int  # Changed from main_topic: Topic
   media: [MediaItemInput]  # Changed to use MediaItemInput
   lead: String
-  description: String
   subtitle: String
   lang: String
   seo: String
@@ -93,12 +92,14 @@ input LoadShoutsOptions {
 
 input ReactionBy {
   shout: String
+  shout_id: Int
   shouts: [String]
   search: String
   kinds: [ReactionKind]
   reply_to: Int # filter
   topic: String
   created_by: Int
+  author_id: Int
   author: String
   after: Int
   sort: ReactionSort # sort

schema/query.graphql

@@ -4,7 +4,7 @@ type Query {
   get_author_id(user: String!): Author
   get_authors_all: [Author]
   load_authors_by(by: AuthorsBy!, limit: Int, offset: Int): [Author]
-  # search_authors(what: String!): [Author]
+  load_authors_search(text: String!, limit: Int, offset: Int): [Author!] # Search for authors by name or bio
 
   # community
   get_community: Community
@@ -26,10 +26,14 @@ type Query {
   load_shout_ratings(shout: Int!, limit: Int, offset: Int): [Reaction]
   load_comment_ratings(comment: Int!, limit: Int, offset: Int): [Reaction]
 
+  # branched comments pagination
+  load_comments_branch(shout: Int!, parent_id: Int, limit: Int, offset: Int, sort: ReactionSort, children_limit: Int, children_offset: Int): [Reaction]
+
   # reader
   get_shout(slug: String, shout_id: Int): Shout
   load_shouts_by(options: LoadShoutsOptions): [Shout]
   load_shouts_search(text: String!, options: LoadShoutsOptions): [SearchResult]
+  get_search_results_count(text: String!): CountResult!
   load_shouts_bookmarked(options: LoadShoutsOptions): [Shout]
 
   # rating
@@ -57,7 +61,7 @@ type Query {
   get_topic(slug: String!): Topic
   get_topics_all: [Topic]
   get_topics_by_author(slug: String, user: String, author_id: Int): [Topic]
-  get_topics_by_community(slug: String, community_id: Int): [Topic]
+  get_topics_by_community(community_id: Int!, limit: Int, offset: Int): [Topic]
 
   # notifier
   load_notifications(after: Int!, limit: Int, offset: Int): NotificationsResult!

schema/type.graphql

@@ -55,6 +55,7 @@ type Reaction {
   stat: Stat
   oid: String
   # old_thread: String
+  first_replies: [Reaction]
 }
 
 type MediaItem {
@@ -79,7 +80,6 @@ type Shout {
   layout: String!
 
   lead: String
-  description: String
   subtitle: String
   lang: String
   cover: String
@@ -99,6 +99,7 @@ type Shout {
   featured_at: Int
   deleted_at: Int
 
+  seo: String # generated if not set
   version_of: Shout  # TODO: use version_of somewhere
   draft: Draft
   media: [MediaItem]
@@ -106,17 +107,22 @@ type Shout {
   score: Float
 }
 
+type PublicationInfo {
+  id: Int!
+  slug: String!
+  published_at: Int
+}
+
 type Draft {
   id: Int!
   created_at: Int!
   created_by: Author!
-
+  community: Community!
   layout: String
   slug: String
   title: String
   subtitle: String
   lead: String
-  description: String
   body: String
   media: [MediaItem]
   cover: String
@@ -129,14 +135,14 @@ type Draft {
   deleted_at: Int
   updated_by: Author
   deleted_by: Author
-  authors: [Author]
+  authors: [Author]!
-  topics: [Topic]
+  topics: [Topic]!
-
+  publication: PublicationInfo
 }
 
 type Stat {
   rating: Int
-  commented: Int
+  comments_count: Int
   viewed: Int
   last_commented_at: Int
 }
@@ -207,6 +213,7 @@ type CommonResult {
 }
 
 type SearchResult {
+    id: Int!
     slug: String!
     title: String!
     cover: String
@@ -274,3 +281,7 @@ type MyRateComment {
   my_rate: ReactionKind
 }
 
+type CountResult {
+  count: Int!
+}
+

services/db.py

@@ -19,7 +19,7 @@ from sqlalchemy import (
     inspect,
     text,
 )
-from sqlalchemy.orm import Session, configure_mappers, declarative_base
+from sqlalchemy.orm import Session, configure_mappers, declarative_base, joinedload
 from sqlalchemy.sql.schema import Table
 
 from settings import DB_URL
@@ -259,3 +259,32 @@ def get_json_builder():
 
 # Используем их в коде
 json_builder, json_array_builder, json_cast = get_json_builder()
+
+# Fetch all shouts, with authors preloaded
+# This function is used for search indexing
+
+async def fetch_all_shouts(session=None):
+    """Fetch all published shouts for search indexing with authors preloaded"""
+    from orm.shout import Shout
+    
+    close_session = False
+    if session is None:
+        session = local_session()
+        close_session = True
+    
+    try:
+        # Fetch only published and non-deleted shouts with authors preloaded
+        query = session.query(Shout).options(
+            joinedload(Shout.authors)
+        ).filter(
+            Shout.published_at.is_not(None),
+            Shout.deleted_at.is_(None)
+        )
+        shouts = query.all()
+        return shouts
+    except Exception as e:
+        logger.error(f"Error fetching shouts for search indexing: {e}")
+        return []
+    finally:
+        if close_session:
+            session.close()

services/notify.py

@@ -53,3 +53,66 @@ async def notify_follower(follower: dict, author_id: int, action: str = "follow"
     except Exception as e:
         # Log the error and re-raise it
         logger.error(f"Failed to publish to channel {channel_name}: {e}")
+
+
+async def notify_draft(draft_data, action: str = "publish"):
+    """
+    Отправляет уведомление о публикации или обновлении черновика.
+    
+    Функция гарантирует, что данные черновика сериализуются корректно, включая
+    связанные атрибуты (topics, authors).
+    
+    Args:
+        draft_data (dict): Словарь с данными черновика. Должен содержать минимум id и title
+        action (str, optional): Действие ("publish", "update"). По умолчанию "publish"
+    
+    Returns:
+        None
+    
+    Examples:
+        >>> draft = {"id": 1, "title": "Тестовый черновик", "slug": "test-draft"}
+        >>> await notify_draft(draft, "publish")
+    """
+    channel_name = "draft"
+    try:
+        # Убеждаемся, что все необходимые данные присутствуют
+        # и объект не требует доступа к отсоединенным атрибутам
+        if isinstance(draft_data, dict):
+            draft_payload = draft_data
+        else:
+            # Если это ORM объект, преобразуем его в словарь с нужными атрибутами
+            draft_payload = {
+                "id": getattr(draft_data, "id", None),
+                "slug": getattr(draft_data, "slug", None),
+                "title": getattr(draft_data, "title", None),
+                "subtitle": getattr(draft_data, "subtitle", None),
+                "media": getattr(draft_data, "media", None),
+                "created_at": getattr(draft_data, "created_at", None),
+                "updated_at": getattr(draft_data, "updated_at", None)
+            }
+            
+            # Если переданы связанные атрибуты, добавим их
+            if hasattr(draft_data, "topics") and draft_data.topics is not None:
+                draft_payload["topics"] = [
+                    {"id": t.id, "name": t.name, "slug": t.slug} 
+                    for t in draft_data.topics
+                ]
+            
+            if hasattr(draft_data, "authors") and draft_data.authors is not None:
+                draft_payload["authors"] = [
+                    {"id": a.id, "name": a.name, "slug": a.slug, "pic": getattr(a, "pic", None)} 
+                    for a in draft_data.authors
+                ]
+                
+        data = {"payload": draft_payload, "action": action}
+        
+        # Сохраняем уведомление
+        save_notification(action, channel_name, data.get("payload"))
+        
+        # Публикуем в Redis
+        json_data = orjson.dumps(data)
+        if json_data:
+            await redis.publish(channel_name, json_data)
+            
+    except Exception as e:
+        logger.error(f"Failed to publish to channel {channel_name}: {e}")

services/schema.py

@@ -1,14 +1,15 @@
 from asyncio.log import logger
 
 import httpx
-from ariadne import MutationType, QueryType
+from ariadne import MutationType, ObjectType, QueryType
 
 from services.db import create_table_if_not_exists, local_session
 from settings import AUTH_URL
 
 query = QueryType()
 mutation = MutationType()
-resolvers = [query, mutation]
+type_draft = ObjectType("Draft")
+resolvers = [query, mutation, type_draft]
 
 
 async def request_graphql_data(gql, url=AUTH_URL, headers=None):
@@ -28,12 +29,19 @@ async def request_graphql_data(gql, url=AUTH_URL, headers=None):
         async with httpx.AsyncClient() as client:
             response = await client.post(url, json=gql, headers=headers)
             if response.status_code == 200:
-                data = response.json()
+                # Check if the response has content before parsing
-                errors = data.get("errors")
+                if response.content and len(response.content.strip()) > 0:
-                if errors:
+                    try:
-                    logger.error(f"{url} response: {data}")
+                        data = response.json()
+                        errors = data.get("errors")
+                        if errors:
+                            logger.error(f"{url} response: {data}")
+                        else:
+                            return data
+                    except Exception as json_err:
+                        logger.error(f"JSON decode error: {json_err}, Response content: {response.text[:100]}")
                 else:
-                    return data
+                    logger.error(f"{url}: Response is empty")
             else:
                 logger.error(f"{url}: {response.status_code} {response.text}")
     except Exception as _e:

services/viewed.py

@@ -2,9 +2,7 @@ import asyncio
 import os
 import time
 from datetime import datetime, timedelta, timezone
-from typing import Dict
+from typing import Dict, Optional
-
-import orjson
 
 # ga
 from google.analytics.data_v1beta import BetaAnalyticsDataClient
@@ -20,33 +18,39 @@ from orm.author import Author
 from orm.shout import Shout, ShoutAuthor, ShoutTopic
 from orm.topic import Topic
 from services.db import local_session
+from services.redis import redis
 from utils.logger import root_logger as logger
 
 GOOGLE_KEYFILE_PATH = os.environ.get("GOOGLE_KEYFILE_PATH", "/dump/google-service.json")
 GOOGLE_PROPERTY_ID = os.environ.get("GOOGLE_PROPERTY_ID", "")
-VIEWS_FILEPATH = "/dump/views.json"
 
 
 class ViewedStorage:
+    """
+    Класс для хранения и доступа к данным о просмотрах.
+    Использует Redis в качестве основного хранилища и Google Analytics для сбора новых данных.
+    """
+
     lock = asyncio.Lock()
-    precounted_by_slug = {}
     views_by_shout = {}
     shouts_by_topic = {}
     shouts_by_author = {}
     views = None
     period = 60 * 60  # каждый час
-    analytics_client: BetaAnalyticsDataClient | None = None
+    analytics_client: Optional[BetaAnalyticsDataClient] = None
     auth_result = None
     running = False
+    redis_views_key = None
+    last_update_timestamp = 0
     start_date = datetime.now().strftime("%Y-%m-%d")
 
     @staticmethod
     async def init():
-        """Подключение к клиенту Google Analytics с использованием аутентификации"""
+        """Подключение к клиенту Google Analytics и загрузка данных о просмотрах из Redis"""
         self = ViewedStorage
         async with self.lock:
-            # Загрузка предварительно подсчитанных просмотров из файла JSON
+            # Загрузка предварительно подсчитанных просмотров из Redis
-            self.load_precounted_views()
+            await self.load_views_from_redis()
 
             os.environ.setdefault("GOOGLE_APPLICATION_CREDENTIALS", GOOGLE_KEYFILE_PATH)
             if GOOGLE_KEYFILE_PATH and os.path.isfile(GOOGLE_KEYFILE_PATH):
@@ -62,40 +66,54 @@ class ViewedStorage:
                 self.running = False
 
     @staticmethod
-    def load_precounted_views():
+    async def load_views_from_redis():
-        """Загрузка предварительно подсчитанных просмотров из файла JSON"""
+        """Загрузка предварительно подсчитанных просмотров из Redis"""
         self = ViewedStorage
-        viewfile_path = VIEWS_FILEPATH
-        if not os.path.exists(viewfile_path):
-            viewfile_path = os.path.join(os.path.curdir, "views.json")
-            if not os.path.exists(viewfile_path):
-                logger.warning(" * views.json not found")
-                return
 
-        logger.info(f" * loading views from {viewfile_path}")
+        # Подключаемся к Redis если соединение не установлено
-        try:
+        if not redis._client:
-            start_date_int = os.path.getmtime(viewfile_path)
+            await redis.connect()
-            start_date_str = datetime.fromtimestamp(start_date_int).strftime("%Y-%m-%d")
+
-            self.start_date = start_date_str
+        # Получаем список всех ключей migrated_views_* и находим самый последний
+        keys = await redis.execute("KEYS", "migrated_views_*")
+        if not keys:
+            logger.warning(" * No migrated_views keys found in Redis")
+            return
+
+        # Фильтруем только ключи timestamp формата (исключаем migrated_views_slugs)
+        timestamp_keys = [k for k in keys if k != "migrated_views_slugs"]
+        if not timestamp_keys:
+            logger.warning(" * No migrated_views timestamp keys found in Redis")
+            return
+
+        # Сортируем по времени создания (в названии ключа) и берем последний
+        timestamp_keys.sort()
+        latest_key = timestamp_keys[-1]
+        self.redis_views_key = latest_key
+
+        # Получаем метку времени создания для установки start_date
+        timestamp = await redis.execute("HGET", latest_key, "_timestamp")
+        if timestamp:
+            self.last_update_timestamp = int(timestamp)
+            timestamp_dt = datetime.fromtimestamp(int(timestamp))
+            self.start_date = timestamp_dt.strftime("%Y-%m-%d")
+
+            # Если данные сегодняшние, считаем их актуальными
             now_date = datetime.now().strftime("%Y-%m-%d")
-
             if now_date == self.start_date:
-                logger.info(" * views data is up to date!")
+                logger.info(" * Views data is up to date!")
             else:
-                logger.warn(f" * {viewfile_path} is too old: {self.start_date}")
+                logger.warning(f" * Views data is from {self.start_date}, may need update")
 
-            with open(viewfile_path, "r") as file:
+        # Выводим информацию о количестве загруженных записей
-                precounted_views = orjson.loads(file.read())
+        total_entries = await redis.execute("HGET", latest_key, "_total")
-                self.precounted_by_slug.update(precounted_views)
+        if total_entries:
-                logger.info(f" * {len(precounted_views)} shouts with views was loaded.")
+            logger.info(f" * {total_entries} shouts with views loaded from Redis key: {latest_key}")
-
-        except Exception as e:
-            logger.error(f"precounted views loading error: {e}")
 
     # noinspection PyTypeChecker
     @staticmethod
     async def update_pages():
-        """Запрос всех страниц от Google Analytics, отсортрованных по количеству просмотров"""
+        """Запрос всех страниц от Google Analytics, отсортированных по количеству просмотров"""
         self = ViewedStorage
         logger.info(" ⎧ views update from Google Analytics ---")
         if self.running:
@@ -140,15 +158,40 @@ class ViewedStorage:
                 self.running = False
 
     @staticmethod
-    def get_shout(shout_slug="", shout_id=0) -> int:
+    async def get_shout(shout_slug="", shout_id=0) -> int:
-        """Получение метрики просмотров shout по slug или id."""
+        """
+        Получение метрики просмотров shout по slug или id.
+
+        Args:
+            shout_slug: Slug публикации
+            shout_id: ID публикации
+
+        Returns:
+            int: Количество просмотров
+        """
         self = ViewedStorage
+
+        # Получаем данные из Redis для новой схемы хранения
+        if not redis._client:
+            await redis.connect()
+
         fresh_views = self.views_by_shout.get(shout_slug, 0)
-        precounted_views = self.precounted_by_slug.get(shout_slug, 0)
+
-        return fresh_views + precounted_views
+        # Если есть id, пытаемся получить данные из Redis по ключу migrated_views_<timestamp>
+        if shout_id and self.redis_views_key:
+            precounted_views = await redis.execute("HGET", self.redis_views_key, str(shout_id))
+            if precounted_views:
+                return fresh_views + int(precounted_views)
+
+        # Если нет id или данных, пытаемся получить по slug из отдельного хеша
+        precounted_views = await redis.execute("HGET", "migrated_views_slugs", shout_slug)
+        if precounted_views:
+            return fresh_views + int(precounted_views)
+
+        return fresh_views
 
     @staticmethod
-    def get_shout_media(shout_slug) -> Dict[str, int]:
+    async def get_shout_media(shout_slug) -> Dict[str, int]:
         """Получение метрики воспроизведения shout по slug."""
         self = ViewedStorage
 
@@ -157,23 +200,29 @@ class ViewedStorage:
         return self.views_by_shout.get(shout_slug, 0)
 
     @staticmethod
-    def get_topic(topic_slug) -> int:
+    async def get_topic(topic_slug) -> int:
         """Получение суммарного значения просмотров темы."""
         self = ViewedStorage
-        return sum(self.views_by_shout.get(shout_slug, 0) for shout_slug in self.shouts_by_topic.get(topic_slug, []))
+        views_count = 0
+        for shout_slug in self.shouts_by_topic.get(topic_slug, []):
+            views_count += await self.get_shout(shout_slug=shout_slug)
+        return views_count
 
     @staticmethod
-    def get_author(author_slug) -> int:
+    async def get_author(author_slug) -> int:
         """Получение суммарного значения просмотров автора."""
         self = ViewedStorage
-        return sum(self.views_by_shout.get(shout_slug, 0) for shout_slug in self.shouts_by_author.get(author_slug, []))
+        views_count = 0
+        for shout_slug in self.shouts_by_author.get(author_slug, []):
+            views_count += await self.get_shout(shout_slug=shout_slug)
+        return views_count
 
     @staticmethod
     def update_topics(shout_slug):
         """Обновление счетчиков темы по slug shout"""
         self = ViewedStorage
         with local_session() as session:
-            # Определение вспомогательной функции для избежа<EFBFBD><EFBFBD>ия повторения кода
+            # Определение вспомогательной функции для избежания повторения кода
             def update_groups(dictionary, key, value):
                 dictionary[key] = list(set(dictionary.get(key, []) + [value]))
 

utils/__init__.py

@@ -0,0 +1 @@
+ 

utils/html_wrapper.py

@@ -0,0 +1,38 @@
+"""
+Модуль для обработки HTML-фрагментов
+"""
+
+def wrap_html_fragment(fragment: str) -> str:
+    """
+    Оборачивает HTML-фрагмент в полную HTML-структуру для корректной обработки.
+    
+    Args:
+        fragment: HTML-фрагмент для обработки
+        
+    Returns:
+        str: Полный HTML-документ
+        
+    Example:
+        >>> wrap_html_fragment("<p>Текст параграфа</p>")
+        '<!DOCTYPE html><html><head><meta charset="utf-8"></head><body><p>Текст параграфа</p></body></html>'
+    """
+    if not fragment or not fragment.strip():
+        return fragment
+        
+    # Проверяем, является ли контент полным HTML-документом
+    is_full_html = fragment.strip().startswith('<!DOCTYPE') or fragment.strip().startswith('<html')
+    
+    # Если это фрагмент, оборачиваем его в полный HTML-документ
+    if not is_full_html:
+        return f"""<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title></title>
+</head>
+<body>
+{fragment}
+</body>
+</html>"""
+    
+    return fragment