Из каких компонентов состоит Nest.js

Компоненты NestJS архитектуры

NestJS — это модульный фреймворк, построенный на основе принципов многоуровневой архитектуры. Приложение состоит из взаимосвязанных компонентов, которые работают вместе для обработки запросов.

Основные компоненты NestJS

1. Controllers (Контроллеры)

Обрабатывают входящие HTTP запросы и отправляют ответы. Это первая линия обработки.

import { Controller, Get, Post, Body } from '@nestjs/common';
import { UserService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private userService: UserService) {}

  @Get()
  getAllUsers() {
    return this.userService.findAll();
  }

  @Post()
  createUser(@Body() data: CreateUserDto) {
    return this.userService.create(data);
  }
}

2. Services (Сервисы)

Содержат бизнес-логику приложения. Могут быть переиспользованы несколькими контроллерами.

import { Injectable } from '@nestjs/common';

@Injectable()
export class UsersService {
  private users = [];

  findAll() {
    return this.users;
  }

  create(data: CreateUserDto) {
    const user = { id: Date.now(), ...data };
    this.users.push(user);
    return user;
  }
}

3. Modules (Модули)

Группируют контроллеры, сервисы и другие компоненты в логические единицы. Обеспечивают инкапсуляцию и переиспользуемость.

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 {}

4. Providers (Провайдеры)

Любой класс с декоратором @Injectable(). Может быть инъектирован в другие компоненты через Dependency Injection.

// Services, Guards, Interceptors, Pipes - всё это провайдеры
@Injectable()
export class ConfigService {
  // Провайдер
}

5. Middleware (Промежуточное ПО)

Обрабатывает запросы до попадания в контроллеры. Используется для логирования, валидации, кеширования.

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.originalUrl}`);
    next();
  }
}

// В модуле
@Module({})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('*'); // Для всех маршрутов
  }
}

6. Guards (Охранители)

Определяют, может ли запрос быть обработан контроллером. Используются для авторизации и аутентификации.

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const token = request.headers.authorization;
    return !!token && this.validateToken(token);
  }

  private validateToken(token: string): boolean {
    // Проверка токена
    return true;
  }
}

// Использование
@Controller('posts')
export class PostsController {
  @Get()
  @UseGuards(AuthGuard)
  getPosts() {
    return [];
  }
}

7. Interceptors (Перехватчики)

Перенаправляют запросы и ответы. Используются для трансформации данных, обработки ошибок, логирования.

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

@Injectable()
export class TransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      map(data => ({
        success: true,
        data: data,
        timestamp: new Date().toISOString(),
      })),
    );
  }
}

// Использование
@Controller('users')
@UseInterceptors(TransformInterceptor)
export class UsersController {
  // Все ответы будут обёрнуты в { success, data, timestamp }
}

8. Pipes (Трубопроводы)

Преобразуют и валидируют данные перед попаданием в контроллер.

import { PipeTransform, Injectable, BadRequestException } from '@nestjs/common';

@Injectable()
export class ParseIntPipe implements PipeTransform<string, number> {
  transform(value: string): number {
    const val = parseInt(value, 10);
    if (isNaN(val)) {
      throw new BadRequestException('ID должен быть числом');
    }
    return val;
  }
}

// Использование
@Controller('posts')
export class PostsController {
  @Get(':id')
  getPost(@Param('id', ParseIntPipe) id: number) {
    return { id, title: 'My Post' };
  }
}

9. Filters (Фильтры исключений)

Обрабатывают исключения, выброшенные в приложении.

import { ExceptionFilter, Catch, ArgumentsHost } from '@nestjs/common';
import { Response } from 'express';

@Catch()
export class GlobalExceptionFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();

    response.status(500).json({
      message: 'Internal Server Error',
      error: exception instanceof Error ? exception.message : 'Unknown error',
    });
  }
}

// В main.ts
app.useGlobalFilters(new GlobalExceptionFilter());

10. DTOs (Data Transfer Objects)

Объекты для переноса данных между слоями приложения.

export class CreateUserDto {
  name: string;
  email: string;
  password: string;
}

Архитектурная схема NestJS

Client (HTTP Request)
  ↓
[Middleware] - логирование, парсинг
  ↓
[Guards] - авторизация, проверки
  ↓
[Pipes] - валидация, трансформация
  ↓
[Controllers] - маршрутизация
  ↓
[Interceptors] - обработка запроса
  ↓
[Services] - бизнес-логика
  ↓
[Repositories] - работа с БД
  ↓
Database
  ↓
[Interceptors] - трансформация ответа
  ↓
[Filters] - обработка ошибок
  ↓
Client (HTTP Response)

Пример полного цикла

// 1. DTO
export class CreatePostDto {
  title: string;
  content: string;
}

// 2. Pipe для валидации
@Injectable()
export class ValidatePostPipe implements PipeTransform {
  transform(value: CreatePostDto) {
    if (!value.title || value.title.length < 3) {
      throw new BadRequestException('Title слишком короткий');
    }
    return value;
  }
}

// 3. Guard для авторизации
@Injectable()
export class PostAuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    return !!request.user; // Проверка авторизации
  }
}

// 4. Service с бизнес-логикой
@Injectable()
export class PostsService {
  create(dto: CreatePostDto) {
    return { id: 1, ...dto, createdAt: new Date() };
  }
}

// 5. Controller с всеми компонентами
@Controller('posts')
export class PostsController {
  constructor(private postsService: PostsService) {}

  @Post()
  @UseGuards(PostAuthGuard)
  createPost(
    @Body(ValidatePostPipe) createPostDto: CreatePostDto,
    @Request() req: any,
  ) {
    return this.postsService.create(createPostDto);
  }
}

Порядок выполнения компонентов

1. Middleware — первым обрабатывает входящий запрос
2. Guards — проверяет права доступа
3. Interceptors (входящие) — может модифицировать запрос
4. Pipes — валидирует параметры
5. Controllers & Services — обработка бизнес-логики
6. Interceptors (исходящие) — трансформирует ответ
7. Filters — ловит исключения
8. Response — отправляет ответ клиенту

Все компоненты NestJS работают вместе, обеспечивая гибкую и масштабируемую архитектуру приложения.