NestJS: Архитектура и основные концепции

Вопрос для собеседования

"Что такое NestJS? Объясни архитектуру: Controllers, Services, Modules. Что такое Dependency Injection?"

Ответ

NestJS — это прогрессивный Node.js фреймворк для создания эффективных и масштабируемых серверных приложений. Построен на TypeScript и использует архитектурные паттерны из Angular.

Основная идея: структурированная архитектура вместо хаоса Express.js.

Что такое NestJS?

📚 Определение

NestJS - это фреймворк для построения серверных приложений на Node.js, который предоставляет:

🏗️ Четкую архитектуру (из коробки)
💉 Dependency Injection (внедрение зависимостей)
📦 Модульную структуру
🎯 TypeScript первоклассная поддержка
🛡️ Типизация везде

🎯 Для чего используется?

NestJS используется для:
✅ REST API
✅ GraphQL API
✅ Микросервисы
✅ WebSockets
✅ CRUD приложения
✅ Enterprise приложения

🔍 Философия

Express.js (хаос):
├── index.js
├── users.js
├── products.js
└── utils.js
     ↓
Нет структуры, каждый делает как хочет

NestJS (порядок):
src/
├── users/
│   ├── users.controller.ts    ← HTTP запросы
│   ├── users.service.ts       ← Бизнес-логика
│   ├── users.module.ts        ← Связывает всё
│   └── dto/                   ← Валидация данных
├── products/
│   ├── products.controller.ts
│   ├── products.service.ts
│   └── products.module.ts
└── app.module.ts              ← Главный модуль
     ↓
Четкая структура, единый стиль

Основные компоненты архитектуры

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

Что это? Обрабатывают HTTP запросы и возвращают ответы.

Аналогия с PHP/Laravel:

// Laravel Controller
class UserController extends Controller {
    public function index() {
        return User::all();
    }
}

NestJS Controller:

// users.controller.ts
import { Controller, Get } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')  // ← Роут: /users
export class UsersController {
  constructor(private usersService: UsersService) {}
  
  @Get()  // ← GET /users
  findAll() {
    return this.usersService.findAll();
  }
  
  @Get(':id')  // ← GET /users/:id
  findOne(@Param('id') id: string) {
    return this.usersService.findOne(id);
  }
  
  @Post()  // ← POST /users
  create(@Body() createUserDto: CreateUserDto) {
    return this.usersService.create(createUserDto);
  }
}

Декораторы для HTTP методов:

@Get()      // GET запрос
@Post()     // POST запрос
@Put()      // PUT запрос
@Patch()    // PATCH запрос
@Delete()   // DELETE запрос

Параметры запроса:

@Get(':id')
findOne(
  @Param('id') id: string,              // /users/123
  @Query('limit') limit: number,        // /users/123?limit=10
  @Body() data: any,                    // Тело запроса (POST/PUT)
  @Headers('authorization') token: string  // Заголовок
) {
  // ...
}

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

Что это? Содержат бизнес-логику приложения.

Зачем? Отделить логику от HTTP слоя (контроллера).

Аналогия с PHP/Laravel:

// Laravel Service
class UserService {
    public function getAllUsers() {
        return User::all();
    }
    
    public function createUser($data) {
        return User::create($data);
    }
}

NestJS Service:

// users.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()  // ← Этот декоратор делает класс "инъектируемым"
export class UsersService {
  private users = [
    { id: 1, name: 'John', email: 'john@mail.com' },
    { id: 2, name: 'Jane', email: 'jane@mail.com' },
  ];
  
  findAll() {
    return this.users;
  }
  
  findOne(id: string) {
    return this.users.find(user => user.id === +id);
  }
  
  create(createUserDto: CreateUserDto) {
    const newUser = {
      id: this.users.length + 1,
      ...createUserDto
    };
    this.users.push(newUser);
    return newUser;
  }
  
  update(id: string, updateUserDto: UpdateUserDto) {
    const user = this.findOne(id);
    if (user) {
      Object.assign(user, updateUserDto);
    }
    return user;
  }
  
  delete(id: string) {
    const index = this.users.findIndex(user => user.id === +id);
    if (index > -1) {
      this.users.splice(index, 1);
      return { deleted: true };
    }
    return { deleted: false };
  }
}

