from __future__ import annotations import base64 import json import os import secrets import uuid from datetime import datetime, timedelta, timezone from pathlib import Path from typing import Any, Dict, List, Optional, Tuple import psycopg from psycopg_pool import ConnectionPool import redis from argon2 import PasswordHasher from fastapi import FastAPI, Header, HTTPException, Request from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse, Response from pydantic import BaseModel, ConfigDict, StringConstraints, ValidationError from typing_extensions import Annotated APP_HOST = os.getenv("APP_HOST", "0.0.0.0") APP_PORT = int(os.getenv("APP_PORT", "8080")) SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) INSTANCE_ID = os.getenv("INSTANCE_ID", uuid.uuid4().hex[:12]) USERNAME_RE = r"^[a-z0-9_]{3,32}$" class ApiError(Exception): def __init__(self, status_code: int, code: str, message: str, *, headers: Optional[Dict[str, str]] = None): self.status_code = status_code self.code = code self.message = message self.headers = headers or {} class UserOut(BaseModel): model_config = ConfigDict(extra="forbid") id: str username: str display_name: str created_at: str class SessionOut(BaseModel): model_config = ConfigDict(extra="forbid") token: str token_type: str expires_at: str user: UserOut class ChatOut(BaseModel): model_config = ConfigDict(extra="forbid") id: str title: str member_ids: List[str] created_at: str class MessageOut(BaseModel): model_config = ConfigDict(extra="forbid") id: str chat_id: str sender_id: str text: str created_at: str class CreateUserIn(BaseModel): model_config = ConfigDict(extra="forbid") username: Annotated[str, StringConstraints(pattern=USERNAME_RE, min_length=3, max_length=32)] display_name: Annotated[str, StringConstraints(min_length=1, max_length=100)] password: Annotated[str, StringConstraints(min_length=12, max_length=128)] class CreateChatIn(BaseModel): model_config = ConfigDict(extra="forbid") title: Annotated[str, StringConstraints(min_length=1, max_length=100)] member_ids: List[str] class CreateMessageIn(BaseModel): model_config = ConfigDict(extra="forbid") text: Annotated[str, StringConstraints(min_length=1, max_length=4000)] class Store: def __init__(self) -> None: self.connection_url = self._resolve_database_url() self.cache_url = self._resolve_cache_url() self.session_store = os.getenv("SESSION_STORE", "valkey") self.password_hasher = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=2, hash_len=32, salt_len=16) self.pool = ConnectionPool( self.connection_url, min_size=1, max_size=int(os.getenv("DB_POOL_MAX_SIZE", "10")), timeout=5, max_waiting=20, open=False, kwargs={"connect_timeout": 5, "autocommit": False, "options": "-c statement_timeout=5000 -c lock_timeout=500"}, ) def _resolve_database_url(self) -> str: value = os.getenv("DATABASE_URL") if value: return value secret_path = os.getenv("DATABASE_URL_FILE") if secret_path and os.path.exists(secret_path): with open(secret_path, "r", encoding="utf-8") as handle: return handle.read().strip() return os.getenv("DEFAULT_DATABASE_URL", "postgresql://messenger:messenger@localhost:5432/messenger") def _resolve_cache_url(self) -> str: value = os.getenv("CACHE_URL") if value: return value secret_path = os.getenv("CACHE_URL_FILE") if secret_path and os.path.exists(secret_path): with open(secret_path, "r", encoding="utf-8") as handle: return handle.read().strip() return os.getenv("DEFAULT_CACHE_URL", "redis://localhost:6379/0") def connect(self): return self.pool.connection() def cache_client(self): return redis.Redis.from_url(self.cache_url, decode_responses=True, socket_connect_timeout=2, socket_timeout=2) def cache_session(self, session: Dict[str, Any]) -> None: if self.session_store != "valkey": return try: client = self.cache_client() ttl_seconds = max(1, int((self.parse_session_expiry(session["expires_at"]) - self.utc_now()).total_seconds())) payload = json.dumps({ "token": session["token"], "user_id": session["user_id"], "expires_at": session["expires_at"], "revoked_at": session.get("revoked_at"), "user": session["user"], }, separators=(",", ":"), ensure_ascii=False) client.setex(f"session:{session['token']}", ttl_seconds, payload) except redis.RedisError: return def get_cached_session(self, token: str, *, db_session) -> Optional[Dict[str, Any]]: if self.session_store != "valkey": return None try: client = self.cache_client() payload = client.get(f"session:{token}") if not payload: return None data = json.loads(payload) session = { "token": data["token"], "user_id": data["user_id"], "expires_at": data["expires_at"], "revoked_at": data.get("revoked_at"), "user": data["user"], } if not self.is_session_valid(session): client.delete(f"session:{token}") return None if session != db_session: client.delete(f"session:{token}") return None return db_session except (redis.RedisError, KeyError, TypeError, ValueError): return None def delete_cached_session(self, token: str) -> None: if self.session_store != "valkey": return try: self.cache_client().delete(f"session:{token}") except redis.RedisError: return @staticmethod def parse_session_expiry(value: Any) -> datetime: if isinstance(value, datetime): return value.astimezone(timezone.utc) if isinstance(value, str): return datetime.fromisoformat(value.replace("Z", "+00:00")).astimezone(timezone.utc) raise ValueError("invalid session expiry") def init(self) -> None: migration_dir = Path(__file__).resolve().parent / "migrations" with self.connect() as conn: with conn.cursor() as cur: cur.execute( """ CREATE TABLE IF NOT EXISTS schema_migrations ( version TEXT PRIMARY KEY, applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW() ); """ ) applied = set() cur.execute("SELECT version FROM schema_migrations") for (version,) in cur.fetchall(): applied.add(version) for migration_path in sorted(migration_dir.glob("*.sql")): version = migration_path.stem if version in applied: continue sql = migration_path.read_text(encoding="utf-8") cur.execute(sql) cur.execute( "INSERT INTO schema_migrations(version, applied_at) VALUES (%s, %s)", (version, self.utc_now()), ) conn.commit() def utc_now(self) -> datetime: return datetime.now(timezone.utc) def isoformat_utc(self, value: datetime) -> str: return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z") def hash_password(self, password: str) -> str: return self.password_hasher.hash(password) def verify_password(self, password_hash: str, password: str) -> bool: try: self.password_hasher.verify(password_hash, password) return True except Exception: return False def require_user_by_username(self, username: str, conn): with conn.cursor() as cur: cur.execute("SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s", (username,)) row = cur.fetchone() if row is None: return None return { "id": str(row[0]), "username": row[1], "display_name": row[2], "created_at": self.isoformat_utc(row[3]), "password_hash": row[4], } def fetch_user(self, user_id: str, 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 is None: return None return { "id": str(row[0]), "username": row[1], "display_name": row[2], "created_at": self.isoformat_utc(row[3]), } def fetch_session_by_token(self, token: str, conn): with conn.cursor() as cur: cur.execute( "SELECT s.token, s.user_id, s.expires_at, s.revoked_at, u.id, u.username, u.display_name, u.created_at FROM sessions s JOIN users u ON u.id = s.user_id WHERE s.token = %s", (token,), ) row = cur.fetchone() if row is None: return None return { "token": row[0], "user_id": str(row[1]), "expires_at": self.isoformat_utc(row[2]), "revoked_at": row[3], "user": { "id": str(row[4]), "username": row[5], "display_name": row[6], "created_at": self.isoformat_utc(row[7]), }, } def list_member_ids(self, chat_id: str, conn) -> List[str]: with conn.cursor() as cur: cur.execute("SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", (chat_id,)) rows = cur.fetchall() return [str(row[0]) for row in rows] def fetch_chat(self, chat_id: str, conn): with conn.cursor() as cur: cur.execute("SELECT id, title, created_at FROM chats WHERE id = %s", (chat_id,)) row = cur.fetchone() if row is None: return None return { "id": str(row[0]), "title": row[1], "created_at": self.isoformat_utc(row[2]), "member_ids": self.list_member_ids(str(row[0]), conn), } def fetch_message(self, message_id: str, conn): with conn.cursor() as cur: cur.execute("SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE id = %s", (message_id,)) row = cur.fetchone() if row is None: return None return { "id": str(row[0]), "chat_id": str(row[1]), "sender_id": str(row[2]), "text": row[3], "created_at": self.isoformat_utc(row[4]), } def fetch_chat_membership(self, chat_id: str, user_id: str, conn) -> bool: with conn.cursor() as cur: cur.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user_id)) return cur.fetchone() is not None def insert_user(self, username: str, display_name: str, password: str): now = self.utc_now() user_id = uuid.uuid4() password_hash = self.hash_password(password) with self.connect() as conn: with conn.cursor() as cur: 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), ) conn.commit() return { "id": str(user_id), "username": username, "display_name": display_name, "created_at": self.isoformat_utc(now), } def insert_chat(self, title: str, member_ids: List[str], actor_id: str): now = self.utc_now() chat_id = uuid.uuid4() with self.connect() as conn: with conn.cursor() as cur: cur.execute("INSERT INTO chats(id,title,created_at) VALUES (%s,%s,%s)", (chat_id, title, now)) for member_id in sorted(set(member_ids)): cur.execute("INSERT INTO chat_members(chat_id,user_id) VALUES (%s,%s)", (chat_id, member_id)) conn.commit() return { "id": str(chat_id), "title": title, "member_ids": sorted(set(member_ids)), "created_at": self.isoformat_utc(now), } def insert_message(self, chat_id: str, sender_id: str, text: str): now = self.utc_now() message_id = uuid.uuid4() with self.connect() as conn: with conn.cursor() as cur: 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), ) conn.commit() return { "id": str(message_id), "chat_id": chat_id, "sender_id": sender_id, "text": text, "created_at": self.isoformat_utc(now), } @staticmethod def cursor_uuid_key(value: str) -> int: try: return uuid.UUID(value).int except (ValueError, TypeError): return 0 def list_chats_for_user(self, user_id: str, limit: int, cursor: Optional[str]): with self.connect() as conn: with conn.cursor() as cur: query = """ SELECT c.id, c.title, c.created_at FROM chats c JOIN chat_members cm ON cm.chat_id = c.id WHERE cm.user_id = %s """ params: List[Any] = [user_id] if cursor: prefix = f"user:{user_id}|" if not cursor.startswith(prefix): raise ApiError(400, "invalid_request", "cursor does not match user chat list") remainder = cursor[len(prefix):] if not remainder: raise ApiError(400, "invalid_request", "invalid cursor") try: cursor_ts_raw, cursor_id = remainder.split("|", 1) cursor_dt = datetime.fromisoformat(cursor_ts_raw.replace("Z", "+00:00")).astimezone(timezone.utc) except ValueError as exc: raise ApiError(400, "invalid_request", "invalid cursor") from exc query += " AND (c.created_at > %s OR (c.created_at = %s AND c.id > %s::uuid))" params.extend([cursor_dt, cursor_dt, cursor_id]) query += " ORDER BY c.created_at ASC, c.id ASC LIMIT %s" params.append(limit + 1) cur.execute(query, tuple(params)) rows = cur.fetchall() items = [ { "id": str(row[0]), "title": row[1], "created_at": self.isoformat_utc(row[2]), "member_ids": self.list_member_ids(str(row[0]), conn), } for row in rows ] next_cursor = None if len(items) > limit: last_item = items[limit - 1] next_cursor = f"user:{user_id}|{last_item['created_at']}|{last_item['id']}" items = items[:limit] return {"items": items, "next_cursor": next_cursor} def list_messages_for_chat(self, chat_id: str, limit: int, cursor: Optional[str]): with self.connect() as conn: with conn.cursor() as cur: query = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s" params: List[Any] = [chat_id] if cursor: prefix = f"chat:{chat_id}|" if not cursor.startswith(prefix): raise ApiError(400, "invalid_request", "cursor does not match chat") remainder = cursor[len(prefix):] if not remainder: raise ApiError(400, "invalid_request", "invalid cursor") try: cursor_ts_raw, cursor_id = remainder.split("|", 1) cursor_dt = datetime.fromisoformat(cursor_ts_raw.replace("Z", "+00:00")).astimezone(timezone.utc) except ValueError as exc: raise ApiError(400, "invalid_request", "invalid cursor") from exc query += " AND (created_at, id) > (%s, %s::uuid)" params.extend([cursor_dt, cursor_id]) query += " ORDER BY created_at ASC, id ASC LIMIT %s" params.append(limit + 1) cur.execute(query, tuple(params)) rows = cur.fetchall() items = [{ "id": str(row[0]), "chat_id": str(row[1]), "sender_id": str(row[2]), "text": row[3], "created_at": self.isoformat_utc(row[4]), } for row in rows] next_cursor = None if len(items) > limit: last_item = items[limit - 1] next_cursor = f"chat:{chat_id}|{last_item['created_at']}|{last_item['id']}" items = items[:limit] return {"items": items, "next_cursor": next_cursor} def create_session(self, user_id: str, username: str): token = secrets.token_urlsafe(32) expires_at = self.utc_now() + timedelta(seconds=SESSION_TTL_SECONDS) with self.connect() as conn: with conn.cursor() as cur: cur.execute( "INSERT INTO sessions(id, token, user_id, expires_at, created_at) VALUES (%s,%s,%s,%s,%s)", (uuid.uuid4(), token, user_id, expires_at, self.utc_now()), ) conn.commit() with self.connect() as conn: user = self.fetch_user(user_id, conn) if user is None: raise ApiError(500, "internal_error", "session user missing") session = { "token": token, "user_id": user_id, "expires_at": self.isoformat_utc(expires_at), "revoked_at": None, "user": user, } self.cache_session(session) return { "token": token, "token_type": "Bearer", "expires_at": self.isoformat_utc(expires_at), "user": user, } def get_session_by_token(self, token: str, conn=None): if conn is None: with self.connect() as db_conn: return self.get_session_by_token(token, db_conn) db_session = self.fetch_session_by_token(token, conn) if db_session is None or not self.is_session_valid(db_session): self.delete_cached_session(token) return None cached = self.get_cached_session(token, db_session=db_session) if cached is None: self.cache_session(db_session) return db_session def revoke_current_session(self, token: str): with self.connect() as conn: with conn.cursor() as cur: cur.execute("UPDATE sessions SET revoked_at = %s WHERE token = %s AND revoked_at IS NULL", (self.utc_now(), token)) conn.commit() self.delete_cached_session(token) def is_session_valid(self, session) -> bool: if session is None: return False if session.get("revoked_at") is not None: return False try: expiry = self.parse_session_expiry(session["expires_at"]) except ValueError: return False if expiry <= self.utc_now(): return False return True store = Store() app = FastAPI(title="MTUSI Messenger") @app.on_event("startup") def startup_event() -> None: store.pool.open(wait=True, timeout=10) store.init() @app.on_event("shutdown") def shutdown_event() -> None: store.pool.close() @app.exception_handler(psycopg.OperationalError) async def database_error_handler(request: Request, exc): return await api_error_handler(request, ApiError(503, "unavailable", "database unavailable")) @app.middleware("http") async def request_id_middleware(request: Request, call_next): request_id = uuid.uuid4().hex request.state.request_id = request_id response = await call_next(request) response.headers["X-Request-Id"] = request_id response.headers["X-Instance-Id"] = INSTANCE_ID return response @app.exception_handler(ApiError) async def api_error_handler(request: Request, exc: ApiError): body = {"error": {"code": exc.code, "message": exc.message, "request_id": getattr(request.state, "request_id", "")}} return JSONResponse(status_code=exc.status_code, headers={**exc.headers, "X-Request-Id": getattr(request.state, "request_id", ""), "X-Instance-Id": INSTANCE_ID}, content=body) @app.exception_handler(RequestValidationError) async def validation_error_handler(request: Request, exc: RequestValidationError): request_id = getattr(request.state, "request_id", "") return JSONResponse( status_code=400, headers={"X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID}, content={"error": {"code": "invalid_request", "message": "invalid request", "request_id": request_id}}, ) @app.exception_handler(Exception) async def generic_error_handler(request: Request, exc: Exception): request_id = getattr(request.state, "request_id", "") return JSONResponse( status_code=500, headers={"X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID}, content={"error": {"code": "internal_error", "message": "internal error", "request_id": request_id}}, ) def get_auth_header(request: Request): auth = request.headers.get("Authorization") if not auth: raise ApiError(401, "unauthorized", "missing authorization", headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) scheme, _, token = auth.partition(" ") if scheme.lower() != "bearer" or not token: raise ApiError(401, "unauthorized", "invalid bearer token", headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) return token.strip() def require_bearer_session(request: Request): token = get_auth_header(request) with store.connect() as conn: session = store.get_session_by_token(token, conn) if session is None or not store.is_session_valid(session): raise ApiError(401, "unauthorized", "invalid or expired session", headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) return session async def parse_json_body(request: Request) -> Dict[str, Any]: try: raw = await request.body() if not raw: return {} return __import__("json").loads(raw) except Exception as exc: raise ApiError(400, "invalid_request", "malformed JSON") from exc @app.get("/health/live") def health_live(): return {"status": "ok"} @app.get("/health/ready") def health_ready(): try: with store.connect() as conn: with conn.cursor() as cur: cur.execute("SELECT 1") return {"status": "ok"} except Exception as exc: raise ApiError(503, "unavailable", "database unavailable") from exc @app.post("/api/v1/users", status_code=201) async def create_user_endpoint(request: Request): try: body = await request.json() except Exception as exc: raise ApiError(400, "invalid_request", "malformed JSON") from exc if not isinstance(body, dict): raise ApiError(400, "invalid_request", "invalid user payload") try: payload = CreateUserIn.model_validate(body) except ValidationError as exc: raise ApiError(400, "invalid_request", "invalid user payload") from exc if not payload.username or not payload.display_name.strip(): raise ApiError(400, "invalid_request", "invalid request") payload.display_name = payload.display_name.strip() try: user = store.insert_user(payload.username, payload.display_name, payload.password) return UserOut.model_validate(user) except Exception as exc: if "duplicate key" in str(exc).lower() or "unique" in str(exc).lower(): raise ApiError(409, "conflict", "username already exists") from exc raise ApiError(503, "unavailable", "database unavailable") from exc @app.get("/api/v1/users/me") async def current_user(request: Request): session = require_bearer_session(request) user = session["user"] return UserOut.model_validate(user) @app.post("/api/v1/auth/sessions", status_code=201) async def create_session(request: Request): auth = request.headers.get("Authorization", "") if not auth.lower().startswith("basic "): raise ApiError(401, "unauthorized", "invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}) encoded = auth.split(" ", 1)[1].strip() try: decoded = base64.b64decode(encoded.encode("ascii"), validate=True) raw = decoded.decode("utf-8") except Exception: raise ApiError(401, "unauthorized", "invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}) if ":" not in raw: raise ApiError(401, "unauthorized", "invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}) username, password = raw.split(":", 1) if not re_match(username): raise ApiError(401, "unauthorized", "invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}) if not (12 <= len(password) <= 128): raise ApiError(401, "unauthorized", "invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}) try: with store.connect() as conn: user = store.require_user_by_username(username, conn) if user is None or not store.verify_password(user["password_hash"], password): raise ApiError(401, "unauthorized", "invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}) session = store.create_session(user["id"], username) return SessionOut.model_validate(session) except ApiError: raise except Exception as exc: raise ApiError(503, "unavailable", "database unavailable") from exc @app.delete("/api/v1/auth/sessions/current", status_code=204) async def revoke_session(request: Request): session = require_bearer_session(request) token = session["token"] store.revoke_current_session(token) return Response(status_code=204) @app.post("/api/v1/chats", status_code=201) async def create_chat_endpoint(request: Request): session = require_bearer_session(request) try: body = await request.json() except Exception as exc: raise ApiError(400, "invalid_request", "malformed JSON") from exc if not isinstance(body, dict): raise ApiError(400, "invalid_request", "invalid chat payload") try: payload = CreateChatIn.model_validate(body) except ValidationError as exc: raise ApiError(400, "invalid_request", "invalid chat payload") from exc if len(payload.member_ids) < 1 or len(payload.member_ids) > 100: raise ApiError(400, "invalid_request", "invalid member_ids") title = payload.title.strip() if not title: raise ApiError(400, "invalid_request", "invalid title") normalized = [] seen = set() for member_id in payload.member_ids: try: member_id = str(uuid.UUID(member_id)) except ValueError as exc: raise ApiError(400, "invalid_request", "invalid member_ids") from exc if member_id in seen: raise ApiError(400, "invalid_request", "duplicate member_ids") seen.add(member_id) normalized.append(member_id) if session["user_id"] not in normalized: raise ApiError(400, "invalid_request", "current user must be a member") try: with store.connect() as conn: for member_id in normalized: with conn.cursor() as cur: cur.execute("SELECT id FROM users WHERE id = %s", (member_id,)) if cur.fetchone() is None: raise ApiError(400, "invalid_request", "unknown member") chat = store.insert_chat(title, normalized, session["user_id"]) return ChatOut.model_validate(chat) except ApiError: raise except Exception as exc: raise ApiError(503, "unavailable", "database unavailable") from exc @app.get("/api/v1/chats") async def list_chats(request: Request): session = require_bearer_session(request) limit = request.query_params.get("limit", "50") cursor = request.query_params.get("cursor") try: limit_int = int(limit) except ValueError as exc: raise ApiError(400, "invalid_request", "invalid limit") from exc if not (1 <= limit_int <= 100): raise ApiError(400, "invalid_request", "invalid limit") result = store.list_chats_for_user(session["user_id"], limit_int, cursor) return {"items": [ChatOut.model_validate(item) for item in result["items"]], "next_cursor": result["next_cursor"]} @app.get("/api/v1/chats/{chat_id}") async def get_chat(request: Request, chat_id: str): session = require_bearer_session(request) try: uuid.UUID(chat_id) except ValueError as exc: raise ApiError(400, "invalid_request", "invalid chat_id") from exc with store.connect() as conn: chat = store.fetch_chat(chat_id, conn) if chat is None or not store.fetch_chat_membership(chat_id, session["user_id"], conn): raise ApiError(404, "not_found", "chat not found") return ChatOut.model_validate(chat) @app.post("/api/v1/chats/{chat_id}/messages", status_code=201) async def create_message(request: Request, chat_id: str): session = require_bearer_session(request) try: uuid.UUID(chat_id) except ValueError as exc: raise ApiError(400, "invalid_request", "invalid chat_id") from exc try: body = await request.json() except Exception as exc: raise ApiError(400, "invalid_request", "malformed JSON") from exc if not isinstance(body, dict): raise ApiError(400, "invalid_request", "invalid message payload") try: payload = CreateMessageIn.model_validate(body) except ValidationError as exc: raise ApiError(400, "invalid_request", "invalid message payload") from exc if not payload.text.strip(): raise ApiError(400, "invalid_request", "invalid text") payload.text = payload.text.strip() with store.connect() as conn: chat = store.fetch_chat(chat_id, conn) if chat is None or not store.fetch_chat_membership(chat_id, session["user_id"], conn): raise ApiError(404, "not_found", "chat not found") message = store.insert_message(chat_id, session["user_id"], payload.text) return MessageOut.model_validate(message) @app.get("/api/v1/chats/{chat_id}/messages") async def list_messages(request: Request, chat_id: str): session = require_bearer_session(request) try: uuid.UUID(chat_id) except ValueError as exc: raise ApiError(400, "invalid_request", "invalid chat_id") from exc limit = request.query_params.get("limit", "50") cursor = request.query_params.get("cursor") try: limit_int = int(limit) except ValueError as exc: raise ApiError(400, "invalid_request", "invalid limit") from exc if not (1 <= limit_int <= 100): raise ApiError(400, "invalid_request", "invalid limit") with store.connect() as conn: if not store.fetch_chat_membership(chat_id, session["user_id"], conn): raise ApiError(404, "not_found", "chat not found") result = store.list_messages_for_chat(chat_id, limit_int, cursor) return {"items": [MessageOut.model_validate(item) for item in result["items"]], "next_cursor": result["next_cursor"]} def re_match(value: str) -> bool: import re return bool(re.fullmatch(USERNAME_RE, value)) if __name__ == "__main__": import uvicorn uvicorn.run("app:app", host=APP_HOST, port=APP_PORT, reload=False)