feat: add search APIs and telegram-like chats sidebar flow

- implement chat query filtering and message search endpoints

- add db indexes for search fields

- activate chats search input in web

- replace inline create panel with floating TG-style action menu

app/chats/repository.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Select, func, select
+from sqlalchemy import Select, String, func, or_, select
 from sqlalchemy.orm import aliased
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -28,20 +28,31 @@ async def count_chat_members(db: AsyncSession, *, chat_id: int) -> int:
     return int(result.scalar_one())
 
 
-def _user_chats_query(user_id: int) -> Select[tuple[Chat]]:
-    return (
-        select(Chat)
-        .join(ChatMember, ChatMember.chat_id == Chat.id)
-        .where(ChatMember.user_id == user_id)
-        .order_by(Chat.id.desc())
-    )
+def _user_chats_query(user_id: int, query: str | None = None) -> Select[tuple[Chat]]:
+    stmt = select(Chat).join(ChatMember, ChatMember.chat_id == Chat.id).where(ChatMember.user_id == user_id)
+    if query and query.strip():
+        q = f"%{query.strip()}%"
+        stmt = stmt.where(
+            or_(
+                Chat.title.ilike(q),
+                Chat.type.cast(String).ilike(q),
+            )
+        )
+    return stmt.order_by(Chat.id.desc())
 
 
-async def list_user_chats(db: AsyncSession, *, user_id: int, limit: int = 50, before_id: int | None = None) -> list[Chat]:
-    query = _user_chats_query(user_id).limit(limit)
+async def list_user_chats(
+    db: AsyncSession,
+    *,
+    user_id: int,
+    limit: int = 50,
+    before_id: int | None = None,
+    query: str | None = None,
+) -> list[Chat]:
+    query_stmt = _user_chats_query(user_id, query=query).limit(limit)
     if before_id is not None:
-        query = query.where(Chat.id < before_id)
-    result = await db.execute(query)
+        query_stmt = query_stmt.where(Chat.id < before_id)
+    result = await db.execute(query_stmt)
     return list(result.scalars().all())
 
 

app/chats/router.py

@@ -31,10 +31,11 @@ router = APIRouter(prefix="/chats", tags=["chats"])
 async def list_chats(
     limit: int = 50,
     before_id: int | None = None,
+    query: str | None = None,
     db: AsyncSession = Depends(get_db),
     current_user: User = Depends(get_current_user),
 ) -> list[ChatRead]:
-    return await get_chats_for_user(db, user_id=current_user.id, limit=limit, before_id=before_id)
+    return await get_chats_for_user(db, user_id=current_user.id, limit=limit, before_id=before_id, query=query)
 
 
 @router.post("", response_model=ChatRead)

app/chats/service.py

@@ -47,9 +47,16 @@ async def create_chat_for_user(db: AsyncSession, *, creator_id: int, payload: Ch
     return chat
 
 
-async def get_chats_for_user(db: AsyncSession, *, user_id: int, limit: int = 50, before_id: int | None = None) -> list[Chat]:
+async def get_chats_for_user(
+    db: AsyncSession,
+    *,
+    user_id: int,
+    limit: int = 50,
+    before_id: int | None = None,
+    query: str | None = None,
+) -> list[Chat]:
     safe_limit = max(1, min(limit, 100))
-    return await repository.list_user_chats(db, user_id=user_id, limit=safe_limit, before_id=before_id)
+    return await repository.list_user_chats(db, user_id=user_id, limit=safe_limit, before_id=before_id, query=query)
 
 
 async def get_chat_for_user(db: AsyncSession, *, chat_id: int, user_id: int) -> tuple[Chat, list]:

app/messages/repository.py

@@ -1,6 +1,7 @@
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.chats.models import ChatMember
 from app.messages.models import Message, MessageIdempotencyKey, MessageReceipt, MessageType
 
 
@@ -76,6 +77,31 @@ async def list_chat_messages(
     return list(result.scalars().all())
 
 
+async def search_messages(
+    db: AsyncSession,
+    *,
+    user_id: int,
+    query: str,
+    chat_id: int | None = None,
+    limit: int = 50,
+) -> list[Message]:
+    stmt = (
+        select(Message)
+        .join(ChatMember, ChatMember.chat_id == Message.chat_id)
+        .where(
+            ChatMember.user_id == user_id,
+            Message.text.is_not(None),
+            Message.text.ilike(f"%{query.strip()}%"),
+        )
+        .order_by(Message.id.desc())
+        .limit(limit)
+    )
+    if chat_id is not None:
+        stmt = stmt.where(Message.chat_id == chat_id)
+    result = await db.execute(stmt)
+    return list(result.scalars().all())
+
+
 async def delete_message(db: AsyncSession, message: Message) -> None:
     await db.delete(message)
 

app/messages/router.py

@@ -4,7 +4,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from app.auth.service import get_current_user
 from app.database.session import get_db
 from app.messages.schemas import MessageCreateRequest, MessageRead, MessageStatusUpdateRequest, MessageUpdateRequest
-from app.messages.service import create_chat_message, delete_message, get_messages, update_message
+from app.messages.service import create_chat_message, delete_message, get_messages, search_messages, update_message
 from app.realtime.schemas import MessageStatusPayload
 from app.realtime.service import realtime_gateway
 from app.users.models import User
@@ -27,6 +27,17 @@ async def create_message(
     return message
 
 
+@router.get("/search", response_model=list[MessageRead])
+async def search_messages_endpoint(
+    query: str,
+    chat_id: int | None = None,
+    limit: int = 50,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> list[MessageRead]:
+    return await search_messages(db, user_id=current_user.id, query=query, chat_id=chat_id, limit=limit)
+
+
 @router.get("/{chat_id}", response_model=list[MessageRead])
 async def list_messages(
     chat_id: int,

app/messages/service.py

@@ -76,6 +76,29 @@ async def get_messages(
     return await repository.list_chat_messages(db, chat_id, limit=safe_limit, before_id=before_id)
 
 
+async def search_messages(
+    db: AsyncSession,
+    *,
+    user_id: int,
+    query: str,
+    chat_id: int | None = None,
+    limit: int = 50,
+) -> list[Message]:
+    normalized = query.strip()
+    if len(normalized) < 2:
+        return []
+    safe_limit = max(1, min(limit, 100))
+    if chat_id is not None:
+        await ensure_chat_membership(db, chat_id=chat_id, user_id=user_id)
+    return await repository.search_messages(
+        db,
+        user_id=user_id,
+        query=normalized,
+        chat_id=chat_id,
+        limit=safe_limit,
+    )
+
+
 async def update_message(
     db: AsyncSession,
     *,