Почему Service отдельно от Controller?

// ❌ Плохо - всё в контроллере
@Controller('users')
export class UsersController {
  @Get()
  findAll() {
    // HTTP логика + бизнес-логика + работа с БД - ВСЁ ВМЕСТЕ!
    const users = database.query('SELECT * FROM users');
    return users.map(u => ({ ...u, fullName: u.firstName + ' ' + u.lastName }));
  }
}

// ✅ Хорошо - разделение ответственности
@Controller('users')
export class UsersController {
  constructor(private usersService: UsersService) {}
  
  @Get()
  findAll() {
    return this.usersService.findAll();  // Только HTTP логика
  }
}

@Injectable()
export class UsersService {
  findAll() {
    // Только бизнес-логика
    const users = this.database.query('SELECT * FROM users');
    return users.map(u => this.formatUser(u));
  }
  
  private formatUser(user) {
    return {
      ...user,
      fullName: `${user.firstName} ${user.lastName}`
    };
  }
}

Преимущества:

✅ Легко тестировать (можно мокировать сервис)
✅ Переиспользуемость (один сервис в нескольких контроллерах)
✅ Чистый код (Single Responsibility Principle)

3. Modules (Модули)

Что это? Группируют связанные компоненты (controllers, services) вместе.

Аналогия с PHP/Laravel:

// Laravel ServiceProvider
class UserServiceProvider extends ServiceProvider {
    public function register() {
        $this->app->bind(UserService::class);
    }
}

NestJS Module:

// users.module.ts
import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';

@Module({
  imports: [],                        // ← Другие модули
  controllers: [UsersController],     // ← Контроллеры
  providers: [UsersService],          // ← Сервисы
  exports: [UsersService],            // ← Что экспортируем наружу
})
export class UsersModule {}

Структура приложения:

// app.module.ts (главный модуль)
import { Module } from '@nestjs/common';
import { UsersModule } from './users/users.module';
import { ProductsModule } from './products/products.module';
import { AuthModule } from './auth/auth.module';

@Module({
  imports: [
    UsersModule,      // Импортируем модуль пользователей
    ProductsModule,   // Импортируем модуль продуктов
    AuthModule,       // Импортируем модуль аутентификации
  ],
})
export class AppModule {}

Визуализация:

AppModule (главный)
├── UsersModule
│   ├── UsersController
│   └── UsersService
├── ProductsModule
│   ├── ProductsController
│   └── ProductsService
└── AuthModule
    ├── AuthController
    └── AuthService

Dependency Injection (Внедрение зависимостей)

📚 Что это?

Dependency Injection (DI) - это паттерн проектирования, где зависимости "инъектируются" в класс, вместо того чтобы класс создавал их сам.

❌ Без DI (плохо):

class UsersController {
  private usersService: UsersService;
  
  constructor() {
    // Контроллер САМ создает сервис
    this.usersService = new UsersService();  // ❌ Жесткая связь!
  }
  
  getUsers() {
    return this.usersService.findAll();
  }
}

// Проблемы:
// - Сложно тестировать (нельзя подменить UsersService)
// - Жесткая связь между классами
// - Если UsersService нужны параметры - усложняется

✅ С DI (хорошо):

@Controller('users')
class UsersController {
  // NestJS САМ создаст и передаст UsersService
  constructor(private usersService: UsersService) {}
  
  @Get()
  getUsers() {
    return this.usersService.findAll();
  }
}

// Преимущества:
// ✅ Легко тестировать (можно передать mock)
// ✅ Слабая связь между классами
// ✅ NestJS управляет жизненным циклом объектов

🔧 Как работает DI в NestJS?

// 1. Помечаем класс как Injectable
@Injectable()
export class UsersService {
  findAll() {
    return ['user1', 'user2'];
  }
}

// 2. Регистрируем в модуле
@Module({
  providers: [UsersService],  // ← NestJS знает про этот сервис
  controllers: [UsersController],
})
export class UsersModule {}

// 3. Инъектируем в контроллер
@Controller('users')
export class UsersController {
  constructor(private usersService: UsersService) {}
  //          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  //          NestJS автоматически передаст экземпляр!
  
