diff --git a/Makefile b/Makefile index 9ecb223..e732da2 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -PYTHON ?= python3 +PYTHON ?= python BASE_URL ?= http://localhost:8080 CA_FILE ?= ACTION_SCRIPT ?= diff --git a/src/api/dependencies.py b/src/api/dependencies.py index 1cb6864..6113e10 100644 --- a/src/api/dependencies.py +++ b/src/api/dependencies.py @@ -1,8 +1,5 @@ -from datetime import datetime, timezone from fastapi import Request, HTTPException, Depends, status -from fastapi.responses import JSONResponse from typing import Annotated -import uuid from src.api.repositories.main_repo import Repository from src.models.users import User from src.auth.tokens import hash_token @@ -13,26 +10,15 @@ from src.database import get_db type DbSession = Annotated[AsyncSession, Depends(get_db)] ##Dependency Injection -def get_now_iso(): - return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") - - async def get_current_user(request: Request, session: DbSession) -> User: repo = Repository(session) - path = request.url.path - method = request.method - - if path in ["/health/ready", "/health/live"]: - return None - if path == "/api/v1/users" and method == "POST": - return None auth_header = request.headers.get("Authorization") if not auth_header or not auth_header.startswith("Bearer "): raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="missing or invalid Bearer token", - headers={"WWW-Authenticate": "Bearer"}, + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, ) raw_token = auth_header[7:] @@ -40,25 +26,21 @@ async def get_current_user(request: Request, session: DbSession) -> User: current_session = await repo.sessions.get_by_token_hash(token_hash) if not current_session: - raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, - detail="invalid or expired token", - headers={"WWW-Authenticate": "Bearer"}) + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="invalid or expired token", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) user = await repo.users.get_by_id(current_session.user_id) if not user: - raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, - deatil="user not found", - headers={"WWW-Authenticate": "Bearer"}) + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="user not found", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + return user -def generate_id() -> str: - return str(uuid.uuid4()) - - -def create_error_response(message: str, code: str, status_code: int, request_id: str) -> JSONResponse: - body = {"error": {"code": code, "message": message, "request_id": request_id}} - return JSONResponse(status_code=status_code, content=body, headers={"X-Request-Id": request_id}) - - type CurrentUser = Annotated[User, Depends(get_current_user)] \ No newline at end of file diff --git a/src/api/repositories/chat_repo.py b/src/api/repositories/chat_repo.py index eb6b2be..c95ac67 100644 --- a/src/api/repositories/chat_repo.py +++ b/src/api/repositories/chat_repo.py @@ -1,6 +1,6 @@ import uuid from datetime import datetime -from typing import Optional, List +from typing import Optional, List, Tuple from sqlalchemy import select, delete from sqlalchemy.ext.asyncio import AsyncSession @@ -11,8 +11,8 @@ from src.api.repositories.core import DatabaseManager class ChatRepo(DatabaseManager): - def __init__(self, session: AsyncSession, model: Chat): - super().__init__(session, model) + def __init__(self, session: AsyncSession): + super().__init__(session, Chat) async def create_with_members(self, title: str, member_ids: List[uuid.UUID]) -> Optional[Chat]: @@ -63,4 +63,34 @@ class ChatRepo(DatabaseManager): except Exception as e: await self.session.rollback() raise - \ No newline at end of file + + + async def get_user_chats_paginated( + self, + user_id: uuid.UUID, + limit: int = 50, + cursor_created_at: Optional[datetime] = None, + cursor_chat_id: Optional[uuid.UUID] = None, + ) -> Tuple[List[Chat], bool]: + + query = (select(Chat).join(ChatMember, Chat.id == ChatMember.chat_id).options(selectinload(Chat.members)).where(ChatMember.user_id == user_id).order_by(Chat.created_at.asc(), Chat.id.asc())) + + if cursor_created_at is not None and cursor_chat_id is not None: + query = query.where( + (Chat.created_at > cursor_created_at) | + ( + (Chat.created_at == cursor_created_at) & + (Chat.id > cursor_chat_id) + ) + ) + + query = query.limit(limit + 1) + + result = await self.session.execute(query) + chats = list(result.scalars().all()) + + has_more = len(chats) > limit + if has_more: + chats = chats[:limit] + + return chats, has_more \ No newline at end of file diff --git a/src/api/repositories/message_repo.py b/src/api/repositories/message_repo.py index 6d188d8..9333674 100644 --- a/src/api/repositories/message_repo.py +++ b/src/api/repositories/message_repo.py @@ -10,8 +10,8 @@ from src.api.repositories.core import DatabaseManager class MessageRepo(DatabaseManager): - def __init__(self, session: AsyncSession, model: Message): - super().__init__(session, model) + def __init__(self, session: AsyncSession): + super().__init__(session, Message) async def create(self, chat_id: uuid.UUID, sender_id: uuid.UUID, text: str) -> Message: return await super().create(chat_id=chat_id, sender_id=sender_id, text=text) diff --git a/src/api/repositories/session_repo.py b/src/api/repositories/session_repo.py index 275c132..64f413d 100644 --- a/src/api/repositories/session_repo.py +++ b/src/api/repositories/session_repo.py @@ -4,10 +4,12 @@ from datetime import datetime from typing import Optional from src.models.sessions import Session from src.api.repositories.core import DatabaseManager +from src.models.sessions import Session + class SessionRepo(DatabaseManager): - def __init__(self, session: AsyncSession, model: Session): - super().__init__(session, model) + def __init__(self, session: AsyncSession): + super().__init__(session, Session) async def create(self, token_hash: str, user_id: uuid.UUID, expires_at: datetime) -> Optional[Session]: result = await super().create(token_hash=token_hash, user_id=user_id, expires_at=expires_at) diff --git a/src/api/repositories/user_repo.py b/src/api/repositories/user_repo.py index d82612f..6364a9c 100644 --- a/src/api/repositories/user_repo.py +++ b/src/api/repositories/user_repo.py @@ -1,15 +1,14 @@ import uuid -from datetime import datetime from typing import Optional from sqlalchemy.ext.asyncio import AsyncSession from src.models.users import User from src.api.repositories.core import DatabaseManager -from src.api.dependencies import generate_id +from src.utils import generate_id class UserRepo(DatabaseManager): - def __init__(self, session: AsyncSession, model: User): - super().__init__(session, model) + def __init__(self, session: AsyncSession): + super().__init__(session, User) async def get_by_username(self, username: str) -> Optional[User]: result = await super().get_by_field("username", username.lower()) diff --git a/src/api/routes/auth/auth.py b/src/api/routes/auth/auth.py index 3e2f16d..1b876ea 100644 --- a/src/api/routes/auth/auth.py +++ b/src/api/routes/auth/auth.py @@ -1,8 +1,5 @@ -from datetime import datetime, timezone -from typing import Annotated import base64 -from fastapi import APIRouter, HTTPException, Request, Response, status, Depends -from sqlalchemy.ext.asyncio import AsyncSession +from fastapi import APIRouter, HTTPException, Request, Response, status from src.api.dependencies import DbSession, CurrentUser from src.pydantic_valid.session import SessionUser, SessionCreateResponse from src.api.repositories.main_repo import Repository @@ -10,10 +7,9 @@ from src.auth.password import verify_password from src.auth.tokens import generate_token, hash_token, calculate_expires_at from src.config import settings - - router = APIRouter(prefix="/v1/auth") + @router.post("/sessions", response_model=SessionCreateResponse, status_code=status.HTTP_201_CREATED) async def create_session(request: Request, session: DbSession): repo = Repository(session) @@ -23,40 +19,49 @@ async def create_session(request: Request, session: DbSession): raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="missing or invalid Basic auth header", - headers={"WWW-Authenticate": "Basic"}, + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}, ) try: encoded_credentials = auth_header[6:] decoded = base64.b64decode(encoded_credentials).decode("utf-8") username, password = decoded.split(":", 1) except Exception: - raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, - detail="invalid credentials format", - headers={"WWW-Authenticate": "Basic"}) + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="invalid credentials format", + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}, + ) user = await repo.users.get_by_username(username) if not user: - raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, - detail="invalid username or password", - headers={"WWW-Authenticate": "Basic"}) + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="invalid username or password", + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}, + ) + if not verify_password(password, user.password_hash): - raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, - detail="invalid username or password", - headers={"WWW-Authenticate": "Basic"}) + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="invalid username or password", + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}, + ) + raw_token, token_hash = generate_token() expires_at = calculate_expires_at(settings.SESSION_TTL_SECONDS) await repo.sessions.create(token_hash=token_hash, user_id=user.id, expires_at=expires_at) - return SessionCreateResponse(token=raw_token, - expires_at=expires_at.strftime("%Y-%m-%dT%H:%M:%SZ"), - user=SessionUser( - id=str(user.id), - username=user.username, - display_name=user.display_name, - created_at=user.created_at.strftime("%Y-%m-%dT%H:%M:%SZ"), - ), - ) + return SessionCreateResponse( + token=raw_token, + expires_at=expires_at.strftime("%Y-%m-%dT%H:%M:%SZ"), + user=SessionUser( + id=str(user.id), + username=user.username, + display_name=user.display_name, + created_at=user.created_at.strftime("%Y-%m-%dT%H:%M:%SZ"), + ), + ) @router.delete("/sessions/current", status_code=status.HTTP_204_NO_CONTENT) @@ -65,24 +70,32 @@ async def delete_current_session(request: Request, session: DbSession, current_u auth_header = request.headers.get("Authorization") if not auth_header or not auth_header.startswith("Bearer "): - raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, - detail="invalid or missing Bearer token") + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="invalid or missing Bearer token", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) raw_token = auth_header[7:] token_hash = hash_token(raw_token) user_session = await repo.sessions.get_by_token_hash(token_hash) if not user_session: - raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, - detail="invalid token") + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="invalid token", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) - if not user_session.user_id == current_user.id: - raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, - detail="token in request doesn't align with current_user") + if user_session.user_id != current_user.id: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="token in request doesn't align with current_user", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) deleted = await repo.sessions.delete_by_token_hash(token_hash) if not deleted: - raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, - detail="invalid or expired token") + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="invalid or expired token", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) - return Response(status_code=status.HTTP_204_NO_CONTENT) + return Response(status_code=status.HTTP_204_NO_CONTENT) \ No newline at end of file diff --git a/src/api/routes/chats/chat.py b/src/api/routes/chats/chat.py index 168732e..ef7cc19 100644 --- a/src/api/routes/chats/chat.py +++ b/src/api/routes/chats/chat.py @@ -1,57 +1,113 @@ from fastapi import HTTPException, APIRouter, Query from typing import Optional from uuid import UUID +import datetime from src.pydantic_valid.chat import CreateChat, Chat from src.pydantic_valid.page_response import PageResponse -from src.api.dependencies import CurrentUser, Repo, generate_id, get_now_iso +from src.api.dependencies import CurrentUser, DbSession +from src.api.repositories.main_repo import Repository +from src.utils import generate_id, get_now_iso +import base64 router = APIRouter() +def _encode_chat_cursor(created_at: str, chat_id: str) -> str: + raw = f"c|{created_at}|{chat_id}" + return base64.urlsafe_b64encode(raw.encode("utf-8")).decode("ascii").rstrip("=") + + +def _decode_chat_cursor(cursor: str) -> tuple[str, str]: + try: + padded = cursor + "=" * (-len(cursor) % 4) + raw = base64.urlsafe_b64decode(padded).decode("utf-8") + parts = raw.split("|", 2) + if len(parts) != 3 or parts[0] != "c": + raise ValueError("bad cursor structure") + created_at, chat_id = parts[1], parts[2] + except Exception as e: + raise HTTPException(status_code=400, detail="invalid cursor") from e + + return created_at, chat_id + + @router.post("/v1/chats", response_model=Chat, status_code=201) -async def chat(current_user: CurrentUser, repo: Repo, chat_in:CreateChat) -> Chat: - if current_user.id not in chat_in.member_ids: - raise HTTPException(statuc_code=400, detail="Creator of chat should be in chat member list") - for usr in chat_in.member_ids: - if usr not in repo.users.users_db: +async def create_chat(session: DbSession, current_user: CurrentUser, chat_in: CreateChat) -> Chat: + repo = Repository(session) + + if str(current_user.id) not in chat_in.member_ids: + raise HTTPException(status_code=400, detail="Creator of chat should be in chat member list") + + member_uuids = [UUID(mid) for mid in chat_in.member_ids] + + for member_id in member_uuids: + user = await repo.users.get_by_id(member_id) + if not user: raise HTTPException(status_code=400, detail="Unexisting user_id in chat member list") - chat_data = Chat( - id = generate_id(), - title = chat_in.title, - member_ids = chat_in.member_ids, - created_at = get_now_iso() + + chat = await repo.chats.create_with_members(title=chat_in.title, member_ids=member_uuids) + + return Chat( + id=str(chat.id), + title=chat.title, + member_ids=[str(m.user_id) for m in chat.members], + created_at = chat.created_at.strftime("%Y-%m-%dT%H:%M:%SZ") ) - await repo.create_chat(chat_data) - return chat_data @router.get("/v1/chats", response_model=PageResponse) -async def list_chats(current_user: CurrentUser, repo: Repo, limit: int = Query(default=50, ge=1, le=100), cursor: Optional[str] = Query(default=None, min_length=1)) -> PageResponse: - accessible_chats = [c for c in repo.chats.chats_db.values() - if current_user.id in c["member_ids"]] - accessible_chats.sort(key=lambda x: (x["created_at"], x["id"])) +async def list_chats(current_user: CurrentUser, session: DbSession, limit: int = Query(default=50, ge=1, le=100), cursor: Optional[str] = Query(default=None, min_length=1)) -> PageResponse: + repo = Repository(session) - start_idx = 0 + cursor_created_at = None + cursor_chat_id = None if cursor: - try: - start_idx = int(cursor) - except ValueError: - raise HTTPException(status_code=400, detail="Invalid cursor") - - page_items = accessible_chats[start_idx: start_idx + limit] + created_at_str, chat_id_str = _decode_chat_cursor(cursor) + cursor_created_at = datetime.fromisoformat(created_at_str.replace("Z", "+00:00")) + cursor_chat_id = UUID(chat_id_str) + + chats, has_more = await repo.chats.get_user_chats_paginated( + user_id=current_user.id, + limit=limit, + cursor_created_at=cursor_created_at, + cursor_chat_id=cursor_chat_id, + ) + next_cursor = None - if start_idx + limit < len(accessible_chats): - next_cursor = str(start_idx + limit) + if has_more and chats: + last = chats[-1] + next_cursor = _encode_chat_cursor( + created_at=last.created_at.strftime("%Y-%m-%dT%H:%M:%SZ"), + chat_id=str(last.id), + ) + + return PageResponse(items=[Chat( + id=str(c.id), + title=c.title, + member_ids=[str(m.user_id) for m in c.members], + created_at=c.created_at.strftime("%Y-%m-%dT%H:%M:%SZ")) + for c in chats], + next_cursor=next_cursor, + ) - return PageResponse(items=page_items, next_cursor=next_cursor) @router.get("/v1/chats/{chat_id}", response_model=Chat) -async def get_chat(current_user: CurrentUser, repo: Repo, chat_id: UUID) -> Chat: - chat = repo.chats.chats_db.get(str(chat_id)) +async def get_chat(current_user: CurrentUser, session: DbSession, chat_id: UUID) -> Chat: + repo = Repository(session) + + chat = await repo.chats.get_by_id_with_members(chat_id) if not chat: raise HTTPException(status_code=404, detail="Chat not found") - if current_user.id not in chat["member_ids"]: + + member_ids = {str(m.user_id) for m in chat.members} + if str(current_user.id) not in member_ids: raise HTTPException(status_code=404, detail="Chat not found") - return chat + + return Chat( + id=str(chat.id), + title=chat.title, + member_ids=[str(m.user_id) for m in chat.members], + created_at=chat.created_at.strftime("%Y-%m-%dT%H:%M:%SZ"), + ) diff --git a/src/api/routes/messages/message.py b/src/api/routes/messages/message.py index cb60e34..d50c28f 100644 --- a/src/api/routes/messages/message.py +++ b/src/api/routes/messages/message.py @@ -4,8 +4,9 @@ from typing import Optional from uuid import UUID from src.pydantic_valid.message import Message, CreateMessage from src.pydantic_valid.page_response import PageResponse -from src.api.dependencies import DbSession, CurrentUser, generate_id, get_now_iso +from src.api.dependencies import DbSession, CurrentUser from src.api.repositories.main_repo import Repository +from src.utils import generate_id, get_now_iso import datetime diff --git a/src/api/routes/users/user.py b/src/api/routes/users/user.py index a608eb0..5dbe95a 100644 --- a/src/api/routes/users/user.py +++ b/src/api/routes/users/user.py @@ -3,14 +3,15 @@ from src.pydantic_valid.user import CreateUser, User as UserSchema from src.models.users import User from src.api.repositories.main_repo import Repository from src.auth.password import hash_password -from src.api.dependencies import DbSession, CurrentUser, get_now_iso +from src.api.dependencies import DbSession, CurrentUser +from src.utils import get_now_iso router = APIRouter(prefix="/v1") @router.post("/users", response_model=UserSchema, status_code=201) -async def register_user(body: CreateUser, session: DbSession) -> User: +async def register_user(body: CreateUser, session: DbSession) -> UserSchema: repo = Repository(session) existing_user = await repo.users.get_by_username(body.username) if existing_user: @@ -30,15 +31,17 @@ async def register_user(body: CreateUser, session: DbSession) -> User: return UserSchema( id=str(new_user.id), username=new_user.username, - dispaly_name=new_user.display_name, + display_name=new_user.display_name, created_at=new_user.created_at.strftime("%Y-%m-%dT%H:%M:%SZ"), ) @router.get("/users/me", response_model=UserSchema, status_code=200) -async def get_me(session: DbSession, current_user: CurrentUser) -> User: - repo = Repository(session) - user = await repo.get_user(current_user.id) - if not user: - raise HTTPException(status_code=401, detail="Unknown user") - return user +async def get_me(current_user: CurrentUser) -> UserSchema: + + return UserSchema( + id=str(current_user.id), + username=current_user.username, + display_name=current_user.display_name, + created_at=current_user.created_at.strftime("%Y-%m-%dT%H:%M:%SZ"), + ) diff --git a/src/lifespan.py b/src/lifespan.py index 231a897..6c5f599 100644 --- a/src/lifespan.py +++ b/src/lifespan.py @@ -1,22 +1,24 @@ from contextlib import asynccontextmanager +from fastapi import FastAPI +from sqlalchemy import text + +from src.database import engine, close_engine from src.migrations.runner import run_migrations -from src.database import engine @asynccontextmanager -async def lifespan(): - print(f"Startup: begin sql migratoins") - run_migrations() +async def lifespan(app: FastAPI): - print(f"startup: initializing db") - async with engine.connect as conn: - await conn.execute( - __import__("sqlalchemy").text("SELECT 1") - ) - print(f"startup: database ready") + print("lifespan startup: applying migrations...") + await run_migrations() + + print("lifespan startup: initializing database engine...") + async with engine.connect() as conn: + await conn.execute(text("SELECT 1")) + print("lifespan startup: database ready") yield - print(f"shutdown: closing database connection") - await engine.dispose() - print(f"shutdown: complete") + print("lifespan shutdown: closing database engine...") + await close_engine() + print("lifespan shutdown: complete") \ No newline at end of file diff --git a/src/main.py b/src/main.py index 05cfbc8..b4139df 100644 --- a/src/main.py +++ b/src/main.py @@ -2,7 +2,7 @@ from fastapi import FastAPI, Request, HTTPException from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse import os -from src.api.dependencies import generate_id, create_error_response +from src.utils import generate_id, create_error_response from src.api.routes.health import health from src.api.routes.users import user from src.api.routes.chats import chat @@ -15,7 +15,7 @@ application = FastAPI(title="MTUSI Messenger", version="1.0.0", lifespan=lifespa @application.middleware("http") async def add_request_id(request: Request, call_next): - request_id = generate_id() + request_id = str(generate_id()) request.state.request_id = request_id response = await call_next(request) response.headers["X-Request-Id"] = request_id @@ -47,7 +47,7 @@ async def validation_exception_handler(request: Request, exc: RequestValidationE async def http_exception_handler(request: Request, exc: HTTPException): request_id = getattr(request.state, "request_id", None) if request_id is None: - request_id = generate_id() + request_id = str(generate_id()) code_map = { 400: "invalid_request", @@ -67,7 +67,7 @@ async def http_exception_handler(request: Request, exc: HTTPException): async def global_exception_handler(request: Request, exc: Exception): request_id = getattr(request.state, "request_id", None) if request_id is None: - request_id = generate_id() + request_id = str(generate_id()) print(f'Internal Error: {exc}') return create_error_response(message="Internal Server Error", code="internal_error", status_code=500, request_id=request_id) diff --git a/src/migrations/001_initial.sql b/src/migrations/001_initial.sql index bfb9694..5568680 100644 --- a/src/migrations/001_initial.sql +++ b/src/migrations/001_initial.sql @@ -1,70 +1,63 @@ BEGIN; -CREATE TABLE IF NOT EXISTS users( - id UUID PRIMARY_KEY +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, username VARCHAR(32) NOT NULL, display_name VARCHAR(100) NOT NULL, password_hash TEXT NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now(), - - CONSTRAINT users_username_unique UNIQUE(username), - CONSTRAINT users_username_pattern CHECK (username ~ '^[a-z0-9_]{3, 32}S') + + CONSTRAINT users_username_unique UNIQUE (username), + CONSTRAINT users_username_pattern CHECK (username ~ '^[a-z0-9_]{3,32}$'), CONSTRAINT users_display_name_length CHECK ( char_length(display_name) BETWEEN 1 AND 100 AND trim(display_name) <> '' ) ); -CREATE TABLE IF NOT EXISTS sessions( - token_hash CHAR(64) PRIMARY_KEY, +CREATE TABLE IF NOT EXISTS sessions ( + token_hash CHAR(64) PRIMARY KEY, user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, - created_at TIMESTAMPTZ NOT NULL DEFAULT now(), - expires_at TIMESTAMPTZ NOT NULL + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() ); -CREATE INDEX IF NOT EXISTS sessions_user_id_idx - ON sessions(user_id); +CREATE INDEX IF NOT EXISTS sessions_user_id_idx ON sessions(user_id); +CREATE INDEX IF NOT EXISTS sessions_expires_at_idx ON sessions(expires_at); -CREATE INDEX IF NOT EXISTS sessions_created_at_idx - ON sessions(created_at); - -CREATE TABLE IF NOT EXISTS chats( - id UUID PRIMARY_KEY, +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, title VARCHAR(100) NOT NULL, - created_at TIMESTAMPTZ DEFAULT now() - - CONSTRAINT chats_title_length CHECK( + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + + CONSTRAINT chats_title_length CHECK ( char_length(title) BETWEEN 1 AND 100 AND trim(title) <> '' ) ); -CREATE TABLE IF NOT EXISTS chat_members( +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) + PRIMARY KEY (chat_id, user_id) ); -CREATE INDEX IF NOT EXISTS chat_members_user_id_idx - ON chat_members(user_id); +CREATE INDEX IF NOT EXISTS chat_members_user_id_idx ON chat_members(user_id); -CREATE TABLE IN NOT EXISTS messages( - id UUID PRIMARY_KEY, - chat_id NOT NULL REFERENCES chats(id) ON DELETE CASCADE, - sender_id NOT NULL REFERENCES users(id) ON DELETE CASCADE, +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT, text TEXT NOT NULL, - created_at TIMESTAMPTZ NOT NULL DEFAULT now() - - CREATE CONSTRAINT messages_text_length CHECK( + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + + CONSTRAINT messages_text_length CHECK ( char_length(text) BETWEEN 1 AND 4000 AND trim(text) <> '' ) ); -CREATE INDEX IF NOT EXISTS messages_chat_created_id_idx +CREATE INDEX IF NOT EXISTS messages_chat_created_id_idx ON messages(chat_id, created_at, id); -CREATE INDEX IF NOT EXISTS messages_chat_id_idx - ON messages(chat_id); - COMMIT; \ No newline at end of file diff --git a/src/migrations/runner.py b/src/migrations/runner.py index 9a7c6f9..e9a84e3 100644 --- a/src/migrations/runner.py +++ b/src/migrations/runner.py @@ -24,7 +24,7 @@ async def run_migrations() -> None: return for sql_file in sql_files: print(f"migration applying {sql_file.name}") - sql = sql_file.read_text(encding="utf-8") + sql = sql_file.read_text(encoding="utf-8") await conn.execute(sql) print(f"mighration applied succesful to {sql_file.name}") print(f"All {len(sql_files)} migrations done") @@ -35,4 +35,3 @@ async def run_migrations() -> None: if __name__ == "__main__": asyncio.run(run_migrations()) - \ No newline at end of file diff --git a/src/models/chats.py b/src/models/chats.py index 3ee9f01..6e4adef 100644 --- a/src/models/chats.py +++ b/src/models/chats.py @@ -1,6 +1,7 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship from sqlalchemy.dialects.postgresql import UUID -from sqlalchemy import String, DateTime, ForeignKey, text +from sqlalchemy import String, DateTime, ForeignKey +from sqlalchemy.sql import text as sqltext import uuid from datetime import datetime from src.database import Base @@ -19,17 +20,17 @@ class Chat(Base): title: Mapped[str] = mapped_column(String(100), nullable=False) created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, - server_dafault=text("now()")) - members: Mapped[list["Chat_Member"]] = relationship("Member_Chat", - cascade="True", - back_populates="") + server_default=sqltext("now()")) + members: Mapped[list["ChatMember"]] = relationship("ChatMember", + cascade="all, delete-orphan", + back_populates="chat") def __repr__(self) -> str: return f"" -class Chat_Member(Base): +class ChatMember(Base): __tablename__ = "chat_members" chat_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), @@ -44,5 +45,5 @@ class Chat_Member(Base): def __repr__(self) -> str: - return f"" + return f"" \ No newline at end of file diff --git a/src/models/messages.py b/src/models/messages.py index eee3e30..7ab4a23 100644 --- a/src/models/messages.py +++ b/src/models/messages.py @@ -1,56 +1,45 @@ -from sqlalchemy import String, DateTime, ForeignKey, Text, text -from sqlalchemy.orm import Mapped, mapped_column -from sqlalchemy.dialects.postgresql import UUID -from typing import TYPING_CHECKING import uuid from datetime import datetime +from sqlalchemy import String, DateTime, ForeignKey, Text +from sqlalchemy.sql import text as sql_text +from sqlalchemy.dialects.postgresql import UUID +from sqlalchemy.orm import Mapped, mapped_column + from src.database import Base -# if TYPING_CHECKING: -# from src.models.users import User -# from src.models.chats import Chat - - class Message(Base): __tablename__ = "messages" - id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), - primary_key=True, - server_default=uuid.uuid4) - chat_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), - ForeignKey("chats.id", ondelete="CASCADE"), - nullable=False, - index="True") - sender_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), - ForeignKey("users.id", ondelete="RESTRICT"), - nullable=False) - text: Mapped[str] = mapped_column(Text, - nullable=False) - created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), - nullable=False, - server_default=text("now()")) - - - def __repr__(self): - return f"" - + id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + primary_key=True, + default=uuid.uuid4 + ) - # async def append_message(self, chat_id: str, msg: dict) -> bool: - # if chat_id not in self.message_db: - # return False - # else: - # self.message_db[chat_id].append(msg) - # self._cache_valid[chat_id] = False - # return True + chat_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + ForeignKey("chats.id", ondelete="CASCADE"), + nullable=False, + index=True + ) + + sender_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), + ForeignKey("users.id", ondelete="RESTRICT"), + nullable=False + ) + + text: Mapped[str] = mapped_column( + Text, + nullable=False + ) + + created_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), + nullable=False, + server_default=sql_text("now()") + ) - - # def get_sorted_messages(self, chat_id: str) -> list[dict]: - # if chat_id not in self.message_db: - # return [] - # if self._cache_valid.get(chat_id, False) and chat_id in self._sorted_cache: - # return self._sorted_cache[chat_id] - # sorted_msg = sorted(self.message_db[chat_id], key=lambda x: (x["created_at"], x["id"])) - # self._sorted_cache[chat_id] = sorted_msg - # self._cache_valid[chat_id] = True - # return sorted_msg + def __repr__(self) -> str: + return f"" \ No newline at end of file diff --git a/src/models/sessions.py b/src/models/sessions.py index 4d6a8da..60316b8 100644 --- a/src/models/sessions.py +++ b/src/models/sessions.py @@ -2,7 +2,8 @@ import uuid from datetime import datetime from sqlalchemy.dialects.postgresql import UUID from sqlalchemy.orm import Mapped, mapped_column, relationship -from sqlalchemy import String, DateTime, ForeignKey, text +from sqlalchemy import String, DateTime, ForeignKey +from sqlalchemy.sql import text as sqltext from src.database import Base class Session(Base): @@ -11,7 +12,7 @@ class Session(Base): token_hash: Mapped[str] = mapped_column(String(64), primary_key=True, comment="SHA-256 opaque token") user_id: Mapped[uuid.UUID] = mapped_column( UUID(as_uuid=True), - ForeignKey("user.id", ondelete="CASCADE",), + ForeignKey("users.id", ondelete="CASCADE",), nullable=False, index=True, comment="Внешний ключ на идентификатор пользователя") @@ -21,7 +22,7 @@ class Session(Base): comment="время истечения сессии") created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, - server_default=text("now()"), + server_default=sqltext("now()"), comment="время создания сессии") diff --git a/src/models/users.py b/src/models/users.py index da90e63..7652222 100644 --- a/src/models/users.py +++ b/src/models/users.py @@ -1,6 +1,7 @@ from sqlalchemy import Column, String, DateTime, Text from sqlalchemy.dialects.postgresql import UUID from sqlalchemy.orm import Mapped, mapped_column +from sqlalchemy.sql import text as sqltext import uuid from datetime import datetime from src.database import Base @@ -13,7 +14,7 @@ class User(Base): username: Mapped[str] = mapped_column(String(32), unique=True, nullable=False, index=True, comment="Логин пользователя") display_name: Mapped[str] = mapped_column(String(100), nullable=False) password_hash: Mapped[str] = mapped_column(String, nullable=False, comment="Argon2id hash пароля") - created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True)) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=sqltext("now()"), nullable=False) def __repr__(self) -> str: diff --git a/src/pydantic_valid/chat.py b/src/pydantic_valid/chat.py index 03cf4ad..f370917 100644 --- a/src/pydantic_valid/chat.py +++ b/src/pydantic_valid/chat.py @@ -5,7 +5,7 @@ from pydantic import BaseModel, Field, field_validator, ConfigDict class CreateChat(BaseModel): model_config = ConfigDict(extra="forbid") title: str = Field(..., min_length=1, max_length=100) - member_ids: list[str] = Field(..., min_items=1, max_items=100) + member_ids: list[str] = Field(..., min_length=1, max_length=100) @field_validator("title") diff --git a/src/pydantic_valid/user.py b/src/pydantic_valid/user.py index 4d79a3d..d12d083 100644 --- a/src/pydantic_valid/user.py +++ b/src/pydantic_valid/user.py @@ -5,6 +5,7 @@ class CreateUser(BaseModel): model_config = ConfigDict(extra="forbid") username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$") display_name: str = Field(..., min_length=1, max_length=100) + password: str = Field(..., min_length=12, max_length=128) @field_validator("display_name") diff --git a/src/utils.py b/src/utils.py new file mode 100644 index 0000000..9ad8dcb --- /dev/null +++ b/src/utils.py @@ -0,0 +1,16 @@ +import uuid +from datetime import datetime, timezone +from fastapi.responses import JSONResponse + + +def generate_id() -> str: + return uuid.uuid4() + + +def get_now_iso() -> str: + return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + + +def create_error_response(message: str, code: str, status_code: int, request_id: str) -> JSONResponse: + body = {"error": {"code": code, "message": message, "request_id": request_id}} + return JSONResponse(status_code=status_code, content=body, headers={"X-Request-Id": request_id})