forked from mtusi2026/mtusi2026lab3
lab3: идентичность реплики, LB-проверка и общая идемпотентность отправки
Этот коммит впервые фиксирует порт lab2 (приложение NestJS+Fastify, Dockerfile, одноservice-стенд compose, restart hook) и добавляет уровень 3/4 по lab3: - X-Instance-Id = INSTANCE_ID либо hostname контейнера (стабилен для процесса), добавляется и в ответах об ошибках, которые формируются до интерсептора. - /internal/lb-check: проба LB, намеренно не зависящая от PostgreSQL и Redis (отказ общей БД нельзя лечить выводом реплик из ротации); /health/ready остаётся операторским сигналом. /internal/metrics отдаёт instance_id и build_id. - Общая идемпотентность POST сообщения: таблица idempotency_keys, область (user, method, path, key), канонический отпечаток тела, заявка+результат в одной транзакции, повтор возвращает сохранённый ответ, другое тело — 409, отсутствие/неверный ключ — 400, просрочка по IDEMPOTENCY_TTL_SECONDS. - Транзиентные коды PostgreSQL (57014/40001/40P01) отображаются в 503, чтобы прерывание не фиксировалось идемпотентной записью как окончательный результат. - Миграции 003 (идемпотентность) и 004 (pg_stat_statements для трека 1), операторский прогон GC: npm run idempotency:gc.
This commit is contained in:
+33
@@ -0,0 +1,33 @@
|
||||
FROM node:25.7.0-slim AS build
|
||||
|
||||
WORKDIR /usr/src/app
|
||||
|
||||
RUN apt-get update \
|
||||
&& apt-get install -y --no-install-recommends python3 make g++ \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
COPY app/package.json app/package-lock.json ./
|
||||
RUN npm ci
|
||||
|
||||
COPY app/ ./
|
||||
RUN npm run build && npm prune --omit=dev
|
||||
|
||||
FROM node:25.7.0-slim AS runtime
|
||||
|
||||
WORKDIR /usr/src/app
|
||||
|
||||
ENV NODE_ENV=production
|
||||
ENV APP_PORT=8080
|
||||
ENV DRAIN_DELAY_MS=5000
|
||||
COPY --from=build /usr/src/app/package.json /usr/src/app/package-lock.json ./
|
||||
COPY --from=build /usr/src/app/node_modules ./node_modules
|
||||
COPY --from=build /usr/src/app/dist ./dist
|
||||
|
||||
USER node
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \
|
||||
CMD node -e "const port=process.env.APP_PORT||'8080'; fetch('http://127.0.0.1:'+port+'/health/ready').then((response) => { if (!response.ok) process.exit(1); }).catch(() => process.exit(1))"
|
||||
|
||||
CMD ["node", "dist/main.js"]
|
||||
@@ -3,11 +3,12 @@ BASE_URL ?= http://localhost:8080
|
||||
CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
COMPOSE_ENV_FILE ?= .env
|
||||
|
||||
.PHONY: help check validate test load test-persistence test-failover
|
||||
.PHONY: help check validate test load test-persistence test-failover test-dependencies
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes; test-dependencies: stops/restarts Redis and PostgreSQL"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -28,3 +29,6 @@ test-persistence:
|
||||
test-failover:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
test-dependencies:
|
||||
cd app && E2E_COMPOSE_DIR="$(CURDIR)" E2E_COMPOSE_ENV_FILE="$(COMPOSE_ENV_FILE)" npm run test:dependencies
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
# compiled output
|
||||
/dist
|
||||
/node_modules
|
||||
/build
|
||||
|
||||
# TypeScript build cache
|
||||
*.tsbuildinfo
|
||||
|
||||
# Logs
|
||||
logs
|
||||
*.log
|
||||
npm-debug.log*
|
||||
pnpm-debug.log*
|
||||
yarn-debug.log*
|
||||
yarn-error.log*
|
||||
lerna-debug.log*
|
||||
|
||||
# OS
|
||||
.DS_Store
|
||||
|
||||
# Tests
|
||||
/coverage
|
||||
/.nyc_output
|
||||
|
||||
# IDEs and editors
|
||||
/.idea
|
||||
.project
|
||||
.classpath
|
||||
.c9/
|
||||
*.launch
|
||||
.settings/
|
||||
*.sublime-workspace
|
||||
|
||||
# IDE - VSCode
|
||||
.vscode/*
|
||||
!.vscode/settings.json
|
||||
!.vscode/tasks.json
|
||||
!.vscode/launch.json
|
||||
!.vscode/extensions.json
|
||||
|
||||
# dotenv environment variable files
|
||||
.env
|
||||
.env.development.local
|
||||
.env.test.local
|
||||
.env.production.local
|
||||
.env.local
|
||||
|
||||
# temp directory
|
||||
.temp
|
||||
.tmp
|
||||
|
||||
# Runtime data
|
||||
pids
|
||||
*.pid
|
||||
*.seed
|
||||
*.pid.lock
|
||||
|
||||
# Diagnostic reports (https://nodejs.org/api/report.html)
|
||||
report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
|
||||
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"singleQuote": true,
|
||||
"trailingComma": "all",
|
||||
"tabWidth": 4,
|
||||
"useTabs": true
|
||||
}
|
||||
+197
@@ -0,0 +1,197 @@
|
||||
# app — API мессенджера
|
||||
|
||||
NestJS 12 + Fastify, ESM TypeScript. PostgreSQL — источник истины бизнес-данных,
|
||||
Redis — серверные Bearer-сессии и производный кэш истории сообщений.
|
||||
|
||||
Общая документация (в корне репозитория):
|
||||
|
||||
| Документ | Что содержит |
|
||||
|---|---|
|
||||
| [`../REPORT.md`](../REPORT.md) | архитектура, схема данных, транзакции, политика кэша, команды, результаты проверок и трека 1 |
|
||||
| [`../evidence/README.md`](../evidence/README.md) | индекс доказательств: что подтверждено и как это воспроизвести |
|
||||
| [`../contracts/openapi.json`](../contracts/openapi.json) | нормативный контракт API |
|
||||
| [`../tests/README.md`](../tests/README.md) | публичные проверки репозитория (`make check`, `make test`, persistence) |
|
||||
|
||||
## Что внутри
|
||||
|
||||
```text
|
||||
src/
|
||||
main.ts bootstrap: Fastify, ValidationPipe, shutdown hooks
|
||||
app.module.ts сборка модулей приложения
|
||||
config/ Zod-схема env + глобальный ConfigModule
|
||||
database/ pg.Pool, транзакции, миграции (001, 002)
|
||||
redis/ клиент Redis (AOF-совместимый, без offline queue)
|
||||
auth/ Basic-вход, Redis-сессии, logout
|
||||
users/ регистрация (Argon2id), профиль
|
||||
chats/ создание чата в транзакции, список и чтение
|
||||
messages/ отправка сообщения, keyset-история
|
||||
cache/ версионированный кэш истории + lock на страницу
|
||||
metrics/ /internal/metrics и /internal/metrics/reset
|
||||
health/ liveness/readiness с проверкой зависимостей
|
||||
common/
|
||||
http/ cursor (формат+календарь), page (конверт {items,next_cursor}), request-id
|
||||
errors/ exception filter и тип тела ошибки ApiErrorBody
|
||||
validation/ декоратор CodePointLength (длины в Unicode code points)
|
||||
auth/ guard и декоратор текущего пользователя
|
||||
test/
|
||||
app.e2e-spec.ts black-box набор против запущенного API (PG + Redis)
|
||||
scripts/
|
||||
graph-modules.ts генератор графа зависимостей (nestjs-spelunker)
|
||||
```
|
||||
|
||||
Принципы: raw `pg.Pool` без ORM, параметризованные запросы, никаких in-memory
|
||||
хранилищ в боевых путях; кэш — производное состояние и всегда допускает
|
||||
восстановление из PostgreSQL; отказ зависимости даёт ограниченную ошибку
|
||||
(`503`), а не аварийное завершение процесса; длины строк проверяются в Unicode
|
||||
code points (свой декоратор `@CodePointLength`), как в JSON Schema, а не в
|
||||
UTF-16-единицах.
|
||||
|
||||
## Быстрый старт
|
||||
|
||||
Рекомендуемый путь — весь стенд из корня репозитория (PostgreSQL, Redis, миграции, API):
|
||||
|
||||
```sh
|
||||
cd ..
|
||||
cp .env.example .env
|
||||
password=$(openssl rand -hex 32)
|
||||
sed -i "s/^POSTGRES_PASSWORD=.*/POSTGRES_PASSWORD=$password/" .env
|
||||
sed -i "s|^DATABASE_URL=.*|DATABASE_URL=postgresql://messenger:$password@postgres:5432/messenger|" .env
|
||||
docker compose --env-file .env up -d --build
|
||||
curl -fsS http://localhost:8080/health/ready
|
||||
```
|
||||
|
||||
Локальный запуск без Docker (нужны доступные PostgreSQL и Redis):
|
||||
|
||||
```sh
|
||||
cd app
|
||||
npm ci
|
||||
npm run build
|
||||
|
||||
export DATABASE_URL=postgresql://messenger:<password>@127.0.0.1:5432/messenger
|
||||
export REDIS_URL=redis://127.0.0.1:6379
|
||||
export APP_PORT=8080
|
||||
node dist/database/migration.runner.js # применяет миграции из dist/database/migrations
|
||||
|
||||
npm run start:dev # или npm run start:prod после build
|
||||
```
|
||||
|
||||
## Переменные окружения
|
||||
|
||||
Читаются только через конфигурационный слой (`src/config`), типы и диапазоны
|
||||
проверяет Zod-схема на старте — при некорректном значении приложение падает
|
||||
с понятной ошибкой.
|
||||
|
||||
| Переменная | По умолчанию | Назначение |
|
||||
|---|---|---|
|
||||
| `APP_HOST` / `APP_PORT` | `0.0.0.0` / `8080` | адрес прослушивания |
|
||||
| `APP_ENV` | `lab` | метка окружения |
|
||||
| `DATABASE_URL` | — (обязательна) | строка подключения PostgreSQL |
|
||||
| `REDIS_URL` | — (обязательна) | строка подключения Redis |
|
||||
| `DATABASE_POOL_MAX` | `10` | размер пула соединений |
|
||||
| `DATABASE_CONNECTION_TIMEOUT_MS` | `5000` | таймаут установки соединения |
|
||||
| `DATABASE_STATEMENT_TIMEOUT_MS` | `5000` | таймаут SQL-запроса |
|
||||
| `SESSION_TTL_SECONDS` | `3600` | TTL сессии (минимум 2) |
|
||||
| `CACHE_TTL_SECONDS` | `30` | TTL страницы истории в Redis |
|
||||
| `CACHE_MODE` | `protected` | `protected` (lock на страницу) или `naive` (только для эксперимента) |
|
||||
| `CACHE_LOCK_TTL_MS` | `1000` | TTL lock-а страницы |
|
||||
| `CACHE_MISS_DELAY_MS` | `0` | искусственная пауза на промахе; влияет только на `naive` |
|
||||
| `METRICS_TOKEN` | — (необязательна) | токен доступа к `/internal/metrics*`; без него endpoint закрыт |
|
||||
| `DRAIN_DELAY_MS` | `5000` | окно дрейна при получении сигнала завершения |
|
||||
|
||||
Поддерживаются также `DATABASE_URL_FILE` / `REDIS_URL_FILE`: если заданы, значение
|
||||
читается из файла (docker secrets / Swarm). Подробности и компромиссы —
|
||||
[`../REPORT.md`](../REPORT.md), раздел «Конфигурация и секреты».
|
||||
|
||||
## Эндпоинты
|
||||
|
||||
Публичный контракт — [`../contracts/openapi.json`](../contracts/openapi.json).
|
||||
|
||||
| Метод и путь | Аутентификация | Назначение |
|
||||
|---|---|---|
|
||||
| `GET /health/live` | нет | процесс жив |
|
||||
| `GET /health/ready` | нет | готовность: PostgreSQL и Redis доступны, иначе `503` |
|
||||
| `POST /api/v1/users` | нет | регистрация с паролем (Argon2id) |
|
||||
| `POST /api/v1/auth/sessions` | `Basic` | вход, выдаёт opaque Bearer-токен |
|
||||
| `DELETE /api/v1/auth/sessions/current` | `Bearer` | отзыв текущей сессии, `204` |
|
||||
| `GET /api/v1/users/me` | `Bearer` | текущий пользователь |
|
||||
| `POST /api/v1/chats` | `Bearer` | создание чата (транзакция) |
|
||||
| `GET /api/v1/chats` | `Bearer` | список доступных чатов |
|
||||
| `GET /api/v1/chats/:chatId` | `Bearer` | чат по id (чужой — `404`) |
|
||||
| `POST /api/v1/chats/:chatId/messages` | `Bearer` | отправка сообщения |
|
||||
| `GET /api/v1/chats/:chatId/messages` | `Bearer` | история, keyset-пагинация `(created_at, id)` |
|
||||
| `GET /internal/metrics` | `Bearer METRICS_TOKEN` | счётчики и агрегаты латентности |
|
||||
| `POST /internal/metrics/reset` | `Bearer METRICS_TOKEN` | сброс счётчиков (`200`) |
|
||||
|
||||
Правила: `Basic` принимается только на создании сессии, бизнес-запросы — только
|
||||
`Bearer`; заголовок `X-User-Id` не аутентифицирует и не подменяет владельца
|
||||
сессии; истёкший, отозванный или неизвестный токен — `401` с соответствующим
|
||||
`WWW-Authenticate`.
|
||||
|
||||
## npm-скрипты
|
||||
|
||||
| Команда | Что делает |
|
||||
|---|---|
|
||||
| `npm run build` | сборка в `dist/` |
|
||||
| `npm run start:dev` | watch-режим |
|
||||
| `npm run start:prod` | запуск собранного приложения (`node dist/main`) |
|
||||
| `npm test` / `npm run test:unit` | unit-тесты (vitest) |
|
||||
| `npm run test:e2e` | black-box набор против запущенного API (см. ниже) |
|
||||
| `npm run test:dependencies` | автоматическая проверка отказов Redis/PostgreSQL: останавливает и поднимает контейнеры Compose-стенда |
|
||||
| `npm run lint` | oxlint по `src/` и `test/` |
|
||||
| `npm run format` | prettier |
|
||||
| `npm run graph` | граф модулей и провайдеров через nestjs-spelunker (пишет `../docs/architecture/`) |
|
||||
|
||||
## Тесты
|
||||
|
||||
Unit-тесты не требуют инфраструктуры:
|
||||
|
||||
```sh
|
||||
npm test
|
||||
```
|
||||
|
||||
Интеграционный набор работает по HTTP против запущенного стенда и дополнительно
|
||||
подключается к PostgreSQL (очистка тестовых данных) и Redis:
|
||||
|
||||
```sh
|
||||
export API_BASE_URL=http://localhost:8080
|
||||
export DATABASE_URL=postgresql://messenger:<password>@<pg-host>:5432/messenger
|
||||
export REDIS_URL=redis://<redis-host>:6379
|
||||
npm run test:e2e
|
||||
```
|
||||
|
||||
Название `API_BASE_URL` (а не `BASE_URL`) выбрано потому, что Vitest сам
|
||||
устанавливает `process.env.BASE_URL` в значение Vite base. Кейс истечения сессии
|
||||
включается переменной `SESSION_TTL_SECONDS=2` и у запущенного API, и у набора.
|
||||
|
||||
## Отказы зависимостей
|
||||
|
||||
Отдельный набор останавливает и поднимает контейнеры Compose-стенда и проверяет
|
||||
ограниченные ошибки вместо 500:
|
||||
|
||||
```sh
|
||||
cd .. # из корня репозитория, стенд поднят через docker compose
|
||||
make test-dependencies
|
||||
```
|
||||
|
||||
Он включён по флагу `E2E_DEPENDENCY_FAULTS=1` (им же управляет цель Makefile),
|
||||
потому что требует прав на управление Docker Compose-проектом; остальные
|
||||
переменные — `E2E_COMPOSE_DIR`, `E2E_COMPOSE_ENV_FILE`, `E2E_REDIS_SERVICE`,
|
||||
`E2E_POSTGRES_SERVICE`. Проверяется для Redis и PostgreSQL: `/health/live`
|
||||
остаётся `200`, `/health/ready` и бизнес-запросы возвращают `503 unavailable`
|
||||
с `request_id` из `X-Request-Id` и без деталей драйвера, запрос без сессии —
|
||||
по-прежнему `401`, а после старта зависимости живы прежняя сессия,
|
||||
подтверждённое сообщение и новая запись. Каждый запрос к остановленной БД ждёт
|
||||
`DATABASE_CONNECTION_TIMEOUT_MS`, поэтому набор идёт около 40 секунд.
|
||||
|
||||
## Метрики
|
||||
|
||||
`GET /internal/metrics` возвращает `{counters, latency_ms}`: именованные SQL-метки,
|
||||
операции Redis, `cache_hit`/`cache_miss`/`cache_lock_wait`, `session_get/set/del`,
|
||||
`request_count` и процентили латентности (буфер ограничен). Деградации
|
||||
наблюдаемы отдельными счётчиками: `cache_fallback`, `cache_write_error`,
|
||||
`cache_unlock_error`, `cache_lock_timeout`, `cache_corrupt_entry`,
|
||||
`database.pool_error`, `database.rollback_error`, `redis.error`.
|
||||
|
||||
Счётчики локальны процессу: при нескольких репликах их нельзя суммировать как
|
||||
распределённый снимок, а рестарт API обнуляет их (данные PostgreSQL и Redis при
|
||||
этом не затрагиваются).
|
||||
@@ -0,0 +1,15 @@
|
||||
{
|
||||
"$schema": "https://json.schemastore.org/nest-cli",
|
||||
"collection": "@nestjs/schematics",
|
||||
"sourceRoot": "src",
|
||||
"compilerOptions": {
|
||||
"deleteOutDir": true,
|
||||
"assets": [
|
||||
{
|
||||
"include": "database/migrations/*.sql",
|
||||
"outDir": "dist"
|
||||
}
|
||||
],
|
||||
"watchAssets": true
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
{
|
||||
"$schema": "https://raw.githubusercontent.com/oxc-project/oxc/main/crates/oxc_linter/src/rules.rs",
|
||||
"rules": {
|
||||
"@typescript-eslint/no-explicit-any": "off",
|
||||
"@typescript-eslint/no-floating-promises": "warn"
|
||||
},
|
||||
"env": {
|
||||
"node": true
|
||||
}
|
||||
}
|
||||
Generated
+7401
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,66 @@
|
||||
{
|
||||
"name": "app",
|
||||
"version": "0.0.1",
|
||||
"description": "",
|
||||
"author": "",
|
||||
"private": true,
|
||||
"license": "UNLICENSED",
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
"build": "nest build",
|
||||
"deploy": "nest deploy",
|
||||
"format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
|
||||
"start": "nest start",
|
||||
"start:dev": "nest start --watch",
|
||||
"start:debug": "nest start --debug --watch",
|
||||
"start:prod": "node dist/main",
|
||||
"lint": "oxlint src/ test/",
|
||||
"test": "vitest run",
|
||||
"test:unit": "vitest run --include 'src/**/*.spec.ts'",
|
||||
"test:watch": "vitest",
|
||||
"test:cov": "vitest run --coverage",
|
||||
"test:debug": "vitest --inspect-brk --no-file-parallelism",
|
||||
"graph": "npm run build && DATABASE_URL=postgresql://graph-only.invalid/messenger REDIS_URL=redis://graph-only.invalid:6379 tsx scripts/graph-modules.ts",
|
||||
"test:e2e": "vitest run --config ./vitest.config.e2e.ts",
|
||||
"test:dependencies": "E2E_DEPENDENCY_FAULTS=1 vitest run --config ./vitest.config.e2e.ts dependency-failures",
|
||||
"idempotency:gc": "tsx src/messages/idempotency/idempotency-gc.cli.ts"
|
||||
},
|
||||
"dependencies": {
|
||||
"@nestjs/common": "^12.0.1",
|
||||
"@nestjs/config": "^12.0.0",
|
||||
"@nestjs/core": "^12.0.1",
|
||||
"@nestjs/platform-express": "^12.0.1",
|
||||
"@nestjs/platform-fastify": "^12.0.3",
|
||||
"argon2": "^0.45.1",
|
||||
"class-transformer": "^0.5.1",
|
||||
"class-validator": "^0.15.1",
|
||||
"date-fns": "^4.4.0",
|
||||
"fastify": "^5.12.5",
|
||||
"pg": "^8.23.1",
|
||||
"redis": "^6.3.0",
|
||||
"reflect-metadata": "^0.2.2",
|
||||
"rxjs": "^7.8.1",
|
||||
"zod": "^4.6.5"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@nestjs/cli": "^12.0.0",
|
||||
"@nestjs/mau": "^0.2.6",
|
||||
"@nestjs/schematics": "^12.0.0",
|
||||
"@nestjs/testing": "^12.0.1",
|
||||
"@types/express": "^5.0.0",
|
||||
"@types/node": "^24.0.0",
|
||||
"@types/pg": "^8.23.1",
|
||||
"@types/supertest": "^7.0.0",
|
||||
"@vitest/coverage-v8": "^4.1.2",
|
||||
"dotenv": "^18.0.5",
|
||||
"nestjs-spelunker": "^1.3.2",
|
||||
"oxlint": "^1.58.0",
|
||||
"prettier": "^3.4.2",
|
||||
"source-map-support": "^0.5.21",
|
||||
"supertest": "^7.2.2",
|
||||
"tsx": "^4.23.15",
|
||||
"typescript": "^6.0.3",
|
||||
"vite-tsconfig-paths": "^5.1.4",
|
||||
"vitest": "^4.1.2"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
import { mkdir, writeFile } from 'node:fs/promises';
|
||||
import 'reflect-metadata';
|
||||
import { SpelunkerModule, type DebuggedTree } from 'nestjs-spelunker';
|
||||
import { AppModule } from '../dist/app.module.js';
|
||||
|
||||
function mermaidId(name: string): string {
|
||||
return name.replace(/[^a-zA-Z0-9_]/gu, '_');
|
||||
}
|
||||
|
||||
function findDependencyModule(
|
||||
tree: DebuggedTree[],
|
||||
dependency: string,
|
||||
): DebuggedTree | undefined {
|
||||
return tree.find(
|
||||
(candidate) =>
|
||||
candidate.providers.some((item) => item.name === dependency) ||
|
||||
candidate.controllers.some((item) => item.name === dependency),
|
||||
);
|
||||
}
|
||||
|
||||
function renderMermaid(tree: DebuggedTree[]): string {
|
||||
const lines = [
|
||||
'flowchart LR',
|
||||
' %% Generated by scripts/graph-modules.ts',
|
||||
' %% Solid arrows: module imports; dotted arrows: constructor dependencies',
|
||||
];
|
||||
const moduleNames = tree.map((module) => module.name);
|
||||
|
||||
for (const module of tree) {
|
||||
const moduleId = mermaidId(module.name);
|
||||
lines.push(` subgraph ${moduleId}["${module.name}"]`);
|
||||
for (const provider of module.providers) {
|
||||
lines.push(
|
||||
` ${moduleId}_${mermaidId(provider.name)}["provider: ${provider.name}"]`,
|
||||
);
|
||||
}
|
||||
for (const controller of module.controllers) {
|
||||
lines.push(
|
||||
` ${moduleId}_${mermaidId(controller.name)}["controller: ${controller.name}"]`,
|
||||
);
|
||||
}
|
||||
lines.push(' end');
|
||||
}
|
||||
|
||||
for (const module of tree) {
|
||||
for (const imported of module.imports) {
|
||||
if (moduleNames.includes(imported)) {
|
||||
lines.push(
|
||||
` ${mermaidId(module.name)} -->|imports| ${mermaidId(imported)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
for (const item of [...module.providers, ...module.controllers]) {
|
||||
for (const dependency of item.dependencies) {
|
||||
const targetModule = findDependencyModule(tree, dependency);
|
||||
if (targetModule) {
|
||||
const source = `${mermaidId(module.name)}_${mermaidId(item.name)}`;
|
||||
const target = `${mermaidId(targetModule.name)}_${mermaidId(dependency)}`;
|
||||
lines.push(` ${source} -.->|injects| ${target}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return `${lines.join('\n')}\n`;
|
||||
}
|
||||
|
||||
function renderMarkdown(tree: DebuggedTree[], mermaid: string): string {
|
||||
const lines = [
|
||||
'# NestJS dependency graph',
|
||||
'',
|
||||
'Generated from `AppModule` with `nestjs-spelunker` static module debugging.',
|
||||
'',
|
||||
'- Solid arrows: module imports.',
|
||||
'- Dotted arrows: constructor dependencies.',
|
||||
'- The generator does not boot PostgreSQL or Redis.',
|
||||
'',
|
||||
'```mermaid',
|
||||
mermaid.trim(),
|
||||
'```',
|
||||
'',
|
||||
'## Module details',
|
||||
'',
|
||||
];
|
||||
|
||||
for (const module of tree) {
|
||||
lines.push(
|
||||
`### ${module.name}`,
|
||||
'',
|
||||
`- Imports: ${module.imports.join(', ') || 'none'}`,
|
||||
);
|
||||
lines.push(
|
||||
`- Exports: ${module.exports.map((item) => `${item.name} (${item.type})`).join(', ') || 'none'}`,
|
||||
);
|
||||
lines.push('', '| Kind | Name | Dependencies |', '| --- | --- | --- |');
|
||||
for (const provider of module.providers) {
|
||||
lines.push(
|
||||
`| provider | ${provider.name} | ${provider.dependencies.join(', ') || 'none'} |`,
|
||||
);
|
||||
}
|
||||
for (const controller of module.controllers) {
|
||||
lines.push(
|
||||
`| controller | ${controller.name} | ${controller.dependencies.join(', ') || 'none'} |`,
|
||||
);
|
||||
}
|
||||
lines.push('');
|
||||
}
|
||||
|
||||
return lines.join('\n');
|
||||
}
|
||||
|
||||
const tree = await SpelunkerModule.debug(AppModule);
|
||||
const mermaid = renderMermaid(tree);
|
||||
await mkdir('../docs/architecture', { recursive: true });
|
||||
await writeFile(
|
||||
'../docs/architecture/nest-module-details.json',
|
||||
JSON.stringify(tree, null, 2),
|
||||
);
|
||||
await writeFile('../docs/architecture/nest-module-graph.mmd', mermaid);
|
||||
await writeFile(
|
||||
'../docs/architecture/nest-dependency-graph.md',
|
||||
renderMarkdown(tree, mermaid),
|
||||
);
|
||||
@@ -0,0 +1,33 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { AppConfigModule } from './config/app-config.module.js';
|
||||
import { DatabaseModule } from './database/database.module.js';
|
||||
import { RedisModule } from './redis/redis.module.js';
|
||||
import { AuthModule } from './auth/auth.module.js';
|
||||
import { ChatsModule } from './chats/chats.module.js';
|
||||
import { HealthModule } from './health/health.module.js';
|
||||
import { MessagesModule } from './messages/messages.module.js';
|
||||
import { MetricsModule } from './metrics/metrics.module.js';
|
||||
import { UsersModule } from './users/users.module.js';
|
||||
import { APP_FILTER } from '@nestjs/core';
|
||||
import { ApiExceptionFilter } from './common/errors/api-exception.filter.js';
|
||||
|
||||
@Module({
|
||||
imports: [
|
||||
AppConfigModule,
|
||||
DatabaseModule,
|
||||
RedisModule,
|
||||
UsersModule,
|
||||
AuthModule,
|
||||
HealthModule,
|
||||
ChatsModule,
|
||||
MessagesModule,
|
||||
MetricsModule,
|
||||
],
|
||||
providers: [
|
||||
{
|
||||
provide: APP_FILTER,
|
||||
useClass: ApiExceptionFilter,
|
||||
},
|
||||
],
|
||||
})
|
||||
export class AppModule {}
|
||||
@@ -0,0 +1,79 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
Body,
|
||||
Controller,
|
||||
Delete,
|
||||
Headers,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
Post,
|
||||
UnauthorizedException,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import { TextDecoder } from 'node:util';
|
||||
import { AuthService } from './auth.service.js';
|
||||
import { CurrentUserGuard } from '../common/auth/current-user.guard.js';
|
||||
|
||||
const BASE64 =
|
||||
/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;
|
||||
const BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"';
|
||||
|
||||
function basicUnauthorized(): UnauthorizedException {
|
||||
return new UnauthorizedException({
|
||||
message: 'Unauthorized',
|
||||
challenge: BASIC_CHALLENGE,
|
||||
});
|
||||
}
|
||||
|
||||
function bearerUnauthorized(): UnauthorizedException {
|
||||
return new UnauthorizedException({
|
||||
message: 'Unauthorized',
|
||||
challenge: 'Bearer realm="messenger"',
|
||||
});
|
||||
}
|
||||
|
||||
function parseBasic(value: string | undefined): [string, string] {
|
||||
if (typeof value !== 'string') throw basicUnauthorized();
|
||||
const match = /^Basic[ \t]+([^ \t]+)$/iu.exec(value);
|
||||
if (!match || !BASE64.test(match[1])) throw basicUnauthorized();
|
||||
const bytes = Buffer.from(match[1], 'base64');
|
||||
if (bytes.toString('base64') !== match[1]) throw basicUnauthorized();
|
||||
let decoded: string;
|
||||
try {
|
||||
decoded = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
|
||||
} catch {
|
||||
throw basicUnauthorized();
|
||||
}
|
||||
const separator = decoded.indexOf(':');
|
||||
if (separator < 1) throw basicUnauthorized();
|
||||
return [decoded.slice(0, separator), decoded.slice(separator + 1)];
|
||||
}
|
||||
|
||||
@Controller('api/v1/auth/sessions')
|
||||
export class AuthController {
|
||||
constructor(private readonly auth: AuthService) {}
|
||||
|
||||
@Post()
|
||||
create(
|
||||
@Headers('authorization') authorization: string | undefined,
|
||||
@Body() body: unknown,
|
||||
) {
|
||||
const [username, password] = parseBasic(authorization);
|
||||
if (body !== undefined)
|
||||
throw new BadRequestException(
|
||||
'Session creation does not accept a body',
|
||||
);
|
||||
return this.auth.createSession(username, password);
|
||||
}
|
||||
|
||||
@Delete('current')
|
||||
@UseGuards(CurrentUserGuard)
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
async delete(
|
||||
@Headers('authorization') authorization: string | undefined,
|
||||
): Promise<void> {
|
||||
if (!authorization || !/^Bearer\s+[^\s]+$/iu.test(authorization))
|
||||
throw bearerUnauthorized();
|
||||
await this.auth.deleteSession(authorization.slice(7).trim());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { DatabaseModule } from '../database/database.module.js';
|
||||
import { RedisModule } from '../redis/redis.module.js';
|
||||
import { UsersModule } from '../users/users.module.js';
|
||||
import { AuthController } from './auth.controller.js';
|
||||
import { AuthService } from './auth.service.js';
|
||||
import { SessionRepository } from './session.repository.js';
|
||||
import { MetricsModule } from '../metrics/metrics.module.js';
|
||||
|
||||
@Module({
|
||||
imports: [UsersModule, DatabaseModule, RedisModule, MetricsModule],
|
||||
controllers: [AuthController],
|
||||
providers: [AuthService, SessionRepository],
|
||||
exports: [AuthService, SessionRepository],
|
||||
})
|
||||
export class AuthModule {}
|
||||
@@ -0,0 +1,63 @@
|
||||
import {
|
||||
Injectable,
|
||||
ServiceUnavailableException,
|
||||
UnauthorizedException,
|
||||
} from '@nestjs/common';
|
||||
import argon2 from 'argon2';
|
||||
import type { User } from '../users/user.js';
|
||||
import { UsersService } from '../users/users.service.js';
|
||||
import { SessionRepository } from './session.repository.js';
|
||||
|
||||
export type SessionResponse = {
|
||||
token: string;
|
||||
token_type: 'Bearer';
|
||||
expires_at: string;
|
||||
user: User;
|
||||
};
|
||||
|
||||
@Injectable()
|
||||
export class AuthService {
|
||||
constructor(
|
||||
private readonly users: UsersService,
|
||||
private readonly sessions: SessionRepository,
|
||||
) {}
|
||||
|
||||
async createSession(
|
||||
username: string,
|
||||
password: string,
|
||||
): Promise<SessionResponse> {
|
||||
const storedUser = await this.users.findByUsername(username);
|
||||
if (
|
||||
!storedUser ||
|
||||
!(await argon2.verify(storedUser.password_hash, password))
|
||||
) {
|
||||
throw new UnauthorizedException();
|
||||
}
|
||||
const user: User = {
|
||||
id: storedUser.id,
|
||||
username: storedUser.username,
|
||||
display_name: storedUser.display_name,
|
||||
created_at: storedUser.created_at,
|
||||
};
|
||||
let session: { token: string; expiresAt: string };
|
||||
try {
|
||||
session = await this.sessions.create(user.id);
|
||||
} catch {
|
||||
throw new ServiceUnavailableException('Session store unavailable');
|
||||
}
|
||||
return {
|
||||
token: session.token,
|
||||
token_type: 'Bearer',
|
||||
expires_at: session.expiresAt,
|
||||
user,
|
||||
};
|
||||
}
|
||||
|
||||
async deleteSession(token: string): Promise<void> {
|
||||
try {
|
||||
await this.sessions.delete(token);
|
||||
} catch {
|
||||
throw new ServiceUnavailableException('Session store unavailable');
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import { randomBytes } from 'node:crypto';
|
||||
import type { AppConfig } from '../config/app-config.schema.js';
|
||||
import { RedisClient } from '../redis/redis.client.js';
|
||||
import { MetricsService } from '../metrics/metrics.service.js';
|
||||
|
||||
@Injectable()
|
||||
export class SessionRepository {
|
||||
constructor(
|
||||
private readonly redis: RedisClient,
|
||||
private readonly config: ConfigService<AppConfig>,
|
||||
private readonly metrics: MetricsService,
|
||||
) {}
|
||||
|
||||
async create(
|
||||
userId: string,
|
||||
): Promise<{ token: string; expiresAt: string }> {
|
||||
const token = randomBytes(32).toString('base64url');
|
||||
const ttl = this.config.getOrThrow('SESSION_TTL_SECONDS');
|
||||
const expiresAt = new Date(Date.now() + ttl * 1000).toISOString();
|
||||
this.metrics.increment('session_set');
|
||||
await this.redis.set(
|
||||
`session:${token}`,
|
||||
JSON.stringify({ user_id: userId, expires_at: expiresAt }),
|
||||
{ EX: ttl },
|
||||
);
|
||||
return { token, expiresAt };
|
||||
}
|
||||
|
||||
delete(token: string): Promise<number> {
|
||||
this.metrics.increment('session_del');
|
||||
return this.redis.del(`session:${token}`);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
export type Chat = {
|
||||
id: string;
|
||||
title: string;
|
||||
member_ids: string[];
|
||||
created_at: string;
|
||||
};
|
||||
@@ -0,0 +1,49 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
Body,
|
||||
Controller,
|
||||
DefaultValuePipe,
|
||||
Get,
|
||||
Param,
|
||||
ParseIntPipe,
|
||||
ParseUUIDPipe,
|
||||
Post,
|
||||
Query,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import { CurrentUser } from '../common/auth/current-user.decorator.js';
|
||||
import { CurrentUserGuard } from '../common/auth/current-user.guard.js';
|
||||
import { ChatsService } from './chats.service.js';
|
||||
import { CreateChatDto } from './dto/create-chat.dto.js';
|
||||
import type { User } from '../users/user.js';
|
||||
|
||||
@Controller('api/v1/chats')
|
||||
@UseGuards(CurrentUserGuard)
|
||||
export class ChatsController {
|
||||
constructor(private readonly chatsService: ChatsService) {}
|
||||
|
||||
@Post()
|
||||
create(@Body() body: CreateChatDto, @CurrentUser() currentUser: User) {
|
||||
return this.chatsService.create(body, currentUser);
|
||||
}
|
||||
|
||||
@Get()
|
||||
list(
|
||||
@CurrentUser() currentUser: User,
|
||||
@Query('limit', new DefaultValuePipe(50), new ParseIntPipe())
|
||||
limit: number,
|
||||
@Query('cursor') cursor?: string,
|
||||
) {
|
||||
if (limit < 1 || limit > 100)
|
||||
throw new BadRequestException('limit must be between 1 and 100');
|
||||
return this.chatsService.listForUser(currentUser, limit, cursor);
|
||||
}
|
||||
|
||||
@Get(':chatId')
|
||||
get(
|
||||
@Param('chatId', new ParseUUIDPipe()) chatId: string,
|
||||
@CurrentUser() currentUser: User,
|
||||
) {
|
||||
return this.chatsService.getForUser(chatId, currentUser);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { DatabaseModule } from '../database/database.module.js';
|
||||
import { RedisModule } from '../redis/redis.module.js';
|
||||
import { MetricsModule } from '../metrics/metrics.module.js';
|
||||
import { UsersModule } from '../users/users.module.js';
|
||||
import { ChatsController } from './chats.controller.js';
|
||||
import { ChatsRepository } from './chats.repository.js';
|
||||
import { ChatsService } from './chats.service.js';
|
||||
|
||||
@Module({
|
||||
imports: [UsersModule, DatabaseModule, RedisModule, MetricsModule],
|
||||
controllers: [ChatsController],
|
||||
providers: [ChatsRepository, ChatsService],
|
||||
exports: [ChatsService],
|
||||
})
|
||||
export class ChatsModule {}
|
||||
@@ -0,0 +1,109 @@
|
||||
import { BadRequestException, Injectable } from '@nestjs/common';
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import { DatabaseClient } from '../database/database.client.js';
|
||||
import type { Cursor } from '../common/http/cursor.js';
|
||||
import type { User } from '../users/user.js';
|
||||
import type { Chat } from './chat.js';
|
||||
|
||||
type ChatRow = {
|
||||
id: string;
|
||||
title: string;
|
||||
created_at: Date | string;
|
||||
member_ids: string[];
|
||||
};
|
||||
|
||||
function toChat(row: ChatRow): Chat {
|
||||
return {
|
||||
id: row.id,
|
||||
title: row.title,
|
||||
created_at: new Date(row.created_at).toISOString(),
|
||||
member_ids: row.member_ids,
|
||||
};
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class ChatsRepository {
|
||||
constructor(private readonly database: DatabaseClient) {}
|
||||
|
||||
async create(title: string, memberIds: string[]): Promise<Chat> {
|
||||
const id = randomUUID();
|
||||
return this.database.withTransaction(async (client) => {
|
||||
const users = await client.query<{ id: string }>({
|
||||
name: 'chats.validateMembers',
|
||||
text: 'SELECT id FROM users WHERE id = ANY($1::uuid[])',
|
||||
values: [memberIds],
|
||||
});
|
||||
if (users.rowCount !== memberIds.length)
|
||||
throw new BadRequestException('Chat member does not exist');
|
||||
const inserted = await client.query<ChatRow>({
|
||||
name: 'chats.insert',
|
||||
text: 'INSERT INTO chats (id, title) VALUES ($1, $2) RETURNING id, title, created_at',
|
||||
values: [id, title],
|
||||
});
|
||||
for (const memberId of memberIds) {
|
||||
await client.query({
|
||||
name: 'chats.insertMember',
|
||||
text: 'INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)',
|
||||
values: [id, memberId],
|
||||
});
|
||||
}
|
||||
return {
|
||||
...toChat({ ...inserted.rows[0], member_ids: memberIds }),
|
||||
member_ids: memberIds,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
async findForUser(id: string, user: User): Promise<Chat | undefined> {
|
||||
const result = await this.database.query<ChatRow>(
|
||||
'chats.findForUser',
|
||||
`SELECT c.id, c.title, c.created_at,
|
||||
COALESCE(array_agg(cm.user_id ORDER BY cm.user_id)
|
||||
FILTER (WHERE cm.user_id IS NOT NULL), '{}') AS member_ids
|
||||
FROM chats c
|
||||
LEFT JOIN chat_members cm ON cm.chat_id = c.id
|
||||
WHERE c.id = $1
|
||||
AND EXISTS (
|
||||
SELECT 1 FROM chat_members own
|
||||
WHERE own.chat_id = c.id AND own.user_id = $2
|
||||
)
|
||||
GROUP BY c.id`,
|
||||
[id, user.id],
|
||||
);
|
||||
return result.rows[0] ? toChat(result.rows[0]) : undefined;
|
||||
}
|
||||
|
||||
async findPageForUser(
|
||||
user: User,
|
||||
limit: number,
|
||||
cursor?: Cursor,
|
||||
): Promise<{ items: Chat[]; hasMore: boolean }> {
|
||||
const values: unknown[] = [user.id];
|
||||
let predicate = '';
|
||||
if (cursor) {
|
||||
values.push(cursor.created_at, cursor.id);
|
||||
predicate =
|
||||
'AND (c.created_at, c.id) > ($2::timestamptz, $3::uuid)';
|
||||
}
|
||||
values.push(limit + 1);
|
||||
const result = await this.database.query<ChatRow>(
|
||||
'chats.listForUser',
|
||||
`SELECT c.id, c.title, c.created_at,
|
||||
COALESCE(array_agg(cm.user_id ORDER BY cm.user_id)
|
||||
FILTER (WHERE cm.user_id IS NOT NULL), '{}') AS member_ids
|
||||
FROM chats c
|
||||
LEFT JOIN chat_members cm ON cm.chat_id = c.id
|
||||
WHERE EXISTS (
|
||||
SELECT 1 FROM chat_members own
|
||||
WHERE own.chat_id = c.id AND own.user_id = $1
|
||||
)
|
||||
${predicate}
|
||||
GROUP BY c.id ORDER BY c.created_at, c.id LIMIT $${values.length}`,
|
||||
values,
|
||||
);
|
||||
return {
|
||||
items: result.rows.slice(0, limit).map(toChat),
|
||||
hasMore: result.rows.length > limit,
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
Injectable,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import { encodeCursor, decodeCursor } from '../common/http/cursor.js';
|
||||
import type { Page } from '../common/http/page.js';
|
||||
import type { User } from '../users/user.js';
|
||||
import type { CreateChatDto } from './dto/create-chat.dto.js';
|
||||
import type { Chat } from './chat.js';
|
||||
import { ChatsRepository } from './chats.repository.js';
|
||||
|
||||
@Injectable()
|
||||
export class ChatsService {
|
||||
constructor(private readonly chatsRepository: ChatsRepository) {}
|
||||
|
||||
create(input: CreateChatDto, currentUser: User): Promise<Chat> {
|
||||
if (!input.member_ids.includes(currentUser.id))
|
||||
throw new BadRequestException('Current user must be a chat member');
|
||||
if (new Set(input.member_ids).size !== input.member_ids.length)
|
||||
throw new BadRequestException('Duplicate chat member');
|
||||
return this.chatsRepository.create(input.title, input.member_ids);
|
||||
}
|
||||
|
||||
async getForUser(chatId: string, currentUser: User): Promise<Chat> {
|
||||
const chat = await this.chatsRepository.findForUser(
|
||||
chatId,
|
||||
currentUser,
|
||||
);
|
||||
if (!chat) throw new NotFoundException();
|
||||
return chat;
|
||||
}
|
||||
|
||||
async listForUser(
|
||||
currentUser: User,
|
||||
limit: number,
|
||||
cursorValue?: string,
|
||||
): Promise<Page<Chat>> {
|
||||
const scope = `chats:${currentUser.id}`;
|
||||
const cursor = cursorValue
|
||||
? decodeCursor(cursorValue, scope)
|
||||
: undefined;
|
||||
const page = await this.chatsRepository.findPageForUser(
|
||||
currentUser,
|
||||
limit,
|
||||
cursor,
|
||||
);
|
||||
const last = page.items.at(-1);
|
||||
return {
|
||||
items: page.items,
|
||||
next_cursor:
|
||||
page.hasMore && last
|
||||
? encodeCursor({
|
||||
scope,
|
||||
created_at: last.created_at,
|
||||
id: last.id,
|
||||
})
|
||||
: null,
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
import {
|
||||
ArrayMaxSize,
|
||||
ArrayMinSize,
|
||||
ArrayUnique,
|
||||
IsArray,
|
||||
IsString,
|
||||
IsUUID,
|
||||
Matches,
|
||||
} from 'class-validator';
|
||||
import { CodePointLength } from '../../common/validation/code-point-length.js';
|
||||
|
||||
export class CreateChatDto {
|
||||
@IsString()
|
||||
@CodePointLength(1, 100)
|
||||
@Matches(/\S/, {
|
||||
message: 'title must contain a non-whitespace character',
|
||||
})
|
||||
title: string;
|
||||
|
||||
@IsArray()
|
||||
@ArrayMinSize(1)
|
||||
@ArrayMaxSize(100)
|
||||
@ArrayUnique()
|
||||
@IsUUID('4', { each: true })
|
||||
member_ids: string[];
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
import { createParamDecorator, ExecutionContext } from '@nestjs/common';
|
||||
import type { User } from '../../users/user.js';
|
||||
import { FastifyRequest } from 'fastify';
|
||||
|
||||
export const CurrentUser = createParamDecorator(
|
||||
(_data: unknown, context: ExecutionContext): User => {
|
||||
const request = context.switchToHttp().getRequest<FastifyRequest>();
|
||||
return request.currentUser!;
|
||||
},
|
||||
);
|
||||
@@ -0,0 +1,85 @@
|
||||
import {
|
||||
CanActivate,
|
||||
ExecutionContext,
|
||||
Injectable,
|
||||
ServiceUnavailableException,
|
||||
UnauthorizedException,
|
||||
} from '@nestjs/common';
|
||||
import type { FastifyRequest } from 'fastify';
|
||||
import type { User } from '../../users/user.js';
|
||||
import { RedisClient } from '../../redis/redis.client.js';
|
||||
import { UsersService } from '../../users/users.service.js';
|
||||
import { MetricsService } from '../../metrics/metrics.service.js';
|
||||
|
||||
@Injectable()
|
||||
export class CurrentUserGuard implements CanActivate {
|
||||
constructor(
|
||||
private readonly redis: RedisClient,
|
||||
private readonly users: UsersService,
|
||||
private readonly metrics: MetricsService,
|
||||
) {}
|
||||
|
||||
async canActivate(context: ExecutionContext): Promise<boolean> {
|
||||
const request = context.switchToHttp().getRequest<FastifyRequest>();
|
||||
const authorization = request.headers.authorization;
|
||||
if (
|
||||
typeof authorization !== 'string' ||
|
||||
!/^Bearer\s+[^\s]+$/u.test(authorization)
|
||||
) {
|
||||
throw new UnauthorizedException({
|
||||
message: 'Unauthorized',
|
||||
challenge: 'Bearer realm="messenger"',
|
||||
});
|
||||
}
|
||||
let session: string | null;
|
||||
try {
|
||||
this.metrics.increment('session_get');
|
||||
session = await this.redis.get(
|
||||
`session:${authorization.slice(7).trim()}`,
|
||||
);
|
||||
} catch {
|
||||
throw new ServiceUnavailableException('Session store unavailable');
|
||||
}
|
||||
if (!session)
|
||||
throw new UnauthorizedException({
|
||||
message: 'Unauthorized',
|
||||
challenge: 'Bearer realm="messenger"',
|
||||
});
|
||||
let userId: string;
|
||||
try {
|
||||
const parsed: unknown = JSON.parse(session);
|
||||
if (
|
||||
typeof parsed !== 'object' ||
|
||||
parsed === null ||
|
||||
!('user_id' in parsed) ||
|
||||
typeof parsed.user_id !== 'string' ||
|
||||
!('expires_at' in parsed) ||
|
||||
typeof parsed.expires_at !== 'string' ||
|
||||
!/^(?:\d{4})-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/u.test(
|
||||
parsed.expires_at,
|
||||
)
|
||||
)
|
||||
throw new Error('invalid session');
|
||||
const expiresAt = Date.parse(parsed.expires_at);
|
||||
if (!Number.isFinite(expiresAt) || Date.now() >= expiresAt)
|
||||
throw new Error('expired session');
|
||||
userId = parsed.user_id;
|
||||
} catch {
|
||||
throw new UnauthorizedException({
|
||||
message: 'Unauthorized',
|
||||
challenge: 'Bearer realm="messenger"',
|
||||
});
|
||||
}
|
||||
let user: User | undefined;
|
||||
try {
|
||||
user = await this.users.findById(userId);
|
||||
} catch {
|
||||
throw new ServiceUnavailableException(
|
||||
'Authentication service unavailable',
|
||||
);
|
||||
}
|
||||
if (!user) throw new UnauthorizedException();
|
||||
request.currentUser = user;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
export type ApiErrorBody = {
|
||||
error: {
|
||||
code: string;
|
||||
message: string;
|
||||
request_id: string;
|
||||
};
|
||||
};
|
||||
@@ -0,0 +1,168 @@
|
||||
import {
|
||||
ArgumentsHost,
|
||||
Catch,
|
||||
ExceptionFilter,
|
||||
HttpException,
|
||||
HttpStatus,
|
||||
Logger,
|
||||
} from '@nestjs/common';
|
||||
import { HttpAdapterHost } from '@nestjs/core';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import type { AppConfig } from '../../config/app-config.schema.js';
|
||||
import { resolveInstanceId } from '../../config/instance-id.js';
|
||||
import type { ApiErrorBody } from './api-error.js';
|
||||
|
||||
type RequestWithId = { requestId?: string; method?: string; url?: string };
|
||||
type ExceptionBody = { message?: unknown; challenge?: unknown };
|
||||
|
||||
// Connection/session loss codes reported by node-postgres and the network layer.
|
||||
const UNAVAILABLE_ERROR_CODES: Record<string, true> = {
|
||||
ECONNREFUSED: true,
|
||||
ECONNRESET: true,
|
||||
ENOTFOUND: true,
|
||||
ETIMEDOUT: true,
|
||||
EPIPE: true,
|
||||
'08000': true,
|
||||
'08001': true,
|
||||
'08003': true,
|
||||
'08004': true,
|
||||
'08006': true,
|
||||
'57P01': true,
|
||||
'57P02': true,
|
||||
'57P03': true,
|
||||
'53300': true,
|
||||
// Transient aborts: the statement was cancelled by statement_timeout, the
|
||||
// transaction was rolled back by a serialization failure or a deadlock. The
|
||||
// work was never confirmed, so callers see a retryable 503 instead of an
|
||||
// internal error. Without this, such an abort would be recorded as the final
|
||||
// result of an idempotent operation.
|
||||
'57014': true,
|
||||
'40001': true,
|
||||
'40P01': true,
|
||||
};
|
||||
|
||||
// Some driver failures carry no `code` at all: node-postgres raises plain errors
|
||||
// when a connection dies or its pool attempt times out, and node-redis reports a
|
||||
// closed socket the same way. Without these patterns a stopped database would
|
||||
// surface as an internal fault instead of a bounded outage.
|
||||
const UNAVAILABLE_ERROR_MESSAGES = [
|
||||
'Connection terminated unexpectedly',
|
||||
'Connection terminated due to connection timeout',
|
||||
'timeout exceeded when trying to connect',
|
||||
'Client has encountered a connection error and is not queryable',
|
||||
'Socket closed unexpectedly',
|
||||
'Connection is closed',
|
||||
];
|
||||
|
||||
function isDependencyOutage(exception: unknown): boolean {
|
||||
if (typeof exception !== 'object' || exception === null) return false;
|
||||
const code = (exception as { code?: unknown }).code;
|
||||
if (typeof code === 'string' && UNAVAILABLE_ERROR_CODES[code] === true)
|
||||
return true;
|
||||
const message = (exception as { message?: unknown }).message;
|
||||
return (
|
||||
typeof message === 'string' &&
|
||||
UNAVAILABLE_ERROR_MESSAGES.some((pattern) => message.includes(pattern))
|
||||
);
|
||||
}
|
||||
|
||||
function errorCodeForStatus(status: number): string {
|
||||
const codes: Record<number, string> = {
|
||||
[HttpStatus.BAD_REQUEST]: 'invalid_request',
|
||||
[HttpStatus.UNAUTHORIZED]: 'unauthorized',
|
||||
[HttpStatus.NOT_FOUND]: 'not_found',
|
||||
[HttpStatus.CONFLICT]: 'conflict',
|
||||
[HttpStatus.PAYLOAD_TOO_LARGE]: 'payload_too_large',
|
||||
[HttpStatus.UNSUPPORTED_MEDIA_TYPE]: 'unsupported_media_type',
|
||||
[HttpStatus.TOO_MANY_REQUESTS]: 'rate_limited',
|
||||
[HttpStatus.SERVICE_UNAVAILABLE]: 'unavailable',
|
||||
};
|
||||
return codes[status] ?? 'internal_error';
|
||||
}
|
||||
|
||||
@Catch()
|
||||
export class ApiExceptionFilter implements ExceptionFilter {
|
||||
private readonly logger = new Logger(ApiExceptionFilter.name);
|
||||
// Guards and pipes run before interceptors, so an error response may be the
|
||||
// first thing the filter writes: it must carry the replica identity too.
|
||||
private readonly instanceId: string;
|
||||
|
||||
constructor(
|
||||
private readonly adapterHost: HttpAdapterHost,
|
||||
config: ConfigService<AppConfig>,
|
||||
) {
|
||||
this.instanceId = resolveInstanceId(config);
|
||||
}
|
||||
|
||||
catch(exception: unknown, host: ArgumentsHost): void {
|
||||
const http = host.switchToHttp();
|
||||
const request = http.getRequest<RequestWithId>();
|
||||
const response = http.getResponse<unknown>();
|
||||
const adapter = this.adapterHost.httpAdapter;
|
||||
const requestId = request.requestId ?? randomUUID();
|
||||
request.requestId = requestId;
|
||||
|
||||
let status = HttpStatus.INTERNAL_SERVER_ERROR;
|
||||
let message = 'Internal server error';
|
||||
let challenge: string | undefined;
|
||||
if (exception instanceof HttpException) {
|
||||
status = exception.getStatus();
|
||||
const body = exception.getResponse();
|
||||
const details: ExceptionBody =
|
||||
typeof body === 'object' && body !== null
|
||||
? (body as ExceptionBody)
|
||||
: {};
|
||||
const rawMessage =
|
||||
'message' in details ? details.message : undefined;
|
||||
challenge =
|
||||
typeof details.challenge === 'string'
|
||||
? details.challenge
|
||||
: undefined;
|
||||
message = Array.isArray(rawMessage)
|
||||
? rawMessage.join('; ')
|
||||
: typeof rawMessage === 'string'
|
||||
? rawMessage
|
||||
: 'Request failed';
|
||||
if (status === HttpStatus.NOT_FOUND) message = 'Resource not found';
|
||||
if (status >= HttpStatus.INTERNAL_SERVER_ERROR)
|
||||
message =
|
||||
status === HttpStatus.SERVICE_UNAVAILABLE
|
||||
? 'Service unavailable'
|
||||
: 'Internal server error';
|
||||
} else if (isDependencyOutage(exception)) {
|
||||
// A dropped dependency is a bounded outage, not an internal fault.
|
||||
status = HttpStatus.SERVICE_UNAVAILABLE;
|
||||
message = 'Service unavailable';
|
||||
this.logger.warn(
|
||||
`Dependency outage on ${request.method ?? ''} ${request.url ?? ''}: ${exception instanceof Error ? exception.message : 'unknown error'}`,
|
||||
);
|
||||
} else {
|
||||
this.logger.error(
|
||||
`Unhandled exception on ${request.method ?? ''} ${request.url ?? ''}`,
|
||||
exception instanceof Error
|
||||
? exception.stack
|
||||
: String(exception),
|
||||
);
|
||||
}
|
||||
if (status === HttpStatus.UNAUTHORIZED) {
|
||||
const authChallenge =
|
||||
challenge ??
|
||||
(request.method === 'POST' &&
|
||||
request.url?.startsWith('/api/v1/auth/sessions')
|
||||
? 'Basic realm="messenger", charset="UTF-8"'
|
||||
: 'Bearer realm="messenger"');
|
||||
adapter.setHeader(response, 'WWW-Authenticate', authChallenge);
|
||||
}
|
||||
adapter.setHeader(response, 'X-Request-Id', requestId);
|
||||
adapter.setHeader(response, 'X-Instance-Id', this.instanceId);
|
||||
const payload: ApiErrorBody = {
|
||||
error: {
|
||||
code: errorCodeForStatus(status),
|
||||
message,
|
||||
request_id: requestId,
|
||||
},
|
||||
};
|
||||
adapter.reply(response, payload, status);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
import { BadRequestException } from '@nestjs/common';
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import { describe, expect, it } from 'vitest';
|
||||
import { decodeCursor, encodeCursor } from './cursor.js';
|
||||
|
||||
const scope = 'messages:6f1c2a3e-1111-4222-8333-444455556666';
|
||||
|
||||
function encode(createdAt: string, cursorScope = scope): string {
|
||||
return encodeCursor({
|
||||
scope: cursorScope,
|
||||
created_at: createdAt,
|
||||
id: randomUUID(),
|
||||
});
|
||||
}
|
||||
|
||||
describe('decodeCursor', () => {
|
||||
it('accepts valid instants and normalizes them to canonical milliseconds', () => {
|
||||
const accepted: Array<[string, string]> = [
|
||||
['2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z'],
|
||||
['2026-01-01T00:00:00Z', '2026-01-01T00:00:00.000Z'],
|
||||
['2026-01-01T00:00:00.999999Z', '2026-01-01T00:00:00.999Z'],
|
||||
['2024-02-29T23:59:59.000Z', '2024-02-29T23:59:59.000Z'],
|
||||
['2026-12-31T23:59:59.999Z', '2026-12-31T23:59:59.999Z'],
|
||||
];
|
||||
for (const [createdAt, expected] of accepted) {
|
||||
const decoded = decodeCursor(encode(createdAt), scope);
|
||||
expect(decoded.created_at).toBe(expected);
|
||||
expect(decoded.scope).toBe(scope);
|
||||
}
|
||||
});
|
||||
|
||||
it('rejects calendar dates that the platform parser rolls over', () => {
|
||||
// 2026-02-31 would silently become 2026-03-03 and then fail inside SQL.
|
||||
for (const createdAt of [
|
||||
'2026-02-31T00:00:00.000Z',
|
||||
'2025-02-29T00:00:00.000Z',
|
||||
'2026-04-31T00:00:00.000Z',
|
||||
'2026-06-31T12:00:00.000Z',
|
||||
]) {
|
||||
expect(() => decodeCursor(encode(createdAt), scope)).toThrow(
|
||||
BadRequestException,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
it('rejects out-of-range and malformed timestamps', () => {
|
||||
for (const createdAt of [
|
||||
'2026-01-01T24:00:00.000Z',
|
||||
'2026-01-01T00:00:60.000Z',
|
||||
'2026-13-01T00:00:00.000Z',
|
||||
'2026-00-01T00:00:00.000Z',
|
||||
'2026-01-01T00:00:00',
|
||||
'2026-01-01T00:00:00+02:00',
|
||||
'2026-1-1T00:00:00.000Z',
|
||||
'2026-01-01',
|
||||
'not-a-timestamp',
|
||||
]) {
|
||||
expect(() => decodeCursor(encode(createdAt), scope)).toThrow(
|
||||
BadRequestException,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
it('rejects a cursor from another scope, a malformed id, and non-cursor input', () => {
|
||||
expect(() =>
|
||||
decodeCursor(
|
||||
encode('2026-01-01T00:00:00.000Z', 'messages:other'),
|
||||
scope,
|
||||
),
|
||||
).toThrow(BadRequestException);
|
||||
expect(() =>
|
||||
decodeCursor(
|
||||
encodeCursor({
|
||||
scope,
|
||||
created_at: '2026-01-01T00:00:00.000Z',
|
||||
id: 'not-a-uuid',
|
||||
}),
|
||||
scope,
|
||||
),
|
||||
).toThrow(BadRequestException);
|
||||
expect(() => decodeCursor('not-a-cursor', scope)).toThrow(
|
||||
BadRequestException,
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,54 @@
|
||||
import { BadRequestException } from '@nestjs/common';
|
||||
import { isValid, parseISO } from 'date-fns';
|
||||
|
||||
export type Cursor = {
|
||||
scope: string;
|
||||
created_at: string;
|
||||
id: string;
|
||||
};
|
||||
|
||||
// Format check for the canonical API shape: `Date.prototype.toISOString()` with
|
||||
// optional fractional seconds. Explicit ranges reject values such as 24:00:00.
|
||||
// Calendar validity (2026-02-31, 2025-02-29, 2026-04-31) is checked by
|
||||
// date-fns `parseISO`, which refuses impossible dates that the platform parser
|
||||
// would silently roll over into another day.
|
||||
const CURSOR_TIMESTAMP =
|
||||
/^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?Z$/u;
|
||||
|
||||
export function encodeCursor(cursor: Cursor): string {
|
||||
return Buffer.from(JSON.stringify(cursor), 'utf8').toString('base64url');
|
||||
}
|
||||
|
||||
export function decodeCursor(value: string, expectedScope: string): Cursor {
|
||||
try {
|
||||
const parsed: unknown = JSON.parse(
|
||||
Buffer.from(value, 'base64url').toString('utf8'),
|
||||
);
|
||||
if (
|
||||
typeof parsed !== 'object' ||
|
||||
parsed === null ||
|
||||
!('scope' in parsed) ||
|
||||
!('created_at' in parsed) ||
|
||||
!('id' in parsed) ||
|
||||
typeof parsed.scope !== 'string' ||
|
||||
typeof parsed.created_at !== 'string' ||
|
||||
typeof parsed.id !== 'string' ||
|
||||
parsed.scope !== expectedScope ||
|
||||
!/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu.test(
|
||||
parsed.id,
|
||||
) ||
|
||||
!CURSOR_TIMESTAMP.test(parsed.created_at)
|
||||
)
|
||||
throw new Error('invalid cursor');
|
||||
const instant = parseISO(parsed.created_at);
|
||||
if (!isValid(instant)) throw new Error('invalid cursor');
|
||||
|
||||
return {
|
||||
scope: parsed.scope,
|
||||
created_at: instant.toISOString(),
|
||||
id: parsed.id,
|
||||
};
|
||||
} catch {
|
||||
throw new BadRequestException('Invalid cursor');
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
export type Page<T> = {
|
||||
items: T[];
|
||||
next_cursor: string | null;
|
||||
};
|
||||
@@ -0,0 +1,59 @@
|
||||
import {
|
||||
CallHandler,
|
||||
ExecutionContext,
|
||||
Injectable,
|
||||
NestInterceptor,
|
||||
} from '@nestjs/common';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import { HttpAdapterHost } from '@nestjs/core';
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import { finalize, Observable } from 'rxjs';
|
||||
import type { AppConfig } from '../../config/app-config.schema.js';
|
||||
import { resolveInstanceId } from '../../config/instance-id.js';
|
||||
import { MetricsService } from '../../metrics/metrics.service.js';
|
||||
|
||||
type RequestWithId = { requestId?: string };
|
||||
|
||||
@Injectable()
|
||||
export class RequestIdInterceptor implements NestInterceptor {
|
||||
// Resolved once: the identity must be stable for the whole process lifetime,
|
||||
// otherwise a client cannot tell whether it moved to another replica.
|
||||
private readonly instanceId: string;
|
||||
|
||||
constructor(
|
||||
private readonly adapterHost: HttpAdapterHost,
|
||||
private readonly metrics: MetricsService,
|
||||
config: ConfigService<AppConfig>,
|
||||
) {
|
||||
this.instanceId = resolveInstanceId(config);
|
||||
}
|
||||
|
||||
intercept(
|
||||
context: ExecutionContext,
|
||||
next: CallHandler,
|
||||
): Observable<unknown> {
|
||||
const request = context.switchToHttp().getRequest<RequestWithId>();
|
||||
const response = context.switchToHttp().getResponse<unknown>();
|
||||
const requestId = randomUUID();
|
||||
const startedAt = performance.now();
|
||||
request.requestId = requestId;
|
||||
this.adapterHost.httpAdapter.setHeader(
|
||||
response,
|
||||
'X-Request-Id',
|
||||
requestId,
|
||||
);
|
||||
this.adapterHost.httpAdapter.setHeader(
|
||||
response,
|
||||
'X-Instance-Id',
|
||||
this.instanceId,
|
||||
);
|
||||
this.metrics.increment('request_count');
|
||||
return next
|
||||
.handle()
|
||||
.pipe(
|
||||
finalize(() =>
|
||||
this.metrics.observeLatency(performance.now() - startedAt),
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
import { validate } from 'class-validator';
|
||||
import { describe, expect, it } from 'vitest';
|
||||
import { CodePointLength } from './code-point-length.js';
|
||||
|
||||
class Sample {
|
||||
@CodePointLength(3, 5)
|
||||
value!: string;
|
||||
}
|
||||
|
||||
async function fails(value: unknown): Promise<boolean> {
|
||||
const sample = new Sample();
|
||||
(sample as { value: unknown }).value = value;
|
||||
const errors = await validate(sample);
|
||||
return errors.length > 0;
|
||||
}
|
||||
|
||||
describe('CodePointLength', () => {
|
||||
it('counts Unicode code points instead of UTF-16 units', async () => {
|
||||
// '🔐' is one code point but two UTF-16 units.
|
||||
expect(await fails('🔐🔐')).toBe(true);
|
||||
expect(await fails('🔐🔐🔐')).toBe(false);
|
||||
expect(await fails('🔐🔐🔐🔐🔐')).toBe(false);
|
||||
expect(await fails('🔐🔐🔐🔐🔐🔐')).toBe(true);
|
||||
// Combining marks are separate code points, not grapheme clusters:
|
||||
// three 'é' sequences are six code points and exceed the maximum.
|
||||
expect(await fails('e\u0301e\u0301')).toBe(false);
|
||||
expect(await fails('e\u0301e\u0301e\u0301')).toBe(true);
|
||||
});
|
||||
|
||||
it('applies to BMP text boundaries', async () => {
|
||||
expect(await fails('ab')).toBe(true);
|
||||
expect(await fails('abc')).toBe(false);
|
||||
expect(await fails('abcde')).toBe(false);
|
||||
expect(await fails('abcdef')).toBe(true);
|
||||
});
|
||||
|
||||
it('rejects empty and non-string values', async () => {
|
||||
expect(await fails('')).toBe(true);
|
||||
expect(await fails(undefined)).toBe(true);
|
||||
expect(await fails(12345)).toBe(true);
|
||||
expect(await fails(['a', 'b', 'c'])).toBe(true);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,38 @@
|
||||
import {
|
||||
registerDecorator,
|
||||
ValidatorConstraint,
|
||||
type ValidationArguments,
|
||||
type ValidatorConstraintInterface,
|
||||
} from 'class-validator';
|
||||
|
||||
// JSON Schema (and the course contract) measure string lengths in Unicode code
|
||||
// points, while String.prototype.length counts UTF-16 units: one emoji outside
|
||||
// the BMP is two units. `@Length` therefore accepted an 11-emoji password
|
||||
// (22 units) and rejected 4000 emoji (8000 units), so these fields use an
|
||||
// explicit code-point validator instead.
|
||||
@ValidatorConstraint({ name: 'codePointLength', async: false })
|
||||
class CodePointLengthConstraint implements ValidatorConstraintInterface {
|
||||
validate(value: unknown, args: ValidationArguments): boolean {
|
||||
const [min, max] = args.constraints as [number, number];
|
||||
if (typeof value !== 'string') return false;
|
||||
const length = [...value].length;
|
||||
return length >= min && length <= max;
|
||||
}
|
||||
|
||||
defaultMessage(args: ValidationArguments): string {
|
||||
const [min, max] = args.constraints as [number, number];
|
||||
return `${args.property} must be between ${min} and ${max} code points`;
|
||||
}
|
||||
}
|
||||
|
||||
export function CodePointLength(min: number, max: number): PropertyDecorator {
|
||||
return (target, propertyKey) => {
|
||||
registerDecorator({
|
||||
name: 'codePointLength',
|
||||
target: target.constructor,
|
||||
propertyName: String(propertyKey),
|
||||
constraints: [min, max],
|
||||
validator: CodePointLengthConstraint,
|
||||
});
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
import { Global, Module } from '@nestjs/common';
|
||||
import { ConfigModule } from '@nestjs/config';
|
||||
import { parseAppConfig } from './app-config.schema.js';
|
||||
|
||||
@Global()
|
||||
@Module({
|
||||
imports: [
|
||||
ConfigModule.forRoot({
|
||||
isGlobal: true,
|
||||
cache: true,
|
||||
validate: parseAppConfig,
|
||||
}),
|
||||
],
|
||||
exports: [ConfigModule],
|
||||
})
|
||||
export class AppConfigModule {}
|
||||
@@ -0,0 +1,98 @@
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { z } from 'zod';
|
||||
|
||||
function numeric(
|
||||
name: string,
|
||||
minimum: number,
|
||||
maximum: number | undefined,
|
||||
fallback: number,
|
||||
) {
|
||||
let schema = z
|
||||
.number({ message: `${name} must be a number` })
|
||||
.int()
|
||||
.min(minimum);
|
||||
if (maximum !== undefined) schema = schema.max(maximum);
|
||||
return z.preprocess(
|
||||
(value) =>
|
||||
typeof value === 'string' && value.trim() !== ''
|
||||
? Number(value)
|
||||
: value,
|
||||
schema.default(fallback),
|
||||
);
|
||||
}
|
||||
|
||||
function requiredString(name: string) {
|
||||
return z
|
||||
.string({ message: `${name} is required` })
|
||||
.min(1, `${name} is required`);
|
||||
}
|
||||
|
||||
export const appConfigSchema = z
|
||||
.object({
|
||||
APP_HOST: z.string().min(1).default('0.0.0.0'),
|
||||
APP_PORT: numeric('APP_PORT', 1, 65535, 8080),
|
||||
APP_ENV: z.string().min(1).default('lab'),
|
||||
SESSION_TTL_SECONDS: numeric('SESSION_TTL_SECONDS', 2, undefined, 3600),
|
||||
DATABASE_URL: requiredString('DATABASE_URL'),
|
||||
REDIS_URL: requiredString('REDIS_URL'),
|
||||
DATABASE_POOL_MAX: numeric('DATABASE_POOL_MAX', 1, 100, 10),
|
||||
DATABASE_CONNECTION_TIMEOUT_MS: numeric(
|
||||
'DATABASE_CONNECTION_TIMEOUT_MS',
|
||||
1,
|
||||
undefined,
|
||||
5000,
|
||||
),
|
||||
DATABASE_STATEMENT_TIMEOUT_MS: numeric(
|
||||
'DATABASE_STATEMENT_TIMEOUT_MS',
|
||||
1,
|
||||
undefined,
|
||||
5000,
|
||||
),
|
||||
CACHE_TTL_SECONDS: numeric('CACHE_TTL_SECONDS', 1, undefined, 30),
|
||||
CACHE_MODE: z.enum(['protected', 'naive']).default('protected'),
|
||||
CACHE_LOCK_TTL_MS: numeric('CACHE_LOCK_TTL_MS', 1, undefined, 1000),
|
||||
CACHE_MISS_DELAY_MS: numeric('CACHE_MISS_DELAY_MS', 0, undefined, 0),
|
||||
METRICS_TOKEN: z.string().min(1).optional(),
|
||||
DRAIN_DELAY_MS: numeric('DRAIN_DELAY_MS', 0, undefined, 5000),
|
||||
INSTANCE_ID: z.string().min(1).optional(),
|
||||
IDEMPOTENCY_TTL_SECONDS: numeric(
|
||||
'IDEMPOTENCY_TTL_SECONDS',
|
||||
60,
|
||||
undefined,
|
||||
86400,
|
||||
),
|
||||
})
|
||||
.strip();
|
||||
|
||||
export type AppConfig = z.infer<typeof appConfigSchema>;
|
||||
export type AppConfigKey = keyof AppConfig;
|
||||
|
||||
function resolveSecret(
|
||||
raw: Record<string, unknown>,
|
||||
key: 'DATABASE_URL' | 'REDIS_URL',
|
||||
): unknown {
|
||||
const fileKey = `${key}_FILE`;
|
||||
const path = raw[fileKey];
|
||||
if (typeof path !== 'string' || path.length === 0) return raw[key];
|
||||
try {
|
||||
const value = readFileSync(path, 'utf8').trim();
|
||||
if (value.length === 0)
|
||||
throw new Error(`${fileKey} contains an empty value`);
|
||||
return value;
|
||||
} catch (error) {
|
||||
if (
|
||||
error instanceof Error &&
|
||||
error.message.includes('contains an empty value')
|
||||
)
|
||||
throw error;
|
||||
throw new Error(`${fileKey} could not be read`);
|
||||
}
|
||||
}
|
||||
|
||||
export function parseAppConfig(raw: Record<string, unknown>): AppConfig {
|
||||
return appConfigSchema.parse({
|
||||
...raw,
|
||||
DATABASE_URL: resolveSecret(raw, 'DATABASE_URL'),
|
||||
REDIS_URL: resolveSecret(raw, 'REDIS_URL'),
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import { hostname } from 'node:os';
|
||||
import type { ConfigService } from '@nestjs/config';
|
||||
import type { AppConfig } from './app-config.schema.js';
|
||||
|
||||
// A replica must be identifiable from the outside. Inside Docker the hostname is
|
||||
// the short container ID, so X-Instance-Id can be mapped back to exactly one
|
||||
// container; INSTANCE_ID exists for platforms where that mapping is not useful.
|
||||
export function resolveInstanceId(config: ConfigService<AppConfig>): string {
|
||||
const configured = config.get('INSTANCE_ID');
|
||||
if (configured) return configured;
|
||||
const host = hostname();
|
||||
return host.length > 0 ? host : randomUUID();
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import pg from 'pg';
|
||||
import { MetricsService } from '../metrics/metrics.service.js';
|
||||
import type { AppConfig } from '../config/app-config.schema.js';
|
||||
|
||||
@Injectable()
|
||||
export class DatabaseClient implements OnModuleDestroy {
|
||||
readonly pool: pg.Pool;
|
||||
private readonly logger = new Logger(DatabaseClient.name);
|
||||
|
||||
constructor(
|
||||
private readonly config: ConfigService<AppConfig>,
|
||||
private readonly metrics: MetricsService,
|
||||
) {
|
||||
this.pool = new pg.Pool({
|
||||
connectionString: this.config.getOrThrow('DATABASE_URL'),
|
||||
max: this.config.getOrThrow('DATABASE_POOL_MAX'),
|
||||
connectionTimeoutMillis: this.config.getOrThrow(
|
||||
'DATABASE_CONNECTION_TIMEOUT_MS',
|
||||
),
|
||||
statement_timeout: this.config.getOrThrow(
|
||||
'DATABASE_STATEMENT_TIMEOUT_MS',
|
||||
),
|
||||
});
|
||||
// Idle clients emit 'error' on the pool when the database drops; without a
|
||||
// listener Node treats it as uncaught and terminates the process.
|
||||
this.pool.on('error', (error: Error) => {
|
||||
this.metrics.increment('database.pool_error');
|
||||
this.logger.warn(`PostgreSQL pool error: ${error.message}`);
|
||||
});
|
||||
}
|
||||
|
||||
query<T extends pg.QueryResultRow = pg.QueryResultRow>(
|
||||
label: string,
|
||||
text: string,
|
||||
values: readonly unknown[] = [],
|
||||
): Promise<pg.QueryResult<T>> {
|
||||
this.metrics.increment(label);
|
||||
return this.pool.query<T>({ text, values: [...values] });
|
||||
}
|
||||
|
||||
async health(): Promise<void> {
|
||||
await this.query('health.database', 'SELECT 1');
|
||||
}
|
||||
|
||||
async withTransaction<T>(
|
||||
work: (client: pg.PoolClient) => Promise<T>,
|
||||
): Promise<T> {
|
||||
const client = await this.pool.connect();
|
||||
try {
|
||||
await client.query('BEGIN');
|
||||
const result = await work(client);
|
||||
await client.query('COMMIT');
|
||||
return result;
|
||||
} catch (error) {
|
||||
try {
|
||||
await client.query('ROLLBACK');
|
||||
} catch (rollbackError) {
|
||||
this.metrics.increment('database.rollback_error');
|
||||
this.logger.warn(
|
||||
`Rollback failed: ${rollbackError instanceof Error ? rollbackError.message : 'unknown error'}`,
|
||||
);
|
||||
}
|
||||
// Callers must see the operation error, not the rollback error.
|
||||
throw error;
|
||||
} finally {
|
||||
client.release();
|
||||
}
|
||||
}
|
||||
|
||||
async onModuleDestroy(): Promise<void> {
|
||||
await this.pool.end();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { MetricsModule } from '../metrics/metrics.module.js';
|
||||
import { DatabaseClient } from './database.client.js';
|
||||
|
||||
@Module({
|
||||
imports: [MetricsModule],
|
||||
providers: [DatabaseClient],
|
||||
exports: [DatabaseClient],
|
||||
})
|
||||
export class DatabaseModule {}
|
||||
@@ -0,0 +1,63 @@
|
||||
import { readdir, readFile } from 'node:fs/promises';
|
||||
import { dirname, join } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { DatabaseClient } from './database.client.js';
|
||||
import { MetricsService } from '../metrics/metrics.service.js';
|
||||
import { parseAppConfig } from '../config/app-config.schema.js';
|
||||
|
||||
const migrationsDirectory = join(
|
||||
dirname(fileURLToPath(import.meta.url)),
|
||||
'migrations',
|
||||
);
|
||||
|
||||
async function migrationFiles(): Promise<string[]> {
|
||||
const files = await readdir(migrationsDirectory);
|
||||
return files.filter((file) => /^\d+_.+\.sql$/u.test(file)).sort();
|
||||
}
|
||||
|
||||
export async function runMigrations(database: DatabaseClient): Promise<void> {
|
||||
await database.query(
|
||||
'migrations.ensure_table',
|
||||
`CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY,
|
||||
applied_at timestamptz NOT NULL DEFAULT now()
|
||||
)`,
|
||||
);
|
||||
|
||||
for (const version of await migrationFiles()) {
|
||||
await database.withTransaction(async (client) => {
|
||||
const applied = await client.query({
|
||||
text: 'SELECT version FROM schema_migrations WHERE version = $1',
|
||||
values: [version],
|
||||
});
|
||||
if (applied.rowCount) return;
|
||||
|
||||
const sql = await readFile(
|
||||
join(migrationsDirectory, version),
|
||||
'utf8',
|
||||
);
|
||||
await client.query(sql);
|
||||
await client.query({
|
||||
text: 'INSERT INTO schema_migrations (version) VALUES ($1)',
|
||||
values: [version],
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
async function main(): Promise<void> {
|
||||
const config = parseAppConfig(process.env as Record<string, unknown>);
|
||||
const database = new DatabaseClient(
|
||||
{
|
||||
getOrThrow: (key: keyof typeof config) => config[key],
|
||||
} as never,
|
||||
new MetricsService(),
|
||||
);
|
||||
try {
|
||||
await runMigrations(database);
|
||||
} finally {
|
||||
await database.onModuleDestroy();
|
||||
}
|
||||
}
|
||||
|
||||
if (process.argv[1] === fileURLToPath(import.meta.url)) await main();
|
||||
@@ -0,0 +1,41 @@
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY,
|
||||
applied_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL UNIQUE,
|
||||
display_name text NOT NULL,
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
message_version bigint NOT NULL DEFAULT 0
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS 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 IF NOT EXISTS messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
sender_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
CONSTRAINT messages_sender_member_fk
|
||||
FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members(chat_id, user_id)
|
||||
ON DELETE RESTRICT
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS messages_chat_created_id_idx
|
||||
ON messages (chat_id, created_at, id);
|
||||
CREATE INDEX IF NOT EXISTS chat_members_user_chat_idx
|
||||
ON chat_members (user_id, chat_id);
|
||||
@@ -0,0 +1,5 @@
|
||||
-- HTTP timestamps and keyset cursors use JavaScript millisecond precision.
|
||||
-- Store the same precision so a returned cursor cannot point before its own row.
|
||||
ALTER TABLE users ALTER COLUMN created_at TYPE timestamptz(3);
|
||||
ALTER TABLE chats ALTER COLUMN created_at TYPE timestamptz(3);
|
||||
ALTER TABLE messages ALTER COLUMN created_at TYPE timestamptz(3);
|
||||
@@ -0,0 +1,20 @@
|
||||
-- Shared idempotency ledger for POST /api/v1/chats/{id}/messages.
|
||||
-- The key scope is (user, method, path, key): the same key from another user or
|
||||
-- another chat is independent, as the contract requires.
|
||||
-- claim + response are committed in one transaction, so a committed row always
|
||||
-- carries status_code and response_body (there is no "poisoned" intermediate state).
|
||||
CREATE TABLE IF NOT EXISTS idempotency_keys (
|
||||
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
method text NOT NULL,
|
||||
path text NOT NULL,
|
||||
key text NOT NULL,
|
||||
request_fingerprint text NOT NULL,
|
||||
status_code integer,
|
||||
response_body jsonb,
|
||||
message_id uuid,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (user_id, method, path, key)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idempotency_keys_created_at_idx
|
||||
ON idempotency_keys (created_at);
|
||||
@@ -0,0 +1,9 @@
|
||||
-- Instrumentation for the scaling experiments. pg_stat_statements only works
|
||||
-- when the server is started with shared_preload_libraries=pg_stat_statements
|
||||
-- (compose.yaml does that); without the preload the CREATE fails with a plain
|
||||
-- notice, so a database started without the preload still migrates cleanly.
|
||||
DO $$ BEGIN
|
||||
CREATE EXTENSION IF NOT EXISTS pg_stat_statements;
|
||||
EXCEPTION WHEN OTHERS THEN
|
||||
RAISE NOTICE 'pg_stat_statements unavailable: %', SQLERRM;
|
||||
END $$;
|
||||
@@ -0,0 +1,17 @@
|
||||
import { Controller, Get } from '@nestjs/common';
|
||||
import { HealthService } from './health.service.js';
|
||||
|
||||
@Controller('health')
|
||||
export class HealthController {
|
||||
constructor(private readonly healthService: HealthService) {}
|
||||
|
||||
@Get('live')
|
||||
getLive() {
|
||||
return this.healthService.getLiveness();
|
||||
}
|
||||
|
||||
@Get('ready')
|
||||
async getReady() {
|
||||
return this.healthService.getReadiness();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { HealthController } from './health.controller.js';
|
||||
import { LbCheckController } from './lb-check.controller.js';
|
||||
import { HealthService } from './health.service.js';
|
||||
import { DatabaseModule } from '../database/database.module.js';
|
||||
import { RedisModule } from '../redis/redis.module.js';
|
||||
|
||||
@Module({
|
||||
imports: [DatabaseModule, RedisModule],
|
||||
controllers: [HealthController, LbCheckController],
|
||||
providers: [HealthService],
|
||||
})
|
||||
export class HealthModule {}
|
||||
@@ -0,0 +1,57 @@
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
import { ServiceUnavailableException } from '@nestjs/common';
|
||||
import { HealthService } from './health.service.js';
|
||||
|
||||
describe('HealthService', () => {
|
||||
it('reports liveness and readiness when dependencies are healthy', async () => {
|
||||
const database = { health: vi.fn().mockResolvedValue(undefined) };
|
||||
const redis = { health: vi.fn().mockResolvedValue(undefined) };
|
||||
const config = { get: vi.fn().mockReturnValue(0) };
|
||||
const service = new HealthService(
|
||||
database as never,
|
||||
redis as never,
|
||||
config as never,
|
||||
);
|
||||
expect(service.getLiveness()).toEqual({ status: 'ok' });
|
||||
await expect(service.getReadiness()).resolves.toEqual({ status: 'ok' });
|
||||
});
|
||||
|
||||
it('rejects readiness when a dependency is unavailable', async () => {
|
||||
const database = {
|
||||
health: vi.fn().mockRejectedValue(new Error('down')),
|
||||
};
|
||||
const redis = { health: vi.fn().mockResolvedValue(undefined) };
|
||||
const service = new HealthService(
|
||||
database as never,
|
||||
redis as never,
|
||||
{ get: vi.fn() } as never,
|
||||
);
|
||||
await expect(service.getReadiness()).rejects.toBeInstanceOf(
|
||||
ServiceUnavailableException,
|
||||
);
|
||||
});
|
||||
|
||||
it('keeps liveness healthy while draining', async () => {
|
||||
const service = new HealthService(
|
||||
{ health: vi.fn() } as never,
|
||||
{ health: vi.fn() } as never,
|
||||
{ get: vi.fn() } as never,
|
||||
);
|
||||
service.setDraining();
|
||||
expect(service.getLiveness()).toEqual({ status: 'ok' });
|
||||
await expect(service.getReadiness()).rejects.toThrow(
|
||||
'Service is shutting down',
|
||||
);
|
||||
});
|
||||
|
||||
it('keeps the load-balancer check positive while a dependency is down', async () => {
|
||||
const service = new HealthService(
|
||||
{ health: vi.fn().mockRejectedValue(new Error('down')) } as never,
|
||||
{ health: vi.fn().mockRejectedValue(new Error('down')) } as never,
|
||||
{ get: vi.fn() } as never,
|
||||
);
|
||||
expect(service.getLbCheck()).toEqual({ status: 'ok' });
|
||||
service.setDraining();
|
||||
expect(() => service.getLbCheck()).toThrow('Draining');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,57 @@
|
||||
import {
|
||||
Global,
|
||||
Injectable,
|
||||
Module,
|
||||
ServiceUnavailableException,
|
||||
} from '@nestjs/common';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import { DatabaseClient } from '../database/database.client.js';
|
||||
import { RedisClient } from '../redis/redis.client.js';
|
||||
import type { AppConfig } from '../config/app-config.schema.js';
|
||||
|
||||
@Injectable()
|
||||
export class HealthService {
|
||||
private ready = true;
|
||||
constructor(
|
||||
private readonly database: DatabaseClient,
|
||||
private readonly redis: RedisClient,
|
||||
private readonly config: ConfigService<AppConfig>,
|
||||
) {}
|
||||
getLiveness() {
|
||||
return { status: 'ok' as const };
|
||||
}
|
||||
// Load-balancer probe, deliberately independent of PostgreSQL and Redis: a
|
||||
// shared dependency outage cannot be fixed by removing replicas from
|
||||
// rotation, and draining every backend would answer clients with the LB's
|
||||
// own HTML error page instead of the bounded API 503. /health/ready stays
|
||||
// the operator-facing readiness signal.
|
||||
getLbCheck() {
|
||||
if (!this.ready)
|
||||
throw new ServiceUnavailableException('Draining');
|
||||
return { status: 'ok' as const };
|
||||
}
|
||||
async getReadiness() {
|
||||
if (!this.ready)
|
||||
throw new ServiceUnavailableException('Service is shutting down');
|
||||
try {
|
||||
await Promise.all([this.database.health(), this.redis.health()]);
|
||||
} catch {
|
||||
throw new ServiceUnavailableException('Dependencies unavailable');
|
||||
}
|
||||
return { status: 'ok' as const };
|
||||
}
|
||||
setDraining() {
|
||||
this.ready = false;
|
||||
}
|
||||
async beforeApplicationShutdown(signal?: string): Promise<void> {
|
||||
this.setDraining();
|
||||
const delay = this.config.get<number>('DRAIN_DELAY_MS') ?? 5000;
|
||||
if (signal && delay > 0) {
|
||||
await new Promise<void>((resolve) => setTimeout(resolve, delay));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Global()
|
||||
@Module({ providers: [HealthService], exports: [HealthService] })
|
||||
export class HealthServiceModule {}
|
||||
@@ -0,0 +1,14 @@
|
||||
import { Controller, Get } from '@nestjs/common';
|
||||
import { HealthService } from './health.service.js';
|
||||
|
||||
// The load balancer probes this route instead of /health/ready so that a shared
|
||||
// database outage cannot drain the whole fleet; see HealthService.getLbCheck.
|
||||
@Controller('internal')
|
||||
export class LbCheckController {
|
||||
constructor(private readonly health: HealthService) {}
|
||||
|
||||
@Get('lb-check')
|
||||
check() {
|
||||
return this.health.getLbCheck();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
import { NestFactory } from '@nestjs/core';
|
||||
import { HttpAdapterHost } from '@nestjs/core';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import { ValidationPipe } from '@nestjs/common';
|
||||
import {
|
||||
FastifyAdapter,
|
||||
NestFastifyApplication,
|
||||
} from '@nestjs/platform-fastify';
|
||||
import { AppModule } from './app.module.js';
|
||||
import { MetricsService } from './metrics/metrics.service.js';
|
||||
import { RequestIdInterceptor } from './common/http/request-id.interceptor.js';
|
||||
|
||||
async function bootstrap(): Promise<void> {
|
||||
const app = await NestFactory.create<NestFastifyApplication>(
|
||||
AppModule,
|
||||
new FastifyAdapter({ logger: true }),
|
||||
);
|
||||
app.useGlobalInterceptors(
|
||||
new RequestIdInterceptor(
|
||||
app.get(HttpAdapterHost),
|
||||
app.get(MetricsService),
|
||||
app.get(ConfigService),
|
||||
),
|
||||
);
|
||||
app.useGlobalPipes(
|
||||
new ValidationPipe({
|
||||
whitelist: true,
|
||||
forbidNonWhitelisted: true,
|
||||
transform: true,
|
||||
}),
|
||||
);
|
||||
app.enableShutdownHooks();
|
||||
|
||||
const config = app.get(ConfigService);
|
||||
const port = config.getOrThrow<number>('APP_PORT');
|
||||
const host = config.getOrThrow<string>('APP_HOST');
|
||||
await app.listen(port, host);
|
||||
}
|
||||
|
||||
await bootstrap();
|
||||
@@ -0,0 +1,37 @@
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
import { MetricsService } from '../../metrics/metrics.service.js';
|
||||
import { MessagesCacheService } from './messages-cache.service.js';
|
||||
|
||||
describe('MessagesCacheService metrics', () => {
|
||||
it('records a miss and a hit for a protected page fill', async () => {
|
||||
const metrics = new MetricsService();
|
||||
const page = { items: [], next_cursor: null };
|
||||
const redis = {
|
||||
get: vi
|
||||
.fn()
|
||||
.mockResolvedValueOnce(null)
|
||||
.mockResolvedValueOnce(null)
|
||||
.mockResolvedValue(JSON.stringify(page)),
|
||||
setNxPx: vi.fn().mockResolvedValue(true),
|
||||
set: vi.fn().mockResolvedValue('OK'),
|
||||
unlock: vi.fn().mockResolvedValue(1),
|
||||
};
|
||||
const config = new ConfigService({
|
||||
CACHE_MODE: 'protected',
|
||||
CACHE_LOCK_TTL_MS: 1000,
|
||||
CACHE_TTL_SECONDS: 30,
|
||||
});
|
||||
const service = new MessagesCacheService(
|
||||
redis as never,
|
||||
config,
|
||||
metrics,
|
||||
);
|
||||
await service.getOrLoad('chat', 1n, undefined, 50, async () => page);
|
||||
await service.getOrLoad('chat', 1n, undefined, 50, async () => page);
|
||||
expect(metrics.snapshot().counters).toMatchObject({
|
||||
cache_miss: 1,
|
||||
cache_hit: 1,
|
||||
});
|
||||
});
|
||||
});
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { MessagesCacheService } from './messages-cache.service.js';
|
||||
import { MetricsModule } from '../../metrics/metrics.module.js';
|
||||
import { RedisModule } from '../../redis/redis.module.js';
|
||||
|
||||
@Module({
|
||||
imports: [RedisModule, MetricsModule],
|
||||
providers: [MessagesCacheService],
|
||||
exports: [MessagesCacheService],
|
||||
})
|
||||
export class MessagesCacheModule {}
|
||||
@@ -0,0 +1,72 @@
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
import type { AppConfig } from '../../config/app-config.schema.js';
|
||||
import type { RedisClient } from '../../redis/redis.client.js';
|
||||
import { MessagesCacheService } from './messages-cache.service.js';
|
||||
import { MetricsService } from '../../metrics/metrics.service.js';
|
||||
|
||||
function serviceWithRedis(redis: Partial<RedisClient>): MessagesCacheService {
|
||||
const config = new ConfigService<AppConfig>({
|
||||
CACHE_MODE: 'protected',
|
||||
CACHE_LOCK_TTL_MS: 1000,
|
||||
CACHE_TTL_SECONDS: 30,
|
||||
CACHE_MISS_DELAY_MS: 0,
|
||||
});
|
||||
return new MessagesCacheService(
|
||||
redis as RedisClient,
|
||||
config,
|
||||
new MetricsService(),
|
||||
);
|
||||
}
|
||||
|
||||
describe('MessagesCacheService fallback', () => {
|
||||
it('loads from the authoritative source when Redis read fails', async () => {
|
||||
const load = vi
|
||||
.fn()
|
||||
.mockResolvedValue({ items: [{ id: 'db' }], next_cursor: null });
|
||||
const service = serviceWithRedis({
|
||||
get: vi.fn().mockRejectedValue(new Error('redis down')),
|
||||
});
|
||||
|
||||
await expect(
|
||||
service.getOrLoad('chat', 1n, undefined, 50, load),
|
||||
).resolves.toEqual({
|
||||
items: [{ id: 'db' }],
|
||||
next_cursor: null,
|
||||
});
|
||||
expect(load).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it('falls back after bounded lock contention', async () => {
|
||||
const load = vi
|
||||
.fn()
|
||||
.mockResolvedValue({ items: [{ id: 'db' }], next_cursor: null });
|
||||
const service = serviceWithRedis({
|
||||
get: vi.fn().mockResolvedValue(null),
|
||||
setNxPx: vi.fn().mockResolvedValue(false),
|
||||
});
|
||||
|
||||
await expect(
|
||||
service.getOrLoad('chat', 1n, undefined, 50, load),
|
||||
).resolves.toEqual({
|
||||
items: [{ id: 'db' }],
|
||||
next_cursor: null,
|
||||
});
|
||||
expect(load).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it('returns the authoritative page when cache write fails', async () => {
|
||||
const page = { items: [{ id: 'db' }], next_cursor: null };
|
||||
const load = vi.fn().mockResolvedValue(page);
|
||||
const service = serviceWithRedis({
|
||||
get: vi.fn().mockResolvedValue(null),
|
||||
setNxPx: vi.fn().mockResolvedValue(true),
|
||||
set: vi.fn().mockRejectedValue(new Error('redis down')),
|
||||
unlock: vi.fn().mockResolvedValue(1),
|
||||
});
|
||||
|
||||
await expect(
|
||||
service.getOrLoad('chat', 1n, undefined, 50, load),
|
||||
).resolves.toEqual(page);
|
||||
});
|
||||
});
|
||||
+205
@@ -0,0 +1,205 @@
|
||||
import { Injectable, Logger } from '@nestjs/common';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import { setTimeout as delay } from 'node:timers/promises';
|
||||
import type { AppConfig } from '../../config/app-config.schema.js';
|
||||
import { RedisClient } from '../../redis/redis.client.js';
|
||||
import type { Page } from '../../common/http/page.js';
|
||||
import { MetricsService } from '../../metrics/metrics.service.js';
|
||||
|
||||
const LOCK_RETRY_COUNT = 4;
|
||||
const LOCK_RETRY_DELAY_MS = 25;
|
||||
|
||||
export type CachePage = Page<unknown>;
|
||||
|
||||
@Injectable()
|
||||
export class MessagesCacheService {
|
||||
private readonly logger = new Logger(MessagesCacheService.name);
|
||||
|
||||
constructor(
|
||||
private readonly redis: RedisClient,
|
||||
private readonly config: ConfigService<AppConfig>,
|
||||
private readonly metrics: MetricsService,
|
||||
) {}
|
||||
|
||||
async getOrLoad(
|
||||
chatId: string,
|
||||
version: bigint,
|
||||
cursor: string | undefined,
|
||||
limit: number,
|
||||
loader: () => Promise<CachePage>,
|
||||
): Promise<CachePage> {
|
||||
const key = this.cacheKey(chatId, version, cursor, limit);
|
||||
if (this.config.getOrThrow('CACHE_MODE') === 'naive') {
|
||||
return this.loadNaively(key, loader);
|
||||
}
|
||||
|
||||
let cached: string | null;
|
||||
try {
|
||||
cached = await this.redis.get(key);
|
||||
} catch (error) {
|
||||
return this.fallbackToDatabase('read', error, loader);
|
||||
}
|
||||
const cachedPage = this.parsePage(cached);
|
||||
if (cachedPage) {
|
||||
this.metrics.increment('cache_hit');
|
||||
return cachedPage;
|
||||
}
|
||||
this.metrics.increment('cache_miss');
|
||||
|
||||
const lockKey = `lock:${key}`;
|
||||
const owner = `${process.pid}:${Math.random().toString(36).slice(2)}`;
|
||||
for (let attempt = 0; attempt < LOCK_RETRY_COUNT; attempt += 1) {
|
||||
let locked: boolean;
|
||||
try {
|
||||
locked = await this.redis.setNxPx(
|
||||
lockKey,
|
||||
owner,
|
||||
this.config.getOrThrow('CACHE_LOCK_TTL_MS'),
|
||||
);
|
||||
} catch (error) {
|
||||
return this.fallbackToDatabase('lock', error, loader);
|
||||
}
|
||||
if (locked) return this.fillLocked(key, lockKey, owner, loader);
|
||||
|
||||
if (attempt === 0) this.metrics.increment('cache_lock_wait');
|
||||
try {
|
||||
const waitedPage = this.parsePage(await this.redis.get(key));
|
||||
if (waitedPage) {
|
||||
this.metrics.increment('cache_hit');
|
||||
return waitedPage;
|
||||
}
|
||||
} catch (error) {
|
||||
return this.fallbackToDatabase('waiting read', error, loader);
|
||||
}
|
||||
await delay(LOCK_RETRY_DELAY_MS);
|
||||
}
|
||||
|
||||
// The owner did not publish the page within the bounded wait: serve the
|
||||
// authoritative result instead of blocking the request further.
|
||||
this.metrics.increment('cache_lock_timeout');
|
||||
return loader();
|
||||
}
|
||||
|
||||
private async fillLocked(
|
||||
key: string,
|
||||
lockKey: string,
|
||||
owner: string,
|
||||
loader: () => Promise<CachePage>,
|
||||
): Promise<CachePage> {
|
||||
try {
|
||||
let secondCheck: string | null;
|
||||
try {
|
||||
secondCheck = await this.redis.get(key);
|
||||
} catch (error) {
|
||||
return this.fallbackToDatabase('double-check', error, loader);
|
||||
}
|
||||
const secondPage = this.parsePage(secondCheck);
|
||||
if (secondPage) {
|
||||
this.metrics.increment('cache_hit');
|
||||
return secondPage;
|
||||
}
|
||||
|
||||
const page = await loader();
|
||||
try {
|
||||
await this.redis.set(key, JSON.stringify(page), {
|
||||
EX: this.config.getOrThrow('CACHE_TTL_SECONDS'),
|
||||
});
|
||||
} catch (error) {
|
||||
// Redis is derived state: the page is still valid for this response,
|
||||
// but the failure must stay visible in metrics and logs.
|
||||
this.metrics.increment('cache_write_error');
|
||||
this.logger.warn(
|
||||
`Cache fill failed: ${error instanceof Error ? error.message : 'unknown error'}`,
|
||||
);
|
||||
}
|
||||
return page;
|
||||
} finally {
|
||||
try {
|
||||
await this.redis.unlock(lockKey, owner);
|
||||
} catch (error) {
|
||||
// The lock has a TTL, so a stale lock expires on its own; a successful
|
||||
// response must not be replaced by an unlock failure.
|
||||
this.metrics.increment('cache_unlock_error');
|
||||
this.logger.warn(
|
||||
`Cache unlock failed: ${error instanceof Error ? error.message : 'unknown error'}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private cacheKey(
|
||||
chatId: string,
|
||||
version: bigint,
|
||||
cursor: string | undefined,
|
||||
limit: number,
|
||||
): string {
|
||||
return `messages:${chatId}:v${version.toString()}:c${cursor ?? 'start'}:l${limit}`;
|
||||
}
|
||||
|
||||
private async loadNaively(
|
||||
key: string,
|
||||
loader: () => Promise<CachePage>,
|
||||
): Promise<CachePage> {
|
||||
let cached: string | null;
|
||||
try {
|
||||
cached = await this.redis.get(key);
|
||||
} catch (error) {
|
||||
return this.fallbackToDatabase('naive read', error, loader);
|
||||
}
|
||||
const cachedPage = this.parsePage(cached);
|
||||
if (cachedPage) {
|
||||
this.metrics.increment('cache_hit');
|
||||
return cachedPage;
|
||||
}
|
||||
this.metrics.increment('cache_miss');
|
||||
|
||||
const cacheMissDelay = this.config.getOrThrow('CACHE_MISS_DELAY_MS');
|
||||
if (cacheMissDelay > 0) await delay(cacheMissDelay);
|
||||
const page = await loader();
|
||||
try {
|
||||
await this.redis.set(key, JSON.stringify(page), {
|
||||
EX: this.config.getOrThrow('CACHE_TTL_SECONDS'),
|
||||
});
|
||||
} catch (error) {
|
||||
this.metrics.increment('cache_write_error');
|
||||
this.logger.warn(
|
||||
`Cache fill failed: ${error instanceof Error ? error.message : 'unknown error'}`,
|
||||
);
|
||||
}
|
||||
return page;
|
||||
}
|
||||
|
||||
private async fallbackToDatabase(
|
||||
stage: string,
|
||||
error: unknown,
|
||||
loader: () => Promise<CachePage>,
|
||||
): Promise<CachePage> {
|
||||
this.metrics.increment('cache_fallback');
|
||||
this.logger.warn(
|
||||
`Cache ${stage} failed, serving PostgreSQL: ${error instanceof Error ? error.message : 'unknown error'}`,
|
||||
);
|
||||
return loader();
|
||||
}
|
||||
|
||||
private parsePage(value: string | null): CachePage | undefined {
|
||||
if (!value) return undefined;
|
||||
try {
|
||||
const parsed: unknown = JSON.parse(value);
|
||||
if (
|
||||
typeof parsed !== 'object' ||
|
||||
parsed === null ||
|
||||
!('items' in parsed) ||
|
||||
!('next_cursor' in parsed) ||
|
||||
!Array.isArray(parsed.items) ||
|
||||
(parsed.next_cursor !== null &&
|
||||
typeof parsed.next_cursor !== 'string')
|
||||
)
|
||||
return undefined;
|
||||
return { items: parsed.items, next_cursor: parsed.next_cursor };
|
||||
} catch {
|
||||
// A malformed entry is treated as a miss and overwritten by the owner fill.
|
||||
this.metrics.increment('cache_corrupt_entry');
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
import { IsString } from 'class-validator';
|
||||
import { CodePointLength } from '../../common/validation/code-point-length.js';
|
||||
|
||||
export class CreateMessageDto {
|
||||
@IsString()
|
||||
@CodePointLength(1, 4000)
|
||||
text!: string;
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { parseAppConfig } from '../../config/app-config.schema.js';
|
||||
import { DatabaseClient } from '../../database/database.client.js';
|
||||
import { MetricsService } from '../../metrics/metrics.service.js';
|
||||
import { IdempotencyRepository } from './idempotency.repository.js';
|
||||
|
||||
// Manual operator pass over the idempotency ledger: the API also purges expired
|
||||
// claims in the background, but an operator must be able to reclaim space
|
||||
// without waiting for traffic. It never touches unexpired claims.
|
||||
// in the stand: docker compose exec api node dist/messages/idempotency/idempotency-gc.cli.js
|
||||
// on the host: npm run idempotency:gc (needs a reachable DATABASE_URL)
|
||||
async function main(): Promise<void> {
|
||||
const config = parseAppConfig(process.env as Record<string, unknown>);
|
||||
const database = new DatabaseClient(
|
||||
{
|
||||
getOrThrow: (key: keyof typeof config) => config[key],
|
||||
} as never,
|
||||
new MetricsService(),
|
||||
);
|
||||
try {
|
||||
const repository = new IdempotencyRepository(database);
|
||||
const purged = await repository.purgeExpired(
|
||||
config.IDEMPOTENCY_TTL_SECONDS,
|
||||
);
|
||||
process.stdout.write(
|
||||
`Purged ${purged} idempotency key(s) older than ${config.IDEMPOTENCY_TTL_SECONDS} seconds\n`,
|
||||
);
|
||||
} finally {
|
||||
await database.onModuleDestroy();
|
||||
}
|
||||
}
|
||||
|
||||
if (process.argv[1] === fileURLToPath(import.meta.url)) await main();
|
||||
@@ -0,0 +1,10 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { DatabaseModule } from '../../database/database.module.js';
|
||||
import { IdempotencyRepository } from './idempotency.repository.js';
|
||||
|
||||
@Module({
|
||||
imports: [DatabaseModule],
|
||||
providers: [IdempotencyRepository],
|
||||
exports: [IdempotencyRepository],
|
||||
})
|
||||
export class IdempotencyModule {}
|
||||
@@ -0,0 +1,152 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import type pg from 'pg';
|
||||
import { DatabaseClient } from '../../database/database.client.js';
|
||||
import type { Message } from '../message.js';
|
||||
|
||||
// A committed row always carries the response: the claim and the stored response
|
||||
// are written in the same transaction, so there is no poisoned intermediate
|
||||
// state to re-check at replay time.
|
||||
export type IdempotencyRecord = {
|
||||
request_fingerprint: string;
|
||||
status_code: number;
|
||||
response_body: Message;
|
||||
created_at: Date | string;
|
||||
expired: boolean;
|
||||
};
|
||||
|
||||
const PURGE_BATCH_LIMIT = 1000;
|
||||
const PURGE_BATCHES = 10;
|
||||
|
||||
@Injectable()
|
||||
export class IdempotencyRepository {
|
||||
constructor(private readonly database: DatabaseClient) {}
|
||||
|
||||
/** True when this request created the claim, i.e. it owns the side effect. */
|
||||
async claim(
|
||||
client: pg.PoolClient,
|
||||
userId: string,
|
||||
path: string,
|
||||
key: string,
|
||||
fingerprint: string,
|
||||
): Promise<boolean> {
|
||||
const result = await client.query({
|
||||
text: `INSERT INTO idempotency_keys (user_id, method, path, key, request_fingerprint)
|
||||
VALUES ($1, 'POST', $2, $3, $4)
|
||||
ON CONFLICT DO NOTHING
|
||||
RETURNING created_at`,
|
||||
values: [userId, path, key, fingerprint],
|
||||
});
|
||||
return result.rowCount === 1;
|
||||
}
|
||||
|
||||
async read(
|
||||
client: pg.PoolClient,
|
||||
userId: string,
|
||||
path: string,
|
||||
key: string,
|
||||
ttlSeconds: number,
|
||||
): Promise<IdempotencyRecord | undefined> {
|
||||
const result = await client.query<IdempotencyRecord>({
|
||||
text: `SELECT request_fingerprint, status_code, response_body, created_at,
|
||||
created_at < now() - make_interval(secs => $4::double precision) AS expired
|
||||
FROM idempotency_keys
|
||||
WHERE user_id = $1 AND method = 'POST' AND path = $2 AND key = $3`,
|
||||
values: [userId, path, key, ttlSeconds],
|
||||
});
|
||||
return result.rows[0];
|
||||
}
|
||||
|
||||
async store(
|
||||
client: pg.PoolClient,
|
||||
userId: string,
|
||||
path: string,
|
||||
key: string,
|
||||
statusCode: number,
|
||||
message: Message,
|
||||
): Promise<void> {
|
||||
await client.query({
|
||||
text: `UPDATE idempotency_keys
|
||||
SET status_code = $4, response_body = $5::jsonb, message_id = $6
|
||||
WHERE user_id = $1 AND method = 'POST' AND path = $2 AND key = $3`,
|
||||
values: [
|
||||
userId,
|
||||
path,
|
||||
key,
|
||||
statusCode,
|
||||
JSON.stringify(message),
|
||||
message.id,
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
async forget(
|
||||
client: pg.PoolClient,
|
||||
userId: string,
|
||||
path: string,
|
||||
key: string,
|
||||
): Promise<void> {
|
||||
await client.query({
|
||||
text: `DELETE FROM idempotency_keys
|
||||
WHERE user_id = $1 AND method = 'POST' AND path = $2 AND key = $3`,
|
||||
values: [userId, path, key],
|
||||
});
|
||||
}
|
||||
|
||||
async isMember(
|
||||
client: pg.PoolClient,
|
||||
chatId: string,
|
||||
userId: string,
|
||||
): Promise<boolean> {
|
||||
const result = await client.query<{ is_member: boolean }>({
|
||||
text: `SELECT EXISTS (
|
||||
SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2
|
||||
) AS is_member`,
|
||||
values: [chatId, userId],
|
||||
});
|
||||
return result.rows[0]?.is_member === true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Deletes expired claims in bounded batches. The transaction-scoped advisory
|
||||
* lock makes the pass single-flight across replicas without risking a lock
|
||||
* leaking back into the pool with a released connection. Returns the number
|
||||
* of deleted rows (0 when another replica is purging).
|
||||
*/
|
||||
async purgeExpired(ttlSeconds: number): Promise<number> {
|
||||
const client = await this.database.pool.connect();
|
||||
try {
|
||||
await client.query('BEGIN');
|
||||
try {
|
||||
const lock = await client.query<{ locked: boolean }>(
|
||||
"SELECT pg_try_advisory_xact_lock(hashtext('idempotency_gc')) AS locked",
|
||||
);
|
||||
if (lock.rows[0]?.locked !== true) {
|
||||
await client.query('ROLLBACK');
|
||||
return 0;
|
||||
}
|
||||
let purged = 0;
|
||||
for (let batch = 0; batch < PURGE_BATCHES; batch += 1) {
|
||||
const result = await client.query({
|
||||
text: `DELETE FROM idempotency_keys
|
||||
WHERE ctid IN (
|
||||
SELECT ctid FROM idempotency_keys
|
||||
WHERE created_at < now() - make_interval(secs => $1::double precision)
|
||||
LIMIT ${PURGE_BATCH_LIMIT}
|
||||
)`,
|
||||
values: [ttlSeconds],
|
||||
});
|
||||
const deleted = result.rowCount ?? 0;
|
||||
purged += deleted;
|
||||
if (deleted < PURGE_BATCH_LIMIT) break;
|
||||
}
|
||||
await client.query('COMMIT');
|
||||
return purged;
|
||||
} catch (error) {
|
||||
await client.query('ROLLBACK').catch(() => undefined);
|
||||
throw error;
|
||||
}
|
||||
} finally {
|
||||
client.release();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
import { createHash } from 'node:crypto';
|
||||
import type { CreateMessageDto } from '../dto/create-message.dto.js';
|
||||
|
||||
// Contract: ASCII [A-Za-z0-9._:-]{1,128}. Anything else (including a duplicated
|
||||
// header, which Fastify joins with ", ") is rejected as a client error.
|
||||
export const IDEMPOTENCY_KEY_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
|
||||
|
||||
export function messagesPath(chatId: string): string {
|
||||
return `/api/v1/chats/${chatId}/messages`;
|
||||
}
|
||||
|
||||
// The fingerprint is derived from the validated payload with a fixed field
|
||||
// order, so neither JSON key order nor an absent optional field can change it.
|
||||
export function idempotencyFingerprint(input: CreateMessageDto): string {
|
||||
return createHash('sha256')
|
||||
.update(JSON.stringify({ text: input.text }))
|
||||
.digest('hex');
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
export type Message = {
|
||||
id: string;
|
||||
chat_id: string;
|
||||
sender_id: string;
|
||||
text: string;
|
||||
created_at: string;
|
||||
};
|
||||
@@ -0,0 +1,53 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
Body,
|
||||
Controller,
|
||||
DefaultValuePipe,
|
||||
Get,
|
||||
Headers,
|
||||
Param,
|
||||
ParseIntPipe,
|
||||
ParseUUIDPipe,
|
||||
Post,
|
||||
Query,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import { CurrentUser } from '../common/auth/current-user.decorator.js';
|
||||
import { CurrentUserGuard } from '../common/auth/current-user.guard.js';
|
||||
import type { User } from '../users/user.js';
|
||||
import { CreateMessageDto } from './dto/create-message.dto.js';
|
||||
import { MessagesService } from './messages.service.js';
|
||||
|
||||
@Controller('api/v1/chats/:chatId/messages')
|
||||
@UseGuards(CurrentUserGuard)
|
||||
export class MessagesController {
|
||||
constructor(private readonly messagesService: MessagesService) {}
|
||||
|
||||
@Post()
|
||||
create(
|
||||
@Param('chatId', new ParseUUIDPipe()) chatId: string,
|
||||
@Body() body: CreateMessageDto,
|
||||
@CurrentUser() currentUser: User,
|
||||
@Headers('idempotency-key') idempotencyKey?: string | string[],
|
||||
) {
|
||||
return this.messagesService.create(
|
||||
chatId,
|
||||
body,
|
||||
currentUser,
|
||||
idempotencyKey,
|
||||
);
|
||||
}
|
||||
|
||||
@Get()
|
||||
list(
|
||||
@Param('chatId', new ParseUUIDPipe()) chatId: string,
|
||||
@CurrentUser() currentUser: User,
|
||||
@Query('limit', new DefaultValuePipe(50), new ParseIntPipe())
|
||||
limit: number,
|
||||
@Query('cursor') cursor?: string,
|
||||
) {
|
||||
if (limit < 1 || limit > 100)
|
||||
throw new BadRequestException('limit must be between 1 and 100');
|
||||
return this.messagesService.list(chatId, currentUser, limit, cursor);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { DatabaseModule } from '../database/database.module.js';
|
||||
import { ChatsModule } from '../chats/chats.module.js';
|
||||
import { MessagesController } from './messages.controller.js';
|
||||
import { MessagesRepository } from './messages.repository.js';
|
||||
import { MessagesService } from './messages.service.js';
|
||||
import { MessagesCacheModule } from './cache/messages-cache.module.js';
|
||||
import { IdempotencyModule } from './idempotency/idempotency.module.js';
|
||||
import { UsersModule } from '../users/users.module.js';
|
||||
import { RedisModule } from '../redis/redis.module.js';
|
||||
import { MetricsModule } from '../metrics/metrics.module.js';
|
||||
|
||||
@Module({
|
||||
imports: [
|
||||
ChatsModule,
|
||||
MessagesCacheModule,
|
||||
IdempotencyModule,
|
||||
DatabaseModule,
|
||||
UsersModule,
|
||||
RedisModule,
|
||||
MetricsModule,
|
||||
],
|
||||
controllers: [MessagesController],
|
||||
providers: [MessagesRepository, MessagesService],
|
||||
})
|
||||
export class MessagesModule {}
|
||||
@@ -0,0 +1,47 @@
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
import type { Cursor } from '../common/http/cursor.js';
|
||||
import type { Message } from './message.js';
|
||||
import { MessagesRepository } from './messages.repository.js';
|
||||
|
||||
const message = (id: string, created_at: string): Message => ({
|
||||
id,
|
||||
chat_id: 'chat',
|
||||
sender_id: 'sender',
|
||||
text: id,
|
||||
created_at,
|
||||
});
|
||||
|
||||
describe('MessagesRepository', () => {
|
||||
it('uses named SQL history and a keyset cursor', async () => {
|
||||
const query = vi.fn().mockResolvedValue({ rows: [], rowCount: 0 });
|
||||
const repository = new MessagesRepository({
|
||||
query,
|
||||
withTransaction: vi.fn(),
|
||||
} as never);
|
||||
const cursor: Cursor = {
|
||||
scope: 'messages:chat',
|
||||
created_at: '2026-01-01T00:00:01.000Z',
|
||||
id: '1',
|
||||
};
|
||||
await repository.findPage('chat', 10, cursor);
|
||||
expect(query).toHaveBeenCalledWith(
|
||||
'messages.history',
|
||||
expect.stringContaining('(created_at, id) >'),
|
||||
expect.arrayContaining(['chat', cursor.created_at, cursor.id, 11]),
|
||||
);
|
||||
});
|
||||
|
||||
it('returns rows in response shape', async () => {
|
||||
const query = vi
|
||||
.fn()
|
||||
.mockResolvedValue({
|
||||
rows: [message('1', '2026-01-01T00:00:00.000Z')],
|
||||
rowCount: 1,
|
||||
});
|
||||
const repository = new MessagesRepository({ query } as never);
|
||||
await expect(repository.findPage('chat', 1)).resolves.toEqual({
|
||||
items: [message('1', '2026-01-01T00:00:00.000Z')],
|
||||
hasMore: false,
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,93 @@
|
||||
import {
|
||||
Injectable,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import type pg from 'pg';
|
||||
import { DatabaseClient } from '../database/database.client.js';
|
||||
import type { Cursor } from '../common/http/cursor.js';
|
||||
import type { Message } from './message.js';
|
||||
|
||||
type MessageRow = {
|
||||
id: string;
|
||||
chat_id: string;
|
||||
sender_id: string;
|
||||
text: string;
|
||||
created_at: Date | string;
|
||||
};
|
||||
|
||||
function toMessage(row: MessageRow): Message {
|
||||
return {
|
||||
id: row.id,
|
||||
chat_id: row.chat_id,
|
||||
sender_id: row.sender_id,
|
||||
text: row.text,
|
||||
created_at: new Date(row.created_at).toISOString(),
|
||||
};
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class MessagesRepository {
|
||||
constructor(private readonly database: DatabaseClient) {}
|
||||
|
||||
// The caller owns the transaction: the message insert, the chat version bump
|
||||
// and the idempotency claim must commit or roll back as one unit.
|
||||
async create(
|
||||
client: pg.PoolClient,
|
||||
chatId: string,
|
||||
senderId: string,
|
||||
text: string,
|
||||
): Promise<Message> {
|
||||
const id = randomUUID();
|
||||
const membership = await client.query({
|
||||
name: 'messages.checkMembership',
|
||||
text: 'SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2',
|
||||
values: [chatId, senderId],
|
||||
});
|
||||
if (!membership.rowCount) throw new NotFoundException();
|
||||
const result = await client.query<MessageRow>({
|
||||
name: 'messages.insert',
|
||||
text: 'INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1, $2, $3, $4) RETURNING id, chat_id, sender_id, text, created_at',
|
||||
values: [id, chatId, senderId, text],
|
||||
});
|
||||
await client.query({
|
||||
name: 'messages.incrementVersion',
|
||||
text: 'UPDATE chats SET message_version = message_version + 1 WHERE id = $1',
|
||||
values: [chatId],
|
||||
});
|
||||
return toMessage(result.rows[0]);
|
||||
}
|
||||
|
||||
async getVersion(chatId: string, userId: string): Promise<bigint> {
|
||||
const result = await this.database.query<{ message_version: string }>(
|
||||
'messages.version',
|
||||
'SELECT c.message_version FROM chats c WHERE c.id = $1 AND EXISTS (SELECT 1 FROM chat_members WHERE chat_id = c.id AND user_id = $2)',
|
||||
[chatId, userId],
|
||||
);
|
||||
if (!result.rows[0]) throw new NotFoundException();
|
||||
return BigInt(result.rows[0].message_version);
|
||||
}
|
||||
|
||||
async findPage(
|
||||
chatId: string,
|
||||
limit: number,
|
||||
cursor?: Cursor,
|
||||
): Promise<{ items: Message[]; hasMore: boolean }> {
|
||||
const values: unknown[] = [chatId];
|
||||
let predicate = '';
|
||||
if (cursor) {
|
||||
values.push(cursor.created_at, cursor.id);
|
||||
predicate = 'AND (created_at, id) > ($2::timestamptz, $3::uuid)';
|
||||
}
|
||||
values.push(limit + 1);
|
||||
const result = await this.database.query<MessageRow>(
|
||||
'messages.history',
|
||||
`SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1 ${predicate} ORDER BY created_at, id LIMIT $${values.length}`,
|
||||
values,
|
||||
);
|
||||
return {
|
||||
items: result.rows.slice(0, limit).map(toMessage),
|
||||
hasMore: result.rows.length > limit,
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,231 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
ConflictException,
|
||||
HttpStatus,
|
||||
Injectable,
|
||||
Logger,
|
||||
NotFoundException,
|
||||
ServiceUnavailableException,
|
||||
} from '@nestjs/common';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import type pg from 'pg';
|
||||
import { decodeCursor, encodeCursor } from '../common/http/cursor.js';
|
||||
import type { Page } from '../common/http/page.js';
|
||||
import type { AppConfig } from '../config/app-config.schema.js';
|
||||
import type { User } from '../users/user.js';
|
||||
import { ChatsService } from '../chats/chats.service.js';
|
||||
import { DatabaseClient } from '../database/database.client.js';
|
||||
import { MetricsService } from '../metrics/metrics.service.js';
|
||||
import type { CreateMessageDto } from './dto/create-message.dto.js';
|
||||
import type { Message } from './message.js';
|
||||
import { MessagesRepository } from './messages.repository.js';
|
||||
import { MessagesCacheService } from './cache/messages-cache.service.js';
|
||||
import {
|
||||
IDEMPOTENCY_KEY_PATTERN,
|
||||
idempotencyFingerprint,
|
||||
messagesPath,
|
||||
} from './idempotency/idempotency.js';
|
||||
import { IdempotencyRepository } from './idempotency/idempotency.repository.js';
|
||||
|
||||
// A claim row can disappear between our failed insert attempt and the read
|
||||
// (the previous owner rolled back), so a bounded retry is part of the protocol.
|
||||
const MAX_CLAIM_ATTEMPTS = 3;
|
||||
const PURGE_EVERY_REQUESTS = 512;
|
||||
|
||||
type CreateOutcome =
|
||||
| { kind: 'created'; message: Message }
|
||||
| { kind: 'replayed'; message: Message }
|
||||
| { kind: 'retry' };
|
||||
|
||||
@Injectable()
|
||||
export class MessagesService {
|
||||
private readonly logger = new Logger(MessagesService.name);
|
||||
private requestsSincePurge = 0;
|
||||
|
||||
constructor(
|
||||
private readonly messagesRepository: MessagesRepository,
|
||||
private readonly chatsService: ChatsService,
|
||||
private readonly cache: MessagesCacheService,
|
||||
private readonly idempotency: IdempotencyRepository,
|
||||
private readonly database: DatabaseClient,
|
||||
private readonly config: ConfigService<AppConfig>,
|
||||
private readonly metrics: MetricsService,
|
||||
) {}
|
||||
|
||||
async create(
|
||||
chatId: string,
|
||||
input: CreateMessageDto,
|
||||
currentUser: User,
|
||||
rawKey: string | string[] | undefined,
|
||||
): Promise<Message> {
|
||||
// The key is validated before anything else: a missing, malformed or
|
||||
// duplicated header is a client error, never a stored result.
|
||||
if (typeof rawKey !== 'string' || !IDEMPOTENCY_KEY_PATTERN.test(rawKey))
|
||||
throw new BadRequestException(
|
||||
'Idempotency-Key header is required',
|
||||
);
|
||||
if ([...input.text].every((character) => /\s/u.test(character)))
|
||||
throw new BadRequestException('Message text cannot be blank');
|
||||
await this.chatsService.getForUser(chatId, currentUser);
|
||||
|
||||
const path = messagesPath(chatId);
|
||||
const fingerprint = idempotencyFingerprint(input);
|
||||
for (let attempt = 1; attempt <= MAX_CLAIM_ATTEMPTS; attempt += 1) {
|
||||
const outcome = await this.database.withTransaction((client) =>
|
||||
this.attemptCreate(client, {
|
||||
chatId,
|
||||
path,
|
||||
key: rawKey,
|
||||
fingerprint,
|
||||
text: input.text,
|
||||
userId: currentUser.id,
|
||||
}),
|
||||
);
|
||||
if (outcome.kind !== 'retry') {
|
||||
this.scheduleExpiredPurge();
|
||||
return outcome.message;
|
||||
}
|
||||
}
|
||||
throw new ServiceUnavailableException(
|
||||
'Idempotency key could not be claimed',
|
||||
);
|
||||
}
|
||||
|
||||
// One attempt = one transaction: the claim, the side effect and the stored
|
||||
// response commit together, so a retry can never duplicate a message and a
|
||||
// failure never leaves a half-finished claim behind.
|
||||
private async attemptCreate(
|
||||
client: pg.PoolClient,
|
||||
request: {
|
||||
chatId: string;
|
||||
path: string;
|
||||
key: string;
|
||||
fingerprint: string;
|
||||
text: string;
|
||||
userId: string;
|
||||
},
|
||||
): Promise<CreateOutcome> {
|
||||
const { chatId, path, key, fingerprint, text, userId } = request;
|
||||
const claimed = await this.idempotency.claim(
|
||||
client,
|
||||
userId,
|
||||
path,
|
||||
key,
|
||||
fingerprint,
|
||||
);
|
||||
if (claimed) {
|
||||
this.metrics.increment('idempotency.claim');
|
||||
const message = await this.messagesRepository.create(
|
||||
client,
|
||||
chatId,
|
||||
userId,
|
||||
text,
|
||||
);
|
||||
await this.idempotency.store(
|
||||
client,
|
||||
userId,
|
||||
path,
|
||||
key,
|
||||
HttpStatus.CREATED,
|
||||
message,
|
||||
);
|
||||
this.metrics.increment('messages.write');
|
||||
return { kind: 'created', message };
|
||||
}
|
||||
|
||||
const record = await this.idempotency.read(
|
||||
client,
|
||||
userId,
|
||||
path,
|
||||
key,
|
||||
this.config.getOrThrow('IDEMPOTENCY_TTL_SECONDS'),
|
||||
);
|
||||
if (!record) {
|
||||
// The previous owner aborted, so nothing was created and the key is
|
||||
// free again.
|
||||
this.metrics.increment('idempotency.claim_lost');
|
||||
return { kind: 'retry' };
|
||||
}
|
||||
if (record.request_fingerprint !== fingerprint) {
|
||||
this.metrics.increment('idempotency.conflict');
|
||||
throw new ConflictException(
|
||||
'Idempotency key reused with a different body',
|
||||
);
|
||||
}
|
||||
if (record.expired) {
|
||||
this.metrics.increment('idempotency.released');
|
||||
await this.idempotency.forget(client, userId, path, key);
|
||||
return { kind: 'retry' };
|
||||
}
|
||||
// A replay re-checks access, as the contract requires: the stored result
|
||||
// is only returned to a caller that may still read this chat.
|
||||
if (!(await this.idempotency.isMember(client, chatId, userId)))
|
||||
throw new NotFoundException();
|
||||
this.metrics.increment('idempotency.replay');
|
||||
return { kind: 'replayed', message: record.response_body };
|
||||
}
|
||||
|
||||
// Expired claims are storage hygiene, not part of the request: the pass runs
|
||||
// outside the request transaction, at most once per PURGE_EVERY_REQUESTS
|
||||
// successful writes, and its failure never changes the client's result.
|
||||
private scheduleExpiredPurge(): void {
|
||||
this.requestsSincePurge += 1;
|
||||
if (this.requestsSincePurge < PURGE_EVERY_REQUESTS) return;
|
||||
this.requestsSincePurge = 0;
|
||||
const ttl = this.config.getOrThrow('IDEMPOTENCY_TTL_SECONDS');
|
||||
void this.idempotency
|
||||
.purgeExpired(ttl)
|
||||
.then((purged) => {
|
||||
if (purged > 0) this.metrics.increment('idempotency.purged');
|
||||
})
|
||||
.catch((error: unknown) => {
|
||||
this.metrics.increment('idempotency.purge_error');
|
||||
this.logger.warn(
|
||||
`Idempotency purge failed: ${error instanceof Error ? error.message : 'unknown error'}`,
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
async list(
|
||||
chatId: string,
|
||||
currentUser: User,
|
||||
limit: number,
|
||||
cursorValue?: string,
|
||||
): Promise<Page<Message>> {
|
||||
await this.chatsService.getForUser(chatId, currentUser);
|
||||
const scope = `messages:${chatId}`;
|
||||
const cursor = cursorValue
|
||||
? decodeCursor(cursorValue, scope)
|
||||
: undefined;
|
||||
const version = await this.messagesRepository.getVersion(
|
||||
chatId,
|
||||
currentUser.id,
|
||||
);
|
||||
const page = await this.cache.getOrLoad(
|
||||
chatId,
|
||||
version,
|
||||
cursorValue,
|
||||
limit,
|
||||
async () => {
|
||||
const loaded = await this.messagesRepository.findPage(
|
||||
chatId,
|
||||
limit,
|
||||
cursor,
|
||||
);
|
||||
const lastLoaded = loaded.items.at(-1);
|
||||
return {
|
||||
items: loaded.items,
|
||||
next_cursor:
|
||||
loaded.hasMore && lastLoaded
|
||||
? encodeCursor({
|
||||
scope,
|
||||
created_at: lastLoaded.created_at,
|
||||
id: lastLoaded.id,
|
||||
})
|
||||
: null,
|
||||
};
|
||||
},
|
||||
);
|
||||
return page as Page<Message>;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
import {
|
||||
Controller,
|
||||
Get,
|
||||
Headers,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
Post,
|
||||
UnauthorizedException,
|
||||
} from '@nestjs/common';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import type { AppConfig } from '../config/app-config.schema.js';
|
||||
import { resolveInstanceId } from '../config/instance-id.js';
|
||||
import { MetricsService } from './metrics.service.js';
|
||||
|
||||
@Controller('internal')
|
||||
export class MetricsController {
|
||||
private readonly instanceId: string;
|
||||
private readonly buildId: string;
|
||||
|
||||
constructor(
|
||||
private readonly config: ConfigService<AppConfig>,
|
||||
private readonly metrics: MetricsService,
|
||||
) {
|
||||
this.instanceId = resolveInstanceId(config);
|
||||
this.buildId = process.env.BUILD_ID ?? 'unknown';
|
||||
}
|
||||
|
||||
@Get('metrics')
|
||||
get(@Headers('authorization') authorization?: string) {
|
||||
this.requireToken(authorization);
|
||||
return {
|
||||
...this.metrics.snapshot(),
|
||||
instance_id: this.instanceId,
|
||||
build_id: this.buildId,
|
||||
};
|
||||
}
|
||||
|
||||
@Post('metrics/reset')
|
||||
@HttpCode(HttpStatus.OK)
|
||||
reset(@Headers('authorization') authorization?: string): { status: 'ok' } {
|
||||
this.requireToken(authorization);
|
||||
this.metrics.reset();
|
||||
return { status: 'ok' };
|
||||
}
|
||||
|
||||
private requireToken(authorization?: string): void {
|
||||
const token = this.config.get<string>('METRICS_TOKEN');
|
||||
if (!token || authorization !== `Bearer ${token}`)
|
||||
throw new UnauthorizedException({
|
||||
message: 'Unauthorized',
|
||||
challenge: 'Bearer realm="metrics"',
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { MetricsController } from './metrics.controller.js';
|
||||
import { MetricsService } from './metrics.service.js';
|
||||
|
||||
@Module({
|
||||
controllers: [MetricsController],
|
||||
providers: [MetricsService],
|
||||
exports: [MetricsService],
|
||||
})
|
||||
export class MetricsModule {}
|
||||
@@ -0,0 +1,62 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
import { MetricsService } from './metrics.service.js';
|
||||
|
||||
describe('MetricsService', () => {
|
||||
it('computes nearest-rank percentiles from observed latencies', () => {
|
||||
const metrics = new MetricsService();
|
||||
metrics.increment('cache_hit');
|
||||
metrics.increment('cache_hit');
|
||||
metrics.observeLatency(30);
|
||||
metrics.observeLatency(10);
|
||||
metrics.observeLatency(20);
|
||||
expect(metrics.snapshot()).toEqual({
|
||||
counters: { cache_hit: 2 },
|
||||
latency_ms: {
|
||||
count: 3,
|
||||
sample_count: 3,
|
||||
p50: 20,
|
||||
p95: 30,
|
||||
p99: 30,
|
||||
max: 30,
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it('keeps snapshots isolated from callers and later observations', () => {
|
||||
const metrics = new MetricsService();
|
||||
metrics.increment('cache_hit');
|
||||
const snapshot = metrics.snapshot();
|
||||
snapshot.counters.cache_hit = 99;
|
||||
metrics.increment('cache_hit');
|
||||
expect(metrics.snapshot().counters.cache_hit).toBe(2);
|
||||
expect(snapshot.latency_ms.count).toBe(0);
|
||||
});
|
||||
|
||||
it('bounds retained samples but keeps cumulative count and maximum', () => {
|
||||
const metrics = new MetricsService();
|
||||
metrics.observeLatency(9000);
|
||||
for (let index = 0; index < 4096; index += 1)
|
||||
metrics.observeLatency(10);
|
||||
expect(metrics.snapshot().latency_ms).toEqual({
|
||||
count: 4097,
|
||||
sample_count: 4096,
|
||||
p50: 10,
|
||||
p95: 10,
|
||||
p99: 10,
|
||||
max: 9000,
|
||||
});
|
||||
});
|
||||
|
||||
it('ignores invalid latency observations', () => {
|
||||
const metrics = new MetricsService();
|
||||
for (const value of [-1, NaN, Infinity]) metrics.observeLatency(value);
|
||||
expect(metrics.snapshot().latency_ms).toEqual({
|
||||
count: 0,
|
||||
sample_count: 0,
|
||||
p50: 0,
|
||||
p95: 0,
|
||||
p99: 0,
|
||||
max: 0,
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,69 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
|
||||
const LATENCY_SAMPLE_CAPACITY = 4096;
|
||||
|
||||
type LatencySnapshot = {
|
||||
count: number;
|
||||
sample_count: number;
|
||||
p50: number;
|
||||
p95: number;
|
||||
p99: number;
|
||||
max: number;
|
||||
};
|
||||
|
||||
@Injectable()
|
||||
export class MetricsService {
|
||||
private readonly counters: Record<string, number> = {};
|
||||
private readonly latencies: number[] = [];
|
||||
private latencyCount = 0;
|
||||
private maximumLatency = 0;
|
||||
private nextSample = 0;
|
||||
|
||||
increment(name: string): void {
|
||||
this.counters[name] = (this.counters[name] ?? 0) + 1;
|
||||
}
|
||||
|
||||
observeLatency(milliseconds: number): void {
|
||||
if (!Number.isFinite(milliseconds) || milliseconds < 0) return;
|
||||
this.latencyCount += 1;
|
||||
this.maximumLatency = Math.max(this.maximumLatency, milliseconds);
|
||||
this.latencies[this.nextSample] = milliseconds;
|
||||
this.nextSample = (this.nextSample + 1) % LATENCY_SAMPLE_CAPACITY;
|
||||
}
|
||||
|
||||
snapshot(): {
|
||||
counters: Record<string, number>;
|
||||
latency_ms: LatencySnapshot;
|
||||
} {
|
||||
const sorted = [...this.latencies].sort((left, right) => left - right);
|
||||
return {
|
||||
counters: { ...this.counters },
|
||||
latency_ms: {
|
||||
count: this.latencyCount,
|
||||
sample_count: sorted.length,
|
||||
p50: this.percentile(sorted, 0.5),
|
||||
p95: this.percentile(sorted, 0.95),
|
||||
p99: this.percentile(sorted, 0.99),
|
||||
max: this.maximumLatency,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
reset(): void {
|
||||
for (const name of Object.keys(this.counters))
|
||||
delete this.counters[name];
|
||||
this.latencies.length = 0;
|
||||
this.latencyCount = 0;
|
||||
this.maximumLatency = 0;
|
||||
this.nextSample = 0;
|
||||
}
|
||||
|
||||
private percentile(sorted: number[], percentile: number): number {
|
||||
if (sorted.length === 0) return 0;
|
||||
const index = Math.min(
|
||||
sorted.length - 1,
|
||||
Math.ceil(sorted.length * percentile) - 1,
|
||||
);
|
||||
return sorted[index];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
import { Injectable, Logger, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
|
||||
import { ConfigService } from '@nestjs/config';
|
||||
import { createClient, type RedisClientType } from 'redis';
|
||||
import type { AppConfig } from '../config/app-config.schema.js';
|
||||
import { MetricsService } from '../metrics/metrics.service.js';
|
||||
|
||||
const UNLOCK_SCRIPT =
|
||||
'if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end';
|
||||
type Client = RedisClientType;
|
||||
|
||||
@Injectable()
|
||||
export class RedisClient implements OnModuleInit, OnModuleDestroy {
|
||||
readonly client: Client;
|
||||
private readonly logger = new Logger(RedisClient.name);
|
||||
|
||||
constructor(
|
||||
private readonly config: ConfigService<AppConfig>,
|
||||
private readonly metrics: MetricsService,
|
||||
) {
|
||||
this.client = createClient({
|
||||
url: this.config.getOrThrow('REDIS_URL'),
|
||||
disableOfflineQueue: true,
|
||||
socket: {
|
||||
reconnectStrategy: (attempt) =>
|
||||
Math.min(1000 + attempt * 250, 5000),
|
||||
connectTimeout: 5000,
|
||||
},
|
||||
}) as Client;
|
||||
// Reconnect failures must be visible; the readiness probe pings Redis.
|
||||
this.client.on('error', (error: Error) => {
|
||||
this.metrics.increment('redis.error');
|
||||
this.logger.warn(`Redis error: ${error.message}`);
|
||||
});
|
||||
}
|
||||
|
||||
async onModuleInit(): Promise<void> {
|
||||
await this.client.connect();
|
||||
}
|
||||
|
||||
async onModuleDestroy(): Promise<void> {
|
||||
if (this.client.isOpen) await this.client.quit();
|
||||
}
|
||||
|
||||
async health(): Promise<void> {
|
||||
this.metrics.increment('redis.ping');
|
||||
await this.client.ping();
|
||||
}
|
||||
|
||||
async get(key: string): Promise<string | null> {
|
||||
this.metrics.increment('redis.get');
|
||||
return this.client.get(key);
|
||||
}
|
||||
|
||||
async set(
|
||||
key: string,
|
||||
value: string,
|
||||
options?: { EX?: number; PX?: number; NX?: boolean },
|
||||
): Promise<string | null> {
|
||||
this.metrics.increment('redis.set');
|
||||
return this.client.set(key, value, options);
|
||||
}
|
||||
|
||||
async setNxEx(
|
||||
key: string,
|
||||
value: string,
|
||||
seconds: number,
|
||||
): Promise<boolean> {
|
||||
this.metrics.increment('redis.set');
|
||||
return (
|
||||
(await this.client.set(key, value, { NX: true, EX: seconds })) ===
|
||||
'OK'
|
||||
);
|
||||
}
|
||||
|
||||
async setNxPx(
|
||||
key: string,
|
||||
value: string,
|
||||
milliseconds: number,
|
||||
): Promise<boolean> {
|
||||
this.metrics.increment('redis.set');
|
||||
return (
|
||||
(await this.client.set(key, value, {
|
||||
NX: true,
|
||||
PX: milliseconds,
|
||||
})) === 'OK'
|
||||
);
|
||||
}
|
||||
|
||||
async del(key: string): Promise<number> {
|
||||
this.metrics.increment('redis.del');
|
||||
return this.client.del(key);
|
||||
}
|
||||
|
||||
async incr(key: string): Promise<number> {
|
||||
this.metrics.increment('redis.incr');
|
||||
return this.client.incr(key);
|
||||
}
|
||||
|
||||
async expire(key: string, seconds: number): Promise<boolean> {
|
||||
this.metrics.increment('redis.expire');
|
||||
return (await this.client.expire(key, seconds)) === 1;
|
||||
}
|
||||
|
||||
async scan(
|
||||
cursor: number,
|
||||
pattern?: string,
|
||||
count = 100,
|
||||
): Promise<{ cursor: number; keys: string[] }> {
|
||||
this.metrics.increment('redis.scan');
|
||||
const result = await this.client.scan(String(cursor), {
|
||||
MATCH: pattern,
|
||||
COUNT: count,
|
||||
});
|
||||
return { cursor: Number(result.cursor), keys: result.keys };
|
||||
}
|
||||
|
||||
async unlock(key: string, owner: string): Promise<number> {
|
||||
this.metrics.increment('redis.unlock');
|
||||
return Number(
|
||||
await this.client.eval(UNLOCK_SCRIPT, {
|
||||
keys: [key],
|
||||
arguments: [owner],
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
pipeline(commands: Array<[string, ...string[]]>): Promise<unknown[]> {
|
||||
this.metrics.increment('redis.pipeline');
|
||||
const multi = this.client.multi();
|
||||
for (const [command, ...args] of commands)
|
||||
multi.addCommand([command, ...args]);
|
||||
return multi.exec();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { MetricsModule } from '../metrics/metrics.module.js';
|
||||
import { RedisClient } from './redis.client.js';
|
||||
|
||||
@Module({
|
||||
imports: [MetricsModule],
|
||||
providers: [RedisClient],
|
||||
exports: [RedisClient],
|
||||
})
|
||||
export class RedisModule {}
|
||||
Vendored
+7
@@ -0,0 +1,7 @@
|
||||
import { User } from './users/user.ts';
|
||||
|
||||
declare module 'fastify' {
|
||||
interface FastifyRequest {
|
||||
currentUser?: User;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
import { IsString, Matches } from 'class-validator';
|
||||
import { CodePointLength } from '../../common/validation/code-point-length.js';
|
||||
|
||||
export class CreateUserDTO {
|
||||
@IsString()
|
||||
@Matches(/^[a-z0-9_]{3,32}$/)
|
||||
username!: string;
|
||||
|
||||
@IsString()
|
||||
@CodePointLength(1, 100)
|
||||
@Matches(/\S/u, {
|
||||
message: 'display_name must contain a non-whitespace character',
|
||||
})
|
||||
display_name!: string;
|
||||
|
||||
@IsString()
|
||||
@CodePointLength(12, 128)
|
||||
@Matches(/\S/u, {
|
||||
message: 'password must contain a non-whitespace character',
|
||||
})
|
||||
password!: string;
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
export type User = {
|
||||
id: string;
|
||||
username: string;
|
||||
display_name: string;
|
||||
created_at: string;
|
||||
};
|
||||
@@ -0,0 +1,22 @@
|
||||
import { Body, Controller, Get, Post, UseGuards } from '@nestjs/common';
|
||||
import { CurrentUser } from '../common/auth/current-user.decorator.js';
|
||||
import { CurrentUserGuard } from '../common/auth/current-user.guard.js';
|
||||
import type { User } from './user.js';
|
||||
import { CreateUserDTO } from './dto/create-user.dto.js';
|
||||
import { UsersService } from './users.service.js';
|
||||
|
||||
@Controller('api/v1/users')
|
||||
export class UsersController {
|
||||
constructor(private readonly usersService: UsersService) {}
|
||||
|
||||
@Post()
|
||||
create(@Body() body: CreateUserDTO) {
|
||||
return this.usersService.create(body);
|
||||
}
|
||||
|
||||
@Get('/me')
|
||||
@UseGuards(CurrentUserGuard)
|
||||
getMe(@CurrentUser() currentUser: User) {
|
||||
return currentUser;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { UsersController } from './users.controller.js';
|
||||
import { UsersRepository } from './users.repository.js';
|
||||
import { UsersService } from './users.service.js';
|
||||
import { CurrentUserGuard } from '../common/auth/current-user.guard.js';
|
||||
import { RedisModule } from '../redis/redis.module.js';
|
||||
import { MetricsModule } from '../metrics/metrics.module.js';
|
||||
import { DatabaseModule } from '../database/database.module.js';
|
||||
|
||||
@Module({
|
||||
imports: [DatabaseModule, RedisModule, MetricsModule],
|
||||
controllers: [UsersController],
|
||||
providers: [UsersRepository, UsersService, CurrentUserGuard],
|
||||
exports: [UsersService, CurrentUserGuard, RedisModule, MetricsModule],
|
||||
})
|
||||
export class UsersModule {}
|
||||
@@ -0,0 +1,71 @@
|
||||
import { ConflictException, Injectable } from '@nestjs/common';
|
||||
import { DatabaseClient } from '../database/database.client.js';
|
||||
import type { User } from './user.js';
|
||||
|
||||
type UserRow = {
|
||||
id: string;
|
||||
username: string;
|
||||
display_name: string;
|
||||
password_hash: string;
|
||||
created_at: Date | string;
|
||||
};
|
||||
|
||||
function toUser(row: UserRow): User {
|
||||
return {
|
||||
id: row.id,
|
||||
username: row.username,
|
||||
display_name: row.display_name,
|
||||
created_at: new Date(row.created_at).toISOString(),
|
||||
};
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class UsersRepository {
|
||||
constructor(private readonly database: DatabaseClient) {}
|
||||
|
||||
async findById(id: string): Promise<User | undefined> {
|
||||
const result = await this.database.query<UserRow>(
|
||||
'users.findById',
|
||||
'SELECT id, username, display_name, password_hash, created_at FROM users WHERE id = $1',
|
||||
[id],
|
||||
);
|
||||
const row = result.rows[0];
|
||||
return row ? toUser(row) : undefined;
|
||||
}
|
||||
|
||||
async findByUsername(
|
||||
username: string,
|
||||
): Promise<(User & { password_hash: string }) | undefined> {
|
||||
const result = await this.database.query<UserRow>(
|
||||
'users.findByUsername',
|
||||
'SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1',
|
||||
[username],
|
||||
);
|
||||
const row = result.rows[0];
|
||||
return row
|
||||
? { ...toUser(row), password_hash: row.password_hash }
|
||||
: undefined;
|
||||
}
|
||||
|
||||
async create(user: {
|
||||
id: string;
|
||||
username: string;
|
||||
display_name: string;
|
||||
password_hash: string;
|
||||
}): Promise<User> {
|
||||
try {
|
||||
const result = await this.database.query<UserRow>(
|
||||
'users.insert',
|
||||
`INSERT INTO users (id, username, display_name, password_hash)
|
||||
VALUES ($1, $2, $3, $4)
|
||||
RETURNING id, username, display_name, password_hash, created_at`,
|
||||
[user.id, user.username, user.display_name, user.password_hash],
|
||||
);
|
||||
return toUser(result.rows[0]);
|
||||
} catch (error) {
|
||||
if ((error as { code?: string }).code === '23505')
|
||||
throw new ConflictException('Username already exists');
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import argon2 from 'argon2';
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import { CreateUserDTO } from './dto/create-user.dto.js';
|
||||
import { User } from './user.js';
|
||||
import { UsersRepository } from './users.repository.js';
|
||||
|
||||
@Injectable()
|
||||
export class UsersService {
|
||||
constructor(private readonly usersRepository: UsersRepository) {}
|
||||
|
||||
async create(input: CreateUserDTO): Promise<User> {
|
||||
const passwordHash = await argon2.hash(input.password, {
|
||||
type: argon2.argon2id,
|
||||
});
|
||||
return this.usersRepository.create({
|
||||
id: randomUUID(),
|
||||
username: input.username,
|
||||
display_name: input.display_name,
|
||||
password_hash: passwordHash,
|
||||
});
|
||||
}
|
||||
|
||||
findById(id: string): Promise<User | undefined> {
|
||||
return this.usersRepository.findById(id);
|
||||
}
|
||||
|
||||
findByUsername(username: string) {
|
||||
return this.usersRepository.findByUsername(username);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,644 @@
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import { setTimeout as sleep } from 'node:timers/promises';
|
||||
import { Pool } from 'pg';
|
||||
import { createClient } from 'redis';
|
||||
import type { SessionResponse } from '../src/auth/auth.service.js';
|
||||
import type { Chat } from '../src/chats/chat.js';
|
||||
import type { ApiErrorBody } from '../src/common/errors/api-error.js';
|
||||
import type { Page } from '../src/common/http/page.js';
|
||||
import type { Message } from '../src/messages/message.js';
|
||||
import type { User } from '../src/users/user.js';
|
||||
|
||||
// The suite is black-box: run it against the compiled application process.
|
||||
// Vitest sets process.env.BASE_URL itself (Vite base), so the API URL uses its own name.
|
||||
const baseUrl = (process.env.API_BASE_URL ?? 'http://localhost:8080').replace(
|
||||
/\/+$/u,
|
||||
'',
|
||||
);
|
||||
const basicChallenge = 'Basic realm="messenger", charset="UTF-8"';
|
||||
const bearerChallenge = 'Bearer realm="messenger"';
|
||||
const password = 'integration:пароль🔐';
|
||||
const runId = randomUUID().replaceAll('-', '').slice(0, 12);
|
||||
const usernames: string[] = [];
|
||||
const tokens: string[] = [];
|
||||
let sequence = 0;
|
||||
let database: Pool;
|
||||
let redis: ReturnType<typeof createClient>;
|
||||
|
||||
type Actor = { user: User; password: string; token: string };
|
||||
type HttpResult<T> = { body: T; response: Response };
|
||||
|
||||
async function http<T = unknown>(
|
||||
path: string,
|
||||
init: RequestInit = {},
|
||||
): Promise<HttpResult<T>> {
|
||||
const response = await fetch(`${baseUrl}${path}`, init);
|
||||
const text = await response.text();
|
||||
let body: unknown = undefined;
|
||||
if (text) {
|
||||
try {
|
||||
body = JSON.parse(text);
|
||||
} catch {
|
||||
body = text;
|
||||
}
|
||||
}
|
||||
return { body: body as T, response };
|
||||
}
|
||||
|
||||
function json(
|
||||
body: unknown,
|
||||
headers: Record<string, string> = {},
|
||||
): RequestInit {
|
||||
return {
|
||||
method: 'POST',
|
||||
headers: { 'content-type': 'application/json', ...headers },
|
||||
body: JSON.stringify(body),
|
||||
};
|
||||
}
|
||||
|
||||
function basic(username: string, secret: string): string {
|
||||
return `Basic ${Buffer.from(`${username}:${secret}`, 'utf8').toString('base64')}`;
|
||||
}
|
||||
|
||||
function bearer(token: string): Record<string, string> {
|
||||
return { authorization: `Bearer ${token}` };
|
||||
}
|
||||
|
||||
function idempotencyKey(): Record<string, string> {
|
||||
return { 'idempotency-key': randomUUID().replaceAll('-', '') };
|
||||
}
|
||||
|
||||
function messageHeaders(token: string): Record<string, string> {
|
||||
return { ...bearer(token), ...idempotencyKey() };
|
||||
}
|
||||
|
||||
async function register(
|
||||
displayName = 'Интеграционный пользователь',
|
||||
secret = password,
|
||||
): Promise<User> {
|
||||
const username = `e2e_${runId}_${sequence++}`.slice(0, 32);
|
||||
usernames.push(username);
|
||||
const result = await http<User>(
|
||||
'/api/v1/users',
|
||||
json({ username, display_name: displayName, password: secret }),
|
||||
);
|
||||
expect(result.response.status).toBe(201);
|
||||
return result.body;
|
||||
}
|
||||
|
||||
async function login(user: User, secret = password): Promise<SessionResponse> {
|
||||
const result = await http<SessionResponse>('/api/v1/auth/sessions', {
|
||||
method: 'POST',
|
||||
headers: { authorization: basic(user.username, secret) },
|
||||
});
|
||||
expect(result.response.status).toBe(201);
|
||||
tokens.push(result.body.token);
|
||||
return result.body;
|
||||
}
|
||||
|
||||
async function actor(displayName?: string): Promise<Actor> {
|
||||
const user = await register(displayName);
|
||||
const session = await login(user);
|
||||
return { user, password, token: session.token };
|
||||
}
|
||||
|
||||
function expectError(
|
||||
result: HttpResult<ApiErrorBody>,
|
||||
status: number,
|
||||
code: string,
|
||||
): void {
|
||||
expect(result.response.status).toBe(status);
|
||||
expect(result.body.error.code).toBe(code);
|
||||
expect(result.body.error.request_id).toBe(
|
||||
result.response.headers.get('x-request-id'),
|
||||
);
|
||||
}
|
||||
|
||||
describe('HTTP integration contract', () => {
|
||||
beforeAll(async () => {
|
||||
database = new Pool({
|
||||
connectionString: process.env.DATABASE_URL,
|
||||
connectionTimeoutMillis: 5000,
|
||||
});
|
||||
redis = createClient({
|
||||
url: process.env.REDIS_URL,
|
||||
socket: { reconnectStrategy: false },
|
||||
});
|
||||
redis.on('error', () => {});
|
||||
await redis.connect();
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
if (usernames.length) {
|
||||
await database.query('BEGIN');
|
||||
try {
|
||||
await database.query(
|
||||
`DELETE FROM messages WHERE sender_id IN (SELECT id FROM users WHERE username = ANY($1::text[]))`,
|
||||
[usernames],
|
||||
);
|
||||
await database.query(
|
||||
`DELETE FROM chats WHERE id IN (SELECT chat_id FROM chat_members WHERE user_id IN (SELECT id FROM users WHERE username = ANY($1::text[])))`,
|
||||
[usernames],
|
||||
);
|
||||
await database.query(
|
||||
'DELETE FROM users WHERE username = ANY($1::text[])',
|
||||
[usernames],
|
||||
);
|
||||
await database.query('COMMIT');
|
||||
} catch (error) {
|
||||
await database.query('ROLLBACK');
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
if (redis.isOpen) redis.destroy();
|
||||
await database.end();
|
||||
});
|
||||
|
||||
it('serves liveness and requires real session authentication', async () => {
|
||||
const live = await http<{ status: string }>('/health/live');
|
||||
expect(live.response.status).toBe(200);
|
||||
expect(live.body).toEqual({ status: 'ok' });
|
||||
const denied = await http<ApiErrorBody>('/api/v1/users/me');
|
||||
expectError(denied, 401, 'unauthorized');
|
||||
expect(denied.response.headers.get('www-authenticate')).toBe(
|
||||
bearerChallenge,
|
||||
);
|
||||
});
|
||||
|
||||
it('measures string lengths in Unicode code points', async () => {
|
||||
const emoji = '🔐';
|
||||
const username = (suffix: string) =>
|
||||
`e2e_${runId}_${suffix}`.slice(0, 32);
|
||||
const rejected = await http<ApiErrorBody>(
|
||||
'/api/v1/users',
|
||||
json({
|
||||
username: username('cp_short'),
|
||||
display_name: 'Code points',
|
||||
password: emoji.repeat(11),
|
||||
}),
|
||||
);
|
||||
expectError(rejected, 400, 'invalid_request');
|
||||
const tooLongPassword = await http<ApiErrorBody>(
|
||||
'/api/v1/users',
|
||||
json({
|
||||
username: username('cp_long'),
|
||||
display_name: 'Code points',
|
||||
password: emoji.repeat(129),
|
||||
}),
|
||||
);
|
||||
expectError(tooLongPassword, 400, 'invalid_request');
|
||||
const tooLongName = await http<ApiErrorBody>(
|
||||
'/api/v1/users',
|
||||
json({
|
||||
username: username('cp_name'),
|
||||
display_name: emoji.repeat(101),
|
||||
password,
|
||||
}),
|
||||
);
|
||||
expectError(tooLongName, 400, 'invalid_request');
|
||||
|
||||
const shortUsername = username('cp_ok');
|
||||
usernames.push(shortUsername);
|
||||
const boundaryPassword = emoji.repeat(12);
|
||||
const created = await http<User>(
|
||||
'/api/v1/users',
|
||||
json({
|
||||
username: shortUsername,
|
||||
display_name: emoji.repeat(100),
|
||||
password: boundaryPassword,
|
||||
}),
|
||||
);
|
||||
expect(created.response.status).toBe(201);
|
||||
expect([...created.body.display_name].length).toBe(100);
|
||||
// The stored password keeps all 12 code points: authentication works.
|
||||
const session = await http<SessionResponse>('/api/v1/auth/sessions', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
authorization: basic(shortUsername, boundaryPassword),
|
||||
},
|
||||
});
|
||||
expect(session.response.status).toBe(201);
|
||||
tokens.push(session.body.token);
|
||||
|
||||
const longTitleRejected = await http<ApiErrorBody>(
|
||||
'/api/v1/chats',
|
||||
json(
|
||||
{ title: emoji.repeat(101), member_ids: [created.body.id] },
|
||||
bearer(session.body.token),
|
||||
),
|
||||
);
|
||||
expectError(longTitleRejected, 400, 'invalid_request');
|
||||
const longTitle = await http<Chat>(
|
||||
'/api/v1/chats',
|
||||
json(
|
||||
{ title: emoji.repeat(100), member_ids: [created.body.id] },
|
||||
bearer(session.body.token),
|
||||
),
|
||||
);
|
||||
expect(longTitle.response.status).toBe(201);
|
||||
const tooLongText = await http<ApiErrorBody>(
|
||||
`/api/v1/chats/${longTitle.body.id}/messages`,
|
||||
json({ text: emoji.repeat(4001) }, messageHeaders(session.body.token)),
|
||||
);
|
||||
expectError(tooLongText, 400, 'invalid_request');
|
||||
const boundaryText = await http<Message>(
|
||||
`/api/v1/chats/${longTitle.body.id}/messages`,
|
||||
json({ text: emoji.repeat(4000) }, messageHeaders(session.body.token)),
|
||||
);
|
||||
expect(boundaryText.response.status).toBe(201);
|
||||
expect([...boundaryText.body.text].length).toBe(4000);
|
||||
});
|
||||
|
||||
it('rejects whitespace-only and too-short credentials', async () => {
|
||||
const username = `e2e_${runId}_${sequence++}`.slice(0, 32);
|
||||
usernames.push(username);
|
||||
const cases = [
|
||||
{ password: ' '.repeat(12), display_name: 'Пользователь' },
|
||||
{ password: '\t'.repeat(16), display_name: 'Пользователь' },
|
||||
{ password: 'short-pass', display_name: 'Пользователь' },
|
||||
{ password, display_name: ' ' },
|
||||
];
|
||||
for (const body of cases) {
|
||||
const result = await http<ApiErrorBody>(
|
||||
'/api/v1/users',
|
||||
json({ username, ...body }),
|
||||
);
|
||||
expectError(result, 400, 'invalid_request');
|
||||
}
|
||||
const accepted = await http<User>(
|
||||
'/api/v1/users',
|
||||
json({ username, display_name: 'Пользователь', password }),
|
||||
);
|
||||
expect(accepted.response.status).toBe(201);
|
||||
});
|
||||
|
||||
it('registers, logs in with Unicode/colon password, and challenges malformed Basic', async () => {
|
||||
const user = await register();
|
||||
const session = await login(user);
|
||||
expect(session.user.id).toBe(user.id);
|
||||
expect(session.token_type).toBe('Bearer');
|
||||
const me = await http<User>('/api/v1/users/me', {
|
||||
headers: bearer(session.token),
|
||||
});
|
||||
expect(me.response.status).toBe(200);
|
||||
expect(me.body.id).toBe(user.id);
|
||||
for (const authorization of [
|
||||
'Basic !!!',
|
||||
'Basic YWJj',
|
||||
'Bearer nope',
|
||||
]) {
|
||||
const result = await http<ApiErrorBody>('/api/v1/auth/sessions', {
|
||||
method: 'POST',
|
||||
headers: { authorization },
|
||||
});
|
||||
expectError(result, 401, 'unauthorized');
|
||||
expect(result.response.headers.get('www-authenticate')).toBe(
|
||||
basicChallenge,
|
||||
);
|
||||
}
|
||||
const bodyResult = await http<ApiErrorBody>('/api/v1/auth/sessions', {
|
||||
...json({ unexpected: true }),
|
||||
headers: { authorization: basic(user.username, password) },
|
||||
});
|
||||
expectError(bodyResult, 400, 'invalid_request');
|
||||
});
|
||||
|
||||
it('returns conflict for concurrent duplicate registration', async () => {
|
||||
const username = `e2e_${runId}_race`.slice(0, 32);
|
||||
usernames.push(username);
|
||||
const results = await Promise.all([
|
||||
http<User>(
|
||||
'/api/v1/users',
|
||||
json({ username, display_name: 'Race A', password }),
|
||||
),
|
||||
http<User>(
|
||||
'/api/v1/users',
|
||||
json({ username, display_name: 'Race B', password }),
|
||||
),
|
||||
]);
|
||||
expect(
|
||||
results.filter((item) => item.response.status === 201),
|
||||
'duplicate registration must create exactly one user',
|
||||
).toHaveLength(1);
|
||||
expect(
|
||||
results.filter((item) => item.response.status === 409),
|
||||
'loser of the race must receive 409, not 500',
|
||||
).toHaveLength(1);
|
||||
// The database unique index is the race-proof guard, so verify its effect.
|
||||
const persisted = await database.query<{ count: string }>(
|
||||
'SELECT count(*)::text AS count FROM users WHERE username = $1',
|
||||
[username],
|
||||
);
|
||||
expect(persisted.rows[0]?.count).toBe('1');
|
||||
});
|
||||
|
||||
it('uses Bearer only, ignores X-User-Id spoofing, and prevents logout replay', async () => {
|
||||
const alice = await actor('Алиса');
|
||||
const bob = await actor('Боб');
|
||||
const spoof = await http<ApiErrorBody>('/api/v1/users/me', {
|
||||
headers: { ...bearer(alice.token), 'x-user-id': bob.user.id },
|
||||
});
|
||||
expect(spoof.response.status).toBe(200);
|
||||
expect((spoof.body as unknown as User).id).toBe(alice.user.id);
|
||||
const basicBusiness = await http<ApiErrorBody>('/api/v1/users/me', {
|
||||
headers: { authorization: basic(alice.user.username, password) },
|
||||
});
|
||||
expectError(basicBusiness, 401, 'unauthorized');
|
||||
expect(basicBusiness.response.headers.get('www-authenticate')).toBe(
|
||||
bearerChallenge,
|
||||
);
|
||||
const logout = await http('/api/v1/auth/sessions/current', {
|
||||
method: 'DELETE',
|
||||
headers: bearer(alice.token),
|
||||
});
|
||||
expect(logout.response.status).toBe(204);
|
||||
const replay = await http<ApiErrorBody>('/api/v1/users/me', {
|
||||
headers: bearer(alice.token),
|
||||
});
|
||||
expectError(replay, 401, 'unauthorized');
|
||||
});
|
||||
|
||||
it('rejects unknown and duplicate chat members and hides chats from outsiders', async () => {
|
||||
const alice = await actor();
|
||||
const bob = await actor();
|
||||
const outsider = await actor();
|
||||
const unknown = await http<ApiErrorBody>(
|
||||
'/api/v1/chats',
|
||||
json(
|
||||
{ title: 'unknown', member_ids: [alice.user.id, randomUUID()] },
|
||||
bearer(alice.token),
|
||||
),
|
||||
);
|
||||
expectError(unknown, 400, 'invalid_request');
|
||||
const leaked = await http<ApiErrorBody>(`/api/v1/chats?limit=100`, {
|
||||
headers: bearer(alice.token),
|
||||
});
|
||||
expect(leaked.response.status).toBe(200);
|
||||
expect(
|
||||
(leaked.body as unknown as Page<Chat>).items.some(
|
||||
(item) => item.title === 'unknown',
|
||||
),
|
||||
).toBe(false);
|
||||
const duplicate = await http<ApiErrorBody>(
|
||||
'/api/v1/chats',
|
||||
json(
|
||||
{
|
||||
title: 'duplicate',
|
||||
member_ids: [alice.user.id, alice.user.id],
|
||||
},
|
||||
bearer(alice.token),
|
||||
),
|
||||
);
|
||||
expectError(duplicate, 400, 'invalid_request');
|
||||
const created = await http<Chat>(
|
||||
'/api/v1/chats',
|
||||
json(
|
||||
{
|
||||
title: `chat-${runId}`,
|
||||
member_ids: [alice.user.id, bob.user.id],
|
||||
},
|
||||
bearer(alice.token),
|
||||
),
|
||||
);
|
||||
expect(created.response.status).toBe(201);
|
||||
const hidden = await http<ApiErrorBody>(
|
||||
`/api/v1/chats/${created.body.id}`,
|
||||
{ headers: bearer(outsider.token) },
|
||||
);
|
||||
expectError(hidden, 404, 'not_found');
|
||||
});
|
||||
|
||||
it('keeps sender server-owned and makes writes visible to a second session', async () => {
|
||||
const alice = await actor();
|
||||
const secondSession = (await login(alice.user)).token;
|
||||
const chat = await http<Chat>(
|
||||
'/api/v1/chats',
|
||||
json(
|
||||
{ title: `messages-${runId}`, member_ids: [alice.user.id] },
|
||||
bearer(alice.token),
|
||||
),
|
||||
);
|
||||
expect(chat.response.status).toBe(201);
|
||||
const blank = await http<ApiErrorBody>(
|
||||
`/api/v1/chats/${chat.body.id}/messages`,
|
||||
json(
|
||||
{ text: ' \n\t', sender_id: randomUUID() },
|
||||
messageHeaders(alice.token),
|
||||
),
|
||||
);
|
||||
expectError(blank, 400, 'invalid_request');
|
||||
const spoof = await http<ApiErrorBody>(
|
||||
`/api/v1/chats/${chat.body.id}/messages`,
|
||||
json(
|
||||
{ text: 'hello', sender_id: randomUUID() },
|
||||
messageHeaders(alice.token),
|
||||
),
|
||||
);
|
||||
expectError(spoof, 400, 'invalid_request');
|
||||
await http(`/api/v1/chats/${chat.body.id}/messages?limit=50`, {
|
||||
headers: bearer(secondSession),
|
||||
});
|
||||
const sent = await http<Message>(
|
||||
`/api/v1/chats/${chat.body.id}/messages`,
|
||||
json({ text: 'hello' }, messageHeaders(alice.token)),
|
||||
);
|
||||
expect(sent.response.status).toBe(201);
|
||||
expect(sent.body.sender_id).toBe(alice.user.id);
|
||||
const page = await http<Page<Message>>(
|
||||
`/api/v1/chats/${chat.body.id}/messages?limit=50`,
|
||||
{ headers: bearer(secondSession) },
|
||||
);
|
||||
expect(page.response.status).toBe(200);
|
||||
expect(page.body.items.map((item) => item.id)).toContain(sent.body.id);
|
||||
});
|
||||
|
||||
it('validates cursor, limits, malformed JSON, and paginates without repeats', async () => {
|
||||
const alice = await actor();
|
||||
const chat = await http<Chat>(
|
||||
'/api/v1/chats',
|
||||
json(
|
||||
{ title: `pages-${runId}`, member_ids: [alice.user.id] },
|
||||
bearer(alice.token),
|
||||
),
|
||||
);
|
||||
for (const text of ['one', 'two', 'three']) {
|
||||
const sent = await http(
|
||||
`/api/v1/chats/${chat.body.id}/messages`,
|
||||
json({ text }, messageHeaders(alice.token)),
|
||||
);
|
||||
expect(sent.response.status).toBe(201);
|
||||
}
|
||||
const invalidLimit = await http<ApiErrorBody>(
|
||||
`/api/v1/chats/${chat.body.id}/messages?limit=101`,
|
||||
{ headers: bearer(alice.token) },
|
||||
);
|
||||
expectError(invalidLimit, 400, 'invalid_request');
|
||||
const invalidCursor = await http<ApiErrorBody>(
|
||||
`/api/v1/chats/${chat.body.id}/messages?cursor=not-a-cursor`,
|
||||
{ headers: bearer(alice.token) },
|
||||
);
|
||||
expectError(invalidCursor, 400, 'invalid_request');
|
||||
const rolledOver = http<ApiErrorBody>(
|
||||
`/api/v1/chats/${chat.body.id}/messages?cursor=${encodeURIComponent(
|
||||
Buffer.from(
|
||||
JSON.stringify({
|
||||
scope: `messages:${chat.body.id}`,
|
||||
created_at: '2026-02-31T00:00:00.000Z',
|
||||
id: randomUUID(),
|
||||
}),
|
||||
'utf8',
|
||||
).toString('base64url'),
|
||||
)}`,
|
||||
{ headers: bearer(alice.token) },
|
||||
);
|
||||
expectError(await rolledOver, 400, 'invalid_request');
|
||||
const malformed = await http<ApiErrorBody>('/api/v1/users', {
|
||||
method: 'POST',
|
||||
headers: { 'content-type': 'application/json' },
|
||||
body: '{',
|
||||
});
|
||||
expectError(malformed, 400, 'invalid_request');
|
||||
const first = await http<Page<Message>>(
|
||||
`/api/v1/chats/${chat.body.id}/messages?limit=2`,
|
||||
{ headers: bearer(alice.token) },
|
||||
);
|
||||
expect(first.body.items).toHaveLength(2);
|
||||
const second = await http<Page<Message>>(
|
||||
`/api/v1/chats/${chat.body.id}/messages?limit=2&cursor=${encodeURIComponent(first.body.next_cursor!)}`,
|
||||
{ headers: bearer(alice.token) },
|
||||
);
|
||||
expect(second.body.items).toHaveLength(1);
|
||||
expect(
|
||||
new Set(
|
||||
[...first.body.items, ...second.body.items].map(
|
||||
(item) => item.id,
|
||||
),
|
||||
).size,
|
||||
).toBe(3);
|
||||
});
|
||||
|
||||
it.skipIf(process.env.SESSION_TTL_SECONDS !== '2')(
|
||||
'expires sessions with TTL=2',
|
||||
async () => {
|
||||
const user = await register();
|
||||
const session = await login(user);
|
||||
await sleep(2300);
|
||||
const expired = await http<ApiErrorBody>('/api/v1/users/me', {
|
||||
headers: bearer(session.token),
|
||||
});
|
||||
expectError(expired, 401, 'unauthorized');
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
// lab3: the Idempotency-Key contract of POST /chats/{id}/messages. The suite is
|
||||
// black-box, so these assertions hold for one replica and for a load-balanced
|
||||
// fleet alike.
|
||||
describe('message idempotency', () => {
|
||||
async function chatFor(token: string, memberIds: string[]): Promise<string> {
|
||||
const created = await http<Chat>(
|
||||
'/api/v1/chats',
|
||||
json({ title: `idempotency-${runId}`, member_ids: memberIds }, bearer(token)),
|
||||
);
|
||||
expect(created.response.status).toBe(201);
|
||||
return created.body.id;
|
||||
}
|
||||
|
||||
async function textsIn(chatId: string, token: string): Promise<string[]> {
|
||||
const page = await http<Page<Message>>(
|
||||
`/api/v1/chats/${chatId}/messages?limit=100`,
|
||||
{ headers: bearer(token) },
|
||||
);
|
||||
expect(page.response.status).toBe(200);
|
||||
return page.body.items.map((item) => item.text);
|
||||
}
|
||||
|
||||
it('requires a well-formed Idempotency-Key', async () => {
|
||||
const alice = await actor();
|
||||
const chatId = await chatFor(alice.token, [alice.user.id]);
|
||||
const path = `/api/v1/chats/${chatId}/messages`;
|
||||
const missing = await http<ApiErrorBody>(
|
||||
path,
|
||||
json({ text: 'без ключа' }, bearer(alice.token)),
|
||||
);
|
||||
expectError(missing, 400, 'invalid_request');
|
||||
for (const key of ['has space', 'comma,separated', 'x'.repeat(129)]) {
|
||||
const malformed = await http<ApiErrorBody>(
|
||||
path,
|
||||
json({ text: 'плохой ключ' }, { ...bearer(alice.token), 'idempotency-key': key }),
|
||||
);
|
||||
expectError(malformed, 400, 'invalid_request');
|
||||
}
|
||||
});
|
||||
|
||||
it('replays the stored response and conflicts on a different body', async () => {
|
||||
const alice = await actor();
|
||||
const chatId = await chatFor(alice.token, [alice.user.id]);
|
||||
const path = `/api/v1/chats/${chatId}/messages`;
|
||||
const key = randomUUID().replaceAll('-', '');
|
||||
const headers = { ...bearer(alice.token), 'idempotency-key': key };
|
||||
const text = `повтор ${runId}`;
|
||||
|
||||
const first = await http<Message>(path, json({ text }, headers));
|
||||
expect(first.response.status).toBe(201);
|
||||
const replayed = await http<Message>(path, json({ text }, headers));
|
||||
expect(replayed.response.status).toBe(201);
|
||||
expect(replayed.body).toEqual(first.body);
|
||||
|
||||
const conflict = await http<ApiErrorBody>(
|
||||
path,
|
||||
json({ text: 'другой body' }, headers),
|
||||
);
|
||||
expectError(conflict, 409, 'conflict');
|
||||
|
||||
expect(await textsIn(chatId, alice.token)).toEqual([text]);
|
||||
});
|
||||
|
||||
it('creates exactly one message for concurrent requests with one key', async () => {
|
||||
const alice = await actor();
|
||||
const chatId = await chatFor(alice.token, [alice.user.id]);
|
||||
const path = `/api/v1/chats/${chatId}/messages`;
|
||||
const headers = { ...bearer(alice.token), ...idempotencyKey() };
|
||||
const text = `конкурентный повтор ${runId}`;
|
||||
|
||||
const results = await Promise.all(
|
||||
Array.from({ length: 8 }, () => http<Message>(path, json({ text }, headers))),
|
||||
);
|
||||
for (const result of results) expect(result.response.status).toBe(201);
|
||||
const ids = new Set(results.map((result) => result.body.id));
|
||||
expect(
|
||||
ids.size,
|
||||
'one key must resolve to exactly one message across replicas',
|
||||
).toBe(1);
|
||||
expect(await textsIn(chatId, alice.token)).toEqual([text]);
|
||||
});
|
||||
|
||||
it('scopes the key per user and per chat path', async () => {
|
||||
const alice = await actor();
|
||||
const bob = await actor();
|
||||
const outsider = await actor();
|
||||
const chatId = await chatFor(alice.token, [alice.user.id, bob.user.id]);
|
||||
const path = `/api/v1/chats/${chatId}/messages`;
|
||||
const key = randomUUID().replaceAll('-', '');
|
||||
const foreignChatId = await chatFor(outsider.token, [outsider.user.id]);
|
||||
|
||||
const denied = await http<ApiErrorBody>(
|
||||
`/api/v1/chats/${foreignChatId}/messages`,
|
||||
json({ text: 'чужое' }, { ...bearer(alice.token), 'idempotency-key': key }),
|
||||
);
|
||||
expectError(denied, 404, 'not_found');
|
||||
|
||||
const mine = await http<Message>(
|
||||
path,
|
||||
json({ text: 'своё' }, { ...bearer(alice.token), 'idempotency-key': key }),
|
||||
);
|
||||
expect(mine.response.status).toBe(201);
|
||||
const other = await http<Message>(
|
||||
path,
|
||||
json({ text: 'своё' }, { ...bearer(bob.token), 'idempotency-key': key }),
|
||||
);
|
||||
expect(other.response.status).toBe(201);
|
||||
expect(other.body.id).not.toBe(mine.body.id);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,299 @@
|
||||
import { execFile } from 'node:child_process';
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import { setTimeout as sleep } from 'node:timers/promises';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { promisify } from 'node:util';
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
||||
import type { SessionResponse } from '../src/auth/auth.service.js';
|
||||
import type { Chat } from '../src/chats/chat.js';
|
||||
import type { ApiErrorBody } from '../src/common/errors/api-error.js';
|
||||
import type { Page } from '../src/common/http/page.js';
|
||||
import type { Message } from '../src/messages/message.js';
|
||||
import type { User } from '../src/users/user.js';
|
||||
|
||||
// Automated counterpart of the manual Redis/PostgreSQL outage checks: the suite
|
||||
// stops a dependency of the Compose stand, asserts a bounded 503 (never a 500,
|
||||
// never a trusted anonymous request, never a leaked driver error) and then
|
||||
// restarts it to prove recovery without data loss.
|
||||
//
|
||||
// It is opt-in because it needs control over the Docker Compose project:
|
||||
// make test-dependencies
|
||||
// cd app && E2E_DEPENDENCY_FAULTS=1 npm run test:dependencies
|
||||
const enabled = process.env.E2E_DEPENDENCY_FAULTS === '1';
|
||||
const baseUrl = (process.env.API_BASE_URL ?? 'http://localhost:8080').replace(
|
||||
/\/+$/u,
|
||||
'',
|
||||
);
|
||||
const composeDir =
|
||||
process.env.E2E_COMPOSE_DIR ??
|
||||
fileURLToPath(new URL('../..', import.meta.url));
|
||||
const composeEnvFile = process.env.E2E_COMPOSE_ENV_FILE ?? '.env';
|
||||
const redisService = process.env.E2E_REDIS_SERVICE ?? 'redis';
|
||||
const postgresService = process.env.E2E_POSTGRES_SERVICE ?? 'postgres';
|
||||
const password = 'outage-check:пароль🔐';
|
||||
const runId = randomUUID().replaceAll('-', '').slice(0, 12);
|
||||
// A request that reaches a stopped database waits for the pool connection
|
||||
// timeout, so every outage step costs up to DATABASE_CONNECTION_TIMEOUT_MS.
|
||||
const outagedRequestBudgetMs = 180_000;
|
||||
|
||||
const execFileAsync = promisify(execFile);
|
||||
|
||||
type Result<T> = { body: T; text: string; response: Response };
|
||||
|
||||
async function compose(...args: string[]): Promise<void> {
|
||||
await execFileAsync(
|
||||
'docker',
|
||||
['compose', '--env-file', composeEnvFile, ...args],
|
||||
{ cwd: composeDir, timeout: 120_000 },
|
||||
);
|
||||
}
|
||||
|
||||
async function request<T = unknown>(
|
||||
path: string,
|
||||
init: RequestInit = {},
|
||||
): Promise<Result<T>> {
|
||||
const response = await fetch(`${baseUrl}${path}`, init);
|
||||
const text = await response.text();
|
||||
return { body: (text ? JSON.parse(text) : undefined) as T, text, response };
|
||||
}
|
||||
|
||||
function json(
|
||||
body: unknown,
|
||||
headers: Record<string, string> = {},
|
||||
): RequestInit {
|
||||
return {
|
||||
method: 'POST',
|
||||
headers: { 'content-type': 'application/json', ...headers },
|
||||
body: JSON.stringify(body),
|
||||
};
|
||||
}
|
||||
|
||||
function bearer(token: string): Record<string, string> {
|
||||
return { authorization: `Bearer ${token}` };
|
||||
}
|
||||
|
||||
// POST messages needs a unique Idempotency-Key in lab3+; outage checks only
|
||||
// need the write path, not replay semantics.
|
||||
function messageHeaders(token: string): Record<string, string> {
|
||||
return {
|
||||
...bearer(token),
|
||||
'idempotency-key': randomUUID().replaceAll('-', ''),
|
||||
};
|
||||
}
|
||||
|
||||
function basic(username: string, secret: string): string {
|
||||
return `Basic ${Buffer.from(`${username}:${secret}`, 'utf8').toString('base64')}`;
|
||||
}
|
||||
|
||||
// The dependencies recover asynchronously, so readiness is polled instead of
|
||||
// asserted right after docker compose returns.
|
||||
async function waitForReadiness(
|
||||
expected: number,
|
||||
timeoutMs = 90_000,
|
||||
): Promise<void> {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
let last: number | string = 'no response';
|
||||
for (;;) {
|
||||
try {
|
||||
const probe = await request('/health/ready');
|
||||
last = probe.response.status;
|
||||
if (probe.response.status === expected) return;
|
||||
} catch (error) {
|
||||
last = error instanceof Error ? error.message : 'request failed';
|
||||
}
|
||||
if (Date.now() > deadline)
|
||||
throw new Error(
|
||||
`readiness never became ${expected} within ${timeoutMs}ms (last: ${String(last)})`,
|
||||
);
|
||||
await sleep(250);
|
||||
}
|
||||
}
|
||||
|
||||
function expectBoundedOutage(result: Result<ApiErrorBody>): void {
|
||||
expect(result.response.status).toBe(503);
|
||||
expect(result.body.error.code).toBe('unavailable');
|
||||
expect(result.body.error.message).toBe('Service unavailable');
|
||||
expect(result.body.error.request_id).toBe(
|
||||
result.response.headers.get('x-request-id'),
|
||||
);
|
||||
// A bounded error must not leak driver details, SQL text or a stack trace.
|
||||
expect(result.text).not.toMatch(
|
||||
/ECONNREFUSED|ECONNRESET|Connection terminated|pg\.|node_modules|at .*\(.+:\d+:\d+\)/u,
|
||||
);
|
||||
}
|
||||
|
||||
async function historyOf(
|
||||
chatId: string,
|
||||
token: string,
|
||||
): Promise<Result<Page<Message>>> {
|
||||
return request<Page<Message>>(`/api/v1/chats/${chatId}/messages?limit=100`, {
|
||||
headers: bearer(token),
|
||||
});
|
||||
}
|
||||
|
||||
describe.skipIf(!enabled)('dependency outages', () => {
|
||||
let user: User;
|
||||
let token: string;
|
||||
let chat: Chat;
|
||||
let message: Message;
|
||||
|
||||
beforeAll(async () => {
|
||||
await compose('up', '-d');
|
||||
await waitForReadiness(200);
|
||||
const username = `outage_${runId}`;
|
||||
const registered = await request<User>(
|
||||
'/api/v1/users',
|
||||
json({ username, display_name: 'Отказ зависимости', password }),
|
||||
);
|
||||
expect(registered.response.status).toBe(201);
|
||||
user = registered.body;
|
||||
const session = await request<SessionResponse>(
|
||||
'/api/v1/auth/sessions',
|
||||
{
|
||||
method: 'POST',
|
||||
headers: { authorization: basic(username, password) },
|
||||
},
|
||||
);
|
||||
expect(session.response.status).toBe(201);
|
||||
token = session.body.token;
|
||||
const created = await request<Chat>(
|
||||
'/api/v1/chats',
|
||||
json(
|
||||
{ title: `outage-${runId}`, member_ids: [user.id] },
|
||||
bearer(token),
|
||||
),
|
||||
);
|
||||
expect(created.response.status).toBe(201);
|
||||
chat = created.body;
|
||||
const sent = await request<Message>(
|
||||
`/api/v1/chats/${chat.id}/messages`,
|
||||
json({ text: 'Сообщение до отказа' }, messageHeaders(token)),
|
||||
);
|
||||
expect(sent.response.status).toBe(201);
|
||||
message = sent.body;
|
||||
}, outagedRequestBudgetMs);
|
||||
|
||||
afterAll(async () => {
|
||||
// Always restore the stand, even when an assertion failed mid-outage.
|
||||
await compose('start', redisService);
|
||||
await compose('start', postgresService);
|
||||
await waitForReadiness(200);
|
||||
}, outagedRequestBudgetMs);
|
||||
|
||||
it(
|
||||
'serves bounded 503 for the Redis outage and recovers the session',
|
||||
async () => {
|
||||
await compose('stop', redisService);
|
||||
|
||||
const live = await request('/health/live');
|
||||
expect(live.response.status).toBe(200);
|
||||
await waitForReadiness(503);
|
||||
|
||||
expectBoundedOutage(await request<ApiErrorBody>('/health/ready'));
|
||||
|
||||
expectBoundedOutage(
|
||||
await request<ApiErrorBody>('/api/v1/users/me', {
|
||||
headers: bearer(token),
|
||||
}),
|
||||
);
|
||||
|
||||
expectBoundedOutage(
|
||||
await request<ApiErrorBody>('/api/v1/auth/sessions', {
|
||||
method: 'POST',
|
||||
headers: { authorization: basic(user.username, password) },
|
||||
}),
|
||||
);
|
||||
|
||||
// A request without a session must stay unauthorized during an outage:
|
||||
// the outage may not turn an anonymous caller into a trusted one.
|
||||
const anonymous = await request<ApiErrorBody>('/api/v1/chats', {
|
||||
headers: { 'x-user-id': user.id },
|
||||
});
|
||||
expect(anonymous.response.status).toBe(401);
|
||||
expect(anonymous.body.error.code).toBe('unauthorized');
|
||||
|
||||
await compose('start', redisService);
|
||||
await waitForReadiness(200);
|
||||
|
||||
// Sessions live in Redis with persistence, so the old token still works.
|
||||
const recovered = await request<User>('/api/v1/users/me', {
|
||||
headers: bearer(token),
|
||||
});
|
||||
expect(recovered.response.status).toBe(200);
|
||||
expect(recovered.body.id).toBe(user.id);
|
||||
|
||||
const history = await historyOf(chat.id, token);
|
||||
expect(history.response.status).toBe(200);
|
||||
expect(history.body.items.map((item) => item.id)).toContain(
|
||||
message.id,
|
||||
);
|
||||
},
|
||||
outagedRequestBudgetMs,
|
||||
);
|
||||
|
||||
it(
|
||||
'serves bounded 503 for the PostgreSQL outage and keeps confirmed data',
|
||||
async () => {
|
||||
await compose('stop', postgresService);
|
||||
|
||||
const live = await request('/health/live');
|
||||
expect(live.response.status).toBe(200);
|
||||
await waitForReadiness(503);
|
||||
|
||||
expectBoundedOutage(await request<ApiErrorBody>('/health/ready'));
|
||||
|
||||
// Redis still answers, so these requests reach the database layer.
|
||||
expectBoundedOutage(
|
||||
await request<ApiErrorBody>('/api/v1/users/me', {
|
||||
headers: bearer(token),
|
||||
}),
|
||||
);
|
||||
|
||||
expectBoundedOutage(
|
||||
await request<ApiErrorBody>('/api/v1/chats', {
|
||||
headers: bearer(token),
|
||||
}),
|
||||
);
|
||||
|
||||
expectBoundedOutage(
|
||||
await request<ApiErrorBody>(
|
||||
`/api/v1/chats/${chat.id}/messages?limit=100`,
|
||||
{ headers: bearer(token) },
|
||||
),
|
||||
);
|
||||
|
||||
expectBoundedOutage(
|
||||
await request<ApiErrorBody>(
|
||||
'/api/v1/users',
|
||||
json({
|
||||
username: `outage_${runId}_late`,
|
||||
display_name: 'Отказ зависимости',
|
||||
password,
|
||||
}),
|
||||
),
|
||||
);
|
||||
|
||||
await compose('start', postgresService);
|
||||
await waitForReadiness(200);
|
||||
|
||||
const recovered = await request<User>('/api/v1/users/me', {
|
||||
headers: bearer(token),
|
||||
});
|
||||
expect(recovered.response.status).toBe(200);
|
||||
expect(recovered.body.id).toBe(user.id);
|
||||
|
||||
const history = await historyOf(chat.id, token);
|
||||
expect(history.response.status).toBe(200);
|
||||
expect(history.body.items.map((item) => item.id)).toContain(
|
||||
message.id,
|
||||
);
|
||||
|
||||
const sent = await request<Message>(
|
||||
`/api/v1/chats/${chat.id}/messages`,
|
||||
json({ text: 'Сообщение после отказа' }, messageHeaders(token)),
|
||||
);
|
||||
expect(sent.response.status).toBe(201);
|
||||
},
|
||||
outagedRequestBudgetMs,
|
||||
);
|
||||
});
|
||||
@@ -0,0 +1,8 @@
|
||||
{
|
||||
"extends": "./tsconfig.json",
|
||||
"compilerOptions": {
|
||||
"rootDir": "./src"
|
||||
},
|
||||
"include": ["src"],
|
||||
"exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"module": "nodenext",
|
||||
"moduleResolution": "nodenext",
|
||||
"resolvePackageJsonExports": true,
|
||||
"esModuleInterop": true,
|
||||
"isolatedModules": true,
|
||||
"declaration": true,
|
||||
"removeComments": true,
|
||||
"emitDecoratorMetadata": true,
|
||||
"experimentalDecorators": true,
|
||||
"allowSyntheticDefaultImports": true,
|
||||
"target": "ES2023",
|
||||
"sourceMap": true,
|
||||
"outDir": "./dist",
|
||||
"incremental": true,
|
||||
"skipLibCheck": true,
|
||||
"strict": true,
|
||||
"strictPropertyInitialization": false,
|
||||
"types": ["vitest/globals", "node"]
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
import { defineConfig } from 'vitest/config';
|
||||
import tsconfigPaths from 'vite-tsconfig-paths';
|
||||
|
||||
export default defineConfig({
|
||||
plugins: [tsconfigPaths()],
|
||||
test: {
|
||||
globals: true,
|
||||
root: './',
|
||||
include: ['test/*.e2e-spec.ts'],
|
||||
testTimeout: 30_000,
|
||||
hookTimeout: 30_000,
|
||||
sequence: { concurrent: false },
|
||||
},
|
||||
});
|
||||
@@ -0,0 +1,13 @@
|
||||
import { defineConfig } from 'vitest/config';
|
||||
import tsconfigPaths from 'vite-tsconfig-paths';
|
||||
|
||||
export default defineConfig({
|
||||
// Resolves the path aliases declared in tsconfig.json, including the ones
|
||||
// added by `nest g library`.
|
||||
plugins: [tsconfigPaths()],
|
||||
test: {
|
||||
globals: true,
|
||||
root: './',
|
||||
include: ['**/*.spec.ts'],
|
||||
},
|
||||
});
|
||||
@@ -0,0 +1,63 @@
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.4-alpine
|
||||
environment:
|
||||
POSTGRES_DB: ${POSTGRES_DB:-messenger}
|
||||
POSTGRES_USER: ${POSTGRES_USER:-messenger}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env}
|
||||
volumes:
|
||||
- postgres-data:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
|
||||
redis:
|
||||
image: redis:7.4.2-alpine
|
||||
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"]
|
||||
volumes:
|
||||
- redis-data:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
|
||||
migrate:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
image: mtusi-messenger:lab3
|
||||
command: ["node", "dist/database/migration.runner.js"]
|
||||
env_file: [.env]
|
||||
depends_on:
|
||||
postgres: { condition: service_healthy }
|
||||
redis: { condition: service_healthy }
|
||||
restart: "no"
|
||||
|
||||
api:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
image: mtusi-messenger:lab3
|
||||
ports:
|
||||
- "${APP_PUBLIC_PORT:-8080}:${APP_PORT:-8080}"
|
||||
env_file: [.env]
|
||||
environment:
|
||||
CACHE_MODE: ${CACHE_MODE:-protected}
|
||||
CACHE_MISS_DELAY_MS: ${CACHE_MISS_DELAY_MS:-0}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
depends_on:
|
||||
migrate: { condition: service_completed_successfully }
|
||||
postgres: { condition: service_healthy }
|
||||
redis: { condition: service_healthy }
|
||||
healthcheck:
|
||||
test: ["CMD", "node", "-e", "fetch('http://127.0.0.1:'+ (process.env.APP_PORT||8080) + '/health/ready').then(r=>{if(!r.ok)process.exit(1)}).catch(()=>process.exit(1))"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
|
||||
volumes:
|
||||
postgres-data:
|
||||
redis-data:
|
||||
Executable
+8
@@ -0,0 +1,8 @@
|
||||
#!/usr/bin/env bash
|
||||
# Restart hook for `make test-persistence ACTION_SCRIPT=scripts/restart.sh`.
|
||||
# Semantic and evidence notes: tests/README.md ("Проверка сохранности") and REPORT.md.
|
||||
set -euo pipefail
|
||||
|
||||
compose=(docker compose --env-file .env)
|
||||
"${compose[@]}" restart postgres redis api
|
||||
"${compose[@]}" up -d --no-recreate --no-deps --wait postgres redis api
|
||||
Reference in New Issue
Block a user