lab3: Compose+Nginx, две API-реплики и идемпотентность

This commit is contained in:
2026-11-11 22:14:42 +03:00
parent 0ab3a341aa
commit d4adcce4ff
26 changed files with 1409 additions and 20 deletions
+4 -5
View File
@@ -1,13 +1,12 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
# Host publish port of the load balancer; 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
DATABASE_URL=postgresql://messenger:messenger@postgres:5432/messenger
# DATABASE_URL_FILE=/run/secrets/database_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
+20
View File
@@ -0,0 +1,20 @@
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/
COPY scripts/migrate.py ./scripts/migrate.py
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}"]
+131 -15
View File
@@ -1,37 +1,153 @@
# Отчёт — лабораторная 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Гадяцкий Л. Е., БПИ2302
- Целевая оценка: 3
- Commit/PR: solution/BPI2302-Gadiatskiy
- Использованные источники и библиотеки:
- контракт и семантика: `contracts/openapi.json`, `contracts/README.md`, `README.md`, `COURSE.md`
- перенос из lab2: FastAPI, PostgreSQL/сессии, SQLAlchemy, миграции, формат ошибок
- 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`; LB: `nginx:1.27-alpine`
- Помощь ИИ использована при переносе lab2, частично при настройке Compose+Nginx и при написании отчёта. Результаты подтверждаются сохранёнными запусками.
## Запуск из чистого 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:lab3`
- PostgreSQL: `postgres:16-alpine`
- Nginx: `nginx:1.27-alpine`
- зависимости: `requirements.txt`
**Конфигурация:** секретов в Git нет. Локальный `.env` создаётся из примера и не коммитится:
```sh
cp .env.example .env
```
Соответствие `.env.example`:
- `APP_HOST` / `APP_PORT` — bind uvicorn внутри контейнеров API
- `HOST_PORT` — порт LB на host (по умолчанию 8080; если занят — например 8081)
- `APP_ENV` — среда запуска (`lab`)
- `SESSION_TTL_SECONDS` — TTL сессии (по умолчанию 3600; для обычного smoke ≥ 300)
- `SESSION_STORE=postgres` — сессии в PostgreSQL (общие для всех реплик)
- `DATABASE_URL` — строка подключения API/migrate к PostgreSQL в compose-сети
(приложение также поддерживает `DATABASE_URL_FILE`)
- `IDEMPOTENCY_TTL_SECONDS` — срок хранения идемпотентных записей (по умолчанию 86400)
- `API_REPLICAS=2` — в `compose.yaml` зафиксированы сервисы `api1` и `api2`
Учебные credentials compose (`messenger` / `messenger`) только для локального синтетического стенда.
**Сборка и запуск:**
```sh
docker compose --env-file .env up -d --build
```
Миграции `migrations/*.sql` применяет one-shot сервис `migrate` до старта `api1`/`api2` (учёт в `schema_migrations`). Реплики API миграции при старте не выполняют.
Готовность через LB (подставьте свой `HOST_PORT`):
```sh
curl -i http://127.0.0.1:8080/health/ready
```
Ожидается HTTP 200, тело `{"status":"ok"}`, заголовки `X-Request-Id` и `X-Instance-Id` (`api1` или `api2`).
**Публичный 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` для `postgres`, `api1`, `api2`, `lb` **без** удаления volumes (`down -v` не используется).
**Проверка отказа одной API-реплики:**
```sh
# Unix:
chmod +x scripts/stop-one.sh
python tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url http://127.0.0.1:8080
# Windows:
python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd --base-url http://127.0.0.1:8080
```
`TARGET_INSTANCE_ID` = `X-Instance-Id` (`api1`/`api2`); hook делает `docker compose stop` только этой реплики и оставляет её остановленной. После теста: `docker compose --env-file .env start api1` (или `api2`). Для защиты повторить на второй реплике после восстановления первой.
Локальная проверка автора выполнялась на `HOST_PORT=8082` (host-порты 8080/8081 были заняты другими контейнерами).
**Остановка:**
```sh
docker compose --env-file .env down
```
Намеренное удаление учебных данных (volumes):
```sh
docker compose --env-file .env down -v
```
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
HTTP-клиент
→ lb (Nginx)
→ api1 / api2 (uvicorn + FastAPI)
→ PostgreSQL
users, chats, chat_members, messages, sessions, idempotency_records
```
- Источник истины — PostgreSQL. Локального состояния, от которого зависит корректность, в API нет.
- Сессии в PostgreSQL: один Bearer работает через любую реплику без sticky sessions.
- `X-Instance-Id` стабилен на жизнь процесса (`INSTANCE_ID` сервиса).
- `Idempotency-Key` обязателен на `POST .../messages`; область: пользователь + метод + путь + ключ; запись результата атомарна с сообщением; другой body при том же ключе → 409; TTL 24ч.
- ORM-модели: `src/messenger/tables.py`. Доступ к данным: `src/messenger/store.py`.
- Миграции: SQL в `migrations/` + one-shot `migrate`; Alembic не используется.
- Порты API наружу не публикуются; публичная точка входа — LB (`infra/nginx.conf`: `least_conn`, `max_fails=1`, `proxy_next_upstream`).
- Compose: `lb` + `api1` + `api2` + `postgres` + `migrate`, volume `pgdata`; `.env` в Git не коммитится.
Перенесено из lab2: auth Basic→Bearer, Argon2id, чаты/сообщения, keyset-пагинация, формат ошибок.
Добавлено в lab3: Nginx LB, две реплики API, `X-Instance-Id`, общая идемпотентность, отдельный migrate, `scripts/stop-one`.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke (lab2 + Idempotency-Key / X-Instance-Id) | `python tests/smoke.py --base-url http://127.0.0.1:8082` | `PASS: lab3 public API scenario...` | `evidence/smoke.txt` |
| Стенд: ≥2 API, один LB, общая БД и сессии | `docker compose --env-file .env ps` | `lb`, `api1`, `api2`, `postgres`; migrate Exited 0 | `evidence/compose-ps.txt` |
| Разные реплики через LB с одной сессией | серия запросов через LB | `api1` и `api2` | `evidence/instances.txt` |
| Persistence: рестарт без удаления volumes, прежний токен | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8082` | `PASS: persistence preserved...` | `evidence/restart.txt` |
| Failover: остановка одной API-реплики | `python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd --base-url http://127.0.0.1:8082` | 2 instance до отказа; first_recovery ≈2.75 с; без дублей | `evidence/failover.txt` |
| Идемпотентность POST сообщений | smoke replay + failover retries | тот же ключ → то же Message; другой body → 409 | `evidence/smoke.txt`, `evidence/failover.txt` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Для оценки 3 отдельный нагрузочный трек не выполнялся. Проверены сохранность и отказ API-реплики:
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `docker compose --env-file .env restart` (postgres+api1+api2+lb), volumes сохранены | `/health/ready` ok; прежний Bearer читает те же данные; сессия действует | persistence PASS | в бюджете теста (hook ≤90 с, ready ≤90 с); потери данных нет |
| `docker compose stop` одной API-реплики | LB обслуживает живую; записи ≤10 с; без дублей по retry | failover PASS; `first_recovery_seconds≈2.75` | подтверждённые сообщения на месте |
Аппаратный профиль: локальный Docker Desktop на Windows; 2 API + Nginx + PostgreSQL без CPU/RAM limits.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Redis/Valkey, CPU/RAM limits, rolling update под нагрузкой и трек 5 не выполнялись.
- Единственный PostgreSQL и единственный Nginx — SPOF; отказ host/узла не выдерживается.
- Basic по HTTP допустим только на локальном учебном стенде с синтетическими данными.
+105
View File
@@ -0,0 +1,105 @@
x-api: &api
build: .
image: mtusi-messenger:lab3
expose:
- "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
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
depends_on:
migrate:
condition: service_completed_successfully
postgres:
condition: service_healthy
healthcheck:
test:
[
"CMD",
"python",
"-c",
"import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)",
]
interval: 3s
timeout: 3s
retries: 20
start_period: 5s
restart: unless-stopped
services:
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
migrate:
build: .
image: mtusi-messenger:lab3
environment:
DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger
command: ["python", "/app/scripts/migrate.py"]
depends_on:
postgres:
condition: service_healthy
restart: "no"
api1:
<<: *api
hostname: api1
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
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
INSTANCE_ID: api1
api2:
<<: *api
hostname: api2
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
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
INSTANCE_ID: api2
lb:
image: nginx:1.27-alpine
ports:
- "127.0.0.1:${HOST_PORT:-8080}:80"
volumes:
- ./infra/nginx.conf:/etc/nginx/nginx.conf:ro
depends_on:
api1:
condition: service_healthy
api2:
condition: service_healthy
healthcheck:
test: ["CMD", "wget", "-qO-", "http://127.0.0.1/health/live"]
interval: 3s
timeout: 3s
retries: 20
restart: unless-stopped
volumes:
pgdata:
+5
View File
@@ -0,0 +1,5 @@
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab3-fork-api1-1 mtusi-messenger:lab3 "sh -c 'exec uvicorn…" api1 24 minutes ago Up 32 seconds (healthy) 8080/tcp
mtusi2026lab3-fork-api2-1 mtusi-messenger:lab3 "sh -c 'exec uvicorn…" api2 24 minutes ago Up 54 seconds (healthy) 8080/tcp
mtusi2026lab3-fork-lb-1 nginx:1.27-alpine "/docker-entrypoint.…" lb 24 minutes ago Up 54 seconds (healthy) 127.0.0.1:8082->80/tcp
mtusi2026lab3-fork-postgres-1 postgres:16-alpine "docker-entrypoint.s…" postgres 24 minutes ago Up 54 seconds (healthy) 5432/tcp
+3
View File
@@ -0,0 +1,3 @@
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 67, "failed_attempts": 1, "first_recovery_seconds": 0.625}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
+2
View File
@@ -0,0 +1,2 @@
observed=api1,api2
{'api2': 20, 'api1': 20}
+2
View File
@@ -0,0 +1,2 @@
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
+1
View File
@@ -0,0 +1 @@
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
+40
View File
@@ -0,0 +1,40 @@
worker_processes auto;
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
access_log /var/log/nginx/access.log;
sendfile on;
keepalive_timeout 65;
upstream api_backends {
least_conn;
server api1:8080 max_fails=1 fail_timeout=3s;
server api2:8080 max_fails=1 fail_timeout=3s;
}
server {
listen 80;
server_name _;
location / {
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header Connection "";
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 2s;
proxy_send_timeout 10s;
proxy_read_timeout 10s;
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 2;
proxy_pass http://api_backends;
}
}
}
+44
View File
@@ -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);
+9
View File
@@ -0,0 +1,9 @@
CREATE TABLE idempotency_records (
scope_key TEXT PRIMARY KEY,
request_hash TEXT NOT NULL,
message_id UUID NOT NULL REFERENCES messages (id),
created_at TIMESTAMPTZ NOT NULL,
expires_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX idempotency_records_expires_idx ON idempotency_records (expires_at);
+6
View File
@@ -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
+15
View File
@@ -0,0 +1,15 @@
#!/usr/bin/env python3
from messenger.db import apply_migrations, close_engine, init_engine
def main() -> None:
init_engine()
try:
apply_migrations()
print("migrations applied")
finally:
close_engine()
if __name__ == "__main__":
main()
+4
View File
@@ -0,0 +1,4 @@
@echo off
cd /d "%~dp0\.."
docker compose --env-file .env restart postgres api1 api2 lb
exit /b %ERRORLEVEL%
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres api1 api2 lb
+12
View File
@@ -0,0 +1,12 @@
@echo off
cd /d "%~dp0\.."
if "%TARGET_INSTANCE_ID%"=="" (
echo TARGET_INSTANCE_ID is required >&2
exit /b 1
)
if /I not "%TARGET_INSTANCE_ID%"=="api1" if /I not "%TARGET_INSTANCE_ID%"=="api2" (
echo unknown TARGET_INSTANCE_ID: %TARGET_INSTANCE_ID% >&2
exit /b 1
)
docker compose --env-file .env stop %TARGET_INSTANCE_ID%
exit /b %ERRORLEVEL%
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
case "$TARGET_INSTANCE_ID" in
api1|api2)
docker compose --env-file .env stop "$TARGET_INSTANCE_ID"
;;
*)
printf '%s\n' "unknown TARGET_INSTANCE_ID: $TARGET_INSTANCE_ID" >&2
exit 1
;;
esac
View File
+245
View File
@@ -0,0 +1,245 @@
from __future__ import annotations
import base64
import binascii
import os
import re
import socket
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 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"'}
IDEMPOTENCY_KEY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
INSTANCE_ID = os.environ.get("INSTANCE_ID") or socket.gethostname()
@asynccontextmanager
async def lifespan(_app: FastAPI):
init_engine()
yield
close_engine()
app = FastAPI(title="MTUSI Messenger lab3", version="1.3.0", lifespan=lifespan)
@app.middleware("http")
async def attach_request_and_instance(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
response.headers["X-Instance-Id"] = INSTANCE_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
def require_idempotency_key(idempotency_key: Optional[str] = Header(default=None, alias="Idempotency-Key")) -> str:
if idempotency_key is None or not idempotency_key.strip():
raise AppError(400, "invalid_request", "Idempotency-Key is required")
key = idempotency_key.strip()
if not IDEMPOTENCY_KEY_RE.fullmatch(key):
raise AppError(400, "invalid_request", "Idempotency-Key format is invalid")
return key
@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,
request: Request,
user_id: str = Depends(current_user_id),
idempotency_key: str = Depends(require_idempotency_key),
):
require_chat_member(chat_id, user_id)
message = store.create_message(
str(chat_id),
user_id,
body.text,
idempotency_key=idempotency_key,
request_path=request.url.path,
)
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}
+34
View File
@@ -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
+115
View File
@@ -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
+45
View File
@@ -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)
+72
View File
@@ -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")
+404
View File
@@ -0,0 +1,404 @@
from __future__ import annotations
import hashlib
import json
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 delete, func, select, tuple_
from sqlalchemy.exc import IntegrityError
from .db import session_scope
from .errors import AppError
from .tables import (
ChatMemberRow,
ChatRow,
IdempotencyRow,
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 idempotency_ttl_seconds() -> int:
raw = os.environ.get("IDEMPOTENCY_TTL_SECONDS", "86400")
return max(1, int(raw))
def hash_token(token: str) -> str:
return hashlib.sha256(token.encode("utf-8")).hexdigest()
def request_body_hash(text: str) -> str:
normalized = json.dumps({"text": text, "attachment_ids": []}, separators=(",", ":"), ensure_ascii=False)
return hashlib.sha256(normalized.encode("utf-8")).hexdigest()
def idempotency_scope(user_id: str, method: str, path: str, key: str) -> str:
return f"{user_id}|{method.upper()}|{path}|{key}"
@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]
def _aware(value: datetime) -> datetime:
if value.tzinfo is None:
return value.replace(tzinfo=timezone.utc)
return value
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)
if _aware(row.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)
if _aware(row.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,
*,
idempotency_key: str,
request_path: str,
) -> Message:
scope = idempotency_scope(sender_id, "POST", request_path, idempotency_key)
body_hash = request_body_hash(text)
for _ in range(5):
try:
with session_scope() as session:
existing = session.get(IdempotencyRow, scope, with_for_update=True)
if existing is not None:
if _aware(existing.expires_at) > utc_now():
if existing.request_hash != body_hash:
raise AppError(
409,
"conflict",
"Idempotency-Key reused with a different request body",
)
message = session.get(MessageRow, existing.message_id)
if message is None:
raise AppError(500, "internal_error", "Idempotent message missing")
return _message_from_row(message)
session.execute(
delete(IdempotencyRow).where(IdempotencyRow.scope_key == scope)
)
session.flush()
message = MessageRow(
id=uuid.uuid4(),
chat_id=UUID(chat_id),
sender_id=UUID(sender_id),
text=text,
created_at=utc_now(),
)
session.add(message)
session.flush()
session.add(
IdempotencyRow(
scope_key=scope,
request_hash=body_hash,
message_id=message.id,
created_at=utc_now(),
expires_at=utc_now() + timedelta(seconds=idempotency_ttl_seconds()),
)
)
session.flush()
return _message_from_row(message)
except IntegrityError:
continue
with session_scope() as session:
existing = session.get(IdempotencyRow, scope)
if existing is not None and _aware(existing.expires_at) > utc_now():
if existing.request_hash != body_hash:
raise AppError(
409,
"conflict",
"Idempotency-Key reused with a different request body",
)
message = session.get(MessageRow, existing.message_id)
if message is not None:
return _message_from_row(message)
raise AppError(503, "unavailable", "Could not complete idempotent write")
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()
+73
View File
@@ -0,0 +1,73 @@
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)
class IdempotencyRow(Base):
__tablename__ = "idempotency_records"
scope_key: Mapped[str] = mapped_column(Text, primary_key=True)
request_hash: Mapped[str] = mapped_column(Text, nullable=False)
message_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("messages.id"), nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)