  @Get()
  getUsers() {
    return this.usersService.findAll();
  }
}

Магия происходит:

1. NestJS видит UsersController в module
2. Видит что UsersController требует UsersService в constructor
3. Находит UsersService в providers
4. Создает экземпляр UsersService
5. Передает его в UsersController
6. Кэширует UsersService (singleton по умолчанию)

💡 Сервис может использовать другой сервис:

// email.service.ts
@Injectable()
export class EmailService {
  sendEmail(to: string, subject: string) {
    console.log(`Отправка письма на ${to}`);
  }
}

// users.service.ts
@Injectable()
export class UsersService {
  // UsersService использует EmailService!
  constructor(private emailService: EmailService) {}
  
  createUser(data: CreateUserDto) {
    const user = this.saveToDatabase(data);
    
    // Отправляем приветственное письмо
    this.emailService.sendEmail(user.email, 'Добро пожаловать!');
    
    return user;
  }
}

// users.module.ts
@Module({
  providers: [
    UsersService,
    EmailService,  // ← Оба сервиса зарегистрированы
  ],
  controllers: [UsersController],
})
export class UsersModule {}

Декораторы в NestJS

Что такое декоратор? Специальная функция с @, которая добавляет метаданные к классу/методу/параметру.

Основные декораторы:

1. Декораторы классов

@Controller('users')     // Помечает класс как контроллер
@Injectable()            // Помечает класс как инъектируемый
@Module({})              // Помечает класс как модуль

2. Декораторы методов (HTTP)

@Get()                   // GET запрос
@Post()                  // POST запрос
@Put()                   // PUT запрос
@Patch()                 // PATCH запрос
@Delete()                // DELETE запрос

@Get(':id')              // GET с параметром
@Post('create')          // POST на /users/create

3. Декораторы параметров

@Param('id')             // Параметр из URL
@Query('page')           // Query параметр (?page=1)
@Body()                  // Тело запроса
@Headers('token')        // Заголовок
@Req()                   // Весь объект request
@Res()                   // Весь объект response

Пример использования всех вместе:

@Controller('articles')  // ← Декоратор класса
export class ArticlesController {
  constructor(private articlesService: ArticlesService) {}
  
  @Get()  // ← Декоратор метода
  findAll(@Query('page') page: number) {  // ← Декоратор параметра
    return this.articlesService.findAll(page);
  }
  
  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.articlesService.findOne(id);
  }
  
  @Post()
  create(@Body() createArticleDto: CreateArticleDto) {
    return this.articlesService.create(createArticleDto);
  }
  
  @Patch(':id')
  update(
    @Param('id') id: string,
    @Body() updateArticleDto: UpdateArticleDto
  ) {
    return this.articlesService.update(id, updateArticleDto);
  }
  
  @Delete(':id')
  delete(@Param('id') id: string) {
    return this.articlesService.delete(id);
  }
}

Полный пример: CRUD для статей

Структура:

src/articles/
├── articles.controller.ts
├── articles.service.ts
├── articles.module.ts
└── dto/
    ├── create-article.dto.ts
    └── update-article.dto.ts

1. DTO (Data Transfer Object)

// dto/create-article.dto.ts
export class CreateArticleDto {
  title: string;
  content: string;
  category: string;
  tags: string[];
}

// dto/update-article.dto.ts
export class UpdateArticleDto {
  title?: string;
  content?: string;
  category?: string;
  tags?: string[];
}

2. Service

// articles.service.ts
import { Injectable } from '@nestjs/common';
import { CreateArticleDto } from './dto/create-article.dto';
import { UpdateArticleDto } from './dto/update-article.dto';

@Injectable()
export class ArticlesService {
  private articles = [
    {
      id: 1,
      title: 'Введение в NestJS',
      content: 'NestJS это...',
      category: 'javascript',
      tags: ['nestjs', 'node.js']
    }
  ];
  
  findAll() {
    return this.articles;
  }
  
  findOne(id: number) {
    return this.articles.find(article => article.id === id);
  }
  
