init: minimum from lab2

This commit is contained in:
2026-11-01 13:37:02 +03:00
parent 0ab3a341aa
commit b4d1497d1c
66 changed files with 13594 additions and 0 deletions
+4
View File
@@ -16,5 +16,9 @@ backups
.venv
__pycache__
node_modules
dist
coverage
evidence
.DS_Store
.idea
.vscode
+2
View File
@@ -0,0 +1,2 @@
* text=auto eol=lf
*.png binary
+6
View File
@@ -0,0 +1,6 @@
{
"useTabs": true,
"tabWidth": 4,
"singleQuote": true,
"trailingComma": "all"
}
+44
View File
@@ -0,0 +1,44 @@
# syntax=docker/dockerfile:1
FROM node:20.17.0-slim AS base
RUN apt-get update \
&& apt-get install -y --no-install-recommends openssl \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /app
FROM base AS deps
COPY package.json package-lock.json ./
RUN npm ci
FROM deps AS build
COPY prisma ./prisma
RUN npx prisma generate
COPY tsconfig.json tsconfig.build.json nest-cli.json ./
COPY src ./src
RUN npm run build
FROM build AS test
COPY contracts/openapi.json ./contracts/openapi.json
COPY test ./test
CMD ["npm", "test"]
FROM build AS migrate
CMD ["sh", "-c", "DATABASE_URL=\"$(cat \"$DATABASE_URL_FILE\")\" exec npx prisma migrate deploy"]
FROM build AS prod-deps
RUN npm prune --omit=dev
FROM base AS runtime
ENV NODE_ENV=production
COPY package.json ./
COPY --from=prod-deps /app/node_modules ./node_modules
COPY --from=build /app/dist ./dist
COPY contracts/openapi.json ./contracts/openapi.json
USER node
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD node -e "require('http').get('http://127.0.0.1:8080/health/live',r=>process.exit(r.statusCode===200?0:1)).on('error',()=>process.exit(1))"
CMD ["node", "dist/main.js"]
+34
View File
@@ -0,0 +1,34 @@
name: messenger-lab3-test
services:
postgres:
image: postgres:17.2-alpine
environment:
POSTGRES_USER: test
POSTGRES_PASSWORD: test
POSTGRES_DB: messenger_test
tmpfs:
- /var/lib/postgresql/data
healthcheck:
test: ["CMD", "pg_isready", "-U", "test", "-d", "messenger_test"]
interval: 2s
timeout: 3s
retries: 15
redis:
image: redis:7.4.1-alpine
command: ["redis-server", "--save", "", "--appendonly", "no"]
tests:
build:
context: .
target: test
image: mtusi-messenger-lab3-test:dev
environment:
DATABASE_URL: postgresql://test:test@postgres:5432/messenger_test?connection_limit=20
CACHE_URL: redis://redis:6379/0
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_started
+109
View File
@@ -0,0 +1,109 @@
name: messenger-lab3
services:
secrets-init:
image: alpine:3.20.3
volumes:
- secrets:/secrets
command:
- sh
- -ec
- |
cd /secrets
[ -s pg_password ] || head -c 24 /dev/urandom | od -An -tx1 | tr -d ' \n' > pg_password
printf 'postgresql://messenger:%s@postgres:5432/messenger?connection_limit=10&pool_timeout=5&connect_timeout=5&socket_timeout=10&application_name=api&options=-c%%20statement_timeout%%3D5000' "$$(cat pg_password)" > database_url
[ -s redis_password ] || head -c 24 /dev/urandom | od -An -tx1 | tr -d ' \n' > redis_password
printf 'redis://:%s@redis:6379/0' "$$(cat redis_password)" > cache_url
chmod 0444 pg_password database_url redis_password cache_url
postgres:
image: postgres:17.2-alpine
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/pg_password
volumes:
- pgdata:/var/lib/postgresql/data
- secrets:/run/secrets:ro
healthcheck:
test: ["CMD", "pg_isready", "-U", "messenger", "-d", "messenger"]
interval: 5s
timeout: 3s
retries: 10
depends_on:
secrets-init:
condition: service_completed_successfully
restart: unless-stopped
redis:
image: redis:7.4.1-alpine
user: redis
command:
- sh
- -c
- exec redis-server --save '' --appendonly no --maxmemory 64mb --maxmemory-policy allkeys-lru --requirepass "$$(cat /run/secrets/redis_password)"
volumes:
- secrets:/run/secrets:ro
healthcheck:
test: ["CMD-SHELL", "redis-cli --no-auth-warning -a \"$$(cat /run/secrets/redis_password)\" ping | grep -q PONG"]
interval: 5s
timeout: 3s
retries: 10
depends_on:
secrets-init:
condition: service_completed_successfully
restart: unless-stopped
migrate:
build:
context: .
target: migrate
image: mtusi-messenger-lab3-migrate:dev
environment:
DATABASE_URL_FILE: /run/secrets/database_url
volumes:
- secrets:/run/secrets:ro
depends_on:
postgres:
condition: service_healthy
api:
build:
context: .
target: runtime
image: mtusi-messenger-lab3-api:dev
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
ports:
- "127.0.0.1:${APP_PORT:-8080}:8080"
volumes:
- secrets:/run/secrets:ro
depends_on:
migrate:
condition: service_completed_successfully
redis:
condition: service_started
restart: unless-stopped
tools:
profiles: [tools]
build:
dockerfile_inline: |
FROM docker:27.3.1-cli
RUN apk add --no-cache python3 make git && git config --global --add safe.directory /work
WORKDIR /work
image: mtusi-messenger-lab3-tools:dev
environment:
BASE_URL: http://api:8080
volumes:
- .:/work
- /var/run/docker.sock:/var/run/docker.sock
volumes:
pgdata:
secrets:
+8
View File
@@ -0,0 +1,8 @@
{
"$schema": "https://json.schemastore.org/nest-cli",
"collection": "@nestjs/schematics",
"sourceRoot": "src",
"compilerOptions": {
"deleteOutDir": true
}
}
+10106
View File
File diff suppressed because it is too large Load Diff
+50
View File
@@ -0,0 +1,50 @@
{
"name": "mtusi-messenger-lab3",
"version": "1.0.0",
"description": "Lab 1: in-memory messenger API (NestJS + Fastify)",
"private": true,
"license": "UNLICENSED",
"scripts": {
"build": "nest build",
"start": "node dist/main.js",
"start:dev": "nest start --watch",
"lint": "eslint \"{src,test}/**/*.ts\"",
"test": "jest --config ./test/jest-e2e.json",
"test:watch": "jest --config ./test/jest-e2e.json --watch"
},
"dependencies": {
"@fastify/static": "7.0.4",
"@nestjs/common": "^10.4.15",
"@nestjs/core": "^10.4.15",
"@nestjs/platform-fastify": "^10.4.15",
"@nestjs/swagger": "7.4.2",
"@prisma/client": "6.1.0",
"argon2": "0.41.1",
"class-transformer": "^0.5.1",
"class-validator": "^0.14.1",
"ioredis": "5.4.1",
"reflect-metadata": "^0.2.2",
"rxjs": "^7.8.1"
},
"devDependencies": {
"@nestjs/cli": "^10.4.9",
"@nestjs/schematics": "^10.2.3",
"@nestjs/testing": "^10.4.15",
"@types/jest": "^29.5.14",
"@types/node": "^20.17.9",
"@types/supertest": "^6.0.2",
"@typescript-eslint/eslint-plugin": "^8.18.1",
"@typescript-eslint/parser": "^8.18.1",
"ajv": "8.12.0",
"eslint": "^8.57.1",
"jest": "^29.7.0",
"prisma": "6.1.0",
"source-map-support": "^0.5.21",
"supertest": "^7.0.0",
"ts-jest": "^29.2.5",
"ts-loader": "^9.5.1",
"ts-node": "^10.9.2",
"tsconfig-paths": "^4.2.0",
"typescript": "^5.7.2"
}
}
@@ -0,0 +1,50 @@
CREATE TABLE "users" (
"id" UUID NOT NULL,
"username" VARCHAR(32) NOT NULL,
"display_name" VARCHAR(100) NOT NULL,
"created_at" TIMESTAMPTZ(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "users_pkey" PRIMARY KEY ("id"),
CONSTRAINT "users_username_format" CHECK ("username" ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT "users_display_name_not_blank" CHECK (btrim("display_name") <> '')
);
CREATE TABLE "chats" (
"id" UUID NOT NULL,
"title" VARCHAR(100) NOT NULL,
"created_at" TIMESTAMPTZ(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "chats_pkey" PRIMARY KEY ("id"),
CONSTRAINT "chats_title_not_blank" CHECK (btrim("title") <> '')
);
CREATE TABLE "chat_members" (
"chat_id" UUID NOT NULL,
"user_id" UUID NOT NULL,
CONSTRAINT "chat_members_pkey" PRIMARY KEY ("chat_id","user_id")
);
CREATE TABLE "messages" (
"id" UUID NOT NULL,
"chat_id" UUID NOT NULL,
"sender_id" UUID NOT NULL,
"text" VARCHAR(4000) NOT NULL,
"created_at" TIMESTAMPTZ(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "messages_pkey" PRIMARY KEY ("id")
);
CREATE UNIQUE INDEX "users_username_key" ON "users"("username");
CREATE INDEX "chat_members_user_id_idx" ON "chat_members"("user_id");
CREATE INDEX "messages_chat_id_created_at_id_idx" ON "messages"("chat_id", "created_at", "id");
ALTER TABLE "chat_members" ADD CONSTRAINT "chat_members_chat_id_fkey" FOREIGN KEY ("chat_id") REFERENCES "chats"("id") ON DELETE CASCADE ON UPDATE CASCADE;
ALTER TABLE "chat_members" ADD CONSTRAINT "chat_members_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
ALTER TABLE "messages" ADD CONSTRAINT "messages_chat_id_fkey" FOREIGN KEY ("chat_id") REFERENCES "chats"("id") ON DELETE CASCADE ON UPDATE CASCADE;
ALTER TABLE "messages" ADD CONSTRAINT "messages_sender_id_fkey" FOREIGN KEY ("sender_id") REFERENCES "users"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
@@ -0,0 +1,14 @@
ALTER TABLE "users" ADD COLUMN "password_hash" TEXT NOT NULL;
CREATE TABLE "sessions" (
"token_hash" CHAR(64) NOT NULL,
"user_id" UUID NOT NULL,
"expires_at" TIMESTAMPTZ(3) NOT NULL,
"created_at" TIMESTAMPTZ(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT "sessions_pkey" PRIMARY KEY ("token_hash")
);
CREATE INDEX "sessions_user_id_idx" ON "sessions"("user_id");
ALTER TABLE "sessions" ADD CONSTRAINT "sessions_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+3
View File
@@ -0,0 +1,3 @@
# Please do not edit this file manually
# It should be added in your version-control system (i.e. Git)
provider = "postgresql"
+66
View File
@@ -0,0 +1,66 @@
generator client {
provider = "prisma-client-js"
}
datasource db {
provider = "postgresql"
url = env("DATABASE_URL")
}
model User {
id String @id @default(uuid()) @db.Uuid
username String @unique @db.VarChar(32)
displayName String @map("display_name") @db.VarChar(100)
passwordHash String @map("password_hash")
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)
memberships ChatMember[]
messages Message[]
sessions Session[]
@@map("users")
}
model Session {
tokenHash String @id @map("token_hash") @db.Char(64)
userId String @map("user_id") @db.Uuid
expiresAt DateTime @map("expires_at") @db.Timestamptz(3)
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)
user User @relation(fields: [userId], references: [id], onDelete: Cascade)
@@index([userId])
@@map("sessions")
}
model Chat {
id String @id @default(uuid()) @db.Uuid
title String @db.VarChar(100)
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)
members ChatMember[]
messages Message[]
@@map("chats")
}
model ChatMember {
chatId String @map("chat_id") @db.Uuid
userId String @map("user_id") @db.Uuid
chat Chat @relation(fields: [chatId], references: [id], onDelete: Cascade)
user User @relation(fields: [userId], references: [id], onDelete: Restrict)
@@id([chatId, userId])
@@index([userId])
@@map("chat_members")
}
model Message {
id String @id @default(uuid()) @db.Uuid
chatId String @map("chat_id") @db.Uuid
senderId String @map("sender_id") @db.Uuid
text String @db.VarChar(4000)
createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)
chat Chat @relation(fields: [chatId], references: [id], onDelete: Cascade)
sender User @relation(fields: [senderId], references: [id], onDelete: Restrict)
@@index([chatId, createdAt, id])
@@map("messages")
}
+64
View File
@@ -0,0 +1,64 @@
#!/usr/bin/env python3
import base64
import json
import os
import sys
import time
import urllib.error
import urllib.request
import uuid
BASE = os.environ.get('BASE_URL', 'http://localhost:8080')
def call(method, path, body=None, headers=None):
data = json.dumps(body).encode() if body is not None else None
content_type = {'Content-Type': 'application/json'} if data else {}
request = urllib.request.Request(BASE + path, data=data, method=method, headers={**content_type, **(headers or {})})
try:
with urllib.request.urlopen(request, timeout=15) as response:
return response.status, json.loads(response.read() or b'null')
except urllib.error.HTTPError as error:
return error.code, json.loads(error.read() or b'null')
except OSError as error:
return 0, str(error)
def ready(timeout=90):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
if call('GET', '/health/ready')[0] == 200:
print('ready')
return
time.sleep(0.5)
sys.exit('not ready within %ds' % timeout)
def status(method, path, authorization=None):
code, body = call(method, path, headers={'Authorization': authorization} if authorization else None)
print(method, path, '(%s)' % (authorization or 'anonymous'), '->', code, json.dumps(body, ensure_ascii=False))
def expiry(ttl):
username = 'expiry_' + uuid.uuid4().hex[:8]
password = 'Expiry-check-' + uuid.uuid4().hex
print('register ->', call('POST', '/api/v1/users', {'username': username, 'display_name': 'Expiry', 'password': password})[0])
credential = base64.b64encode((username + ':' + password).encode()).decode()
code, session = call('POST', '/api/v1/auth/sessions', headers={'Authorization': 'Basic ' + credential})
if code != 201:
sys.exit('login failed: %s %s' % (code, session))
print('login ->', code, 'expires_at:', session['expires_at'])
auth = {'Authorization': 'Bearer ' + session['token']}
print('GET /api/v1/users/me (fresh) ->', call('GET', '/api/v1/users/me', headers=auth)[0])
time.sleep(ttl + 1)
print('GET /api/v1/users/me (after %ds) ->' % (ttl + 1), call('GET', '/api/v1/users/me', headers=auth)[0])
if __name__ == '__main__':
command = sys.argv[1]
if command == 'ready':
ready()
elif command == 'status':
status(*sys.argv[2:5])
elif command == 'expiry':
expiry(int(sys.argv[2]))
+9
View File
@@ -0,0 +1,9 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
started() {
docker inspect -f '{{.Name}} {{.State.Status}} started={{.State.StartedAt}}' $(docker compose ps -q postgres redis api)
}
started
docker compose restart postgres redis api
started
+21
View File
@@ -0,0 +1,21 @@
import { Module } from '@nestjs/common';
import { AuthModule } from './auth/auth.module';
import { CacheModule } from './cache/cache.module';
import { ChatsModule } from './chats/chats.module';
import { DbModule } from './db/db.module';
import { HealthModule } from './health/health.module';
import { MessagesModule } from './messages/messages.module';
import { UsersModule } from './users/users.module';
@Module({
imports: [
DbModule,
CacheModule,
AuthModule,
HealthModule,
UsersModule,
ChatsModule,
MessagesModule,
],
})
export class AppModule {}
+51
View File
@@ -0,0 +1,51 @@
import {
Controller,
Delete,
Headers,
HttpCode,
Post,
Req,
UseGuards,
} from '@nestjs/common';
import { FastifyRequest } from 'fastify';
import { ApiError } from '../common/filters/api-error';
import { toUserResponse, UserResponse } from '../users/dto/user.response';
import { AuthGuard } from './auth.guard';
import { AuthService } from './auth.service';
interface SessionResponse {
token: string;
token_type: 'Bearer';
expires_at: string;
user: UserResponse;
}
@Controller('api/v1/auth/sessions')
export class AuthController {
constructor(private readonly auth: AuthService) {}
@Post()
@HttpCode(201)
async create(
@Headers('authorization') authorization: string | undefined,
@Req() request: FastifyRequest,
): Promise<SessionResponse> {
if (request.body !== undefined) {
throw new ApiError('invalid_request', 'request body is not allowed');
}
const session = await this.auth.login(authorization);
return {
token: session.token,
token_type: 'Bearer',
expires_at: session.expiresAt.toISOString(),
user: toUserResponse(session.user),
};
}
@Delete('current')
@HttpCode(204)
@UseGuards(AuthGuard)
async revoke(@Req() request: FastifyRequest): Promise<void> {
await this.auth.revoke(request.sessionTokenHash!);
}
}
+25
View File
@@ -0,0 +1,25 @@
import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
import { FastifyRequest } from 'fastify';
import { ApiError } from '../common/filters/api-error';
import { AuthService } from './auth.service';
const BEARER_CHALLENGE = 'Bearer realm="messenger"';
@Injectable()
export class AuthGuard implements CanActivate {
constructor(private readonly auth: AuthService) {}
async canActivate(context: ExecutionContext): Promise<boolean> {
const request = context.switchToHttp().getRequest<FastifyRequest>();
const match = /^Bearer (\S+)$/i.exec(request.headers.authorization ?? '');
const session = match ? await this.auth.resolve(match[1]) : null;
if (!session) {
throw new ApiError('unauthorized', 'missing or invalid session', {
'WWW-Authenticate': BEARER_CHALLENGE,
});
}
request.currentUser = session.user;
request.sessionTokenHash = session.tokenHash;
return true;
}
}
+12
View File
@@ -0,0 +1,12 @@
import { Global, Module } from '@nestjs/common';
import { AuthController } from './auth.controller';
import { AuthGuard } from './auth.guard';
import { AuthService } from './auth.service';
@Global()
@Module({
controllers: [AuthController],
providers: [AuthService, AuthGuard],
exports: [AuthService, AuthGuard],
})
export class AuthModule {}
+148
View File
@@ -0,0 +1,148 @@
import { Injectable } from '@nestjs/common';
import { createHash, randomBytes } from 'crypto';
import { CacheService } from '../cache/cache.service';
import { codePointLength } from '../common/dto/code-point-length.validator';
import { User } from '../common/domain';
import { ApiError } from '../common/filters/api-error';
import { PrismaService } from '../db/prisma.service';
import { toUser } from '../users/users.service';
import { verifyPassword } from './password';
const BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"';
const USERNAME_PATTERN = /^[a-z0-9_]{3,32}$/;
const CACHE_TTL_MS = 60_000;
const REVOKED = 'revoked';
interface CachedSession {
user: User;
expiresAt: number;
}
export interface CreatedSession {
token: string;
expiresAt: Date;
user: User;
}
export interface ResolvedSession {
tokenHash: string;
user: User;
}
@Injectable()
export class AuthService {
private readonly ttlSeconds = readSessionTtl();
constructor(
private readonly prisma: PrismaService,
private readonly cache: CacheService,
) {}
async login(authorization: string | undefined): Promise<CreatedSession> {
const credentials = parseBasic(authorization);
if (!credentials) {
throw invalidCredentials();
}
const row = await this.prisma.user.findUnique({
where: { username: credentials.username },
});
const valid = await verifyPassword(
row?.passwordHash ?? null,
credentials.password,
);
if (!row || !valid) {
throw invalidCredentials();
}
const token = randomBytes(32).toString('base64url');
const expiresAt = new Date(Date.now() + this.ttlSeconds * 1000);
await this.prisma.session.create({
data: { tokenHash: hashToken(token), userId: row.id, expiresAt },
});
return { token, expiresAt, user: toUser(row) };
}
async resolve(token: string): Promise<ResolvedSession | null> {
const tokenHash = hashToken(token);
const key = cacheKey(tokenHash);
const cached = await this.cache.get(key);
if (cached === REVOKED) {
return null;
}
if (cached) {
const entry = JSON.parse(cached) as CachedSession;
if (entry.expiresAt > Date.now()) {
return { tokenHash, user: entry.user };
}
}
const session = await this.prisma.session.findUnique({
where: { tokenHash },
include: { user: true },
});
const remainingMs = session
? session.expiresAt.getTime() - Date.now()
: 0;
if (!session || remainingMs <= 0) {
return null;
}
const user = toUser(session.user);
const entry: CachedSession = {
user,
expiresAt: session.expiresAt.getTime(),
};
await this.cache.set(
key,
JSON.stringify(entry),
Math.min(remainingMs, CACHE_TTL_MS),
true,
);
return { tokenHash, user };
}
async revoke(tokenHash: string): Promise<void> {
await this.prisma.session.deleteMany({ where: { tokenHash } });
await this.cache.set(cacheKey(tokenHash), REVOKED, CACHE_TTL_MS);
}
}
function cacheKey(tokenHash: string): string {
return `session:v1:${tokenHash}`;
}
function parseBasic(
header: string | undefined,
): { username: string; password: string } | null {
const match = /^Basic ([A-Za-z0-9+/]+={0,2})$/i.exec(header ?? '');
if (!match) {
return null;
}
const decoded = Buffer.from(match[1], 'base64').toString('utf8');
const separator = decoded.indexOf(':');
if (separator < 0) {
return null;
}
const username = decoded.slice(0, separator);
const password = decoded.slice(separator + 1);
const length = codePointLength(password);
if (!USERNAME_PATTERN.test(username) || length < 12 || length > 128) {
return null;
}
return { username, password };
}
function hashToken(token: string): string {
return createHash('sha256').update(token).digest('hex');
}
function invalidCredentials(): ApiError {
return new ApiError('unauthorized', 'invalid credentials', {
'WWW-Authenticate': BASIC_CHALLENGE,
});
}
function readSessionTtl(): number {
const ttl = Number(process.env.SESSION_TTL_SECONDS ?? 3600);
if (!Number.isInteger(ttl) || ttl <= 0) {
throw new Error('SESSION_TTL_SECONDS must be a positive integer');
}
return ttl;
}
+20
View File
@@ -0,0 +1,20 @@
import { createParamDecorator, ExecutionContext } from '@nestjs/common';
import { FastifyRequest } from 'fastify';
import { User } from '../common/domain';
declare module 'fastify' {
interface FastifyRequest {
currentUser?: User;
sessionTokenHash?: string;
}
}
export const CurrentUser = createParamDecorator(
(_data: unknown, ctx: ExecutionContext): User => {
const request = ctx.switchToHttp().getRequest<FastifyRequest>();
if (!request.currentUser) {
throw new Error('CurrentUser used without AuthGuard');
}
return request.currentUser;
},
);
+17
View File
@@ -0,0 +1,17 @@
import { argon2id, hash, verify } from 'argon2';
const OPTIONS = { type: argon2id, memoryCost: 19456, timeCost: 2, parallelism: 1 };
const dummyHash = hash('timing-equalizer-password', OPTIONS);
export function hashPassword(password: string): Promise<string> {
return hash(password, OPTIONS);
}
export async function verifyPassword(
passwordHash: string | null,
password: string,
): Promise<boolean> {
const valid = await verify(passwordHash ?? (await dummyHash), password);
return passwordHash !== null && valid;
}
+9
View File
@@ -0,0 +1,9 @@
import { Global, Module } from '@nestjs/common';
import { CacheService } from './cache.service';
@Global()
@Module({
providers: [CacheService],
exports: [CacheService],
})
export class CacheModule {}
+82
View File
@@ -0,0 +1,82 @@
import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
import { readFileSync } from 'fs';
import Redis from 'ioredis';
@Injectable()
export class CacheService implements OnModuleDestroy {
private readonly logger = new Logger('CacheService');
private readonly client: Redis | null;
private trusted = false;
constructor() {
const url = readCacheUrl();
this.client = url
? new Redis(url, {
enableOfflineQueue: false,
maxRetriesPerRequest: 0,
connectTimeout: 1000,
commandTimeout: 200,
})
: null;
this.client?.on('error', (error) =>
this.logger.warn(`redis unavailable: ${error.message}`),
);
this.client?.on('close', () => {
this.trusted = false;
});
this.client?.on('ready', () => {
this.client!.flushdb().then(
() => {
this.trusted = true;
},
() => this.distrust(),
);
});
}
async get(key: string): Promise<string | null> {
if (!this.client || !this.trusted) {
return null;
}
try {
return await this.client.get(key);
} catch {
this.distrust();
return null;
}
}
async set(
key: string,
value: string,
ttlMs: number,
onlyIfAbsent = false,
): Promise<void> {
if (!this.client || !this.trusted) {
return;
}
try {
if (onlyIfAbsent) {
await this.client.set(key, value, 'PX', ttlMs, 'NX');
} else {
await this.client.set(key, value, 'PX', ttlMs);
}
} catch {
this.distrust();
}
}
onModuleDestroy(): void {
this.client?.disconnect();
}
private distrust(): void {
this.trusted = false;
this.client?.disconnect(true);
}
}
function readCacheUrl(): string | undefined {
const file = process.env.CACHE_URL_FILE;
return file ? readFileSync(file, 'utf8').trim() : process.env.CACHE_URL;
}
+57
View File
@@ -0,0 +1,57 @@
import {
Body,
Controller,
Get,
HttpCode,
Param,
Post,
Query,
UseGuards,
} from '@nestjs/common';
import { AuthGuard } from '../auth/auth.guard';
import { CurrentUser } from '../auth/current-user.decorator';
import { parseLimit, rawCursorParam } from '../common/dto/pagination-query.dto';
import { User } from '../common/domain';
import { ChatsService } from './chats.service';
import {
ChatPageResponse,
ChatResponse,
toChatResponse,
} from './dto/chat.response';
import { CreateChatDto } from './dto/create-chat.dto';
@Controller('api/v1/chats')
@UseGuards(AuthGuard)
export class ChatsController {
constructor(private readonly chats: ChatsService) {}
@Post()
@HttpCode(201)
async create(
@Body() dto: CreateChatDto,
@CurrentUser() user: User,
): Promise<ChatResponse> {
const chat = await this.chats.create(dto.title, dto.member_ids, user.id);
return toChatResponse(chat);
}
@Get()
async list(
@CurrentUser() user: User,
@Query('limit') limitRaw: unknown,
@Query('cursor') cursorRaw: unknown,
): Promise<ChatPageResponse> {
const limit = parseLimit(limitRaw);
const cursor = rawCursorParam(cursorRaw);
return this.chats.listForMember(user.id, limit, cursor);
}
@Get(':chatId')
async getOne(
@Param('chatId') chatId: string,
@CurrentUser() user: User,
): Promise<ChatResponse> {
const chat = await this.chats.getForMember(chatId, user.id);
return toChatResponse(chat);
}
}
+10
View File
@@ -0,0 +1,10 @@
import { Module } from '@nestjs/common';
import { ChatsController } from './chats.controller';
import { ChatsService } from './chats.service';
@Module({
controllers: [ChatsController],
providers: [ChatsService],
exports: [ChatsService],
})
export class ChatsModule {}
+124
View File
@@ -0,0 +1,124 @@
import { Injectable } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { decodeChatCursor, encodeChatCursor } from '../common/cursor';
import { Chat } from '../common/domain';
import { ApiError } from '../common/filters/api-error';
import { validate as isUuid } from '../common/uuid';
import { PrismaService, isForeignKeyViolation } from '../db/prisma.service';
import { ChatPageResponse, toChatResponse } from './dto/chat.response';
interface ChatRow {
id: string;
title: string;
createdAt: Date;
memberIds: string[];
}
@Injectable()
export class ChatsService {
constructor(private readonly prisma: PrismaService) {}
async create(
title: string,
memberIds: string[],
callerId: string,
): Promise<Chat> {
if (!memberIds.includes(callerId)) {
throw new ApiError(
'invalid_request',
'member_ids must include the caller',
);
}
const invalid = memberIds.find((id) => !isUuid(id));
if (invalid) {
throw new ApiError('invalid_request', `unknown member_id: ${invalid}`);
}
try {
const chat = await this.prisma.$transaction(async (tx) => {
const created = await tx.chat.create({
data: { title: title.trim() },
});
await tx.chatMember.createMany({
data: memberIds.map((userId) => ({
chatId: created.id,
userId,
})),
});
return created;
});
return toChat({ ...chat, memberIds });
} catch (error) {
if (isForeignKeyViolation(error)) {
throw new ApiError(
'invalid_request',
'member_ids contain an unknown user',
);
}
throw error;
}
}
async getForMember(chatId: string, callerId: string): Promise<Chat> {
if (!isUuid(chatId)) {
throw new ApiError('invalid_request', 'chatId must be a valid UUID');
}
const chat = await this.prisma.chat.findFirst({
where: { id: chatId, members: { some: { userId: callerId } } },
include: { members: { select: { userId: true } } },
});
if (!chat) {
throw new ApiError('not_found', 'chat not found');
}
return toChat({
...chat,
memberIds: chat.members.map((m) => m.userId),
});
}
async listForMember(
callerId: string,
limit: number,
rawCursor: string | null,
): Promise<ChatPageResponse> {
let after = Prisma.empty;
if (rawCursor !== null) {
const cursor = decodeChatCursor(rawCursor);
const member = cursor
? await this.prisma.chatMember.findUnique({
where: {
chatId_userId: { chatId: cursor.id, userId: callerId },
},
include: { chat: { select: { createdAt: true } } },
})
: null;
if (!member) {
throw new ApiError('invalid_request', 'invalid cursor');
}
after = Prisma.sql`AND (c.created_at, c.id) > (${member.chat.createdAt}::timestamptz, ${member.chatId}::uuid)`;
}
const rows = await this.prisma.$queryRaw<ChatRow[]>`
SELECT c.id, c.title, c.created_at AS "createdAt",
ARRAY(SELECT m.user_id::text FROM chat_members m WHERE m.chat_id = c.id) AS "memberIds"
FROM chat_members cm
JOIN chats c ON c.id = cm.chat_id
WHERE cm.user_id = ${callerId}::uuid ${after}
ORDER BY c.created_at, c.id
LIMIT ${limit + 1}`;
const items = rows.slice(0, limit).map(toChat);
const last = items[items.length - 1];
return {
items: items.map(toChatResponse),
next_cursor:
rows.length > limit ? encodeChatCursor({ id: last.id }) : null,
};
}
}
function toChat(row: ChatRow): Chat {
return {
id: row.id,
title: row.title,
memberIds: row.memberIds,
createdAt: row.createdAt.toISOString(),
};
}
+22
View File
@@ -0,0 +1,22 @@
import { Chat } from '../../common/domain';
export interface ChatResponse {
id: string;
title: string;
member_ids: string[];
created_at: string;
}
export interface ChatPageResponse {
items: ChatResponse[];
next_cursor: string | null;
}
export function toChatResponse(chat: Chat): ChatResponse {
return {
id: chat.id,
title: chat.title,
member_ids: chat.memberIds,
created_at: chat.createdAt,
};
}
+22
View File
@@ -0,0 +1,22 @@
import {
ArrayMaxSize,
ArrayMinSize,
ArrayUnique,
IsArray,
IsString,
} from 'class-validator';
import { CodePointLength } from '../../common/dto/code-point-length.validator';
import { NotBlank } from '../../common/dto/not-blank.validator';
export class CreateChatDto {
@NotBlank()
@CodePointLength(1, 100)
title!: string;
@IsArray()
@ArrayMinSize(1)
@ArrayMaxSize(100)
@ArrayUnique()
@IsString({ each: true })
member_ids!: string[];
}
+49
View File
@@ -0,0 +1,49 @@
import { validate as isUuid } from './uuid';
export interface ChatCursor {
id: string;
}
export interface MessageCursor {
chatId: string;
id: string;
}
export function encodeChatCursor(cursor: ChatCursor): string {
return encode(cursor);
}
export function decodeChatCursor(raw: string): ChatCursor | null {
const decoded = decode(raw);
return decoded && isUuidField(decoded.id) ? { id: decoded.id } : null;
}
export function encodeMessageCursor(cursor: MessageCursor): string {
return encode(cursor);
}
export function decodeMessageCursor(raw: string): MessageCursor | null {
const decoded = decode(raw);
return decoded && isUuidField(decoded.chatId) && isUuidField(decoded.id)
? { chatId: decoded.chatId, id: decoded.id }
: null;
}
function isUuidField(value: unknown): value is string {
return typeof value === 'string' && isUuid(value);
}
function encode(value: object): string {
return Buffer.from(JSON.stringify(value), 'utf8').toString('base64url');
}
function decode(raw: string): Record<string, unknown> | null {
try {
const parsed = JSON.parse(
Buffer.from(raw, 'base64url').toString('utf8'),
);
return typeof parsed === 'object' && parsed !== null ? parsed : null;
} catch {
return null;
}
}
+21
View File
@@ -0,0 +1,21 @@
export interface User {
id: string;
username: string;
displayName: string;
createdAt: string;
}
export interface Chat {
id: string;
title: string;
memberIds: string[];
createdAt: string;
}
export interface Message {
id: string;
chatId: string;
senderId: string;
text: string;
createdAt: string;
}
@@ -0,0 +1,33 @@
import { registerDecorator, ValidationOptions } from 'class-validator';
export function codePointLength(value: string): number {
return [...value].length;
}
export function CodePointLength(
min: number,
max: number,
options?: ValidationOptions,
) {
return function (object: object, propertyName: string) {
registerDecorator({
name: 'codePointLength',
target: object.constructor,
propertyName,
constraints: [min, max],
options,
validator: {
validate(value: unknown): boolean {
if (typeof value !== 'string') {
return false;
}
const length = codePointLength(value);
return length >= min && length <= max;
},
defaultMessage(): string {
return `${propertyName} must be between ${min} and ${max} Unicode code points`;
},
},
});
};
}
+20
View File
@@ -0,0 +1,20 @@
import { registerDecorator, ValidationOptions } from 'class-validator';
export function NotBlank(options?: ValidationOptions) {
return function (object: object, propertyName: string) {
registerDecorator({
name: 'notBlank',
target: object.constructor,
propertyName,
options,
validator: {
validate(value: unknown): boolean {
return typeof value === 'string' && value.trim().length > 0;
},
defaultMessage(): string {
return `${propertyName} must not be empty or whitespace-only`;
},
},
});
};
}
+37
View File
@@ -0,0 +1,37 @@
import { ApiError } from '../filters/api-error';
const DEFAULT_LIMIT = 50;
const MIN_LIMIT = 1;
const MAX_LIMIT = 100;
export function parseLimit(raw: unknown): number {
if (raw === undefined) {
return DEFAULT_LIMIT;
}
const value = Array.isArray(raw) ? raw[0] : raw;
if (typeof value !== 'string' || !/^\d+$/.test(value)) {
throw new ApiError('invalid_request', 'limit must be an integer');
}
const limit = Number(value);
if (limit < MIN_LIMIT || limit > MAX_LIMIT) {
throw new ApiError(
'invalid_request',
`limit must be between ${MIN_LIMIT} and ${MAX_LIMIT}`,
);
}
return limit;
}
export function rawCursorParam(raw: unknown): string | null {
if (raw === undefined) {
return null;
}
const value = Array.isArray(raw) ? raw[0] : raw;
if (typeof value !== 'string' || value.length === 0) {
throw new ApiError(
'invalid_request',
'cursor must be a non-empty string',
);
}
return value;
}
+34
View File
@@ -0,0 +1,34 @@
import { HttpException, HttpStatus } from '@nestjs/common';
export type ErrorCode =
| 'invalid_request'
| 'unauthorized'
| 'not_found'
| 'conflict'
| 'payload_too_large'
| 'unsupported_media_type'
| 'rate_limited'
| 'unavailable'
| 'internal_error';
const STATUS_BY_CODE: Record<ErrorCode, number> = {
invalid_request: HttpStatus.BAD_REQUEST,
unauthorized: HttpStatus.UNAUTHORIZED,
not_found: HttpStatus.NOT_FOUND,
conflict: HttpStatus.CONFLICT,
payload_too_large: HttpStatus.PAYLOAD_TOO_LARGE,
unsupported_media_type: HttpStatus.UNSUPPORTED_MEDIA_TYPE,
rate_limited: HttpStatus.TOO_MANY_REQUESTS,
unavailable: HttpStatus.SERVICE_UNAVAILABLE,
internal_error: HttpStatus.INTERNAL_SERVER_ERROR,
};
export class ApiError extends HttpException {
constructor(
public readonly code: ErrorCode,
message: string,
public readonly headers: Record<string, string> = {},
) {
super(message, STATUS_BY_CODE[code]);
}
}
+115
View File
@@ -0,0 +1,115 @@
import {
ArgumentsHost,
Catch,
ExceptionFilter,
HttpException,
HttpStatus,
Logger,
} from '@nestjs/common';
import { FastifyReply, FastifyRequest } from 'fastify';
import { isDatabaseUnavailable } from '../../db/prisma.service';
import { ApiError, ErrorCode } from './api-error';
const CODE_BY_STATUS: Partial<Record<number, ErrorCode>> = {
[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',
};
interface Resolved {
status: number;
code: ErrorCode;
message: string;
}
@Catch()
export class HttpExceptionFilter implements ExceptionFilter {
private readonly logger = new Logger('HttpExceptionFilter');
catch(exception: unknown, host: ArgumentsHost): void {
const ctx = host.switchToHttp();
const reply = ctx.getResponse<FastifyReply>();
const request = ctx.getRequest<FastifyRequest>();
const requestId = request.requestId;
const { status, code, message } = this.resolve(exception);
if (status >= 500) {
this.logger.error(
`${request.method} ${request.url} -> ${status}: ${message}`,
);
}
if (exception instanceof ApiError) {
reply.headers(exception.headers);
}
reply
.code(status)
.header('x-request-id', requestId)
.send({ error: { code, message, request_id: requestId } });
}
private resolve(exception: unknown): Resolved {
if (exception instanceof ApiError) {
return {
status: exception.getStatus(),
code: exception.code,
message: exception.message,
};
}
if (exception instanceof HttpException) {
const status = exception.getStatus();
const code = CODE_BY_STATUS[status] ?? 'internal_error';
const message =
extractMessage(exception.getResponse()) ?? exception.message;
return { status, code, message };
}
const fastifyStatus = (exception as { statusCode?: unknown })
?.statusCode;
if (typeof fastifyStatus === 'number' && CODE_BY_STATUS[fastifyStatus]) {
const message =
exception instanceof Error ? exception.message : 'Invalid request';
return {
status: fastifyStatus,
code: CODE_BY_STATUS[fastifyStatus]!,
message,
};
}
if (isDatabaseUnavailable(exception)) {
return {
status: 503,
code: 'unavailable',
message: 'database unavailable',
};
}
return {
status: 500,
code: 'internal_error',
message: 'Internal server error',
};
}
}
function extractMessage(response: unknown): string | null {
if (typeof response === 'string') {
return response;
}
if (
typeof response === 'object' &&
response !== null &&
'message' in response
) {
const value = (response as { message: unknown }).message;
if (typeof value === 'string') {
return value;
}
if (Array.isArray(value) && value.every((v) => typeof v === 'string')) {
return value.join('; ');
}
}
return null;
}
+18
View File
@@ -0,0 +1,18 @@
import { randomUUID } from 'crypto';
import { FastifyInstance, FastifyRequest } from 'fastify';
const REQUEST_ID_HEADER = 'x-request-id';
declare module 'fastify' {
interface FastifyRequest {
requestId: string;
}
}
export function registerRequestId(instance: FastifyInstance): void {
instance.addHook('onRequest', (request: FastifyRequest, reply, done) => {
request.requestId = randomUUID();
reply.header(REQUEST_ID_HEADER, request.requestId);
done();
});
}
+6
View File
@@ -0,0 +1,6 @@
const UUID_PATTERN =
/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
export function validate(value: string): boolean {
return UUID_PATTERN.test(value);
}
+18
View File
@@ -0,0 +1,18 @@
import { ValidationPipe } from '@nestjs/common';
import { NestFastifyApplication } from '@nestjs/platform-fastify';
import { HttpExceptionFilter } from './common/filters/http-exception.filter';
import { registerRequestId } from './common/interceptors/request-id';
export function configureApp(app: NestFastifyApplication): void {
registerRequestId(app.getHttpAdapter().getInstance());
app.useGlobalPipes(
new ValidationPipe({
whitelist: true,
forbidNonWhitelisted: true,
transform: true,
forbidUnknownValues: true,
}),
);
app.useGlobalFilters(new HttpExceptionFilter());
}
+9
View File
@@ -0,0 +1,9 @@
import { Global, Module } from '@nestjs/common';
import { PrismaService } from './prisma.service';
@Global()
@Module({
providers: [PrismaService],
exports: [PrismaService],
})
export class DbModule {}
+49
View File
@@ -0,0 +1,49 @@
import { Injectable, OnModuleDestroy } from '@nestjs/common';
import { Prisma, PrismaClient } from '@prisma/client';
import { readFileSync } from 'fs';
const UNAVAILABLE_CODES = new Set(['P1001', 'P1002', 'P1008', 'P1017', 'P2024']);
@Injectable()
export class PrismaService extends PrismaClient implements OnModuleDestroy {
constructor() {
super({ datasourceUrl: readDatabaseUrl() });
}
async onModuleDestroy(): Promise<void> {
await this.$disconnect();
}
}
function readDatabaseUrl(): string {
const file = process.env.DATABASE_URL_FILE;
const url = file ? readFileSync(file, 'utf8').trim() : process.env.DATABASE_URL;
if (!url) {
throw new Error('DATABASE_URL_FILE or DATABASE_URL must be set');
}
return url;
}
export function isUniqueViolation(error: unknown): boolean {
return (
error instanceof Prisma.PrismaClientKnownRequestError &&
error.code === 'P2002'
);
}
export function isForeignKeyViolation(error: unknown): boolean {
return (
error instanceof Prisma.PrismaClientKnownRequestError &&
error.code === 'P2003'
);
}
export function isDatabaseUnavailable(error: unknown): boolean {
if (error instanceof Prisma.PrismaClientInitializationError) {
return true;
}
return (
error instanceof Prisma.PrismaClientKnownRequestError &&
UNAVAILABLE_CODES.has(error.code)
);
}
+327
View File
@@ -0,0 +1,327 @@
const ALICE_ID = '11111111-1111-4111-8111-111111111111';
const BOB_ID = '22222222-2222-4222-8222-222222222222';
const CHAT_ID = '33333333-3333-4333-8333-333333333333';
const MESSAGE_ID = '44444444-4444-4444-8444-444444444444';
const CURSOR =
'eyJjaGF0SWQiOiIzMzMzMzMzMy0zMzMzLTQzMzMtODMzMy0zMzMzMzMzMzMzMzMiLCJpZCI6IjQ0NDQ0NDQ0LTQ0NDQtNDQ0NC04NDQ0LTQ0NDQ0NDQ0NDQ0NCJ9';
const ALICE = {
id: ALICE_ID,
username: 'alice',
display_name: 'Алиса',
created_at: '2026-09-01T12:00:00.000Z',
};
const CHAT = {
id: CHAT_ID,
title: 'Проект по ВНП',
member_ids: [ALICE_ID, BOB_ID],
created_at: '2026-09-01T12:01:00.000Z',
};
const MESSAGE = {
id: MESSAGE_ID,
chat_id: CHAT_ID,
sender_id: ALICE_ID,
text: 'Привет, Боб! 👋',
created_at: '2026-09-01T12:02:00.000Z',
};
export interface Example {
summary: string;
value: unknown;
}
export interface OperationExamples {
request?: Record<string, Example>;
responses: Record<string, Record<string, Example>>;
}
function example(summary: string, value: unknown): Example {
return { summary, value };
}
function error(code: string, message: string): unknown {
return {
error: {
code,
message,
request_id: '9b2c6f1e-5d4a-4c3b-8a2f-1e0d9c8b7a6f',
},
};
}
const UNAUTHORIZED = {
missing: example(
'Нет/неверный/истёкший/отозванный Bearer-токен',
error('unauthorized', 'missing or invalid session'),
),
};
const UNAVAILABLE = {
database: example(
'PostgreSQL недоступен',
error('unavailable', 'database unavailable'),
),
};
const CHAT_NOT_FOUND = {
notFound: example(
'Чата нет или вызывающий не участник (не 403)',
error('not_found', 'chat not found'),
),
};
const INVALID_CHAT_ID = example(
'chat_id не UUID',
error('invalid_request', 'chatId must be a valid UUID'),
);
export const GUIDE = `
Учебный мессенджер, лабораторная 3: PostgreSQL, сессии, Redis-кэш сессий.
Документ — обязательный контракт \`contracts/openapi.json\`, дополненный примерами запросов и ответов.
**Как пройти сценарий в Swagger UI**
1. \`POST /api/v1/users\` — зарегистрируйте пользователей (примеры alice, bob, eve в списке Examples). Повторная регистрация того же username — 409, меняйте username.
2. **Authorize → basicAuth**: username и password из шага 1 → \`POST /api/v1/auth/sessions\` → скопируйте \`token\`.
3. **Authorize → bearerAuth**: вставьте token (без слова Bearer). Basic отправляется только на вход, остальные запросы идут с Bearer.
4. \`GET /api/v1/users/me\` — свой id; id второго участника — из ответа его регистрации.
5. \`POST /api/v1/chats\` с \`member_ids\` = [свой id, id собеседника] → \`chat_id\`.
6. \`POST /api/v1/chats/{chat_id}/messages\`, затем \`GET …/messages?limit=1\` и следующая страница с \`cursor\` = \`next_cursor\`.
7. Чтобы действовать от другого пользователя: Logout в Authorize, вход им и новый token.
8. \`DELETE /api/v1/auth/sessions/current\` — logout; тот же token дальше даёт 401.
Сессия живёт \`SESSION_TTL_SECONDS\` (по умолчанию 3600 с). Пароль — 12–128 символов Unicode, двоеточие допустимо.
`;
export const OPERATION_EXAMPLES: Record<string, OperationExamples> = {
'GET /health/live': {
responses: {
'200': { ok: example('Процесс жив', { status: 'ok' }) },
},
},
'GET /health/ready': {
responses: {
'200': {
ok: example('PostgreSQL доступен (Redis не критичен)', {
status: 'ok',
}),
},
'503': UNAVAILABLE,
},
},
'POST /api/v1/users': {
request: {
alice: example('Алиса', {
username: 'alice',
display_name: 'Алиса',
password: 'Alice-password-123',
}),
bob: example('Боб', {
username: 'bob',
display_name: 'Боб',
password: 'Bob-password-123',
}),
eve: example('Ева (посторонняя)', {
username: 'eve',
display_name: 'Ева',
password: 'Eve-password-123',
}),
colon: example('Пароль с двоеточием и эмодзи', {
username: 'carol',
display_name: 'Кэрол 🌸',
password: 'пароль:с:двоеточием🔑',
}),
},
responses: {
'201': { created: example('Пользователь создан', ALICE) },
'400': {
username: example(
'username не соответствует [a-z0-9_]{3,32}',
error('invalid_request', 'username must match [a-z0-9_]{3,32}'),
),
password: example(
'password короче 12 символов',
error(
'invalid_request',
'password must be between 12 and 128 Unicode code points',
),
),
extra: example(
'Лишнее поле в JSON',
error('invalid_request', 'property extra should not exist'),
),
},
'409': {
taken: example(
'username уже занят',
error('conflict', 'username is already taken'),
),
},
'503': UNAVAILABLE,
},
},
'POST /api/v1/auth/sessions': {
responses: {
'201': {
created: example('Сессия создана', {
token: 'q8Hn3vXl0ZbJ7mWcY2sRkT5uPaE9dFgVhN1oLxI4w6A',
token_type: 'Bearer',
expires_at: '2026-09-01T13:00:00.000Z',
user: ALICE,
}),
},
'401': {
invalid: example(
'Неверный пароль, неизвестный пользователь или нет Basic — ответ одинаковый',
error('unauthorized', 'invalid credentials'),
),
},
'503': UNAVAILABLE,
},
},
'DELETE /api/v1/auth/sessions/current': {
responses: {
'401': UNAUTHORIZED,
'503': UNAVAILABLE,
},
},
'GET /api/v1/users/me': {
responses: {
'200': { me: example('Текущий пользователь из сессии', ALICE) },
'401': UNAUTHORIZED,
'503': UNAVAILABLE,
},
},
'POST /api/v1/chats': {
request: {
pair: example('Чат Алисы и Боба', {
title: CHAT.title,
member_ids: CHAT.member_ids,
}),
solo: example('Чат только с собой', {
title: 'Заметки',
member_ids: [ALICE_ID],
}),
},
responses: {
'201': { created: example('Чат создан атомарно', CHAT) },
'400': {
noCaller: example(
'Вызывающий не в member_ids',
error('invalid_request', 'member_ids must include the caller'),
),
unknown: example(
'Неизвестный участник — транзакция откатывается',
error('invalid_request', 'member_ids contain an unknown user'),
),
duplicate: example(
'Дубликаты в member_ids',
error(
'invalid_request',
"All member_ids's elements must be unique",
),
),
},
'401': UNAUTHORIZED,
'503': UNAVAILABLE,
},
},
'GET /api/v1/chats': {
responses: {
'200': {
page: example('Страница чатов с продолжением', {
items: [CHAT],
next_cursor: 'eyJpZCI6IjMzMzMzMzMzLTMzMzMtNDMzMy04MzMzLTMzMzMzMzMzMzMzMyJ9',
}),
last: example('Последняя страница', {
items: [CHAT],
next_cursor: null,
}),
},
'400': {
limit: example(
'limit вне 1–100',
error('invalid_request', 'limit must be between 1 and 100'),
),
cursor: example(
'Испорченный или чужой cursor',
error('invalid_request', 'invalid cursor'),
),
},
'401': UNAUTHORIZED,
'503': UNAVAILABLE,
},
},
'GET /api/v1/chats/{chat_id}': {
responses: {
'200': { chat: example('Чат, где вызывающий — участник', CHAT) },
'400': { chatId: INVALID_CHAT_ID },
'401': UNAUTHORIZED,
'404': CHAT_NOT_FOUND,
'503': UNAVAILABLE,
},
},
'POST /api/v1/chats/{chat_id}/messages': {
request: {
text: example('Обычное сообщение', { text: MESSAGE.text }),
long: example('Максимум — 4000 символов Unicode', {
text: 'Длинный текст…',
}),
},
responses: {
'201': {
created: example('Отправитель берётся из сессии', MESSAGE),
},
'400': {
blank: example(
'Пустой или пробельный текст',
error(
'invalid_request',
'text must not be empty or whitespace-only',
),
),
sender: example(
'sender_id в теле не принимается',
error('invalid_request', 'property sender_id should not exist'),
),
chatId: INVALID_CHAT_ID,
},
'401': UNAUTHORIZED,
'404': CHAT_NOT_FOUND,
'503': UNAVAILABLE,
},
},
'GET /api/v1/chats/{chat_id}/messages': {
responses: {
'200': {
page: example('Страница истории (limit=1) с cursor', {
items: [MESSAGE],
next_cursor: CURSOR,
}),
last: example('Последняя страница', {
items: [MESSAGE],
next_cursor: null,
}),
},
'400': {
otherChat: example(
'cursor от другого чата',
error('invalid_request', 'cursor belongs to a different chat'),
),
cursor: example(
'Испорченный cursor или cursor несуществующего сообщения',
error('invalid_request', 'invalid cursor'),
),
limit: example(
'limit вне 1–100',
error('invalid_request', 'limit must be between 1 and 100'),
),
},
'401': UNAUTHORIZED,
'404': CHAT_NOT_FOUND,
'503': UNAVAILABLE,
},
},
};
+43
View File
@@ -0,0 +1,43 @@
import { NestFastifyApplication } from '@nestjs/platform-fastify';
import { OpenAPIObject, SwaggerModule } from '@nestjs/swagger';
import { readFileSync } from 'fs';
import { join } from 'path';
import { GUIDE, OPERATION_EXAMPLES } from './examples';
const CONTRACT_PATH = join(process.cwd(), 'contracts', 'openapi.json');
export function setupSwagger(app: NestFastifyApplication): void {
SwaggerModule.setup('docs', app, loadDocument(), {
customSiteTitle: 'Messenger lab3 API',
swaggerOptions: {
persistAuthorization: true,
displayRequestDuration: true,
tryItOutEnabled: true,
},
});
}
export function loadDocument(): OpenAPIObject {
const document = JSON.parse(readFileSync(CONTRACT_PATH, 'utf8'));
document.info.description = GUIDE;
document.servers = [{ url: '/', description: 'Этот экземпляр API' }];
for (const [key, examples] of Object.entries(OPERATION_EXAMPLES)) {
const [method, path] = key.split(' ');
const operation = document.paths[path]?.[method.toLowerCase()];
if (!operation) {
throw new Error(`examples for unknown operation ${key}`);
}
if (examples.request) {
operation.requestBody.content['application/json'].examples =
examples.request;
}
for (const [status, named] of Object.entries(examples.responses)) {
const content = operation.responses[status]?.content;
if (!content) {
throw new Error(`examples for unknown response ${key} ${status}`);
}
content['application/json'].examples = named;
}
}
return document;
}
+23
View File
@@ -0,0 +1,23 @@
import { Controller, Get } from '@nestjs/common';
import { ApiError } from '../common/filters/api-error';
import { PrismaService } from '../db/prisma.service';
@Controller('health')
export class HealthController {
constructor(private readonly prisma: PrismaService) {}
@Get('live')
live(): { status: 'ok' } {
return { status: 'ok' };
}
@Get('ready')
async ready(): Promise<{ status: 'ok' }> {
try {
await this.prisma.$queryRaw`SELECT 1`;
} catch {
throw new ApiError('unavailable', 'database unavailable');
}
return { status: 'ok' };
}
}
+7
View File
@@ -0,0 +1,7 @@
import { Module } from '@nestjs/common';
import { HealthController } from './health.controller';
@Module({
controllers: [HealthController],
})
export class HealthModule {}
+33
View File
@@ -0,0 +1,33 @@
import { Logger } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import {
FastifyAdapter,
NestFastifyApplication,
} from '@nestjs/platform-fastify';
import { AppModule } from './app.module';
import { configureApp } from './configure-app';
import { setupSwagger } from './docs/swagger';
async function bootstrap(): Promise<void> {
const app = await NestFactory.create<NestFastifyApplication>(
AppModule,
new FastifyAdapter(),
{
bufferLogs: true,
},
);
configureApp(app);
setupSwagger(app);
app.enableShutdownHooks();
const host = process.env.APP_HOST ?? '0.0.0.0';
const port = Number(process.env.APP_PORT ?? 8080);
await app.listen(port, host);
Logger.log(`Listening on http://${host}:${port}`, 'Bootstrap');
}
bootstrap().catch((error) => {
Logger.error('Fatal error during bootstrap', error);
process.exit(1);
});
+8
View File
@@ -0,0 +1,8 @@
import { IsString } from 'class-validator';
import { CodePointLength } from '../../common/dto/code-point-length.validator';
export class CreateMessageDto {
@IsString()
@CodePointLength(0, 4000)
text!: string;
}
+24
View File
@@ -0,0 +1,24 @@
import { Message } from '../../common/domain';
export interface MessageResponse {
id: string;
chat_id: string;
sender_id: string;
text: string;
created_at: string;
}
export interface MessagePageResponse {
items: MessageResponse[];
next_cursor: string | null;
}
export function toMessageResponse(message: Message): MessageResponse {
return {
id: message.id,
chat_id: message.chatId,
sender_id: message.senderId,
text: message.text,
created_at: message.createdAt,
};
}
+50
View File
@@ -0,0 +1,50 @@
import {
Body,
Controller,
Get,
HttpCode,
Param,
Post,
Query,
UseGuards,
} from '@nestjs/common';
import { AuthGuard } from '../auth/auth.guard';
import { CurrentUser } from '../auth/current-user.decorator';
import { parseLimit, rawCursorParam } from '../common/dto/pagination-query.dto';
import { User } from '../common/domain';
import { CreateMessageDto } from './dto/create-message.dto';
import {
MessagePageResponse,
MessageResponse,
toMessageResponse,
} from './dto/message.response';
import { MessagesService } from './messages.service';
@Controller('api/v1/chats/:chatId/messages')
@UseGuards(AuthGuard)
export class MessagesController {
constructor(private readonly messages: MessagesService) {}
@Post()
@HttpCode(201)
async create(
@Param('chatId') chatId: string,
@Body() dto: CreateMessageDto,
@CurrentUser() user: User,
): Promise<MessageResponse> {
const message = await this.messages.create(chatId, user.id, dto.text);
return toMessageResponse(message);
}
@Get()
async list(
@Param('chatId') chatId: string,
@CurrentUser() user: User,
@Query('limit') limitRaw: unknown,
@Query('cursor') cursorRaw: unknown,
): Promise<MessagePageResponse> {
const limit = parseLimit(limitRaw);
const cursor = rawCursorParam(cursorRaw);
return this.messages.list(chatId, user.id, limit, cursor);
}
}
+9
View File
@@ -0,0 +1,9 @@
import { Module } from '@nestjs/common';
import { MessagesController } from './messages.controller';
import { MessagesService } from './messages.service';
@Module({
controllers: [MessagesController],
providers: [MessagesService],
})
export class MessagesModule {}
+106
View File
@@ -0,0 +1,106 @@
import { Injectable } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { codePointLength } from '../common/dto/code-point-length.validator';
import { decodeMessageCursor, encodeMessageCursor } from '../common/cursor';
import { Message } from '../common/domain';
import { ApiError } from '../common/filters/api-error';
import { validate as isUuid } from '../common/uuid';
import { PrismaService } from '../db/prisma.service';
import { MessagePageResponse, toMessageResponse } from './dto/message.response';
interface MessageRow {
id: string;
chatId: string;
senderId: string;
text: string;
createdAt: Date;
}
@Injectable()
export class MessagesService {
constructor(private readonly prisma: PrismaService) {}
async create(
chatId: string,
callerId: string,
text: string,
): Promise<Message> {
await this.assertMember(chatId, callerId);
if (codePointLength(text.trim()) === 0) {
throw new ApiError(
'invalid_request',
'text must not be empty or whitespace-only',
);
}
const row = await this.prisma.message.create({
data: { chatId, senderId: callerId, text },
});
return toMessage(row);
}
async list(
chatId: string,
callerId: string,
limit: number,
rawCursor: string | null,
): Promise<MessagePageResponse> {
await this.assertMember(chatId, callerId);
let after = Prisma.empty;
if (rawCursor !== null) {
const cursor = decodeMessageCursor(rawCursor);
if (cursor && cursor.chatId !== chatId) {
throw new ApiError(
'invalid_request',
'cursor belongs to a different chat',
);
}
const anchor = cursor
? await this.prisma.message.findFirst({
where: { id: cursor.id, chatId },
select: { id: true, createdAt: true },
})
: null;
if (!anchor) {
throw new ApiError('invalid_request', 'invalid cursor');
}
after = Prisma.sql`AND (created_at, id) > (${anchor.createdAt}::timestamptz, ${anchor.id}::uuid)`;
}
const rows = await this.prisma.$queryRaw<MessageRow[]>`
SELECT id, chat_id AS "chatId", sender_id AS "senderId", text, created_at AS "createdAt"
FROM messages
WHERE chat_id = ${chatId}::uuid ${after}
ORDER BY created_at, id
LIMIT ${limit + 1}`;
const items = rows.slice(0, limit).map(toMessage);
const last = items[items.length - 1];
return {
items: items.map(toMessageResponse),
next_cursor:
rows.length > limit
? encodeMessageCursor({ chatId, id: last.id })
: null,
};
}
private async assertMember(chatId: string, callerId: string): Promise<void> {
if (!isUuid(chatId)) {
throw new ApiError('invalid_request', 'chatId must be a valid UUID');
}
const member = await this.prisma.chatMember.findUnique({
where: { chatId_userId: { chatId, userId: callerId } },
});
if (!member) {
throw new ApiError('not_found', 'chat not found');
}
}
}
function toMessage(row: MessageRow): Message {
return {
id: row.id,
chatId: row.chatId,
senderId: row.senderId,
text: row.text,
createdAt: row.createdAt.toISOString(),
};
}
+18
View File
@@ -0,0 +1,18 @@
import { Matches } from 'class-validator';
import { CodePointLength } from '../../common/dto/code-point-length.validator';
import { NotBlank } from '../../common/dto/not-blank.validator';
export class CreateUserDto {
@Matches(/^[a-z0-9_]{3,32}$/, {
message: 'username must match [a-z0-9_]{3,32}',
})
username!: string;
@NotBlank()
@CodePointLength(1, 100)
display_name!: string;
@NotBlank()
@CodePointLength(12, 128)
password!: string;
}
+17
View File
@@ -0,0 +1,17 @@
import { User } from '../../common/domain';
export interface UserResponse {
id: string;
username: string;
display_name: string;
created_at: string;
}
export function toUserResponse(user: User): UserResponse {
return {
id: user.id,
username: user.username,
display_name: user.displayName,
created_at: user.createdAt,
};
}
+36
View File
@@ -0,0 +1,36 @@
import {
Body,
Controller,
Get,
HttpCode,
Post,
UseGuards,
} from '@nestjs/common';
import { AuthGuard } from '../auth/auth.guard';
import { CurrentUser } from '../auth/current-user.decorator';
import { User } from '../common/domain';
import { CreateUserDto } from './dto/create-user.dto';
import { toUserResponse, UserResponse } from './dto/user.response';
import { UsersService } from './users.service';
@Controller('api/v1/users')
export class UsersController {
constructor(private readonly users: UsersService) {}
@Post()
@HttpCode(201)
async create(@Body() dto: CreateUserDto): Promise<UserResponse> {
const user = await this.users.register(
dto.username,
dto.display_name,
dto.password,
);
return toUserResponse(user);
}
@Get('me')
@UseGuards(AuthGuard)
me(@CurrentUser() user: User): UserResponse {
return toUserResponse(user);
}
}
+10
View File
@@ -0,0 +1,10 @@
import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';
@Module({
controllers: [UsersController],
providers: [UsersService],
exports: [UsersService],
})
export class UsersModule {}
+48
View File
@@ -0,0 +1,48 @@
import { Injectable } from '@nestjs/common';
import { hashPassword } from '../auth/password';
import { ApiError } from '../common/filters/api-error';
import { User } from '../common/domain';
import { PrismaService, isUniqueViolation } from '../db/prisma.service';
@Injectable()
export class UsersService {
constructor(private readonly prisma: PrismaService) {}
async register(
username: string,
displayName: string,
password: string,
): Promise<User> {
const passwordHash = await hashPassword(password);
try {
const row = await this.prisma.user.create({
data: { username, displayName: displayName.trim(), passwordHash },
});
return toUser(row);
} catch (error) {
if (isUniqueViolation(error)) {
throw new ApiError('conflict', 'username is already taken');
}
throw error;
}
}
async findById(id: string): Promise<User | null> {
const row = await this.prisma.user.findUnique({ where: { id } });
return row ? toUser(row) : null;
}
}
export function toUser(row: {
id: string;
username: string;
displayName: string;
createdAt: Date;
}): User {
return {
id: row.id,
username: row.username,
displayName: row.displayName,
createdAt: row.createdAt.toISOString(),
};
}
+615
View File
@@ -0,0 +1,615 @@
import { INestApplication } from '@nestjs/common';
import request from 'supertest';
import { randomUUID } from 'crypto';
import { PrismaService } from '../src/db/prisma.service';
import {
bearer,
createTestApp,
PASSWORD,
registerUser,
TestUser,
} from './helpers';
describe('API мессенджера (e2e) — граничные случаи сверх публичного smoke', () => {
let app: INestApplication;
let server: any;
beforeAll(async () => {
({ app, server } = await createTestApp());
});
afterAll(async () => {
await app.close();
});
function createUser(label: string): Promise<TestUser> {
return registerUser(server, label);
}
describe('POST /api/v1/users', () => {
it('отклоняет некорректный JSON с кодом 400', async () => {
const res = await request(server)
.post('/api/v1/users')
.set('Content-Type', 'application/json')
.send('{not valid json')
.expect(400);
expect(res.body.error.code).toBe('invalid_request');
expect(res.body.error.request_id).toBeTruthy();
});
it('отклоняет тело с лишними полями', async () => {
const res = await request(server)
.post('/api/v1/users')
.send({
username: 'validname1',
display_name: 'Valid',
password: PASSWORD,
extra: 'nope',
})
.expect(400);
expect(res.body.error.code).toBe('invalid_request');
});
it('отклоняет username с заглавными буквами', async () => {
await request(server)
.post('/api/v1/users')
.send({ username: 'InvalidName', display_name: 'X', password: PASSWORD })
.expect(400);
});
it('отклоняет display_name из одних пробелов', async () => {
await request(server)
.post('/api/v1/users')
.send({ username: 'wsonlyname1', display_name: ' ', password: PASSWORD })
.expect(400);
});
it('отклоняет дубликат username с кодом 409', async () => {
const user = await createUser('dup');
const res = await request(server)
.post('/api/v1/users')
.send({ username: user.username, display_name: 'Someone else', password: PASSWORD })
.expect(409);
expect(res.body.error.code).toBe('conflict');
});
it('никогда не возвращает поле пароля или его хэша', async () => {
const res = await request(server)
.post('/api/v1/users')
.send({
username: `nopass_${randomUUID().slice(0, 8)}`,
display_name: 'X',
password: PASSWORD,
})
.expect(201);
expect(res.body).not.toHaveProperty('password');
expect(res.body).not.toHaveProperty('password_hash');
});
it('отклоняет username короче 3 символов', async () => {
await request(server)
.post('/api/v1/users')
.send({ username: 'ab', display_name: 'X', password: PASSWORD })
.expect(400);
});
it('отклоняет username длиннее 32 символов', async () => {
await request(server)
.post('/api/v1/users')
.send({ username: 'a'.repeat(33), display_name: 'X', password: PASSWORD })
.expect(400);
});
it('отклоняет username с недопустимыми символами (дефис)', async () => {
await request(server)
.post('/api/v1/users')
.send({ username: 'has-hyphen', display_name: 'X', password: PASSWORD })
.expect(400);
});
it('принимает username ровно на границах длины 3 и 32 символа', async () => {
await request(server)
.post('/api/v1/users')
.send({
username: `a${randomUUID().slice(0, 2)}`,
display_name: 'X',
password: PASSWORD,
})
.expect(201);
const longest = ('z' + randomUUID().replace(/-/g, '')).slice(0, 32);
await request(server)
.post('/api/v1/users')
.send({ username: longest, display_name: 'X', password: PASSWORD })
.expect(201);
});
it('отклоняет display_name длиннее 100 Unicode code points', async () => {
await request(server)
.post('/api/v1/users')
.send({
username: `toolongname_${randomUUID().slice(0, 6)}`,
display_name: 'x'.repeat(101),
password: PASSWORD,
})
.expect(400);
});
it('принимает display_name ровно из 100 code points, считая эмодзи вне BMP за один символ', async () => {
const displayName = '👋'.repeat(100);
expect([...displayName].length).toBe(100);
await request(server)
.post('/api/v1/users')
.send({
username: `emojiname_${randomUUID().slice(0, 6)}`,
display_name: displayName,
password: PASSWORD,
})
.expect(201);
});
it('отклоняет display_name из 101 code point, состоящий из эмодзи вне BMP', async () => {
const displayName = '👋'.repeat(100) + 'x';
expect([...displayName].length).toBe(101);
await request(server)
.post('/api/v1/users')
.send({
username: `emojitoolong_${randomUUID().slice(0, 6)}`,
display_name: displayName,
password: PASSWORD,
})
.expect(400);
});
});
describe('контроль доступа', () => {
it('возвращает 401 раньше 404, если и актор, и ресурс невалидны', async () => {
const res = await request(server)
.get(`/api/v1/chats/${randomUUID()}`)
.set('Authorization', 'Bearer not-a-token')
.expect(401);
expect(res.body.error.code).toBe('unauthorized');
});
it('возвращает 404 (не 403), когда чат запрашивает не его участник', async () => {
const alice = await createUser('alice');
const bob = await createUser('bob');
const eve = await createUser('eve');
const chat = await request(server)
.post('/api/v1/chats')
.set('Authorization', bearer(alice))
.send({ title: 'Private', member_ids: [alice.id, bob.id] })
.expect(201);
const res = await request(server)
.get(`/api/v1/chats/${chat.body.id}`)
.set('Authorization', bearer(eve))
.expect(404);
expect(res.body.error.code).toBe('not_found');
});
it('отклоняет создание чата, если вызывающий не входит в member_ids', async () => {
const alice = await createUser('alice2');
const bob = await createUser('bob2');
await request(server)
.post('/api/v1/chats')
.set('Authorization', bearer(alice))
.send({ title: 'Missing caller', member_ids: [bob.id] })
.expect(400);
});
it('отклоняет создание чата с дублирующимися member_ids', async () => {
const alice = await createUser('alice3');
await request(server)
.post('/api/v1/chats')
.set('Authorization', bearer(alice))
.send({
title: 'Dup members',
member_ids: [alice.id, alice.id],
})
.expect(400);
});
it('принимает ровно 100 участников и отклоняет 101', async () => {
const alice = await createUser('max');
const ids = Array.from({ length: 100 }, () => randomUUID());
await app.get(PrismaService).user.createMany({
data: ids.map((id) => ({
id,
username: `m_${id.replace(/-/g, '').slice(0, 30)}`,
displayName: 'Member',
passwordHash: 'not-a-real-hash',
})),
});
const ok = await request(server)
.post('/api/v1/chats')
.set('Authorization', bearer(alice))
.send({ title: 'Max', member_ids: [alice.id, ...ids.slice(0, 99)] })
.expect(201);
expect(ok.body.member_ids).toHaveLength(100);
await request(server)
.post('/api/v1/chats')
.set('Authorization', bearer(alice))
.send({ title: 'Too many', member_ids: [alice.id, ...ids] })
.expect(400);
});
it('отклоняет создание чата с неизвестным участником', async () => {
const alice = await createUser('alice4');
await request(server)
.post('/api/v1/chats')
.set('Authorization', bearer(alice))
.send({
title: 'Unknown member',
member_ids: [alice.id, randomUUID()],
})
.expect(400);
});
it('отклоняет создание чата с пустым/пробельным title', async () => {
const alice = await createUser('alice4b');
await request(server)
.post('/api/v1/chats')
.set('Authorization', bearer(alice))
.send({ title: ' ', member_ids: [alice.id] })
.expect(400);
});
it('возвращает 400 для синтаксически некорректного chat_id (не UUID)', async () => {
const alice = await createUser('alice4c');
const res = await request(server)
.get('/api/v1/chats/not-a-uuid')
.set('Authorization', bearer(alice))
.expect(400);
expect(res.body.error.code).toBe('invalid_request');
});
it('возвращает 404 для корректного по формату, но несуществующего chat_id', async () => {
const alice = await createUser('alice4d');
await request(server)
.get(`/api/v1/chats/${randomUUID()}`)
.set('Authorization', bearer(alice))
.expect(404);
});
});
describe('GET /api/v1/chats (пагинация)', () => {
it('использует limit=50 по умолчанию, если limit не передан', async () => {
const alice = await createUser('pgalice1');
await request(server)
.post('/api/v1/chats')
.set('Authorization', bearer(alice))
.send({ title: 'Only chat', member_ids: [alice.id] })
.expect(201);
const res = await request(server)
.get('/api/v1/chats')
.set('Authorization', bearer(alice))
.expect(200);
expect(res.body.items.length).toBeGreaterThanOrEqual(1);
expect(res.body.items.length).toBeLessThanOrEqual(50);
});
it('отклоняет нечисловой limit', async () => {
const alice = await createUser('pgalice2');
await request(server)
.get('/api/v1/chats?limit=abc')
.set('Authorization', bearer(alice))
.expect(400);
});
it('отклоняет limit=0', async () => {
const alice = await createUser('pgalice3');
await request(server)
.get('/api/v1/chats?limit=0')
.set('Authorization', bearer(alice))
.expect(400);
});
it('отклоняет cursor, не являющийся корректным base64url JSON', async () => {
const alice = await createUser('pgalice4');
await request(server)
.get('/api/v1/chats')
.query({ cursor: 'not-a-real-cursor!!!' })
.set('Authorization', bearer(alice))
.expect(400);
});
it('отклоняет корректно закодированный cursor с id чата, который никогда не существовал', async () => {
const alice = await createUser('pgalice4b');
const bogusCursor = Buffer.from(
JSON.stringify({ id: randomUUID() }),
'utf8',
).toString('base64url');
const res = await request(server)
.get('/api/v1/chats')
.query({ cursor: bogusCursor })
.set('Authorization', bearer(alice))
.expect(400);
expect(res.body.error.code).toBe('invalid_request');
});
it('обходит весь список чатов по страницам без пропусков и дублей', async () => {
const alice = await createUser('pgalice5');
const titles = ['c1', 'c2', 'c3', 'c4', 'c5'];
for (const title of titles) {
await request(server)
.post('/api/v1/chats')
.set('Authorization', bearer(alice))
.send({ title, member_ids: [alice.id] })
.expect(201);
}
const seen: string[] = [];
let cursor: string | null = null;
do {
const res: request.Response = await request(server)
.get('/api/v1/chats')
.query({ limit: 2, ...(cursor ? { cursor } : {}) })
.set('Authorization', bearer(alice))
.expect(200);
seen.push(
...res.body.items.map((c: { title: string }) => c.title),
);
cursor = res.body.next_cursor;
} while (cursor);
expect(seen).toEqual(titles);
});
});
describe('сообщения', () => {
async function createChat(alice: TestUser, bob: TestUser) {
const res = await request(server)
.post('/api/v1/chats')
.set('Authorization', bearer(alice))
.send({ title: 'Chat', member_ids: [alice.id, bob.id] })
.expect(201);
return res.body as { id: string };
}
it('не принимает sender_id, переданный клиентом', async () => {
const alice = await createUser('alice5');
const bob = await createUser('bob5');
const chat = await createChat(alice, bob);
const res = await request(server)
.post(`/api/v1/chats/${chat.id}/messages`)
.set('Authorization', bearer(alice))
.send({ text: 'hi', sender_id: bob.id })
.expect(400);
expect(res.body.error.code).toBe('invalid_request');
});
it('отклоняет пустое сообщение', async () => {
const alice = await createUser('alice6');
const bob = await createUser('bob6');
const chat = await createChat(alice, bob);
await request(server)
.post(`/api/v1/chats/${chat.id}/messages`)
.set('Authorization', bearer(alice))
.send({ text: '' })
.expect(400);
});
it('отклоняет сообщение из одних пробелов', async () => {
const alice = await createUser('alice7');
const bob = await createUser('bob7');
const chat = await createChat(alice, bob);
await request(server)
.post(`/api/v1/chats/${chat.id}/messages`)
.set('Authorization', bearer(alice))
.send({ text: ' \n\t ' })
.expect(400);
});
it('отклоняет отправку в чат, где вызывающий не участник', async () => {
const alice = await createUser('alice8');
const bob = await createUser('bob8');
const eve = await createUser('eve8');
const chat = await createChat(alice, bob);
await request(server)
.post(`/api/v1/chats/${chat.id}/messages`)
.set('Authorization', bearer(eve))
.send({ text: 'intrusion' })
.expect(404);
});
it('отклоняет limit=0 при чтении истории', async () => {
const alice = await createUser('alice9');
const bob = await createUser('bob9');
const chat = await createChat(alice, bob);
await request(server)
.get(`/api/v1/chats/${chat.id}/messages?limit=0`)
.set('Authorization', bearer(alice))
.expect(400);
});
it('отклоняет limit=101 при чтении истории', async () => {
const alice = await createUser('alice10');
const bob = await createUser('bob10');
const chat = await createChat(alice, bob);
await request(server)
.get(`/api/v1/chats/${chat.id}/messages?limit=101`)
.set('Authorization', bearer(alice))
.expect(400);
});
it('отклоняет нечисловой limit', async () => {
const alice = await createUser('alice10b');
const bob = await createUser('bob10b');
const chat = await createChat(alice, bob);
await request(server)
.get(`/api/v1/chats/${chat.id}/messages?limit=abc`)
.set('Authorization', bearer(alice))
.expect(400);
});
it('отклоняет текст сообщения длиннее 4000 Unicode code points', async () => {
const alice = await createUser('alice10c');
const bob = await createUser('bob10c');
const chat = await createChat(alice, bob);
await request(server)
.post(`/api/v1/chats/${chat.id}/messages`)
.set('Authorization', bearer(alice))
.send({ text: 'x'.repeat(4001) })
.expect(400);
});
it('принимает текст сообщения ровно из 4000 Unicode code points', async () => {
const alice = await createUser('alice10d');
const bob = await createUser('bob10d');
const chat = await createChat(alice, bob);
await request(server)
.post(`/api/v1/chats/${chat.id}/messages`)
.set('Authorization', bearer(alice))
.send({ text: 'x'.repeat(4000) })
.expect(201);
});
it('отклоняет текст сообщения свыше 4000 code points, состоящий из эмодзи вне BMP', async () => {
const alice = await createUser('alice10e');
const bob = await createUser('bob10e');
const chat = await createChat(alice, bob);
const text = '👋'.repeat(4001);
expect([...text].length).toBe(4001);
await request(server)
.post(`/api/v1/chats/${chat.id}/messages`)
.set('Authorization', bearer(alice))
.send({ text })
.expect(400);
});
it('отклоняет cursor, не являющийся корректным base64url JSON', async () => {
const alice = await createUser('alice10f');
const bob = await createUser('bob10f');
const chat = await createChat(alice, bob);
await request(server)
.get(`/api/v1/chats/${chat.id}/messages`)
.query({ cursor: '!!!not-valid!!!' })
.set('Authorization', bearer(alice))
.expect(400);
});
it('отклоняет корректно закодированный cursor с id сообщения, которое никогда не существовало в этом чате', async () => {
const alice = await createUser('alice10i');
const bob = await createUser('bob10i');
const chat = await createChat(alice, bob);
await request(server)
.post(`/api/v1/chats/${chat.id}/messages`)
.set('Authorization', bearer(alice))
.send({ text: 'only message' })
.expect(201);
const bogusCursor = Buffer.from(
JSON.stringify({ chatId: chat.id, id: randomUUID() }),
'utf8',
).toString('base64url');
const res = await request(server)
.get(`/api/v1/chats/${chat.id}/messages`)
.query({ cursor: bogusCursor })
.set('Authorization', bearer(alice))
.expect(400);
expect(res.body.error.code).toBe('invalid_request');
});
it('возвращает 400 для синтаксически некорректного chat_id при отправке сообщения', async () => {
const alice = await createUser('alice10g');
const res = await request(server)
.post('/api/v1/chats/not-a-uuid/messages')
.set('Authorization', bearer(alice))
.send({ text: 'hi' })
.expect(400);
expect(res.body.error.code).toBe('invalid_request');
});
it('возвращает 400 для синтаксически некорректного chat_id при чтении истории', async () => {
const alice = await createUser('alice10h');
const res = await request(server)
.get('/api/v1/chats/not-a-uuid/messages')
.set('Authorization', bearer(alice))
.expect(400);
expect(res.body.error.code).toBe('invalid_request');
});
it('отклоняет cursor, взятый из другого чата', async () => {
const alice = await createUser('alice11');
const bob = await createUser('bob11');
const chatA = await createChat(alice, bob);
const chatB = await createChat(alice, bob);
await request(server)
.post(`/api/v1/chats/${chatA.id}/messages`)
.set('Authorization', bearer(alice))
.send({ text: 'first' })
.expect(201);
await request(server)
.post(`/api/v1/chats/${chatA.id}/messages`)
.set('Authorization', bearer(alice))
.send({ text: 'second' })
.expect(201);
const page1 = await request(server)
.get(`/api/v1/chats/${chatA.id}/messages?limit=1`)
.set('Authorization', bearer(alice))
.expect(200);
expect(page1.body.next_cursor).toBeTruthy();
const res = await request(server)
.get(`/api/v1/chats/${chatB.id}/messages`)
.query({ cursor: page1.body.next_cursor })
.set('Authorization', bearer(alice))
.expect(400);
expect(res.body.error.code).toBe('invalid_request');
});
it('обходит всю историю по страницам без пропусков и дублей', async () => {
const alice = await createUser('alice12');
const bob = await createUser('bob12');
const chat = await createChat(alice, bob);
const sentTexts = ['m1', 'm2', 'm3', 'm4', 'm5'];
for (const text of sentTexts) {
await request(server)
.post(`/api/v1/chats/${chat.id}/messages`)
.set('Authorization', bearer(alice))
.send({ text })
.expect(201);
}
const seen: string[] = [];
let cursor: string | null = null;
do {
const res: request.Response = await request(server)
.get(`/api/v1/chats/${chat.id}/messages`)
.query({ limit: 2, ...(cursor ? { cursor } : {}) })
.set('Authorization', bearer(alice))
.expect(200);
seen.push(
...res.body.items.map((m: { text: string }) => m.text),
);
cursor = res.body.next_cursor;
} while (cursor);
expect(seen).toEqual(sentTexts);
});
});
describe('X-Request-Id', () => {
it('присутствует и уникален для независимых запросов', async () => {
const first = await request(server).get('/health/live').expect(200);
const second = await request(server)
.get('/health/live')
.expect(200);
expect(first.headers['x-request-id']).toBeTruthy();
expect(second.headers['x-request-id']).toBeTruthy();
expect(first.headers['x-request-id']).not.toBe(
second.headers['x-request-id'],
);
});
it('совпадает с request_id внутри тела ошибки', async () => {
const res = await request(server)
.get('/api/v1/users/me')
.expect(401);
expect(res.body.error.request_id).toBe(res.headers['x-request-id']);
});
});
});
+179
View File
@@ -0,0 +1,179 @@
import { INestApplication } from '@nestjs/common';
import request from 'supertest';
import { randomUUID } from 'crypto';
import { PrismaService } from '../src/db/prisma.service';
import {
basic,
bearer,
createTestApp,
login,
PASSWORD,
registerUser,
} from './helpers';
describe('Аутентификация и сессии (e2e)', () => {
let app: INestApplication;
let server: any;
beforeAll(async () => {
({ app, server } = await createTestApp());
});
afterAll(async () => {
await app.close();
});
describe('регистрация', () => {
it('требует password', async () => {
await request(server)
.post('/api/v1/users')
.send({ username: `nopw_${randomUUID().slice(0, 8)}`, display_name: 'X' })
.expect(400);
});
it('отклоняет password короче 12 code points', async () => {
await request(server)
.post('/api/v1/users')
.send({
username: `short_${randomUUID().slice(0, 8)}`,
display_name: 'X',
password: 'x'.repeat(11),
})
.expect(400);
});
it('хранит пароль как Argon2id-хеш, а не открытым текстом', async () => {
const user = await registerUser(server, 'hash');
const row = await app
.get(PrismaService)
.user.findUniqueOrThrow({ where: { id: user.id } });
expect(row.passwordHash.startsWith('$argon2id$')).toBe(true);
expect(row.passwordHash).not.toContain(PASSWORD);
});
});
describe('POST /api/v1/auth/sessions', () => {
it('выдаёт непрозрачный Bearer-токен с expires_at и пользователем', async () => {
const user = await registerUser(server, 'login');
const res = await request(server)
.post('/api/v1/auth/sessions')
.set('Authorization', basic(user.username, PASSWORD))
.expect(201);
expect(res.body.token_type).toBe('Bearer');
expect(res.body.token.length).toBeGreaterThanOrEqual(43);
expect(res.body.token).not.toContain(user.id);
expect(res.body.user.id).toBe(user.id);
const expiresIn = Date.parse(res.body.expires_at) - Date.now();
expect(expiresIn).toBeGreaterThan(3500 * 1000);
expect(expiresIn).toBeLessThanOrEqual(3600 * 1000);
});
it('принимает пароль с двоеточием и не-ASCII символами', async () => {
const username = `colon_${randomUUID().slice(0, 8)}`;
const password = 'пароль:с:двоеточием🔑';
await request(server)
.post('/api/v1/users')
.send({ username, display_name: 'X', password })
.expect(201);
await login(server, username, password);
});
it('отвечает одинаковым 401 на неверный пароль и неизвестного пользователя', async () => {
const user = await registerUser(server, 'wrong');
const wrong = await request(server)
.post('/api/v1/auth/sessions')
.set('Authorization', basic(user.username, 'wrong-password-123'))
.expect(401);
const unknown = await request(server)
.post('/api/v1/auth/sessions')
.set('Authorization', basic(`ghost_${randomUUID().slice(0, 8)}`, PASSWORD))
.expect(401);
for (const res of [wrong, unknown]) {
expect(res.headers['www-authenticate']).toBe(
'Basic realm="messenger", charset="UTF-8"',
);
expect(res.body.error.code).toBe('unauthorized');
}
expect(wrong.body.error.message).toBe(unknown.body.error.message);
});
it('отклоняет JSON body при входе даже с верным Basic', async () => {
const user = await registerUser(server, 'body');
for (const body of [{ extra: 'forbidden' }, {}]) {
const res = await request(server)
.post('/api/v1/auth/sessions')
.set('Authorization', basic(user.username, PASSWORD))
.send(body)
.expect(400);
expect(res.body.error.code).toBe('invalid_request');
}
});
it('отвечает 401 без заголовка Authorization', async () => {
const res = await request(server)
.post('/api/v1/auth/sessions')
.expect(401);
expect(res.headers['www-authenticate']).toContain('Basic');
});
});
describe('защищённые endpoint', () => {
it('не принимают Basic', async () => {
const user = await registerUser(server, 'basic');
const res = await request(server)
.get('/api/v1/users/me')
.set('Authorization', basic(user.username, PASSWORD))
.expect(401);
expect(res.headers['www-authenticate']).toBe('Bearer realm="messenger"');
});
it('не принимают X-User-Id сам по себе', async () => {
const user = await registerUser(server, 'xuid');
await request(server)
.get('/api/v1/users/me')
.set('X-User-Id', user.id)
.expect(401);
});
it('игнорируют X-User-Id рядом с Bearer', async () => {
const alice = await registerUser(server, 'alice');
const eve = await registerUser(server, 'eve');
const res = await request(server)
.get('/api/v1/users/me')
.set('Authorization', bearer(alice))
.set('X-User-Id', eve.id)
.expect(200);
expect(res.body.id).toBe(alice.id);
});
it('отвечают 401 на неизвестный токен', async () => {
await request(server)
.get('/api/v1/users/me')
.set('Authorization', 'Bearer unknown-token-value')
.expect(401);
});
});
describe('DELETE /api/v1/auth/sessions/current', () => {
it('отзывает только текущий токен: 204, затем 401 на повтор', async () => {
const user = await registerUser(server, 'logout');
const other = await login(server, user.username);
await request(server)
.delete('/api/v1/auth/sessions/current')
.set('Authorization', bearer(user))
.expect(204);
await request(server)
.get('/api/v1/users/me')
.set('Authorization', bearer(user))
.expect(401);
await request(server)
.delete('/api/v1/auth/sessions/current')
.set('Authorization', bearer(user))
.expect(401);
await request(server)
.get('/api/v1/users/me')
.set('Authorization', `Bearer ${other}`)
.expect(200);
});
});
});
+118
View File
@@ -0,0 +1,118 @@
import { INestApplication } from '@nestjs/common';
import request from 'supertest';
import { randomUUID } from 'crypto';
import {
bearer,
createTestApp,
login,
PASSWORD,
registerUser,
} from './helpers';
describe('Безопасность при конкурентном доступе (e2e)', () => {
let app: INestApplication;
let server: any;
beforeAll(async () => {
({ app, server } = await createTestApp());
});
afterAll(async () => {
await app.close();
});
it('принимает 100 конкурентных сообщений от 10 клиентов и сохраняет ровно 100 уникальных', async () => {
const CLIENTS = 10;
const MESSAGES_PER_CLIENT = 10;
const owner = await registerUser(server, 'owner');
const clients = await Promise.all(
Array.from({ length: CLIENTS }, (_, i) =>
registerUser(server, `racer${i}`),
),
);
const memberIds = [owner.id, ...clients.map((c) => c.id)];
const chat = await request(server)
.post('/api/v1/chats')
.set('Authorization', bearer(owner))
.send({ title: 'Race', member_ids: memberIds })
.expect(201);
const sendTasks: Promise<request.Response>[] = [];
for (let c = 0; c < CLIENTS; c++) {
for (let m = 0; m < MESSAGES_PER_CLIENT; m++) {
sendTasks.push(
request(server)
.post(`/api/v1/chats/${chat.body.id}/messages`)
.set('Authorization', bearer(clients[c]))
.send({ text: `client-${c}-message-${m}` }),
);
}
}
const responses = await Promise.all(sendTasks);
for (const res of responses) {
expect(res.status).toBe(201);
}
const sentIds = new Set(responses.map((r) => r.body.id));
expect(sentIds.size).toBe(CLIENTS * MESSAGES_PER_CLIENT);
const collected: { id: string; text: string }[] = [];
let cursor: string | null = null;
do {
const res: request.Response = await request(server)
.get(`/api/v1/chats/${chat.body.id}/messages`)
.query({ limit: 25, ...(cursor ? { cursor } : {}) })
.set('Authorization', bearer(owner))
.expect(200);
collected.push(...res.body.items);
cursor = res.body.next_cursor;
} while (cursor);
expect(collected.length).toBe(CLIENTS * MESSAGES_PER_CLIENT);
const uniqueIds = new Set(collected.map((m) => m.id));
expect(uniqueIds.size).toBe(CLIENTS * MESSAGES_PER_CLIENT);
const uniqueTexts = new Set(collected.map((m) => m.text));
expect(uniqueTexts.size).toBe(CLIENTS * MESSAGES_PER_CLIENT);
const fullHistory: { id: string; created_at: string }[] =
await request(server)
.get(`/api/v1/chats/${chat.body.id}/messages`)
.query({ limit: 100 })
.set('Authorization', bearer(owner))
.expect(200)
.then((res) => res.body.items);
const sortKeys = fullHistory.map((m) => `${m.created_at}#${m.id}`);
const sortedKeys = [...sortKeys].sort();
expect(sortKeys).toEqual(sortedKeys);
});
it('регистрирует ровно одного пользователя при гонке 10 запросов за один и тот же username', async () => {
const username = `racer_username_${randomUUID().slice(0, 8)}`;
const attempts = 10;
const responses = await Promise.all(
Array.from({ length: attempts }, () =>
request(server)
.post('/api/v1/users')
.send({ username, display_name: 'Racer', password: PASSWORD }),
),
);
const succeeded = responses.filter((r) => r.status === 201);
const conflicted = responses.filter((r) => r.status === 409);
expect(succeeded.length).toBe(1);
expect(conflicted.length).toBe(attempts - 1);
const token = await login(server, username);
const me = await request(server)
.get('/api/v1/users/me')
.set('Authorization', `Bearer ${token}`)
.expect(200);
expect(me.body.id).toBe(succeeded[0].body.id);
});
});
+69
View File
@@ -0,0 +1,69 @@
import { INestApplication } from '@nestjs/common';
import Ajv2020 from 'ajv/dist/2020';
import request from 'supertest';
import { OPERATION_EXAMPLES } from '../src/docs/examples';
import { loadDocument, setupSwagger } from '../src/docs/swagger';
import { createTestApp } from './helpers';
const CONTRACT_ID = 'https://contract.local/openapi.json';
describe('Swagger UI и примеры (e2e)', () => {
let app: INestApplication;
let server: any;
beforeAll(async () => {
({ app, server } = await createTestApp({}, setupSwagger));
});
afterAll(async () => {
await app.close();
});
it('отдаёт Swagger UI и документ контракта со всеми путями', async () => {
await request(server).get('/docs').expect(200);
const res = await request(server).get('/docs-json').expect(200);
expect(res.body.openapi).toBe('3.1.0');
expect(Object.keys(res.body.paths)).toEqual(
Object.keys(loadDocument().paths),
);
expect(res.body.components.securitySchemes).toHaveProperty('basicAuth');
expect(res.body.components.securitySchemes).toHaveProperty('bearerAuth');
});
it('каждый пример запроса и ответа проходит JSON Schema контракта', () => {
const document: any = loadDocument();
const ajv = new Ajv2020({ strict: false, validateFormats: false });
ajv.addSchema(document, CONTRACT_ID);
let checked = 0;
for (const [key, examples] of Object.entries(OPERATION_EXAMPLES)) {
const [method, path] = key.split(' ');
const operation = document.paths[path][method.toLowerCase()];
const targets: [string, any, Record<string, any>][] = [];
if (examples.request) {
targets.push([
'request',
operation.requestBody.content['application/json'].schema,
examples.request,
]);
}
for (const [status, named] of Object.entries(examples.responses)) {
targets.push([
status,
operation.responses[status].content['application/json'].schema,
named,
]);
}
for (const [where, schema, named] of targets) {
const validate = ajv.compile({ $ref: CONTRACT_ID + schema.$ref });
for (const [name, example] of Object.entries(named)) {
const valid = validate(example.value);
expect({ key, where, name, valid, errors: validate.errors }).toEqual(
{ key, where, name, valid: true, errors: null },
);
checked++;
}
}
}
expect(checked).toBeGreaterThan(40);
});
});
+139
View File
@@ -0,0 +1,139 @@
import { INestApplication } from '@nestjs/common';
import request from 'supertest';
import { randomUUID } from 'crypto';
import Redis from 'ioredis';
import { CacheService } from '../src/cache/cache.service';
import { PrismaService } from '../src/db/prisma.service';
import { bearer, createTestApp, registerUser } from './helpers';
const UNREACHABLE_REDIS = 'redis://127.0.0.1:1/0';
const UNREACHABLE_DB = 'postgresql://test:test@127.0.0.1:1/none?connect_timeout=1';
function sleep(ms: number): Promise<void> {
return new Promise((resolve) => setTimeout(resolve, ms));
}
describe('Уровень 4: expiry, отказы зависимостей, rollback (e2e)', () => {
const apps: INestApplication[] = [];
async function start(env: Record<string, string> = {}) {
const started = await createTestApp(env);
apps.push(started.app);
return started;
}
afterAll(async () => {
await Promise.all(apps.map((app) => app.close()));
});
it('сессия истекает при коротком SESSION_TTL_SECONDS, в том числе из кэша', async () => {
const { server } = await start({ SESSION_TTL_SECONDS: '2' });
const user = await registerUser(server, 'ttl');
await request(server)
.get('/api/v1/users/me')
.set('Authorization', bearer(user))
.expect(200);
await sleep(2500);
const res = await request(server)
.get('/api/v1/users/me')
.set('Authorization', bearer(user))
.expect(401);
expect(res.headers['www-authenticate']).toBe('Bearer realm="messenger"');
});
it('без Redis вход, проверка сессии и logout работают через PostgreSQL', async () => {
const { server } = await start({ CACHE_URL: UNREACHABLE_REDIS });
const user = await registerUser(server, 'noredis');
await request(server)
.get('/api/v1/users/me')
.set('Authorization', bearer(user))
.expect(200);
await request(server)
.delete('/api/v1/auth/sessions/current')
.set('Authorization', bearer(user))
.expect(204);
await request(server)
.get('/api/v1/users/me')
.set('Authorization', bearer(user))
.expect(401);
await request(server).get('/api/v1/users/me').expect(401);
});
it('logout при обрыве связи с Redis не оставляет рабочий токен после её восстановления', async () => {
const { app, server } = await start();
const user = await registerUser(server, 'partition');
await request(server)
.get('/api/v1/users/me')
.set('Authorization', bearer(user))
.expect(200);
const cache = app.get(CacheService) as any;
const redis = cache.client as Redis;
expect((await redis.keys('session:v1:*')).length).toBeGreaterThan(0);
redis.disconnect();
await request(server)
.delete('/api/v1/auth/sessions/current')
.set('Authorization', bearer(user))
.expect(204);
await redis.connect();
await sleep(200);
await request(server)
.get('/api/v1/users/me')
.set('Authorization', bearer(user))
.expect(401);
expect(cache.trusted).toBe(true);
});
it('без PostgreSQL отвечает ограниченным 503 и не пускает анонима', async () => {
const healthy = await start();
const user = await registerUser(healthy.server, 'nodb');
await request(healthy.server)
.get('/api/v1/users/me')
.set('Authorization', bearer(user))
.expect(200);
const { server } = await start({ DATABASE_URL: UNREACHABLE_DB });
const ready = await request(server).get('/health/ready').expect(503);
expect(ready.body.error.code).toBe('unavailable');
expect(JSON.stringify(ready.body)).not.toMatch(/127\.0\.0\.1|postgresql:|prisma/i);
await request(server).get('/api/v1/chats').expect(401);
await request(server)
.get('/api/v1/chats')
.set('X-User-Id', user.id)
.expect(401);
await request(server)
.get('/api/v1/chats')
.set('Authorization', 'Bearer unknown-token-value')
.expect(503);
const res = await request(server)
.get('/api/v1/chats')
.set('Authorization', bearer(user))
.expect(503);
expect(res.body.error.code).toBe('unavailable');
await request(server)
.post('/api/v1/users')
.send({
username: `nodb_${randomUUID().slice(0, 8)}`,
display_name: 'X',
password: 'Long-enough-pass-1',
})
.expect(503);
});
it('откатывает создание чата целиком, если один из участников не существует', async () => {
const { app, server } = await start();
const alice = await registerUser(server, 'rollback');
const title = `rollback ${randomUUID()}`;
const res = await request(server)
.post('/api/v1/chats')
.set('Authorization', bearer(alice))
.send({ title, member_ids: [alice.id, randomUUID()] })
.expect(400);
expect(res.body.error.code).toBe('invalid_request');
const prisma = app.get(PrismaService);
expect(await prisma.chat.count({ where: { title } })).toBe(0);
expect(
await prisma.chatMember.count({ where: { userId: alice.id } }),
).toBe(0);
});
});
+5
View File
@@ -0,0 +1,5 @@
import { execSync } from 'child_process';
export default function globalSetup(): void {
execSync('npx prisma migrate deploy', { stdio: 'inherit' });
}
+76
View File
@@ -0,0 +1,76 @@
import { INestApplication } from '@nestjs/common';
import {
FastifyAdapter,
NestFastifyApplication,
} from '@nestjs/platform-fastify';
import { Test } from '@nestjs/testing';
import { randomUUID } from 'crypto';
import request from 'supertest';
import { AppModule } from '../src/app.module';
import { configureApp } from '../src/configure-app';
export const PASSWORD = 'Correct-Horse-Battery-42';
export interface TestUser {
id: string;
username: string;
token: string;
}
export async function createTestApp(
env: Record<string, string> = {},
setup: (app: NestFastifyApplication) => void = () => undefined,
): Promise<{
app: INestApplication;
server: any;
}> {
const saved = { ...process.env };
Object.assign(process.env, env);
let app: NestFastifyApplication;
try {
const moduleRef = await Test.createTestingModule({
imports: [AppModule],
}).compile();
app = moduleRef.createNestApplication<NestFastifyApplication>(
new FastifyAdapter(),
);
} finally {
process.env = saved;
}
configureApp(app);
setup(app);
await app.listen(0, '127.0.0.1');
return { app, server: app.getHttpServer() };
}
export function basic(username: string, password: string): string {
return `Basic ${Buffer.from(`${username}:${password}`, 'utf8').toString('base64')}`;
}
export function bearer(user: TestUser): string {
return `Bearer ${user.token}`;
}
export async function login(
server: any,
username: string,
password = PASSWORD,
): Promise<string> {
const res = await request(server)
.post('/api/v1/auth/sessions')
.set('Authorization', basic(username, password))
.expect(201);
return res.body.token;
}
export async function registerUser(
server: any,
label: string,
): Promise<TestUser> {
const username = `u_${label}_${randomUUID().slice(0, 8)}`;
const res = await request(server)
.post('/api/v1/users')
.send({ username, display_name: `User ${label}`, password: PASSWORD })
.expect(201);
return { id: res.body.id, username, token: await login(server, username) };
}
+10
View File
@@ -0,0 +1,10 @@
{
"moduleFileExtensions": ["js", "json", "ts"],
"rootDir": ".",
"testEnvironment": "node",
"testRegex": ".e2e-spec.ts$",
"globalSetup": "<rootDir>/global-setup.ts",
"transform": {
"^.+\\.(t|j)s$": "ts-jest"
}
}
+4
View File
@@ -0,0 +1,4 @@
{
"extends": "./tsconfig.json",
"exclude": ["node_modules", "test", "dist", "experiments", "**/*spec.ts"]
}
+22
View File
@@ -0,0 +1,22 @@
{
"compilerOptions": {
"module": "commonjs",
"declaration": false,
"removeComments": true,
"emitDecoratorMetadata": true,
"experimentalDecorators": true,
"allowSyntheticDefaultImports": true,
"target": "ES2021",
"sourceMap": true,
"outDir": "./dist",
"baseUrl": "./",
"incremental": true,
"skipLibCheck": true,
"strict": true,
"strictNullChecks": true,
"noImplicitAny": true,
"forceConsistentCasingInFileNames": true,
"esModuleInterop": true,
"types": ["node", "jest"]
}
}