242 lines
6.9 KiB
Python
242 lines
6.9 KiB
Python
import uuid
|
|
import threading
|
|
from datetime import datetime, timezone
|
|
|
|
from fastapi import FastAPI, Header, HTTPException, Query, Request
|
|
from fastapi.exceptions import RequestValidationError
|
|
from fastapi.responses import JSONResponse
|
|
from starlette.exceptions import HTTPException as StarletteHTTPException
|
|
|
|
from schemas import (
|
|
User, CreateUser,
|
|
Chat, CreateChat, ChatPage,
|
|
Message, CreateMessage, MessagePage,
|
|
)
|
|
|
|
app = FastAPI()
|
|
|
|
lock = threading.Lock()
|
|
|
|
users: dict[str, dict] = {}
|
|
usernames: set[str] = set()
|
|
chats: dict[str, Chat] = {}
|
|
messages: dict[str, list[Message]] = {}
|
|
|
|
|
|
def now_iso() -> str:
|
|
return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
|
|
|
|
|
|
def get_current_user(x_user_id: str | None):
|
|
if x_user_id is None:
|
|
raise HTTPException(
|
|
status_code=401,
|
|
detail="unauthorized",
|
|
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
|
|
)
|
|
|
|
try:
|
|
uuid.UUID(x_user_id)
|
|
except ValueError:
|
|
raise HTTPException(status_code=400, detail="Invalid X-User-Id")
|
|
|
|
user = users.get(x_user_id)
|
|
if user is None:
|
|
raise HTTPException(
|
|
status_code=401,
|
|
detail="unauthorized",
|
|
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
|
|
)
|
|
return user
|
|
|
|
|
|
@app.middleware("http")
|
|
async def xri(request: Request, call_next):
|
|
rid = request.headers.get("X-Request-Id") or str(uuid.uuid4())
|
|
request.state.request_id = rid
|
|
response = await call_next(request)
|
|
response.headers["X-Request-Id"] = rid
|
|
return response
|
|
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def validation_handler(request: Request, exc: RequestValidationError):
|
|
return JSONResponse(
|
|
status_code=400,
|
|
content={
|
|
"error": {
|
|
"code": "invalid_request",
|
|
"message": "Invalid request body",
|
|
"request_id": request.state.request_id,
|
|
}
|
|
},
|
|
)
|
|
|
|
|
|
@app.exception_handler(StarletteHTTPException)
|
|
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
|
|
codes = {
|
|
400: "invalid_request",
|
|
401: "unauthorized",
|
|
404: "not_found",
|
|
409: "conflict",
|
|
}
|
|
code = codes.get(exc.status_code, "internal_error")
|
|
return JSONResponse(
|
|
status_code=exc.status_code,
|
|
content={
|
|
"error": {
|
|
"code": code,
|
|
"message": str(exc.detail),
|
|
"request_id": request.state.request_id,
|
|
}
|
|
},
|
|
headers=exc.headers or {},
|
|
)
|
|
|
|
|
|
@app.get("/health/live")
|
|
async def liveness():
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.get("/health/ready")
|
|
async def readiness():
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.post("/api/v1/users", status_code=201)
|
|
async def registerUser(payload: CreateUser):
|
|
uid = str(uuid.uuid4())
|
|
user = User(
|
|
id=uid,
|
|
username=payload.username,
|
|
display_name=payload.display_name,
|
|
created_at=now_iso(),
|
|
)
|
|
with lock:
|
|
if payload.username in usernames:
|
|
raise HTTPException(status_code=409, detail="Username already exists")
|
|
usernames.add(payload.username)
|
|
users[uid] = user
|
|
return user
|
|
|
|
|
|
@app.get("/api/v1/users/me")
|
|
async def currentUser(x_user_id: str | None = Header(default=None)):
|
|
return get_current_user(x_user_id)
|
|
|
|
|
|
@app.post("/api/v1/chats", status_code=201)
|
|
async def createChat(payload: CreateChat, x_user_id: str | None = Header(default=None)):
|
|
me = get_current_user(x_user_id)
|
|
|
|
if len(set(payload.member_ids)) != len(payload.member_ids):
|
|
raise HTTPException(status_code=400, detail="member_ids must be unique")
|
|
|
|
for i in payload.member_ids:
|
|
try:
|
|
uuid.UUID(i)
|
|
except ValueError:
|
|
raise HTTPException(status_code=400, detail="Invalid member id")
|
|
if i not in users:
|
|
raise HTTPException(status_code=400, detail="Unknown member")
|
|
|
|
if me.id not in payload.member_ids:
|
|
raise HTTPException(status_code=400, detail="Caller must be a member")
|
|
|
|
cid = str(uuid.uuid4())
|
|
chat = Chat(
|
|
id=cid,
|
|
title=payload.title,
|
|
member_ids=payload.member_ids,
|
|
created_at=now_iso(),
|
|
)
|
|
with lock:
|
|
chats[cid] = chat
|
|
messages[cid] = []
|
|
return chat
|
|
|
|
|
|
@app.get("/api/v1/chats")
|
|
async def listChats(
|
|
x_user_id: str | None = Header(default=None),
|
|
limit: int = Query(default=50, ge=1, le=100),
|
|
cursor: str | None = Query(default=None, min_length=1),
|
|
):
|
|
me = get_current_user(x_user_id)
|
|
with lock:
|
|
mine = [c for c in chats.values() if me.id in c.member_ids]
|
|
mine.sort(key=lambda c: (c.created_at, c.id))
|
|
|
|
if cursor is not None:
|
|
ids = [c.id for c in mine]
|
|
if cursor not in ids:
|
|
raise HTTPException(status_code=400, detail="Invalid cursor")
|
|
idx = ids.index(cursor)
|
|
mine = mine[idx + 1:]
|
|
|
|
page = mine[:limit]
|
|
next_cursor = page[-1].id if len(mine) > limit else None
|
|
return ChatPage(items=page, next_cursor=next_cursor)
|
|
|
|
|
|
@app.get("/api/v1/chats/{chat_id}")
|
|
async def getChat(chat_id: str, x_user_id: str | None = Header(default=None)):
|
|
me = get_current_user(x_user_id)
|
|
with lock:
|
|
chat = chats.get(chat_id)
|
|
if chat is None or me.id not in chat.member_ids:
|
|
raise HTTPException(status_code=404, detail="Chat not found")
|
|
return chat
|
|
|
|
|
|
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
|
async def createMessage(
|
|
chat_id: str,
|
|
payload: CreateMessage,
|
|
x_user_id: str | None = Header(default=None),
|
|
):
|
|
me = get_current_user(x_user_id)
|
|
with lock:
|
|
chat = chats.get(chat_id)
|
|
if chat is None or me.id not in chat.member_ids:
|
|
raise HTTPException(status_code=404, detail="Chat not found")
|
|
|
|
msg = Message(
|
|
id=str(uuid.uuid4()),
|
|
chat_id=chat_id,
|
|
sender_id=me.id,
|
|
text=payload.text,
|
|
created_at=now_iso(),
|
|
)
|
|
messages.setdefault(chat_id, []).append(msg)
|
|
return msg
|
|
|
|
|
|
@app.get("/api/v1/chats/{chat_id}/messages")
|
|
async def listMessages(
|
|
chat_id: str,
|
|
x_user_id: str | None = Header(default=None),
|
|
limit: int = Query(default=50, ge=1, le=100),
|
|
cursor: str | None = Query(default=None, min_length=1),
|
|
):
|
|
me = get_current_user(x_user_id)
|
|
with lock:
|
|
chat = chats.get(chat_id)
|
|
if chat is None or me.id not in chat.member_ids:
|
|
raise HTTPException(status_code=404, detail="Chat not found")
|
|
msgs = list(messages.get(chat_id, []))
|
|
|
|
msgs.sort(key=lambda m: (m.created_at, m.id))
|
|
|
|
if cursor is not None:
|
|
ids = [m.id for m in msgs]
|
|
if cursor not in ids:
|
|
raise HTTPException(status_code=400, detail="Invalid cursor")
|
|
idx = ids.index(cursor)
|
|
msgs = msgs[idx + 1:]
|
|
|
|
page = msgs[:limit]
|
|
next_cursor = page[-1].id if len(msgs) > limit else None
|
|
return MessagePage(items=page, next_cursor=next_cursor) |