  create(createArticleDto: CreateArticleDto) {
    const newArticle = {
      id: this.articles.length + 1,
      ...createArticleDto
    };
    this.articles.push(newArticle);
    return newArticle;
  }
  
  update(id: number, updateArticleDto: UpdateArticleDto) {
    const article = this.findOne(id);
    if (article) {
      Object.assign(article, updateArticleDto);
      return article;
    }
    return null;
  }
  
  delete(id: number) {
    const index = this.articles.findIndex(a => a.id === id);
    if (index > -1) {
      this.articles.splice(index, 1);
      return { deleted: true };
    }
    return { deleted: false };
  }
}

3. Controller

// articles.controller.ts
import { 
  Controller, 
  Get, 
  Post, 
  Put, 
  Delete, 
  Param, 
  Body 
} from '@nestjs/common';
import { ArticlesService } from './articles.service';
import { CreateArticleDto } from './dto/create-article.dto';
import { UpdateArticleDto } from './dto/update-article.dto';

@Controller('articles')
export class ArticlesController {
  constructor(private articlesService: ArticlesService) {}
  
  @Get()
  findAll() {
    return this.articlesService.findAll();
  }
  
  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.articlesService.findOne(+id);
  }
  
  @Post()
  create(@Body() createArticleDto: CreateArticleDto) {
    return this.articlesService.create(createArticleDto);
  }
  
  @Put(':id')
  update(
    @Param('id') id: string,
    @Body() updateArticleDto: UpdateArticleDto
  ) {
    return this.articlesService.update(+id, updateArticleDto);
  }
  
  @Delete(':id')
  delete(@Param('id') id: string) {
    return this.articlesService.delete(+id);
  }
}

4. Module

// articles.module.ts
import { Module } from '@nestjs/common';
import { ArticlesController } from './articles.controller';
import { ArticlesService } from './articles.service';

@Module({
  controllers: [ArticlesController],
  providers: [ArticlesService],
  exports: [ArticlesService],  // Если хотим использовать в других модулях
})
export class ArticlesModule {}

5. Подключение к главному модулю

// app.module.ts
import { Module } from '@nestjs/common';
import { ArticlesModule } from './articles/articles.module';

@Module({
  imports: [ArticlesModule],
})
export class AppModule {}

Тестирование API

После создания модуля, можешь протестировать:

# GET все статьи
curl http://localhost:3000/articles

# GET одна статья
curl http://localhost:3000/articles/1

# POST создать статью
curl -X POST http://localhost:3000/articles \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Новая статья",
    "content": "Содержимое",
    "category": "javascript",
    "tags": ["nestjs"]
  }'

# PUT обновить статью
curl -X PUT http://localhost:3000/articles/1 \
  -H "Content-Type: application/json" \
  -d '{"title": "Обновленное название"}'

# DELETE удалить статью
curl -X DELETE http://localhost:3000/articles/1

Сравнение с PHP/Laravel

Концепция	Laravel	NestJS
Роутинг	routes/web.php	@Get(), @Post() декораторы
Контроллер	UserController extends Controller	@Controller() class
Сервис	app/Services/UserService	@Injectable() class
DI	app()->make(UserService::class)	constructor(private service)
Модель	User extends Model	Entity (TypeORM/Prisma)
Middleware	app/Http/Middleware	@UseGuards(), @UseInterceptors()
Валидация	FormRequest	DTO + class-validator
Конфиг	config/app.php	ConfigModule

Пример: Тот же код на Laravel и NestJS

Laravel:

// routes/api.php
Route::get('/users', [UserController::class, 'index']);

// app/Http/Controllers/UserController.php
class UserController extends Controller {
    public function __construct(
        private UserService $userService
    ) {}
    
    public function index() {
        return $this->userService->getAllUsers();
    }
}

// app/Services/UserService.php
class UserService {
    public function getAllUsers() {
        return User::all();
    }
}

NestJS:

// users.controller.ts
@Controller('users')
export class UsersController {
  constructor(private usersService: UsersService) {}
  
  @Get()
  findAll() {
    return this.usersService.getAllUsers();
  }
}

// users.service.ts
@Injectable()
export class UsersService {
  getAllUsers() {
    return this.userRepository.find();
  }
}

Очень похоже! Если знаешь Laravel - быстро освоишь NestJS. 🎯

