1 Commits
Author SHA1 Message Date
katyatheestalion 76851cc2f5 Сделана лаба 2
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-11-16 21:11:01 +03:00
8 changed files with 666 additions and 24 deletions
+4
View File
@@ -4,6 +4,10 @@ APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
POSTGRES_DB=messenger
POSTGRES_USER=messenger
POSTGRES_PASSWORD=change-me-local-only
DATABASE_URL=postgresql://messenger:change-me-local-only@postgres:5432/messenger
# 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:
+16
View File
@@ -0,0 +1,16 @@
FROM python:3.13-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
WORKDIR /app
COPY requirements.txt .
RUN python -m pip install --no-cache-dir -r requirements.txt
COPY app.py ./
COPY migrations ./migrations/
RUN useradd --create-home --shell /usr/sbin/nologin appuser && \
chown -R appuser:appuser /app
USER appuser
EXPOSE 8080
CMD ["python", "app.py"]
+63 -24
View File
@@ -1,37 +1,76 @@
# Отчёт — лабораторная 2
## Лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
Автор / группа: Антонова Екатерина
## Запуск из чистого clone
Целевая оценка (3/4/5): 3
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Трек 5, если заявлен: не заявлен
## Архитектура и решения
Что реализовано и что перенесено: перенесены пользователи, чаты, участники, сообщения и keyset-пагинация из lab1. Добавлены PostgreSQL, версионируемая миграция, Argon2id-хеширование паролей, Basic-аутентификация для создания Bearer-сессии, expiry и logout. PostgreSQL хранит пользователей, чаты,
членство, сообщения и действующие сессии. Добавлены [Dockerfile](Dockerfile), [compose.yaml](compose.yaml), именованный volume PostgreSQL и restart hook [scripts/restart.sh](scripts/restart.sh).
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
## Команды запуска из чистого clone
## Доказательства критериев
```powershell
$repo = Join-Path $HOME 'Desktop\univ\4\hideload\mtusi2026lab2'
Set-Location $repo
Copy-Item .env.example .env
docker compose --env-file .env down -v
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
Invoke-WebRequest http://localhost:8080/health/ready
```
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
После запуска:
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
```powershell
python tests/smoke.py --base-url http://localhost:8080
```
## Эксперименты и отказы
Для Linux:
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
```sh
chmod +x scripts/restart.sh
make check
make validate
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
```
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
Остановка без удаления данных:
## Ограничения и следующие шаги
```sh
docker compose --env-file .env down
```
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Намеренное удаление учебных данных:
```sh
docker compose --env-file .env down -v
```
## Результаты проверок
- `scripts/check_contract.py` — PASS.
- `scripts/validate_openapi.py` — PASS.
- `docker compose --env-file .env config --quiet` — PASS.
- Compose успешно собрал и запустил API и PostgreSQL; оба контейнера стали
`healthy`.
- `tests/smoke.py --base-url http://localhost:8080` — PASS:
`PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.`
- После `docker compose restart postgres api` прежний Bearer-токен продолжил
работать; проверка вывела `PERSISTENCE=True`.
- Миграция `001` применена, данные находятся в именованном volume
`postgres-data`.
В Windows-окружении `make` и Bash отсутствуют, поэтому smoke и persistence
были проверены эквивалентными командами PowerShell. В Linux/CI используются
команды Makefile из раздела выше.
## Архитектура и ограничения
PostgreSQL является источником истины. Создание чата и записей членства выполняется атомарно в одной транзакции. Повторный запуск миграций не дублирует данные благодаря таблице `schema_migrations`.
Basic применяется только на `POST /api/v1/auth/sessions`. Все остальные защищённые endpoint требуют Bearer. `X-User-Id` не предоставляет доступ. Токены хранятся в PostgreSQL только в виде SHA-256 отпечатков, пароли — только в виде Argon2id-хешей.
Redis/Valkey, несколько API-реплик, failover и нагрузочное исследование не заявляются, поскольку относятся к следующим уровням. Стенд рассчитан на один локальный API и один PostgreSQL; secrets и volumes не добавляются в Git.
+501
View File
@@ -0,0 +1,501 @@
import base64
import binascii
import hashlib
import json
import os
import secrets
import time
import uuid
from datetime import datetime, timedelta, timezone
from pathlib import Path
from typing import Any
import psycopg
from psycopg.rows import dict_row
from fastapi import FastAPI, Query, Request, Response
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from pydantic import BaseModel, ConfigDict, Field, field_validator
from argon2 import PasswordHasher
from argon2.exceptions import VerificationError
APP_HOST = os.getenv("APP_HOST", "0.0.0.0")
APP_PORT = int(os.getenv("APP_PORT", "8080"))
DATABASE_URL = os.getenv("DATABASE_URL", "")
DATABASE_URL_FILE = os.getenv("DATABASE_URL_FILE", "")
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
MIGRATIONS_DIR = Path(__file__).parent / "migrations"
PASSWORD_HASHER = PasswordHasher()
class APIError(Exception):
def __init__(self, status_code: int, code: str, message: str):
self.status_code = status_code
self.code = code
self.message = message
class CreateUser(BaseModel):
model_config = ConfigDict(extra="forbid")
username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(..., min_length=1, max_length=100)
password: str = Field(..., min_length=12, max_length=128)
@field_validator("display_name", "password")
@classmethod
def validate_non_blank(cls, value: str) -> str:
if not value.strip():
raise ValueError("value must not be blank")
return value
class CreateChat(BaseModel):
model_config = ConfigDict(extra="forbid")
title: str = Field(..., min_length=1, max_length=100)
member_ids: list[str] = Field(..., min_length=1, max_length=100)
@field_validator("title")
@classmethod
def validate_title(cls, value: str) -> str:
if not value.strip():
raise ValueError("title must not be blank")
return value
@field_validator("member_ids")
@classmethod
def validate_member_ids(cls, value: list[str]) -> list[str]:
if len(set(value)) != len(value):
raise ValueError("member_ids must be unique")
for member_id in value:
try:
uuid.UUID(member_id)
except ValueError as exc:
raise ValueError("member_ids must contain UUIDs") from exc
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:
if not value.strip():
raise ValueError("text must not be blank")
return value
def utc_now() -> datetime:
return datetime.now(timezone.utc)
def iso(value: datetime) -> str:
return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace(
"+00:00", "Z"
)
def database_url() -> str:
if DATABASE_URL:
return DATABASE_URL
if DATABASE_URL_FILE:
try:
return Path(DATABASE_URL_FILE).read_text(encoding="utf-8").strip()
except OSError as exc:
raise RuntimeError("database URL file is not readable") from exc
raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE is required")
def db():
return psycopg.connect(database_url(), row_factory=dict_row)
def apply_migrations() -> None:
with db() as conn:
conn.execute(
"""
CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY,
applied_at timestamptz NOT NULL DEFAULT now()
)
"""
)
for path in sorted(MIGRATIONS_DIR.glob("*.sql")):
version = path.name.split("_", 1)[0]
applied = conn.execute(
"SELECT 1 FROM schema_migrations WHERE version = %s", (version,)
).fetchone()
if applied is None:
for statement in path.read_text(encoding="utf-8").split(";"):
if statement.strip():
conn.execute(statement)
conn.execute(
"INSERT INTO schema_migrations(version) VALUES (%s)", (version,)
)
def wait_for_database() -> None:
deadline = time.monotonic() + 60
last_error: Exception | None = None
while time.monotonic() < deadline:
try:
apply_migrations()
return
except (OSError, psycopg.Error) as exc:
last_error = exc
time.sleep(1)
raise RuntimeError("database did not become ready") from last_error
def error_response(request: Request, status_code: int, code: str, message: str):
request_id = getattr(request.state, "request_id", str(uuid.uuid4()))
headers = {"X-Request-Id": request_id}
if status_code == 401:
headers["WWW-Authenticate"] = (
'Bearer realm="messenger"'
if request.url.path != "/api/v1/auth/sessions"
else 'Basic realm="messenger", charset="UTF-8"'
)
return JSONResponse(
status_code=status_code,
content={"error": {"code": code, "message": message, "request_id": request_id}},
headers=headers,
)
def bearer_user(request: Request) -> dict[str, Any]:
header = request.headers.get("Authorization", "")
scheme, _, token = header.partition(" ")
if scheme.lower() != "bearer" or not token or " " in token:
raise APIError(401, "unauthorized", "valid bearer session required")
hashed_token = token_hash(token)
with db() as conn:
user = conn.execute(
"""
SELECT u.id, u.username, u.display_name, u.created_at
FROM sessions s JOIN users u ON u.id = s.user_id
WHERE s.token_hash = %s AND s.revoked_at IS NULL
AND s.expires_at > now()
""",
(hashed_token,),
).fetchone()
if user is None:
raise APIError(401, "unauthorized", "valid bearer session required")
return user
def basic_credentials(request: Request) -> tuple[str, str]:
header = request.headers.get("Authorization", "")
scheme, _, encoded = header.partition(" ")
if scheme.lower() != "basic" or not encoded:
raise APIError(401, "unauthorized", "basic credentials required")
try:
decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
username, separator, password = decoded.partition(":")
except (binascii.Error, UnicodeDecodeError):
raise APIError(401, "unauthorized", "invalid credentials") from None
if not separator or not username or not password:
raise APIError(401, "unauthorized", "invalid credentials")
return username, password
def token_hash(token: str) -> str:
try:
return hashlib.sha256(token.encode("ascii", "strict")).hexdigest()
except UnicodeEncodeError:
raise APIError(401, "unauthorized", "valid bearer session required") from None
def encode_cursor(created_at: datetime, object_id: uuid.UUID) -> str:
payload = json.dumps(
{"created_at": iso(created_at), "id": str(object_id)},
separators=(",", ":"),
).encode()
return base64.urlsafe_b64encode(payload).decode().rstrip("=")
def decode_cursor(cursor: str) -> tuple[datetime, uuid.UUID]:
try:
padding = "=" * ((4 - len(cursor) % 4) % 4)
payload = json.loads(
base64.urlsafe_b64decode((cursor + padding).encode()).decode()
)
created_at = datetime.fromisoformat(payload["created_at"].replace("Z", "+00:00"))
return created_at, uuid.UUID(payload["id"])
except (KeyError, TypeError, ValueError, UnicodeDecodeError, binascii.Error, json.JSONDecodeError):
raise APIError(400, "invalid_request", "cursor is invalid") from None
app = FastAPI(title="MTUSI Messenger Lab2")
@app.on_event("startup")
def startup() -> None:
wait_for_database()
@app.middleware("http")
async def add_request_id(request: Request, call_next):
request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
request.state.request_id = request_id
response = await call_next(request)
response.headers["X-Request-Id"] = request_id
return response
@app.exception_handler(APIError)
async def api_error_handler(request: Request, exc: APIError):
return error_response(request, exc.status_code, exc.code, exc.message)
@app.exception_handler(RequestValidationError)
async def validation_error_handler(request: Request, exc: RequestValidationError):
return error_response(request, 400, "invalid_request", "invalid request")
@app.exception_handler(Exception)
async def unexpected_error_handler(request: Request, exc: Exception):
return error_response(request, 500, "internal_error", "internal server error")
@app.get("/health/live")
def health_live():
return {"status": "ok"}
@app.get("/health/ready")
def health_ready():
try:
with db() as conn:
conn.execute("SELECT 1")
except (OSError, psycopg.Error):
raise APIError(503, "unavailable", "database unavailable")
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
def create_user(payload: CreateUser):
user_id = uuid.uuid4()
password_hash = PASSWORD_HASHER.hash(payload.password)
try:
with db() as conn:
user = conn.execute(
"""
INSERT INTO users(id, username, display_name, password_hash)
VALUES (%s, %s, %s, %s)
RETURNING id, username, display_name, created_at
""",
(user_id, payload.username, payload.display_name, password_hash),
).fetchone()
except psycopg.errors.UniqueViolation:
raise APIError(409, "conflict", "user already exists") from None
return {**user, "id": str(user["id"]), "created_at": iso(user["created_at"])}
@app.post("/api/v1/auth/sessions", status_code=201)
def create_session(request: Request):
username, password = basic_credentials(request)
with db() as conn:
user = conn.execute(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
(username,),
).fetchone()
if user is None:
raise APIError(401, "unauthorized", "invalid credentials")
try:
PASSWORD_HASHER.verify(user["password_hash"], password)
except VerificationError:
raise APIError(401, "unauthorized", "invalid credentials") from None
token = secrets.token_urlsafe(32)
expires_at = utc_now() + timedelta(seconds=SESSION_TTL_SECONDS)
with db() as conn:
conn.execute(
"INSERT INTO sessions(token_hash, user_id, expires_at) VALUES (%s, %s, %s)",
(token_hash(token), user["id"], expires_at),
)
public_user = {
"id": str(user["id"]),
"username": user["username"],
"display_name": user["display_name"],
"created_at": iso(user["created_at"]),
}
return {
"token": token,
"token_type": "Bearer",
"expires_at": iso(expires_at),
"user": public_user,
}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(request: Request):
bearer_user(request)
header = request.headers["Authorization"]
token = header.split(" ", 1)[1]
with db() as conn:
conn.execute(
"UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL",
(token_hash(token),),
)
return Response(status_code=204)
@app.get("/api/v1/users/me")
def current_user(request: Request):
user = bearer_user(request)
return {**user, "id": str(user["id"]), "created_at": iso(user["created_at"])}
@app.post("/api/v1/chats", status_code=201)
def create_chat(payload: CreateChat, request: Request):
actor = bearer_user(request)
member_ids = [uuid.UUID(member_id) for member_id in payload.member_ids]
if actor["id"] not in member_ids:
raise APIError(400, "invalid_request", "actor must be included in member_ids")
chat_id = uuid.uuid4()
with db() as conn:
existing = conn.execute(
"SELECT id FROM users WHERE id = ANY(%s)", (member_ids,)
).fetchall()
if len(existing) != len(member_ids):
raise APIError(400, "invalid_request", "member not found")
chat = conn.execute(
"INSERT INTO chats(id, title) VALUES (%s, %s) RETURNING id, title, created_at",
(chat_id, payload.title),
).fetchone()
with conn.cursor() as cur:
cur.executemany(
"INSERT INTO chat_members(chat_id, user_id) VALUES (%s, %s)",
[(chat_id, member_id) for member_id in member_ids],
)
return {
"id": str(chat["id"]),
"title": chat["title"],
"member_ids": sorted(str(member_id) for member_id in member_ids),
"created_at": iso(chat["created_at"]),
}
def chat_for_user(conn, chat_id: uuid.UUID, user_id: uuid.UUID):
return conn.execute(
"""
SELECT c.id, c.title, c.created_at
FROM chats c JOIN chat_members m ON m.chat_id = c.id
WHERE c.id = %s AND m.user_id = %s
""",
(chat_id, user_id),
).fetchone()
def public_chat(conn, chat: dict[str, Any]) -> dict[str, Any]:
members = conn.execute(
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", (chat["id"],)
).fetchall()
return {
"id": str(chat["id"]),
"title": chat["title"],
"member_ids": [str(row["user_id"]) for row in members],
"created_at": iso(chat["created_at"]),
}
@app.get("/api/v1/chats/{chat_id}")
def get_chat(chat_id: uuid.UUID, request: Request):
actor = bearer_user(request)
with db() as conn:
chat = chat_for_user(conn, chat_id, actor["id"])
if chat is None:
raise APIError(404, "not_found", "chat not found")
return public_chat(conn, chat)
@app.get("/api/v1/chats")
def list_chats(request: Request, limit: int = Query(50, ge=1, le=100), cursor: str | None = None):
actor = bearer_user(request)
after = decode_cursor(cursor) if cursor else None
with db() as conn:
rows = conn.execute(
"""
SELECT c.id, c.title, c.created_at
FROM chats c JOIN chat_members m ON m.chat_id = c.id
WHERE m.user_id = %s
AND (%s::timestamptz IS NULL OR (c.created_at, c.id) > (%s::timestamptz, %s::uuid))
ORDER BY c.created_at, c.id
LIMIT %s
""",
(actor["id"], after[0] if after else None, after[0] if after else None,
after[1] if after else None, limit + 1),
).fetchall()
items = [public_chat(conn, row) for row in rows[:limit]]
next_cursor = (
encode_cursor(rows[limit - 1]["created_at"], rows[limit - 1]["id"])
if len(rows) > limit
else None
)
return {"items": items, "next_cursor": next_cursor}
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def create_message(chat_id: uuid.UUID, payload: CreateMessage, request: Request):
actor = bearer_user(request)
message_id = uuid.uuid4()
with db() as conn:
if chat_for_user(conn, chat_id, actor["id"]) is None:
raise APIError(404, "not_found", "chat not accessible")
message = conn.execute(
"""
INSERT INTO messages(id, chat_id, sender_id, text)
VALUES (%s, %s, %s, %s)
RETURNING id, chat_id, sender_id, text, created_at
""",
(message_id, chat_id, actor["id"], payload.text),
).fetchone()
return {**message, "id": str(message["id"]), "chat_id": str(message["chat_id"]),
"sender_id": str(message["sender_id"]), "created_at": iso(message["created_at"])}
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(
chat_id: uuid.UUID,
request: Request,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = None,
):
actor = bearer_user(request)
after = decode_cursor(cursor) if cursor else None
with db() as conn:
if chat_for_user(conn, chat_id, actor["id"]) is None:
raise APIError(404, "not_found", "chat not accessible")
rows = conn.execute(
"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = %s
AND (%s::timestamptz IS NULL OR (created_at, id) > (%s::timestamptz, %s::uuid))
ORDER BY created_at, id
LIMIT %s
""",
(chat_id, after[0] if after else None, after[0] if after else None,
after[1] if after else None, limit + 1),
).fetchall()
items = [
{**row, "id": str(row["id"]), "chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]), "created_at": iso(row["created_at"])}
for row in rows[:limit]
]
next_cursor = (
encode_cursor(rows[limit - 1]["created_at"], rows[limit - 1]["id"])
if len(rows) > limit
else None
)
return {"items": items, "next_cursor": next_cursor}
if __name__ == "__main__":
import uvicorn
uvicorn.run("app:app", host=APP_HOST, port=APP_PORT, reload=False)
+36
View File
@@ -0,0 +1,36 @@
services:
postgres:
image: postgres:16.4
environment:
POSTGRES_DB: ${POSTGRES_DB}
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
volumes:
- postgres-data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U \"$${POSTGRES_USER}\" -d \"$${POSTGRES_DB}\""]
interval: 3s
timeout: 3s
retries: 20
api:
build: .
environment:
APP_HOST: ${APP_HOST:-0.0.0.0}
APP_PORT: ${APP_PORT:-8080}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
depends_on:
postgres:
condition: service_healthy
ports:
- "127.0.0.1:8080:8080"
restart: unless-stopped
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready')"]
interval: 5s
timeout: 3s
retries: 20
volumes:
postgres-data:
+38
View File
@@ -0,0 +1,38 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
username varchar(32) NOT NULL UNIQUE,
display_name varchar(100) NOT NULL CHECK (btrim(display_name) <> ''),
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title varchar(100) NOT NULL CHECK (btrim(title) <> ''),
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users(id),
text varchar(4000) NOT NULL CHECK (btrim(text) <> ''),
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE sessions (
token_hash char(64) PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at timestamptz NOT NULL,
revoked_at timestamptz
);
CREATE INDEX chat_members_user_idx ON chat_members(user_id, chat_id);
CREATE INDEX messages_chat_order_idx ON messages(chat_id, created_at, id);
CREATE INDEX sessions_user_idx ON sessions(user_id, expires_at);
+4
View File
@@ -0,0 +1,4 @@
argon2-cffi==23.1.0
fastapi==0.115.5
psycopg[binary]==3.2.3
uvicorn==0.32.0
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
docker compose --env-file .env restart postgres api