Мессенджер с Postgres, Redis, Valkey

This commit is contained in:
Queenfish
2026-10-08 13:21:48 +03:00
parent 65003b6119
commit 6bfbcf74fc
41 changed files with 2624 additions and 24 deletions
View File
+104
View File
@@ -0,0 +1,104 @@
from fastapi import APIRouter, Header, HTTPException, Request, Response
from fastapi.responses import JSONResponse
from app.security import (
parse_basic,
verify_password,
new_token,
session_expires_at,
get_current_user,
)
from app.config import config
from app.models import Session
router = APIRouter(tags=["auth"])
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
def error_response(
status: int, code: str, message: str, request_id: str, headers=None,
) -> JSONResponse:
return JSONResponse(
status_code=status,
content={
"error": {
"code": code,
"message": message,
"request_id": request_id,
}
},
headers=headers or {},
)
@router.post("/auth/sessions", response_model=Session, status_code=201)
async def create_session(
request: Request,
authorization: str | None = Header(default=None),
):
storage = request.app.state.storage
session_store = request.app.state.session_store
rid = request.state.request_id
try:
username, password = parse_basic(authorization)
except HTTPException:
return error_response(
401,
"unauthorized",
"invalid credentials",
rid,
headers={"WWW-Authenticate": BASIC_CHALLENGE},
)
user_row = await storage.get_user_by_username(username)
if user_row is None or not verify_password(password, user_row["password_hash"]):
return error_response(
401,
"unauthorized",
"invalid credentials",
rid,
headers={"WWW-Authenticate": BASIC_CHALLENGE},
)
token = new_token()
expires_at = session_expires_at(config.SESSION_TTL_SECONDS)
await session_store.create(token, str(user_row["id"]), expires_at)
user = {
"id": str(user_row["id"]),
"username": user_row["username"],
"display_name": user_row["display_name"],
"created_at": (
user_row["created_at"]
.isoformat()
.replace("+00:00", "Z")
),
}
return {
"token": token,
"token_type": "Bearer",
"expires_at": expires_at.isoformat().replace("+00:00", "Z"),
"user": user,
}
@router.delete("/auth/sessions/current", status_code=204)
async def revoke_session(
request: Request,
authorization: str | None = Header(default=None),
):
rid = request.state.request_id
try:
_, token = await get_current_user(request, authorization)
except HTTPException:
return error_response(
401,
"unauthorized",
"unauthorized",
rid,
headers={"WWW-Authenticate": BEARER_CHALLENGE},
)
await request.app.state.session_store.delete(token)
return Response(status_code=204)
+148
View File
@@ -0,0 +1,148 @@
from fastapi import APIRouter, Header, HTTPException, Query, Request
from fastapi.responses import JSONResponse
from app.models import (
Chat, CreateChat, Message, CreateMessage, ChatPage, MessagePage,
)
from app.security import get_current_user
router = APIRouter(tags=["chats"])
BEARER_CHALLENGE = 'Bearer realm="messenger"'
def error_response(
status: int, code: str, message: str, request_id: str, headers=None,
) -> JSONResponse:
return JSONResponse(
status_code=status,
content={
"error": {
"code": code,
"message": message,
"request_id": request_id,
}
},
headers=headers or {},
)
async def resolve_actor(request: Request, authorization: str | None):
rid = request.state.request_id
try:
user, _ = await get_current_user(request, authorization)
except HTTPException:
return None, error_response(
401,
"unauthorized",
"unauthorized",
rid,
headers={"WWW-Authenticate": BEARER_CHALLENGE},
)
return user, None
@router.post("/chats", response_model=Chat, status_code=201)
async def create_chat(
data: CreateChat,
request: Request,
authorization: str | None = Header(default=None),
):
rid = request.state.request_id
actor, err = await resolve_actor(request, authorization)
if err is not None:
return err
storage = request.app.state.storage
try:
chat = await storage.create_chat(
data.title, data.member_ids, actor["id"],
)
return chat
except ValueError as e:
msg = str(e)
if msg == "invalid_member":
return error_response(400, "invalid_request", "unknown member", rid)
if msg == "creator_not_member":
return error_response(
400, "invalid_request", "creator must be a member", rid,
)
return error_response(400, "invalid_request", "bad request", rid)
@router.get("/chats", response_model=ChatPage)
async def list_chats(
request: Request,
authorization: str | None = Header(default=None),
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None),
):
rid = request.state.request_id
actor, err = await resolve_actor(request, authorization)
if err is not None:
return err
try:
items, next_cursor = await request.app.state.storage.list_chats(
actor["id"], limit, cursor,
)
except ValueError:
return error_response(400, "invalid_request", "bad cursor", rid)
return {"items": items, "next_cursor": next_cursor}
@router.get("/chats/{chat_id}", response_model=Chat)
async def get_chat(
chat_id: str,
request: Request,
authorization: str | None = Header(default=None),
):
rid = request.state.request_id
actor, err = await resolve_actor(request, authorization)
if err is not None:
return err
chat = await request.app.state.storage.get_chat(chat_id, actor["id"])
if chat is None:
return error_response(404, "not_found", "chat not found", rid)
return chat
@router.post("/chats/{chat_id}/messages", response_model=Message, status_code=201)
async def create_message(
chat_id: str,
data: CreateMessage,
request: Request,
authorization: str | None = Header(default=None),
):
rid = request.state.request_id
actor, err = await resolve_actor(request, authorization)
if err is not None:
return err
try:
msg = await request.app.state.storage.add_message(
chat_id, actor["id"], data.text,
)
return msg
except ValueError:
return error_response(404, "not_found", "chat not found", rid)
@router.get("/chats/{chat_id}/messages", response_model=MessagePage)
async def list_messages(
chat_id: str,
request: Request,
authorization: str | None = Header(default=None),
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None),
):
rid = request.state.request_id
actor, err = await resolve_actor(request, authorization)
if err is not None:
return err
try:
items, next_cursor = await request.app.state.storage.list_messages(
chat_id, actor["id"], limit, cursor,
)
except ValueError as e:
if str(e) == "bad_cursor":
return error_response(400, "invalid_request", "bad cursor", rid)
return error_response(404, "not_found", "chat not found", rid)
return {"items": items, "next_cursor": next_cursor}
+53
View File
@@ -0,0 +1,53 @@
import asyncio
from fastapi import APIRouter, Request
from fastapi.responses import JSONResponse
router = APIRouter(tags=["health"])
@router.get("/health/live")
async def liveness():
return {"status": "ok"}
async def _check_postgres(request: Request) -> None:
async with request.app.state.storage._pool.acquire() as conn:
await conn.fetchval("SELECT 1")
async def _check_redis(request: Request) -> None:
store = request.app.state.session_store
if hasattr(store, "_client"):
await store._client.ping()
@router.get("/health/ready")
async def readiness(request: Request):
rid = getattr(request.state, "request_id", "")
try:
await asyncio.wait_for(_check_postgres(request), timeout=2.0)
except Exception:
return JSONResponse(
status_code=503,
content={
"error": {
"code": "unavailable",
"message": "db unavailable",
"request_id": rid,
}
},
)
try:
await asyncio.wait_for(_check_redis(request), timeout=2.0)
except Exception:
return JSONResponse(
status_code=503,
content={
"error": {
"code": "unavailable",
"message": "cache unavailable",
"request_id": rid,
}
},
)
return {"status": "ok"}
+56
View File
@@ -0,0 +1,56 @@
from fastapi import APIRouter, Header, HTTPException, Request
from fastapi.responses import JSONResponse
from app.models import User, CreateUser
from app.security import hash_password, get_current_user
router = APIRouter(tags=["users"])
def error_response(
status: int, code: str, message: str, request_id: str, headers=None,
) -> JSONResponse:
return JSONResponse(
status_code=status,
content={
"error": {
"code": code,
"message": message,
"request_id": request_id,
}
},
headers=headers or {},
)
@router.post("/users", response_model=User, status_code=201)
async def register_user(data: CreateUser, request: Request):
storage = request.app.state.storage
rid = request.state.request_id
password_hash = hash_password(data.password)
try:
user = await storage.create_user(
data.username, data.display_name, password_hash,
)
return user
except ValueError:
return error_response(409, "conflict", "username already taken", rid)
@router.get("/users/me", response_model=User)
async def current_user(
request: Request,
authorization: str | None = Header(default=None),
):
rid = request.state.request_id
try:
user, _ = await get_current_user(request, authorization)
except HTTPException:
return error_response(
401,
"unauthorized",
"unauthorized",
rid,
headers={"WWW-Authenticate": 'Bearer realm="messenger"'},
)
return user