Преимущества NestJS

✅ Для разработчика:

Структура из коробки
- Не нужно думать "как организовать код"
- Единый стиль в команде
TypeScript
- Автодополнение в IDE
- Меньше ошибок
- Рефакторинг проще
Модульность
- Легко разбить на микросервисы
- Переиспользование модулей
- Изолированное тестирование
Dependency Injection
- Легкое тестирование
- Слабая связанность
- Управление зависимостями автоматическое
Экосистема
- TypeORM, Prisma для БД
- Passport для аутентификации
- GraphQL из коробки
- WebSockets, Microservices

✅ Для проекта:

Масштабируемость
- От маленького API до Enterprise
- Четкая архитектура не разваливается
Тестируемость
- Unit тесты легко писать
- E2E тесты встроены
- Моки работают отлично
Производительность
- Быстрее голого Express (оптимизации)
- Асинхронность из коробки
Документация
- Swagger интеграция автоматическая
- Отличная официальная документация

Когда использовать NestJS?

✅ Используй NestJS когда:

🏢 Enterprise проект (много разработчиков)
📈 Проект будет расти (масштабируемость)
🔒 Нужна типизация (меньше багов)
🏗️ Хочешь структуру (не хаос Express)
🧪 Важны тесты (легко тестировать)
🎓 Команда знает Angular/Laravel (похожая архитектура)

⚠️ Можешь не использовать когда:

🚀 MVP за неделю (можно Express + быстрее)
👤 Соло проект на 2 дня (overhead)
📚 Обучение Node.js (начни с Express)
🪶 Нужна легковесность (NestJS тяжелее Express)

Вопросы для самопроверки

Что такое NestJS?

Ответ
Прогрессивный Node.js фреймворк на TypeScript для создания масштабируемых серверных приложений с четкой архитектурой.
Какие три основных компонента архитектуры NestJS?

Ответ
Controllers (обработка HTTP), Services (бизнес-логика), Modules (группировка компонентов).
Что делает декоратор @Controller()?

Ответ
Помечает класс как контроллер, который обрабатывает HTTP запросы. Принимает путь роута как параметр.
Что делает декоратор @Injectable()?

Ответ
Помечает класс как доступный для внедрения зависимостей (Dependency Injection).
Что такое Dependency Injection?

Ответ
Паттерн проектирования, где зависимости "инъектируются" в класс автоматически, вместо того чтобы класс создавал их сам. NestJS управляет созданием и передачей зависимостей.
Зачем Service отдельно от Controller?

Ответ
Разделение ответственности: Controller - только HTTP логика, Service - бизнес-логика. Легче тестировать, переиспользовать, поддерживать.
Что регистрируется в @Module()?

Ответ
imports (другие модули), controllers (контроллеры), providers (сервисы и другие инъектируемые классы), exports (что доступно другим модулям).
В чем разница между @Get() и @Get(':id')?

Ответ
@Get() - обрабатывает GET /route. @Get(':id') - обрабатывает GET /route/:id (с параметром).

Полезные ссылки

Следующие шаги

После изучения основ, стоит посмотреть:

📦 TypeORM / Prisma - работа с базой данных
🔐 Guards & Middleware - аутентификация и авторизация
✅ Pipes & Validation - валидация данных (class-validator)
🔌 Interceptors - трансформация запросов/ответов
🧪 Testing - Unit и E2E тесты

Итог

✅ NestJS - фреймворк с четкой архитектурой
✅ Controllers - обрабатывают HTTP запросы
✅ Services - содержат бизнес-логику
✅ Modules - группируют компоненты
✅ Dependency Injection - автоматическое управление зависимостями
✅ Декораторы - добавляют метаданные (@Controller, @Get, @Injectable)
✅ Очень похож на Laravel - будет легко освоить

На собеседовании важно:

Объяснить разницу Controller/Service/Module
Рассказать про Dependency Injection
Понимать зачем декораторы
Уметь создать простой CRUD
Сравнить с Express (структура vs хаос)

Дата создания: 2026-01-26
Связанные материалы:

004-es-modules-vs-commonjs.md
005-default-vs-named-export.md

Шпаргалка