forked from mtusi2026/mtusi2026lab2
Compare commits
3
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
6e5bd84969 | ||
|
|
b9c8b21209 | ||
|
|
21d4008691 |
+7
-4
@@ -2,10 +2,13 @@
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
# Host publish port; change if 8080 is busy locally.
|
||||
HOST_PORT=8080
|
||||
APP_ENV=lab
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
# Compose lab stand uses DATABASE_URL. DATABASE_URL_FILE is also supported by the app.
|
||||
DATABASE_URL=postgresql://messenger:messenger@postgres:5432/messenger
|
||||
# DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
# CACHE_URL_FILE=/run/secrets/cache_url
|
||||
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
FROM python:3.12.8-slim-bookworm
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
COPY migrations/ ./migrations/
|
||||
COPY src/ ./src/
|
||||
|
||||
ENV PYTHONPATH=/app/src
|
||||
ENV APP_HOST=0.0.0.0
|
||||
ENV APP_PORT=8080
|
||||
ENV APP_ENV=lab
|
||||
ENV SESSION_TTL_SECONDS=3600
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
CMD ["sh", "-c", "exec uvicorn messenger.app:app --host ${APP_HOST} --port ${APP_PORT}"]
|
||||
@@ -1,37 +1,140 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Гадяцкий Л. Е., БПИ2302
|
||||
- Целевая оценка: 3
|
||||
- Commit/PR:`solution/BPI2302-Gadiatskiy` MR#167: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/167
|
||||
- Использованные источники и библиотеки:
|
||||
- контракт и семантика: `contracts/openapi.json`, `contracts/README.md`, `README.md`, `COURSE.md`
|
||||
- перенос из lab1: FastAPI, cursor-пагинация, формат ошибок, стиль Dockerfile
|
||||
- runtime: FastAPI 0.115.6, Uvicorn 0.34.0, Pydantic 2.10.4, SQLAlchemy 2.0.36, psycopg 3.2.4, argon2-cffi 23.1.0
|
||||
- PostgreSQL: образ `postgres:16-alpine`
|
||||
- Помощь ИИ использована при переносе lab1, реализации PostgreSQL/сессий/SQLAlchemy и отчёта. Результаты подтверждаются сохранёнными запусками.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
**Prerequisites:** Docker и Docker Compose. Python 3.9+ нужен только для публичных проверок (`make check` / `make test` / `tests/resilience.py`). Runtime приложения — внутри образа.
|
||||
|
||||
**Версии:**
|
||||
- API: базовый образ `python:3.12.8-slim-bookworm` → локальный `mtusi-messenger:lab2`
|
||||
- PostgreSQL: `postgres:16-alpine`
|
||||
- зависимости: `requirements.txt`
|
||||
|
||||
**Конфигурация:** секретов в Git нет. Локальный `.env` создаётся из примера и не коммитится:
|
||||
|
||||
```sh
|
||||
cp .env.example .env
|
||||
```
|
||||
|
||||
Соответствие `.env.example`:
|
||||
- `APP_HOST` / `APP_PORT` — bind uvicorn внутри контейнера
|
||||
- `HOST_PORT` — порт на host (по умолчанию 8080; если занят — например 8081)
|
||||
- `APP_ENV` — среда запуска (`lab`)
|
||||
- `SESSION_TTL_SECONDS` — TTL сессии (по умолчанию 3600; для обычного smoke ≥ 300)
|
||||
- `SESSION_STORE=postgres` — сессии в PostgreSQL
|
||||
- `DATABASE_URL` — строка подключения API к PostgreSQL в compose-сети
|
||||
(приложение также поддерживает `DATABASE_URL_FILE`)
|
||||
|
||||
Учебные credentials compose (`messenger` / `messenger`) только для локального синтетического стенда.
|
||||
|
||||
**Сборка и запуск:**
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env up -d --build
|
||||
```
|
||||
|
||||
Готовность (подставьте свой `HOST_PORT`):
|
||||
|
||||
```sh
|
||||
curl -i http://127.0.0.1:8080/health/ready
|
||||
```
|
||||
|
||||
Ожидается HTTP 200, тело `{"status":"ok"}`, заголовок `X-Request-Id`.
|
||||
Миграции `migrations/*.sql` применяются при старте API идемпотентно через таблицу `schema_migrations`.
|
||||
|
||||
**Публичный smoke** (при уже запущенном стенде):
|
||||
|
||||
```sh
|
||||
python tests/smoke.py --base-url http://127.0.0.1:8080
|
||||
# или: make test BASE_URL=http://127.0.0.1:8080
|
||||
```
|
||||
|
||||
**Проверка сохранности:**
|
||||
|
||||
```sh
|
||||
# Unix:
|
||||
chmod +x scripts/restart.sh
|
||||
python tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080
|
||||
|
||||
# Windows:
|
||||
python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8080
|
||||
```
|
||||
|
||||
Hook выполняет `docker compose --env-file .env restart` для API и PostgreSQL **без** удаления volumes (`down -v` не используется).
|
||||
|
||||
Локальная проверка автора выполнялась на `HOST_PORT=8081` (host-порт 8080 был занят другим контейнером).
|
||||
|
||||
**Остановка:**
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env down
|
||||
```
|
||||
|
||||
Намеренное удаление учебных данных (volumes):
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env down -v
|
||||
```
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
HTTP-клиент
|
||||
→ api (uvicorn + FastAPI)
|
||||
→ SQLAlchemy ORM
|
||||
→ PostgreSQL
|
||||
users, chats, chat_members, messages, sessions
|
||||
```
|
||||
|
||||
- Источник истины — PostgreSQL. In-memory store lab1 заменён.
|
||||
- ORM-модели: `src/messenger/tables.py`. Доступ к данным: `src/messenger/store.py`.
|
||||
- Схема версионируется SQL-файлами в `migrations/`; runner — `apply_migrations()` в `src/messenger/db.py` (учёт в `schema_migrations`). Alembic не используется.
|
||||
- Регистрация требует `password`; hash — Argon2id (`argon2-cffi`). В ответе User пароль/hash не возвращаются.
|
||||
- `POST /auth/sessions` — только Basic; opaque Bearer-токен (`secrets.token_urlsafe(32)`, ≥256 бит энтропии). В БД хранится SHA-256 токена, `expires_at`, `revoked_at`.
|
||||
- Защищённые endpoint принимают только Bearer. `X-User-Id` игнорируется и сам по себе доступа не даёт. Basic на бизнес-endpoint → 401.
|
||||
- Создание чата (chat + members) — одна транзакция SQLAlchemy.
|
||||
- Keyset-пагинация и формат ошибок перенесены из lab1.
|
||||
- `/health/live` — процесс; `/health/ready` — доступность PostgreSQL (иначе 503).
|
||||
- Compose: сервисы `api` + `postgres`, volume `pgdata`, secrets/`.env` в Git не коммитятся.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Минимум lab1 + переход на auth; публичный smoke | `python tests/smoke.py --base-url http://127.0.0.1:8081` | `PASS: lab2 public API scenario...` | `evidence/smoke.txt` |
|
||||
| Данные и действующие сессии переживают рестарт без удаления volumes | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8081` | `PASS: persistence preserved confirmed data and existing session...` | `evidence/restart.txt` |
|
||||
| PostgreSQL: users/chats/members/messages; PK/FK; unique username; миграции с нуля; атомарный чат | `migrations/001_init.sql` + `store.create_chat` в транзакции; повторный restart API | в `schema_migrations` одна запись `001_init.sql`; число users не размножается при повторном migrate | код + проверка ниже |
|
||||
| Basic только на login; Bearer; TTL/logout; X-User-Id не даёт доступ; password KDF | сценарии внутри smoke (wrong password, Basic на `/users/me`, `X-User-Id`, logout) | соответствующие 401 / logout → 401 | `evidence/smoke.txt` |
|
||||
| Повторный запуск миграций без дублирования данных; secrets/volumes не в Git | restart API после persistence; `.gitignore` для `.env` и `volumes/` | `001_init.sql` применена один раз; users сохраняются | этот отчёт |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
Повторная проверка идемпотентности миграций после persistence:
|
||||
|
||||
```text
|
||||
SELECT version FROM schema_migrations; → 001_init.sql (1 row)
|
||||
SELECT COUNT(*) FROM users; → данные на месте, без дублирования схемы
|
||||
```
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Для оценки 3 отдельный нагрузочный трек не выполнялся. Проверена сохранность:
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| `docker compose --env-file .env restart` (API + PostgreSQL), volumes сохранены | `/health/ready` ok; прежний Bearer читает те же users/chats/messages; сессия действует | persistence PASS | в бюджете теста (hook ≤90 с, ready ≤90 с); потери данных нет |
|
||||
|
||||
Аппаратный профиль: локальный Docker Desktop на Windows; один API и один PostgreSQL без CPU/RAM limits.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- Redis/Valkey, EXPLAIN на ≥10k сообщений, отдельные автотесты expiry/гонки/недоступности зависимостей не выполнялись.
|
||||
- Сессии и бизнес-данные в одном PostgreSQL; недоступность БД → `/health/ready` = 503.
|
||||
- Basic по HTTP допустим только на локальном учебном стенде с синтетическими данными.
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
services:
|
||||
api:
|
||||
build: .
|
||||
image: mtusi-messenger:lab2
|
||||
ports:
|
||||
- "127.0.0.1:${HOST_PORT:-8080}:8080"
|
||||
environment:
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: "8080"
|
||||
APP_ENV: lab
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger
|
||||
SESSION_STORE: postgres
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
restart: unless-stopped
|
||||
|
||||
postgres:
|
||||
image: postgres:16-alpine
|
||||
environment:
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_PASSWORD: messenger
|
||||
POSTGRES_DB: messenger
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,44 @@
|
||||
CREATE TABLE users (
|
||||
id UUID PRIMARY KEY,
|
||||
username TEXT NOT NULL,
|
||||
display_name TEXT NOT NULL,
|
||||
password_hash TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE UNIQUE INDEX users_username_uidx ON users (username);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id UUID PRIMARY KEY,
|
||||
title TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id UUID NOT NULL REFERENCES chats (id),
|
||||
user_id UUID NOT NULL REFERENCES users (id),
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id UUID PRIMARY KEY,
|
||||
chat_id UUID NOT NULL REFERENCES chats (id),
|
||||
sender_id UUID NOT NULL REFERENCES users (id),
|
||||
text TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id);
|
||||
|
||||
CREATE TABLE sessions (
|
||||
token_hash TEXT PRIMARY KEY,
|
||||
user_id UUID NOT NULL REFERENCES users (id),
|
||||
expires_at TIMESTAMPTZ NOT NULL,
|
||||
revoked_at TIMESTAMPTZ,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX sessions_user_idx ON sessions (user_id);
|
||||
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
|
||||
@@ -0,0 +1,6 @@
|
||||
fastapi==0.115.6
|
||||
uvicorn[standard]==0.34.0
|
||||
pydantic==2.10.4
|
||||
SQLAlchemy==2.0.36
|
||||
psycopg[binary]==3.2.4
|
||||
argon2-cffi==23.1.0
|
||||
@@ -0,0 +1,4 @@
|
||||
@echo off
|
||||
cd /d "%~dp0\.."
|
||||
docker compose --env-file .env restart
|
||||
exit /b %ERRORLEVEL%
|
||||
@@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env restart
|
||||
@@ -0,0 +1,223 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import binascii
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
from typing import Optional
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import Depends, FastAPI, Header, Query, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse, Response
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
|
||||
from .cursors import decode_cursor, encode_cursor
|
||||
from .db import apply_migrations, close_engine, init_engine, ping
|
||||
from .errors import AppError, error_response, request_id_of
|
||||
from .models import CreateChat, CreateMessage, CreateUser
|
||||
from .store import store
|
||||
|
||||
BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
|
||||
BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(_app: FastAPI):
|
||||
init_engine()
|
||||
apply_migrations()
|
||||
yield
|
||||
close_engine()
|
||||
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger lab2", version="1.2.0", lifespan=lifespan)
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def attach_request_id(request: Request, call_next):
|
||||
incoming = request.headers.get("x-request-id")
|
||||
request.state.request_id = incoming.strip() if incoming and incoming.strip() else str(uuid.uuid4())
|
||||
response = await call_next(request)
|
||||
response.headers["X-Request-Id"] = request.state.request_id
|
||||
return response
|
||||
|
||||
|
||||
@app.exception_handler(AppError)
|
||||
async def app_error_handler(request: Request, exc: AppError) -> JSONResponse:
|
||||
return error_response(
|
||||
exc.status_code,
|
||||
exc.code,
|
||||
exc.message,
|
||||
request_id_of(request),
|
||||
headers=exc.headers,
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_error_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
|
||||
return error_response(
|
||||
400,
|
||||
"invalid_request",
|
||||
"Request validation failed",
|
||||
request_id_of(request),
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(StarletteHTTPException)
|
||||
async def http_exception_handler(request: Request, exc: StarletteHTTPException) -> JSONResponse:
|
||||
code = "not_found" if exc.status_code == 404 else "invalid_request"
|
||||
headers = None
|
||||
if exc.status_code == 401:
|
||||
code = "unauthorized"
|
||||
headers = BEARER_CHALLENGE
|
||||
elif exc.status_code >= 500:
|
||||
code = "internal_error"
|
||||
message = exc.detail if isinstance(exc.detail, str) else "Request failed"
|
||||
return error_response(
|
||||
exc.status_code,
|
||||
code,
|
||||
message,
|
||||
request_id_of(request),
|
||||
headers=headers,
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def unhandled_error_handler(request: Request, exc: Exception) -> JSONResponse:
|
||||
return error_response(500, "internal_error", "Internal server error", request_id_of(request))
|
||||
|
||||
|
||||
def current_user_id(authorization: Optional[str] = Header(default=None)) -> str:
|
||||
if authorization is None or not authorization.strip():
|
||||
raise AppError(401, "unauthorized", "Missing bearer token", headers=BEARER_CHALLENGE)
|
||||
scheme, _, credential = authorization.partition(" ")
|
||||
if scheme.lower() != "bearer" or not credential.strip():
|
||||
raise AppError(401, "unauthorized", "Bearer token required", headers=BEARER_CHALLENGE)
|
||||
return store.resolve_bearer(credential.strip())
|
||||
|
||||
|
||||
def require_chat_member(chat_id: UUID, user_id: str):
|
||||
chat = store.get_chat(str(chat_id))
|
||||
if chat is None or user_id not in chat.member_ids:
|
||||
raise AppError(404, "not_found", "Chat not found")
|
||||
return chat
|
||||
|
||||
|
||||
def parse_basic_credentials(authorization: Optional[str]) -> tuple[str, str]:
|
||||
if authorization is None or not authorization.strip():
|
||||
raise AppError(401, "unauthorized", "Missing basic credentials", headers=BASIC_CHALLENGE)
|
||||
scheme, _, credential = authorization.partition(" ")
|
||||
if scheme.lower() != "basic" or not credential.strip():
|
||||
raise AppError(401, "unauthorized", "Basic credentials required", headers=BASIC_CHALLENGE)
|
||||
try:
|
||||
decoded = base64.b64decode(credential.strip(), validate=True).decode("utf-8")
|
||||
except (binascii.Error, UnicodeDecodeError, ValueError) as exc:
|
||||
raise AppError(401, "unauthorized", "Invalid basic credentials", headers=BASIC_CHALLENGE) from exc
|
||||
if ":" not in decoded:
|
||||
raise AppError(401, "unauthorized", "Invalid basic credentials", headers=BASIC_CHALLENGE)
|
||||
username, password = decoded.split(":", 1)
|
||||
if not username or not username.isascii():
|
||||
raise AppError(401, "unauthorized", "Invalid basic credentials", headers=BASIC_CHALLENGE)
|
||||
return username, password
|
||||
|
||||
|
||||
@app.get("/health/live")
|
||||
def health_live():
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.get("/health/ready")
|
||||
def health_ready():
|
||||
if not ping():
|
||||
raise AppError(503, "unavailable", "Database is unavailable")
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.post("/api/v1/users", status_code=201)
|
||||
def register_user(body: CreateUser):
|
||||
user = store.create_user(body.username, body.display_name, body.password)
|
||||
return user.to_dict()
|
||||
|
||||
|
||||
@app.post("/api/v1/auth/sessions", status_code=201)
|
||||
def create_session(authorization: Optional[str] = Header(default=None)):
|
||||
username, password = parse_basic_credentials(authorization)
|
||||
session = store.create_session(username, password)
|
||||
return session.to_dict()
|
||||
|
||||
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
def revoke_session(authorization: Optional[str] = Header(default=None)):
|
||||
if authorization is None or not authorization.strip():
|
||||
raise AppError(401, "unauthorized", "Missing bearer token", headers=BEARER_CHALLENGE)
|
||||
scheme, _, credential = authorization.partition(" ")
|
||||
if scheme.lower() != "bearer" or not credential.strip():
|
||||
raise AppError(401, "unauthorized", "Bearer token required", headers=BEARER_CHALLENGE)
|
||||
store.revoke_session(credential.strip())
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@app.get("/api/v1/users/me")
|
||||
def get_me(user_id: str = Depends(current_user_id)):
|
||||
user = store.get_user(user_id)
|
||||
if user is None:
|
||||
raise AppError(401, "unauthorized", "Unknown user", headers=BEARER_CHALLENGE)
|
||||
return user.to_dict()
|
||||
|
||||
|
||||
@app.post("/api/v1/chats", status_code=201)
|
||||
def create_chat(body: CreateChat, user_id: str = Depends(current_user_id)):
|
||||
member_ids = [str(m) for m in body.member_ids]
|
||||
if user_id not in member_ids:
|
||||
raise AppError(400, "invalid_request", "Caller must be included in member_ids")
|
||||
chat = store.create_chat(body.title, member_ids)
|
||||
return chat.to_dict()
|
||||
|
||||
|
||||
@app.get("/api/v1/chats")
|
||||
def list_chats(
|
||||
user_id: str = Depends(current_user_id),
|
||||
limit: int = Query(default=50, ge=1, le=100),
|
||||
cursor: Optional[str] = Query(default=None, min_length=1),
|
||||
):
|
||||
resource = f"chats:{user_id}"
|
||||
after = decode_cursor(cursor, resource) if cursor else None
|
||||
page, last_for_cursor = store.list_chats_for_user(user_id, limit, after)
|
||||
next_cursor = None
|
||||
if last_for_cursor is not None:
|
||||
next_cursor = encode_cursor(last_for_cursor.created_at, last_for_cursor.id, resource)
|
||||
return {"items": [c.to_dict() for c in page], "next_cursor": next_cursor}
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}")
|
||||
def get_chat(chat_id: UUID, user_id: str = Depends(current_user_id)):
|
||||
chat = require_chat_member(chat_id, user_id)
|
||||
return chat.to_dict()
|
||||
|
||||
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
||||
def create_message(
|
||||
chat_id: UUID,
|
||||
body: CreateMessage,
|
||||
user_id: str = Depends(current_user_id),
|
||||
):
|
||||
require_chat_member(chat_id, user_id)
|
||||
message = store.create_message(str(chat_id), user_id, body.text)
|
||||
return message.to_dict()
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}/messages")
|
||||
def list_messages(
|
||||
chat_id: UUID,
|
||||
user_id: str = Depends(current_user_id),
|
||||
limit: int = Query(default=50, ge=1, le=100),
|
||||
cursor: Optional[str] = Query(default=None, min_length=1),
|
||||
):
|
||||
require_chat_member(chat_id, user_id)
|
||||
resource = f"messages:{chat_id}"
|
||||
after = decode_cursor(cursor, resource) if cursor else None
|
||||
page, last_for_cursor = store.list_messages(str(chat_id), limit, after)
|
||||
next_cursor = None
|
||||
if last_for_cursor is not None:
|
||||
next_cursor = encode_cursor(last_for_cursor.created_at, last_for_cursor.id, resource)
|
||||
return {"items": [m.to_dict() for m in page], "next_cursor": next_cursor}
|
||||
@@ -0,0 +1,34 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import json
|
||||
from typing import Tuple
|
||||
|
||||
from .errors import AppError
|
||||
|
||||
|
||||
def encode_cursor(created_at: str, item_id: str, resource: str) -> str:
|
||||
raw = json.dumps(
|
||||
{"t": created_at, "i": item_id, "r": resource},
|
||||
separators=(",", ":"),
|
||||
ensure_ascii=False,
|
||||
).encode("utf-8")
|
||||
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
|
||||
|
||||
|
||||
def decode_cursor(cursor: str, expected_resource: str) -> Tuple[str, str]:
|
||||
try:
|
||||
padded = cursor + "=" * (-len(cursor) % 4)
|
||||
data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")).decode("utf-8"))
|
||||
created_at = data["t"]
|
||||
item_id = data["i"]
|
||||
resource = data["r"]
|
||||
if not isinstance(created_at, str) or not isinstance(item_id, str):
|
||||
raise ValueError("bad cursor fields")
|
||||
if resource != expected_resource:
|
||||
raise AppError(400, "invalid_request", "Cursor does not belong to this resource")
|
||||
return created_at, item_id
|
||||
except AppError:
|
||||
raise
|
||||
except Exception as exc:
|
||||
raise AppError(400, "invalid_request", "Invalid cursor") from exc
|
||||
@@ -0,0 +1,115 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
from contextlib import contextmanager
|
||||
from pathlib import Path
|
||||
from typing import Iterator, Optional
|
||||
|
||||
from sqlalchemy import create_engine, text
|
||||
from sqlalchemy.engine import Engine
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
_engine: Optional[Engine] = None
|
||||
_SessionLocal: Optional[sessionmaker[Session]] = None
|
||||
|
||||
|
||||
def _read_database_url() -> str:
|
||||
url_file = os.environ.get("DATABASE_URL_FILE")
|
||||
if url_file:
|
||||
url = Path(url_file).read_text(encoding="utf-8").strip()
|
||||
else:
|
||||
url = os.environ.get("DATABASE_URL")
|
||||
if not url:
|
||||
raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE is required")
|
||||
url = url.strip()
|
||||
if url.startswith("postgresql://"):
|
||||
url = "postgresql+psycopg://" + url[len("postgresql://") :]
|
||||
elif url.startswith("postgres://"):
|
||||
url = "postgresql+psycopg://" + url[len("postgres://") :]
|
||||
return url
|
||||
|
||||
|
||||
def init_engine() -> Engine:
|
||||
global _engine, _SessionLocal
|
||||
if _engine is not None:
|
||||
return _engine
|
||||
_engine = create_engine(
|
||||
_read_database_url(),
|
||||
pool_size=5,
|
||||
max_overflow=5,
|
||||
pool_pre_ping=True,
|
||||
pool_timeout=10,
|
||||
)
|
||||
_SessionLocal = sessionmaker(bind=_engine, expire_on_commit=False)
|
||||
return _engine
|
||||
|
||||
|
||||
def get_engine() -> Engine:
|
||||
if _engine is None:
|
||||
raise RuntimeError("database engine is not initialized")
|
||||
return _engine
|
||||
|
||||
|
||||
@contextmanager
|
||||
def session_scope() -> Iterator[Session]:
|
||||
if _SessionLocal is None:
|
||||
raise RuntimeError("database engine is not initialized")
|
||||
session = _SessionLocal()
|
||||
try:
|
||||
yield session
|
||||
session.commit()
|
||||
except Exception:
|
||||
session.rollback()
|
||||
raise
|
||||
finally:
|
||||
session.close()
|
||||
|
||||
|
||||
def close_engine() -> None:
|
||||
global _engine, _SessionLocal
|
||||
if _engine is not None:
|
||||
_engine.dispose()
|
||||
_engine = None
|
||||
_SessionLocal = None
|
||||
|
||||
|
||||
def migrations_dir() -> Path:
|
||||
return Path(__file__).resolve().parents[2] / "migrations"
|
||||
|
||||
|
||||
def apply_migrations() -> None:
|
||||
engine = get_engine()
|
||||
with engine.begin() as conn:
|
||||
conn.execute(
|
||||
text(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version TEXT PRIMARY KEY,
|
||||
applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
)
|
||||
"""
|
||||
)
|
||||
)
|
||||
applied = {
|
||||
row[0]
|
||||
for row in conn.execute(text("SELECT version FROM schema_migrations")).fetchall()
|
||||
}
|
||||
for path in sorted(migrations_dir().glob("*.sql")):
|
||||
version = path.name
|
||||
if version in applied:
|
||||
continue
|
||||
conn.exec_driver_sql(path.read_text(encoding="utf-8"))
|
||||
conn.execute(
|
||||
text("INSERT INTO schema_migrations (version) VALUES (:version)"),
|
||||
{"version": version},
|
||||
)
|
||||
|
||||
|
||||
def ping() -> bool:
|
||||
try:
|
||||
engine = get_engine()
|
||||
with engine.connect() as conn:
|
||||
conn.execute(text("SELECT 1"))
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
@@ -0,0 +1,45 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Optional
|
||||
|
||||
from fastapi import Request
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
|
||||
class AppError(Exception):
|
||||
def __init__(
|
||||
self,
|
||||
status_code: int,
|
||||
code: str,
|
||||
message: str,
|
||||
headers: Optional[dict] = None,
|
||||
) -> None:
|
||||
self.status_code = status_code
|
||||
self.code = code
|
||||
self.message = message
|
||||
self.headers = headers
|
||||
super().__init__(message)
|
||||
|
||||
|
||||
def request_id_of(request: Request) -> str:
|
||||
return getattr(request.state, "request_id", "unknown")
|
||||
|
||||
|
||||
def error_response(
|
||||
status_code: int,
|
||||
code: str,
|
||||
message: str,
|
||||
request_id: str,
|
||||
headers: Optional[dict] = None,
|
||||
) -> JSONResponse:
|
||||
payload = {
|
||||
"error": {
|
||||
"code": code,
|
||||
"message": message,
|
||||
"request_id": request_id,
|
||||
}
|
||||
}
|
||||
response_headers = {"X-Request-Id": request_id}
|
||||
if headers:
|
||||
response_headers.update(headers)
|
||||
return JSONResponse(status_code=status_code, content=payload, headers=response_headers)
|
||||
@@ -0,0 +1,72 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from typing import List
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field, field_validator
|
||||
|
||||
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
|
||||
|
||||
|
||||
def _not_blank(value: str, field_name: str) -> str:
|
||||
if value.strip() == "":
|
||||
raise ValueError(f"{field_name} must not be blank")
|
||||
return value
|
||||
|
||||
|
||||
class CreateUser(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
username: str
|
||||
display_name: str = Field(min_length=1, max_length=100)
|
||||
password: str = Field(min_length=12, max_length=128)
|
||||
|
||||
@field_validator("username")
|
||||
@classmethod
|
||||
def validate_username(cls, value: str) -> str:
|
||||
if not USERNAME_RE.fullmatch(value):
|
||||
raise ValueError("username must match [a-z0-9_]{3,32}")
|
||||
return value
|
||||
|
||||
@field_validator("display_name")
|
||||
@classmethod
|
||||
def validate_display_name(cls, value: str) -> str:
|
||||
return _not_blank(value, "display_name")
|
||||
|
||||
@field_validator("password")
|
||||
@classmethod
|
||||
def validate_password(cls, value: str) -> str:
|
||||
if len(value) < 12 or len(value) > 128:
|
||||
raise ValueError("password length must be 12-128")
|
||||
return value
|
||||
|
||||
|
||||
class CreateChat(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
title: str = Field(min_length=1, max_length=100)
|
||||
member_ids: List[UUID] = Field(min_length=1, max_length=100)
|
||||
|
||||
@field_validator("title")
|
||||
@classmethod
|
||||
def validate_title(cls, value: str) -> str:
|
||||
return _not_blank(value, "title")
|
||||
|
||||
@field_validator("member_ids")
|
||||
@classmethod
|
||||
def validate_members(cls, value: List[UUID]) -> List[UUID]:
|
||||
if len(value) != len(set(value)):
|
||||
raise ValueError("member_ids must be unique")
|
||||
return value
|
||||
|
||||
|
||||
class CreateMessage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
text: str = Field(min_length=1, max_length=4000)
|
||||
|
||||
@field_validator("text")
|
||||
@classmethod
|
||||
def validate_text(cls, value: str) -> str:
|
||||
return _not_blank(value, "text")
|
||||
@@ -0,0 +1,325 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import os
|
||||
import secrets
|
||||
import uuid
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import List, Optional, Tuple
|
||||
from uuid import UUID
|
||||
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import VerifyMismatchError
|
||||
from sqlalchemy import func, select, tuple_
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
|
||||
from .db import session_scope
|
||||
from .errors import AppError
|
||||
from .tables import ChatMemberRow, ChatRow, MessageRow, SessionRow, UserRow
|
||||
|
||||
password_hasher = PasswordHasher()
|
||||
|
||||
|
||||
def utc_now() -> datetime:
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
def format_ts(value: datetime) -> str:
|
||||
if value.tzinfo is None:
|
||||
value = value.replace(tzinfo=timezone.utc)
|
||||
return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
|
||||
|
||||
|
||||
def parse_ts(value: str) -> datetime:
|
||||
return datetime.fromisoformat(value.replace("Z", "+00:00"))
|
||||
|
||||
|
||||
def session_ttl_seconds() -> int:
|
||||
raw = os.environ.get("SESSION_TTL_SECONDS", "3600")
|
||||
return max(1, int(raw))
|
||||
|
||||
|
||||
def hash_token(token: str) -> str:
|
||||
return hashlib.sha256(token.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
@dataclass
|
||||
class User:
|
||||
id: str
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: str
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
return {
|
||||
"id": self.id,
|
||||
"username": self.username,
|
||||
"display_name": self.display_name,
|
||||
"created_at": self.created_at,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class Chat:
|
||||
id: str
|
||||
title: str
|
||||
member_ids: List[str]
|
||||
created_at: str
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
return {
|
||||
"id": self.id,
|
||||
"title": self.title,
|
||||
"member_ids": list(self.member_ids),
|
||||
"created_at": self.created_at,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class Message:
|
||||
id: str
|
||||
chat_id: str
|
||||
sender_id: str
|
||||
text: str
|
||||
created_at: str
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
return {
|
||||
"id": self.id,
|
||||
"chat_id": self.chat_id,
|
||||
"sender_id": self.sender_id,
|
||||
"text": self.text,
|
||||
"created_at": self.created_at,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class Session:
|
||||
token: str
|
||||
token_type: str
|
||||
expires_at: str
|
||||
user: User
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
return {
|
||||
"token": self.token,
|
||||
"token_type": self.token_type,
|
||||
"expires_at": self.expires_at,
|
||||
"user": self.user.to_dict(),
|
||||
}
|
||||
|
||||
|
||||
def _user_from_row(row: UserRow) -> User:
|
||||
return User(
|
||||
id=str(row.id),
|
||||
username=row.username,
|
||||
display_name=row.display_name,
|
||||
created_at=format_ts(row.created_at),
|
||||
)
|
||||
|
||||
|
||||
def _chat_from_row(row: ChatRow, member_ids: List[str]) -> Chat:
|
||||
return Chat(
|
||||
id=str(row.id),
|
||||
title=row.title,
|
||||
member_ids=member_ids,
|
||||
created_at=format_ts(row.created_at),
|
||||
)
|
||||
|
||||
|
||||
def _message_from_row(row: MessageRow) -> Message:
|
||||
return Message(
|
||||
id=str(row.id),
|
||||
chat_id=str(row.chat_id),
|
||||
sender_id=str(row.sender_id),
|
||||
text=row.text,
|
||||
created_at=format_ts(row.created_at),
|
||||
)
|
||||
|
||||
|
||||
def _member_ids(session, chat_id: UUID) -> List[str]:
|
||||
rows = session.scalars(
|
||||
select(ChatMemberRow.user_id)
|
||||
.where(ChatMemberRow.chat_id == chat_id)
|
||||
.order_by(ChatMemberRow.user_id)
|
||||
).all()
|
||||
return [str(user_id) for user_id in rows]
|
||||
|
||||
|
||||
class Store:
|
||||
def create_user(self, username: str, display_name: str, password: str) -> User:
|
||||
row = UserRow(
|
||||
id=uuid.uuid4(),
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
password_hash=password_hasher.hash(password),
|
||||
created_at=utc_now(),
|
||||
)
|
||||
try:
|
||||
with session_scope() as session:
|
||||
session.add(row)
|
||||
session.flush()
|
||||
return _user_from_row(row)
|
||||
except IntegrityError as exc:
|
||||
raise AppError(409, "conflict", "Username is already taken") from exc
|
||||
|
||||
def get_user(self, user_id: str) -> Optional[User]:
|
||||
with session_scope() as session:
|
||||
row = session.get(UserRow, UUID(user_id))
|
||||
return _user_from_row(row) if row else None
|
||||
|
||||
def create_session(self, username: str, password: str) -> Session:
|
||||
with session_scope() as session:
|
||||
row = session.scalar(select(UserRow).where(UserRow.username == username))
|
||||
if row is None:
|
||||
raise AppError(
|
||||
401,
|
||||
"unauthorized",
|
||||
"Invalid credentials",
|
||||
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
|
||||
)
|
||||
try:
|
||||
password_hasher.verify(row.password_hash, password)
|
||||
except VerifyMismatchError as exc:
|
||||
raise AppError(
|
||||
401,
|
||||
"unauthorized",
|
||||
"Invalid credentials",
|
||||
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
|
||||
) from exc
|
||||
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires_at = utc_now() + timedelta(seconds=session_ttl_seconds())
|
||||
session.add(
|
||||
SessionRow(
|
||||
token_hash=hash_token(token),
|
||||
user_id=row.id,
|
||||
expires_at=expires_at,
|
||||
created_at=utc_now(),
|
||||
)
|
||||
)
|
||||
user = _user_from_row(row)
|
||||
return Session(
|
||||
token=token,
|
||||
token_type="Bearer",
|
||||
expires_at=format_ts(expires_at),
|
||||
user=user,
|
||||
)
|
||||
|
||||
def resolve_bearer(self, token: str) -> str:
|
||||
with session_scope() as session:
|
||||
row = session.get(SessionRow, hash_token(token))
|
||||
challenge = {"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
if row is None:
|
||||
raise AppError(401, "unauthorized", "Invalid session", headers=challenge)
|
||||
if row.revoked_at is not None:
|
||||
raise AppError(401, "unauthorized", "Session revoked", headers=challenge)
|
||||
expires_at = row.expires_at
|
||||
if expires_at.tzinfo is None:
|
||||
expires_at = expires_at.replace(tzinfo=timezone.utc)
|
||||
if expires_at <= utc_now():
|
||||
raise AppError(401, "unauthorized", "Session expired", headers=challenge)
|
||||
return str(row.user_id)
|
||||
|
||||
def revoke_session(self, token: str) -> None:
|
||||
with session_scope() as session:
|
||||
row = session.get(SessionRow, hash_token(token), with_for_update=True)
|
||||
challenge = {"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
if row is None:
|
||||
raise AppError(401, "unauthorized", "Invalid session", headers=challenge)
|
||||
if row.revoked_at is not None:
|
||||
raise AppError(401, "unauthorized", "Session revoked", headers=challenge)
|
||||
expires_at = row.expires_at
|
||||
if expires_at.tzinfo is None:
|
||||
expires_at = expires_at.replace(tzinfo=timezone.utc)
|
||||
if expires_at <= utc_now():
|
||||
raise AppError(401, "unauthorized", "Session expired", headers=challenge)
|
||||
row.revoked_at = utc_now()
|
||||
|
||||
def create_chat(self, title: str, member_ids: List[str]) -> Chat:
|
||||
chat_id = uuid.uuid4()
|
||||
member_uuids = [UUID(m) for m in member_ids]
|
||||
with session_scope() as session:
|
||||
existing = session.scalar(
|
||||
select(func.count()).select_from(UserRow).where(UserRow.id.in_(member_uuids))
|
||||
)
|
||||
if existing != len(member_uuids):
|
||||
raise AppError(400, "invalid_request", "Unknown member in member_ids")
|
||||
chat = ChatRow(id=chat_id, title=title, created_at=utc_now())
|
||||
session.add(chat)
|
||||
for member_id in member_uuids:
|
||||
session.add(ChatMemberRow(chat_id=chat_id, user_id=member_id))
|
||||
session.flush()
|
||||
return _chat_from_row(chat, list(member_ids))
|
||||
|
||||
def get_chat(self, chat_id: str) -> Optional[Chat]:
|
||||
with session_scope() as session:
|
||||
row = session.get(ChatRow, UUID(chat_id))
|
||||
if row is None:
|
||||
return None
|
||||
return _chat_from_row(row, _member_ids(session, row.id))
|
||||
|
||||
def list_chats_for_user(
|
||||
self,
|
||||
user_id: str,
|
||||
limit: int,
|
||||
after: Optional[Tuple[str, str]] = None,
|
||||
) -> Tuple[List[Chat], Optional[Chat]]:
|
||||
with session_scope() as session:
|
||||
stmt = (
|
||||
select(ChatRow)
|
||||
.join(ChatMemberRow, ChatMemberRow.chat_id == ChatRow.id)
|
||||
.where(ChatMemberRow.user_id == UUID(user_id))
|
||||
)
|
||||
if after is not None:
|
||||
stmt = stmt.where(
|
||||
tuple_(ChatRow.created_at, ChatRow.id)
|
||||
> (parse_ts(after[0]), UUID(after[1]))
|
||||
)
|
||||
stmt = stmt.order_by(ChatRow.created_at.asc(), ChatRow.id.asc()).limit(limit + 1)
|
||||
rows = list(session.scalars(stmt).all())
|
||||
chats = [_chat_from_row(row, _member_ids(session, row.id)) for row in rows]
|
||||
page = chats[:limit]
|
||||
has_more = len(chats) > limit
|
||||
last = page[-1] if page and has_more else None
|
||||
return page, last
|
||||
|
||||
def create_message(self, chat_id: str, sender_id: str, text: str) -> Message:
|
||||
row = MessageRow(
|
||||
id=uuid.uuid4(),
|
||||
chat_id=UUID(chat_id),
|
||||
sender_id=UUID(sender_id),
|
||||
text=text,
|
||||
created_at=utc_now(),
|
||||
)
|
||||
with session_scope() as session:
|
||||
session.add(row)
|
||||
session.flush()
|
||||
return _message_from_row(row)
|
||||
|
||||
def list_messages(
|
||||
self,
|
||||
chat_id: str,
|
||||
limit: int,
|
||||
after: Optional[Tuple[str, str]] = None,
|
||||
) -> Tuple[List[Message], Optional[Message]]:
|
||||
with session_scope() as session:
|
||||
stmt = select(MessageRow).where(MessageRow.chat_id == UUID(chat_id))
|
||||
if after is not None:
|
||||
stmt = stmt.where(
|
||||
tuple_(MessageRow.created_at, MessageRow.id)
|
||||
> (parse_ts(after[0]), UUID(after[1]))
|
||||
)
|
||||
stmt = stmt.order_by(MessageRow.created_at.asc(), MessageRow.id.asc()).limit(
|
||||
limit + 1
|
||||
)
|
||||
rows = list(session.scalars(stmt).all())
|
||||
messages = [_message_from_row(row) for row in rows]
|
||||
page = messages[:limit]
|
||||
has_more = len(messages) > limit
|
||||
last = page[-1] if page and has_more else None
|
||||
return page, last
|
||||
|
||||
|
||||
store = Store()
|
||||
@@ -0,0 +1,63 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
from typing import List, Optional
|
||||
|
||||
from sqlalchemy import DateTime, ForeignKey, String, Text, Uuid
|
||||
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
|
||||
|
||||
|
||||
class Base(DeclarativeBase):
|
||||
pass
|
||||
|
||||
|
||||
class UserRow(Base):
|
||||
__tablename__ = "users"
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
|
||||
username: Mapped[str] = mapped_column(Text, nullable=False, unique=True)
|
||||
display_name: Mapped[str] = mapped_column(Text, nullable=False)
|
||||
password_hash: Mapped[str] = mapped_column(Text, nullable=False)
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
|
||||
|
||||
|
||||
class ChatRow(Base):
|
||||
__tablename__ = "chats"
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
|
||||
title: Mapped[str] = mapped_column(Text, nullable=False)
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
|
||||
members: Mapped[List["ChatMemberRow"]] = relationship(back_populates="chat")
|
||||
|
||||
|
||||
class ChatMemberRow(Base):
|
||||
__tablename__ = "chat_members"
|
||||
|
||||
chat_id: Mapped[uuid.UUID] = mapped_column(
|
||||
Uuid, ForeignKey("chats.id"), primary_key=True
|
||||
)
|
||||
user_id: Mapped[uuid.UUID] = mapped_column(
|
||||
Uuid, ForeignKey("users.id"), primary_key=True
|
||||
)
|
||||
chat: Mapped[ChatRow] = relationship(back_populates="members")
|
||||
|
||||
|
||||
class MessageRow(Base):
|
||||
__tablename__ = "messages"
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
|
||||
chat_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("chats.id"), nullable=False)
|
||||
sender_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id"), nullable=False)
|
||||
text: Mapped[str] = mapped_column(Text, nullable=False)
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
|
||||
|
||||
|
||||
class SessionRow(Base):
|
||||
__tablename__ = "sessions"
|
||||
|
||||
token_hash: Mapped[str] = mapped_column(String, primary_key=True)
|
||||
user_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id"), nullable=False)
|
||||
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
|
||||
revoked_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), nullable=True)
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
|
||||
Reference in New Issue
Block a user