diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..51c0d3ed --- /dev/null +++ b/Dockerfile @@ -0,0 +1,20 @@ +FROM python:3.11-slim + +# Устанавливаем curl для healthcheck +RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/* + +WORKDIR /app + +# Копируем зависимости +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +# Копируем исходный код +COPY src/ ./src/ + +ENV HOST=0.0.0.0 +ENV PORT=8080 + +EXPOSE 8080 + +CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"] \ No newline at end of file diff --git a/docker-compose.yaml b/docker-compose.yaml new file mode 100644 index 00000000..1f4b53a5 --- /dev/null +++ b/docker-compose.yaml @@ -0,0 +1,35 @@ +services: + api: + build: . + ports: + - "8080:8080" + environment: + - DATABASE_URL=postgresql://messenger:messenger_pass@postgres:5432/messenger + - SESSION_TTL_SECONDS=3600 + depends_on: + postgres: + condition: service_healthy + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:8080/health/ready"] + interval: 5s + timeout: 3s + retries: 5 + restart: unless-stopped + + postgres: + image: postgres:16.1 + environment: + - POSTGRES_DB=messenger + - POSTGRES_USER=messenger + - POSTGRES_PASSWORD=messenger_pass + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger"] + interval: 5s + timeout: 3s + retries: 5 + restart: unless-stopped + +volumes: + postgres_data: \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..2f55caaf --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +fastapi==0.104.1 +uvicorn==0.24.0 +psycopg2-binary==2.9.9 +bcrypt==4.1.2 +python-multipart==0.0.6 +pydantic==2.5.0 \ No newline at end of file diff --git a/scripts/restart.bat b/scripts/restart.bat new file mode 100644 index 00000000..9a57e077 --- /dev/null +++ b/scripts/restart.bat @@ -0,0 +1,15 @@ +@echo off +cd /d %~dp0\.. +docker compose restart api postgres + +set /a count=0 +:check_loop +timeout /t 2 /nobreak >nul +curl -s -f http://localhost:8080/health/ready >nul 2>&1 +if %errorlevel% equ 0 exit /b 0 + +set /a count+=1 +if %count% lss 15 goto check_loop + +echo API failed to become ready +exit /b 1 \ No newline at end of file diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/auth.py b/src/auth.py new file mode 100644 index 00000000..14b2fe86 --- /dev/null +++ b/src/auth.py @@ -0,0 +1,61 @@ +import os +import hashlib +import bcrypt +import secrets +from datetime import datetime, timezone, timedelta +from typing import Optional, Dict, Any + + +SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) + + +def hash_password(password: str) -> str: + """Хешировать пароль: SHA-256 пре-хеширование + bcrypt (обход лимита 72 байт)""" + pre_hash = hashlib.sha256(password.encode('utf-8')).digest() + return bcrypt.hashpw(pre_hash, bcrypt.gensalt()).decode('utf-8') + + +def verify_password(password: str, password_hash: str) -> bool: + """Проверить пароль""" + pre_hash = hashlib.sha256(password.encode('utf-8')).digest() + return bcrypt.checkpw(pre_hash, password_hash.encode('utf-8')) + + +def generate_token() -> str: + """Сгенерировать случайный токен сессии (256 бит энтропии)""" + return secrets.token_hex(32) # 64 символа = 256 бит + + +def create_session(db_conn, user_id: str) -> Dict[str, Any]: + """Создать новую сессию в БД""" + token = generate_token() + expires_at = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS) + + with db_conn.cursor() as cur: + cur.execute( + "INSERT INTO sessions (token, user_id, expires_at) VALUES (%s, %s, %s)", + (token, user_id, expires_at) + ) + db_conn.commit() + + return { + "token": token, + "expires_at": expires_at.strftime('%Y-%m-%dT%H:%M:%SZ') + } + + +def get_session(db_conn, token: str) -> Optional[Dict[str, Any]]: + """Получить действительную сессию по токену""" + with db_conn.cursor() as cur: + cur.execute( + "SELECT token, user_id, expires_at FROM sessions WHERE token = %s AND expires_at > NOW()", + (token,) + ) + return cur.fetchone() + + +def delete_session(db_conn, token: str): + """Удалить сессию (logout)""" + with db_conn.cursor() as cur: + cur.execute("DELETE FROM sessions WHERE token = %s", (token,)) + db_conn.commit() \ No newline at end of file diff --git a/src/database.py b/src/database.py new file mode 100644 index 00000000..134ab938 --- /dev/null +++ b/src/database.py @@ -0,0 +1,295 @@ +import os +import psycopg2 +from psycopg2.extras import RealDictCursor +from typing import Optional, List, Dict, Any, Tuple +from contextlib import contextmanager +from uuid import uuid4 +from datetime import datetime, timezone + + +DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://messenger:messenger_pass@localhost:5432/messenger") + + +def get_db_connection(): + """Создать подключение к PostgreSQL""" + return psycopg2.connect(DATABASE_URL, cursor_factory=RealDictCursor) + + +@contextmanager +def get_db(): + """Контекстный менеджер для работы с БД""" + conn = get_db_connection() + try: + yield conn + conn.commit() + except Exception: + conn.rollback() + raise + finally: + conn.close() + + +def init_db(): + """Инициализировать БД (запустить миграции idempotently)""" + migration_path = os.path.join(os.path.dirname(__file__), "migrations", "001_initial.sql") + with open(migration_path, "r") as f: + migration_sql = f.read() + + with get_db() as conn: + with conn.cursor() as cur: + cur.execute(migration_sql) + + +class PostgresStore: + """Store layer для PostgreSQL — заменяет InMemoryStore из Lab 1""" + + def create_user(self, username: str, display_name: str, password_hash: str) -> dict: + with get_db() as conn: + with conn.cursor() as cur: + # Проверяем уникальность username + cur.execute("SELECT id FROM users WHERE username = %s", (username,)) + if cur.fetchone(): + raise ValueError("username_already_exists") + + user_id = str(uuid4()) + now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') + + cur.execute( + "INSERT INTO users (id, username, display_name, password_hash, created_at) " + "VALUES (%s, %s, %s, %s, %s)", + (user_id, username, display_name, password_hash, now) + ) + + return { + "id": user_id, + "username": username, + "display_name": display_name, + "created_at": now + } + + def get_user(self, user_id: str) -> Optional[dict]: + with get_db() as conn: + with conn.cursor() as cur: + cur.execute( + "SELECT id, username, display_name, created_at FROM users WHERE id = %s", + (user_id,) + ) + row = cur.fetchone() + if row: + # Преобразуем datetime в строку ISO8601 + row["created_at"] = row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + return row + + def get_user_by_username(self, username: str) -> Optional[dict]: + with get_db() as conn: + with conn.cursor() as cur: + cur.execute( + "SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = %s", + (username,) + ) + row = cur.fetchone() + if row: + # Преобразуем datetime в строку ISO8601 + row["created_at"] = row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + return row + + def create_chat(self, title: str, member_ids: List[str], creator_id: str) -> dict: + with get_db() as conn: + with conn.cursor() as cur: + # Проверяем, что все участники существуют + for member_id in member_ids: + cur.execute("SELECT id FROM users WHERE id = %s", (member_id,)) + if not cur.fetchone(): + raise ValueError("user_not_found") + + # Проверяем, что создатель входит в список участников + if creator_id not in member_ids: + raise ValueError("creator_not_in_members") + + # Проверяем уникальность member_ids + if len(member_ids) != len(set(member_ids)): + raise ValueError("duplicate_members") + + chat_id = str(uuid4()) + now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') + + # Атомарно: создаём чат и всех участников в одной транзакции + cur.execute( + "INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)", + (chat_id, title, now) + ) + + for member_id in member_ids: + cur.execute( + "INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", + (chat_id, member_id) + ) + + return { + "id": chat_id, + "title": title, + "member_ids": member_ids, + "created_at": now + } + + def get_chat(self, chat_id: str, user_id: str) -> Optional[dict]: + with get_db() as conn: + with conn.cursor() as cur: + cur.execute( + "SELECT c.id, c.title, c.created_at " + "FROM chats c " + "JOIN chat_members cm ON c.id = cm.chat_id " + "WHERE c.id = %s AND cm.user_id = %s", + (chat_id, user_id) + ) + chat = cur.fetchone() + if not chat: + return None + + # Получаем список участников + cur.execute( + "SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", + (chat_id,) + ) + members = [row["user_id"] for row in cur.fetchall()] + + return { + "id": chat["id"], + "title": chat["title"], + "member_ids": members, + "created_at": chat["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + } + + def list_chats(self, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> Tuple[List[dict], Optional[str]]: + with get_db() as conn: + with conn.cursor() as cur: + query = """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members cm ON c.id = cm.chat_id + WHERE cm.user_id = %s + """ + params = [user_id] + + if cursor: + cursor_parts = cursor.split(",", 1) + if len(cursor_parts) == 2: + cursor_time, cursor_id = cursor_parts + query += " AND (c.created_at, c.id) > (%s::timestamptz, %s::uuid)" + params.extend([cursor_time, cursor_id]) + + query += " ORDER BY c.created_at, c.id LIMIT %s" + params.append(limit + 1) # Берём на 1 больше для определения has_more + + cur.execute(query, params) + rows = cur.fetchall() + + has_more = len(rows) > limit + page_rows = rows[:limit] + + chats = [] + for row in page_rows: + cur.execute( + "SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", + (row["id"],) + ) + members = [m["user_id"] for m in cur.fetchall()] + chats.append({ + "id": row["id"], + "title": row["title"], + "member_ids": members, + "created_at": row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + }) + + next_cursor = None + if has_more and chats: + last = page_rows[-1] + next_cursor = f"{last['created_at'].strftime('%Y-%m-%dT%H:%M:%SZ')},{last['id']}" + + return chats, next_cursor + + def create_message(self, chat_id: str, sender_id: str, text: str) -> dict: + with get_db() as conn: + with conn.cursor() as cur: + # Проверяем, что чат существует и отправитель является участником + cur.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, sender_id) + ) + if not cur.fetchone(): + cur.execute("SELECT id FROM chats WHERE id = %s", (chat_id,)) + if cur.fetchone(): + raise ValueError("sender_not_in_chat") + raise ValueError("chat_not_found") + + message_id = str(uuid4()) + now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') + + cur.execute( + "INSERT INTO messages (id, chat_id, sender_id, text, created_at) " + "VALUES (%s, %s, %s, %s, %s)", + (message_id, chat_id, sender_id, text, now) + ) + + return { + "id": message_id, + "chat_id": chat_id, + "sender_id": sender_id, + "text": text, + "created_at": now + } + + def list_messages(self, chat_id: str, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> Tuple[List[dict], Optional[str]]: + with get_db() as conn: + with conn.cursor() as cur: + # Проверяем, что пользователь является участником чата + cur.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, user_id) + ) + if not cur.fetchone(): + cur.execute("SELECT id FROM chats WHERE id = %s", (chat_id,)) + if cur.fetchone(): + raise ValueError("user_not_in_chat") + raise ValueError("chat_not_found") + + query = """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s + """ + params = [chat_id] + + if cursor: + cursor_parts = cursor.split(",", 1) + if len(cursor_parts) == 2: + cursor_time, cursor_id = cursor_parts + query += " AND (created_at, id) > (%s::timestamptz, %s::uuid)" + params.extend([cursor_time, cursor_id]) + + query += " ORDER BY created_at, id LIMIT %s" + params.append(limit + 1) + + cur.execute(query, params) + rows = cur.fetchall() + + has_more = len(rows) > limit + page_rows = rows[:limit] + + messages = [{ + "id": row["id"], + "chat_id": row["chat_id"], + "sender_id": row["sender_id"], + "text": row["text"], + "created_at": row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + } for row in page_rows] + + next_cursor = None + if has_more and messages: + last = page_rows[-1] + next_cursor = f"{last['created_at'].strftime('%Y-%m-%dT%H:%M:%SZ')},{last['id']}" + + return messages, next_cursor + + +store = PostgresStore() \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..1d5bdd25 --- /dev/null +++ b/src/main.py @@ -0,0 +1,305 @@ +import base64 +from fastapi import FastAPI, Request, HTTPException, Query +from fastapi.responses import JSONResponse, Response +from fastapi.exceptions import RequestValidationError +from typing import Optional +from uuid import uuid4 +from .models import ( + CreateUserRequest, CreateChatRequest, CreateMessageRequest, + UserResponse, ChatResponse, MessageResponse, ChatPage, MessagePage, + SessionResponse, HealthResponse +) +from .database import store, init_db, get_db_connection +from .auth import hash_password, verify_password, create_session, get_session, delete_session + +app = FastAPI() + +# Инициализация БД при старте +@app.on_event("startup") +async def startup_event(): + init_db() + + +# Middleware для генерации X-Request-Id +@app.middleware("http") +async def add_request_id(request: Request, call_next): + request_id = str(uuid4()) + request.state.request_id = request_id + response = await call_next(request) + response.headers["X-Request-Id"] = request_id + return response + + +# Обработчик ошибок валидации Pydantic (422 → 400) +@app.exception_handler(RequestValidationError) +async def validation_exception_handler(request: Request, exc: RequestValidationError): + request_id = getattr(request.state, "request_id", str(uuid4())) + content = { + "error": { + "code": "invalid_request", + "message": "Неверный формат запроса, неверные типы данных или лишние поля", + "request_id": request_id + } + } + return JSONResponse(status_code=400, content=content) + + +# Глобальный обработчик HTTP ошибок +@app.exception_handler(HTTPException) +async def http_exception_handler(request: Request, exc: HTTPException): + request_id = getattr(request.state, "request_id", str(uuid4())) + + # Копируем headers из HTTPException, если они есть + headers = dict(exc.headers) if exc.headers else {} + + # Если нет WWW-Authenticate, добавляем по умолчанию для 401 + if exc.status_code == 401 and "WWW-Authenticate" not in headers: + if "/auth/sessions" in str(request.url.path): + headers["WWW-Authenticate"] = 'Basic realm="messenger", charset="UTF-8"' + else: + headers["WWW-Authenticate"] = 'Bearer realm="messenger"' + + if isinstance(exc.detail, dict) and "error" in exc.detail: + content = exc.detail + content["error"]["request_id"] = request_id + else: + code_map = { + 400: "invalid_request", 401: "unauthorized", 404: "not_found", + 409: "conflict", 413: "payload_too_large", 415: "unsupported_media_type", + 429: "rate_limited", 500: "internal_error", 503: "unavailable" + } + code = code_map.get(exc.status_code, "invalid_request") + content = { + "error": { + "code": code, + "message": str(exc.detail), + "request_id": request_id + } + } + + return JSONResponse(status_code=exc.status_code, content=content, headers=headers) + + +# Вспомогательная функция для получения текущего пользователя из Bearer токена +async def get_current_user_from_request(request: Request) -> dict: + auth_header = request.headers.get("Authorization") + if not auth_header or not auth_header.startswith("Bearer "): + raise HTTPException( + status_code=401, + detail="Missing or invalid Authorization header", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'} + ) + + token = auth_header[7:] # Убираем "Bearer " + + conn = get_db_connection() + try: + session = get_session(conn, token) + if not session: + raise HTTPException( + status_code=401, + detail="Invalid or expired session", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'} + ) + + user = store.get_user(session["user_id"]) + if not user: + raise HTTPException( + status_code=401, + detail="User not found", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'} + ) + + return user + finally: + conn.close() + +# --- Health endpoints --- +@app.get("/health/live", response_model=HealthResponse) +async def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready", response_model=HealthResponse) +async def health_ready(): + try: + conn = get_db_connection() + conn.close() + return {"status": "ok"} + except Exception: + raise HTTPException(status_code=503, detail="Database unavailable") + + +# --- Auth endpoints --- +@app.post("/api/v1/auth/sessions", response_model=SessionResponse, status_code=201) +async def create_session_endpoint(request: Request): + # Проверяем Basic auth + auth_header = request.headers.get("Authorization") + if not auth_header or not auth_header.startswith("Basic "): + raise HTTPException( + status_code=401, + detail="Missing Basic authentication", + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} + ) + + try: + # Декодируем base64(username:password) + decoded = base64.b64decode(auth_header[6:]).decode('utf-8') + # Пароль может содержать двоеточие, поэтому split только по первому + username, password = decoded.split(":", 1) + except Exception: + raise HTTPException(status_code=400, detail="Invalid Basic authentication format") + + # Валидация username (ASCII [a-z0-9_]{3,32}) + import re + if not re.match(r'^[a-z0-9_]{3,32}$', username): + raise HTTPException(status_code=400, detail="Invalid username format") + + # Валидация пароля (12-128 code points) + if len(password) < 12 or len(password) > 128: + raise HTTPException(status_code=400, detail="Password must be 12-128 characters") + + # Ищем пользователя + user = store.get_user_by_username(username) + if not user: + raise HTTPException(status_code=401, detail="Invalid credentials") + + # Проверяем пароль + if not verify_password(password, user["password_hash"]): + raise HTTPException(status_code=401, detail="Invalid credentials") + + # Создаём сессию + conn = get_db_connection() + try: + session_data = create_session(conn, user["id"]) + + return { + "token": session_data["token"], + "token_type": "Bearer", + "expires_at": session_data["expires_at"], + "user": { + "id": user["id"], + "username": user["username"], + "display_name": user["display_name"], + "created_at": user["created_at"] + } + } + finally: + conn.close() + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def revoke_session(request: Request): + user = await get_current_user_from_request(request) + + auth_header = request.headers.get("Authorization") + token = auth_header[7:] # Убираем "Bearer " + + conn = get_db_connection() + try: + delete_session(conn, token) + finally: + conn.close() + + return Response(status_code=204) + + +# --- Users endpoints --- +@app.post("/api/v1/users", response_model=UserResponse, status_code=201) +async def create_user(request_body: CreateUserRequest): + try: + password_hash = hash_password(request_body.password) + user = store.create_user( + request_body.username, + request_body.display_name, + password_hash + ) + return user + except ValueError as e: + if str(e) == "username_already_exists": + raise HTTPException(status_code=409, detail="Username already exists") + raise HTTPException(status_code=400, detail=str(e)) + + +@app.get("/api/v1/users/me", response_model=UserResponse) +async def get_current_user(request: Request): + user = await get_current_user_from_request(request) + return user + + +# --- Chats endpoints --- +@app.post("/api/v1/chats", response_model=ChatResponse, status_code=201) +async def create_chat(request_body: CreateChatRequest, request: Request): + user = await get_current_user_from_request(request) + + try: + chat = store.create_chat(request_body.title, request_body.member_ids, user["id"]) + return chat + except ValueError as e: + if str(e) == "user_not_found": + raise HTTPException(status_code=400, detail="One or more members not found") + if str(e) == "creator_not_in_members": + raise HTTPException(status_code=400, detail="Creator must be in member list") + if str(e) == "duplicate_members": + raise HTTPException(status_code=400, detail="Duplicate member IDs") + raise HTTPException(status_code=400, detail=str(e)) + + +@app.get("/api/v1/chats", response_model=ChatPage) +async def list_chats( + request: Request, + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1) +): + user = await get_current_user_from_request(request) + chats, next_cursor = store.list_chats(user["id"], limit, cursor) + return {"items": chats, "next_cursor": next_cursor} + + +@app.get("/api/v1/chats/{chat_id}", response_model=ChatResponse) +async def get_chat(chat_id: str, request: Request): + user = await get_current_user_from_request(request) + chat = store.get_chat(chat_id, user["id"]) + if not chat: + raise HTTPException(status_code=404, detail="Chat not found") + return chat + + +# --- Messages endpoints --- +@app.post("/api/v1/chats/{chat_id}/messages", response_model=MessageResponse, status_code=201) +async def create_message( + chat_id: str, + request_body: CreateMessageRequest, + request: Request +): + user = await get_current_user_from_request(request) + + try: + message = store.create_message(chat_id, user["id"], request_body.text) + return message + except ValueError as e: + if str(e) == "chat_not_found": + raise HTTPException(status_code=404, detail="Chat not found") + if str(e) == "sender_not_in_chat": + raise HTTPException(status_code=404, detail="User not in chat") + raise HTTPException(status_code=400, detail=str(e)) + + +@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage) +async def list_messages( + chat_id: str, + request: Request, + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1) +): + user = await get_current_user_from_request(request) + + try: + messages, next_cursor = store.list_messages(chat_id, user["id"], limit, cursor) + return {"items": messages, "next_cursor": next_cursor} + except ValueError as e: + if str(e) == "chat_not_found": + raise HTTPException(status_code=404, detail="Chat not found") + if str(e) == "user_not_in_chat": + raise HTTPException(status_code=404, detail="User not in chat") + raise HTTPException(status_code=400, detail=str(e)) \ No newline at end of file diff --git a/src/migrations/001_initial.sql b/src/migrations/001_initial.sql new file mode 100644 index 00000000..30df30d5 --- /dev/null +++ b/src/migrations/001_initial.sql @@ -0,0 +1,51 @@ +-- Миграция 001: начальная схема для MTUSI Messenger Lab 2 +-- Запускать idempotently (безопасно повторять) + +-- Таблица пользователей +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + username VARCHAR(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name VARCHAR(100) NOT NULL CHECK (length(display_name) >= 1), + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- Таблица чатов +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + title VARCHAR(100) NOT NULL CHECK (length(title) >= 1), + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- Таблица участников чата +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +-- Таблица сообщений +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + text TEXT NOT NULL CHECK (length(text) >= 1 AND length(text) <= 4000), + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- Таблица сессий +CREATE TABLE IF NOT EXISTS sessions ( + token TEXT PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- Индекс для cursor-based пагинации сообщений +CREATE INDEX IF NOT EXISTS idx_messages_chat_created ON messages(chat_id, created_at, id); + +-- Индекс для очистки истёкших сессий +CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions(expires_at); + +-- Индекс для быстрого поиска чатов пользователя +CREATE INDEX IF NOT EXISTS idx_chat_members_user ON chat_members(user_id); \ No newline at end of file diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..2db90f1c --- /dev/null +++ b/src/models.py @@ -0,0 +1,97 @@ +from datetime import datetime, timezone +from typing import Optional, List +from pydantic import BaseModel, Field, field_validator +import re + + +class CreateUserRequest(BaseModel): + username: str = Field(..., min_length=3, max_length=32) + display_name: str = Field(..., min_length=1, max_length=100) + password: str = Field(..., min_length=12, max_length=128) + + @field_validator('username') + @classmethod + def validate_username(cls, v): + if not re.match(r'^[a-z0-9_]{3,32}$', v): + raise ValueError('username должен содержать только a-z, 0-9, _ (3-32 символа)') + return v + + @field_validator('display_name') + @classmethod + def validate_display_name(cls, v): + if not v.strip(): + raise ValueError('display_name не может состоять только из пробелов') + return v + + @field_validator('password') + @classmethod + def validate_password(cls, v): + if not v.strip(): + raise ValueError('password не может состоять только из пробелов') + return v + + +class CreateChatRequest(BaseModel): + title: str = Field(..., min_length=1, max_length=100) + member_ids: List[str] = Field(..., min_length=1, max_length=100) + + @field_validator('title') + @classmethod + def validate_title(cls, v): + if not v.strip(): + raise ValueError('title не может состоять только из пробелов') + return v + + +class CreateMessageRequest(BaseModel): + text: str = Field(..., min_length=1, max_length=4000) + + @field_validator('text') + @classmethod + def validate_text(cls, v): + if not v.strip(): + raise ValueError('text не может состоять только из пробелов') + return v + + +class UserResponse(BaseModel): + id: str + username: str + display_name: str + created_at: str + + +class ChatResponse(BaseModel): + id: str + title: str + member_ids: List[str] + created_at: str + + +class MessageResponse(BaseModel): + id: str + chat_id: str + sender_id: str + text: str + created_at: str + + +class ChatPage(BaseModel): + items: List[ChatResponse] + next_cursor: Optional[str] = None + + +class MessagePage(BaseModel): + items: List[MessageResponse] + next_cursor: Optional[str] = None + + +class SessionResponse(BaseModel): + token: str + token_type: str = "Bearer" + expires_at: str + user: UserResponse + + +class HealthResponse(BaseModel): + status: str = "ok" \ No newline at end of file