feat-(all routes, models, migration completed)

This commit is contained in:
2026-11-06 13:39:33 +03:00
parent d1a8c0394b
commit 97caa7e8ff
21 changed files with 319 additions and 230 deletions
+1 -1
View File
@@ -1,4 +1,4 @@
PYTHON ?= python3
PYTHON ?= python
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
+12 -30
View File
@@ -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)]
+34 -4
View File
@@ -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
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
+2 -2
View File
@@ -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)
+4 -2
View File
@@ -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)
+3 -4
View File
@@ -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())
+48 -35
View File
@@ -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)
+87 -31
View File
@@ -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"),
)
+2 -1
View File
@@ -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
+12 -9
View File
@@ -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"),
)
+15 -13
View File
@@ -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")
+4 -4
View File
@@ -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)
+27 -34
View File
@@ -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;
+1 -2
View File
@@ -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())
+8 -7
View File
@@ -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"<Chat(id={self.id}, title={self.title})>"
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"<Chat_Member(chat_id={self.chat_id}, user_id={self.user.id})>"
return f"<ChatMember(chat_id={self.chat_id}, user_id={self.user_id})>"
+35 -46
View File
@@ -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"<Message(id={self.id}, chat_id={self.chat_id}, text={self.text[:20]})>"
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"<Message(id={self.id}, chat_id={self.chat_id}, text={self.text[:20]}...)>"
+4 -3
View File
@@ -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="время создания сессии")
+2 -1
View File
@@ -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:
+1 -1
View File
@@ -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")
+1
View File
@@ -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")
+16
View File
@@ -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})