Node.js, Express, NestJS
Материал для подготовки к собеседованию (Middle / Senior). Node.js — среда выполнения JavaScript на сервере (V8 + libuv). Дополнительно — фреймворки Express (минималистичный) и NestJS (структурный, на TypeScript). Термины на английском там, где это принято.
Содержание
- Что такое Node.js
- Event Loop в Node.js
- process.nextTick, setImmediate, setTimeout
- Модули: CommonJS vs ESM
- Однопоточность и блокирующий код
- Потоки (Streams) и Buffer
- EventEmitter
- Асинхронность: callbacks, promises, async/await
- Масштабирование: cluster, worker_threads, child_process
- HTTP-сервер и middleware
- Обработка ошибок
- Производительность и память
- Безопасность
- npm и зависимости
- ORM: Prisma и TypeORM
- Аутентификация (кратко)
- Express
- NestJS
- NestJS глубже: pipes, guards, interceptors, filters
- Express vs NestJS
- Вероятные вопросы
Что такое Node.js
Node.js — среда выполнения JavaScript вне браузера, построенная на движке V8 (тот же, что в Chrome) и библиотеке libuv (асинхронный ввод-вывод, event loop, пул потоков).
Ключевые особенности:
- Однопоточный event loop для JS-кода + неблокирующий ввод-вывод — один процесс обслуживает много соединений без потока на каждое.
- Асинхронность — операции ввода-вывода (файлы, сеть, БД) не блокируют выполнение; результат приходит через колбэк/промис.
- Событийная модель (event-driven).
- Идеален для I/O-bound задач (API, реалтайм, прокси); плохо подходит для тяжёлых CPU-bound вычислений в одном потоке (блокируют event loop).
Node = V8 (исполняет JS) + libuv (event loop, thread pool, асинхронный I/O) + встроенные модули (fs, http, crypto, stream и т.д.) + C++ биндинги.
Event Loop в Node.js
Event Loop — механизм, который позволяет Node выполнять неблокирующие операции, несмотря на однопоточность JS. Он крутится по фазам, на каждой обрабатывает свою очередь колбэков:
┌───────────────────────────┐
┌─>│ timers │ колбэки setTimeout / setInterval
│ ├───────────────────────────┤
│ │ pending callbacks │ отложенные системные колбэки (ошибки TCP и т.п.)
│ ├───────────────────────────┤
│ │ idle, prepare │ внутреннее
│ ├───────────────────────────┤ ┌───────────────┐
│ │ poll │<────│ входящие I/O │ ожидание и обработка I/O
│ ├───────────────────────────┤ └───────────────┘
│ │ check │ колбэки setImmediate
│ ├───────────────────────────┤
└──┤ close callbacks │ колбэки закрытия (socket.on('close'))
└───────────────────────────┘
Между фазами (и после каждого колбэка) Node опустошает очереди микрозадач: сначала process.nextTick, затем промисы (.then/await). То есть микрозадачи имеют приоритет над фазами макроочередей.
Важное отличие от браузера: в браузере (упрощённо) одна очередь макрозадач — по спецификации task queues несколько, и браузер сам выбирает, из какой брать; в Node — фиксированные фазы; плюс есть особая очередь process.nextTick.
process.nextTick, setImmediate, setTimeout
Частый вопрос — порядок выполнения:
process.nextTick(cb)— выполнится сразу после текущей операции, до продолжения event loop (даже раньше промисов). Самый высокий приоритет. Злоупотребление может «заморозить» loop.- Промисы (
.then,await) — микрозадачи, послеnextTick, но до перехода к следующей фазе. setImmediate(cb)— выполнится в фазе check (после фазы poll) — «на следующей итерации».setTimeout(cb, 0)— фаза timers, с минимальной задержкой (~1мс), порядок относительноsetImmediateзависит от контекста.
console.log('1');
setTimeout(() => console.log('timeout'), 0);
setImmediate(() => console.log('immediate'));
process.nextTick(() => console.log('nextTick'));
Promise.resolve().then(() => console.log('promise'));
console.log('2');
// Порядок: 1, 2, nextTick, promise, (timeout / immediate — зависит),
// внутри I/O-колбэка setImmediate всегда раньше setTimeout
Приоритет очередей: синхронный код → process.nextTick → промисы (микрозадачи) → фазы loop (timers/poll/check…).
Модули: CommonJS vs ESM
CommonJS (CJS) — исторический модульный формат Node (require/module.exports):
// экспорт
module.exports = { sum };
// импорт
const { sum } = require('./math');
ES Modules (ESM) — стандарт JS (import/export), поддерживается в Node (файлы .mjs или "type": "module" в package.json):
export function sum(a, b) { return a + b; }
import { sum } from './math.js';
Различия:
| CommonJS | ESM | |
|---|---|---|
| Синтаксис | require/module.exports |
import/export |
| Загрузка | синхронная, в рантайме | асинхронная, статический анализ |
| Когда резолвится | во время выполнения | до выполнения (hoisting импортов) |
__dirname/__filename |
есть | нет (через import.meta.url) |
| Top-level await | нет | есть |
| Tree-shaking | хуже | лучше (статичность) |
Require-кэш: модуль в CJS выполняется один раз, результат кэшируется (повторный require вернёт закэшированный module.exports). Смешивать CJS и ESM можно с ограничениями: ESM может импортировать CJS; обратно — через динамический import(), а с Node 22.12+/20.19+ работает и синхронный require(esm) (если в ESM-графе нет top-level await, иначе ERR_REQUIRE_ASYNC_MODULE).
Однопоточность и блокирующий код
JS-код в Node выполняется в одном потоке. Если выполнить тяжёлую синхронную операцию (большой цикл, синхронное чтение файла, сложная криптография), она заблокирует event loop — сервер перестанет отвечать на все запросы, пока не закончит.
// ПЛОХО — блокирует весь процесс
const data = fs.readFileSync('huge.file'); // синхронно
for (let i = 0; i < 1e10; i++) {} // CPU-bound в основном потоке
// ХОРОШО — асинхронно
const data = await fs.promises.readFile('huge.file');
Правила: избегать *Sync-методов в обработчиках запросов; тяжёлые вычисления выносить в worker_threads или отдельный сервис; разбивать длинные задачи. Пул потоков libuv (по умолчанию 4, UV_THREADPOOL_SIZE) обслуживает файловый I/O, DNS, часть crypto — но JS-колбэки всё равно в одном потоке.
Потоки (Streams) и Buffer
Buffer — область памяти для работы с бинарными данными (вне V8-кучи). Нужен, т.к. JS-строки не подходят для сырых байтов (файлы, сеть, изображения).
const buf = Buffer.from('hello', 'utf8');
buf.toString('hex');
Streams (потоки) — обработка данных по частям (chunks), не загружая всё в память. Критично для больших файлов/сетевых данных.
Типы потоков:
- Readable — источник чтения (
fs.createReadStream, HTTP request). - Writable — приёмник записи (
fs.createWriteStream, HTTP response). - Duplex — и чтение, и запись (TCP socket).
- Transform — Duplex, преобразующий данные на лету (gzip, шифрование).
// Копирование файла потоком — почти без памяти
const rs = fs.createReadStream('in.mp4');
const ws = fs.createWriteStream('out.mp4');
rs.pipe(ws);
// pipeline — с корректной обработкой ошибок
const { pipeline } = require('stream/promises');
await pipeline(
fs.createReadStream('in.txt'),
zlib.createGzip(),
fs.createWriteStream('out.txt.gz'),
);
Backpressure (обратное давление) — когда источник отдаёт данные быстрее, чем приёмник успевает обрабатывать. pipe/pipeline управляют этим автоматически (притормаживают чтение), поэтому их предпочитают ручной обработке событий data.
EventEmitter
EventEmitter — основа событийной модели Node: подписка на именованные события и их эмит. Многие встроенные объекты (streams, HTTP server) наследуют его.
const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.on('order', (data) => console.log('получен заказ', data)); // подписка
emitter.emit('order', { id: 1 }); // эмит
emitter.once('init', () => {}); // однократно
Особенности: обработчики вызываются синхронно в порядке подписки; событие error без обработчика роняет процесс; следить за числом слушателей (предупреждение о возможной утечке при >10).
Асинхронность: callbacks, promises, async/await
Эволюция подходов:
- Callbacks — исторический стиль, «error-first callback» (первый аргумент — ошибка). Приводит к «callback hell» при вложенности.
fs.readFile('f.txt', (err, data) => {
if (err) return handle(err);
// ...
});
- Promises — цепочки
.then/.catch,Promise.all/race/allSettled/any. - async/await — синтаксический сахар над промисами; ошибки через
try/catch.
async function load() {
try {
const [a, b] = await Promise.all([fetchA(), fetchB()]); // параллельно
return process(a, b);
} catch (e) {
logger.error(e);
throw e;
}
}
util.promisify превращает callback-функцию в промис-версию. Современные API Node уже дают промис-версии (fs.promises).
Масштабирование: cluster, worker_threads, child_process
Один процесс Node использует одно ядро для JS. Способы задействовать больше:
- cluster — форкает несколько процессов-воркеров, слушающих один порт (балансировка соединений мастером). Масштабирование по ядрам для I/O-bound серверов. Процессы не разделяют память.
const cluster = require('cluster');
const os = require('os');
if (cluster.isPrimary) {
os.cpus().forEach(() => cluster.fork());
} else {
startServer();
}
- worker_threads — настоящие потоки внутри одного процесса, с возможностью разделять память (
SharedArrayBuffer). Для CPU-bound задач (обработка данных, вычисления), чтобы не блокировать основной event loop. - child_process (
spawn,exec,fork) — запуск внешних процессов/скриптов.
В проде часто используют менеджер процессов PM2 (или запуск в контейнерах/оркестраторе), который поднимает кластер, перезапускает при падении, следит за памятью.
HTTP-сервер и middleware
Базовый HTTP-сервер на встроенном модуле:
const http = require('http');
const server = http.createServer((req, res) => {
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
server.listen(3000);
На практике используют фреймворки (Express, Fastify, NestJS). Middleware — функции, обрабатывающие запрос по цепочке (логирование, парсинг тела, аутентификация, обработка ошибок). Также популярны WebSockets (ws, Socket.IO) для реалтайма.
Обработка ошибок
- Синхронные / async-await —
try/catch. - Промисы —
.catch. - Callbacks — error-first (
if (err) ...). - EventEmitter — обработчик события
error.
Глобальные «ловушки последней надежды» (не для штатной обработки, а для логирования и корректного завершения):
process.on('uncaughtException', (err) => { logger.fatal(err); process.exit(1); });
process.on('unhandledRejection', (reason) => { logger.error(reason); });
С Node 15 необработанный rejection по умолчанию (--unhandled-rejections=throw) завершает процесс, как uncaughtException; если повесить обработчик unhandledRejection, процесс не упадёт — тогда завершать его нужно самому.
Правильная практика: не «глотать» ошибки; централизованный обработчик ошибок (в Express — error-middleware с 4 аргументами); при фатальной ошибке — залогировать и перезапустить процесс (за это отвечает PM2/оркестратор), а не продолжать в неопределённом состоянии. Graceful shutdown — по SIGTERM/SIGINT закрыть сервер, дождаться активных запросов, закрыть соединения с БД.
Производительность и память
- V8 heap ограничен (дефолтный лимит old space зависит от версии Node и доступной RAM/лимита контейнера; задаётся явно
--max-old-space-size). Утечки памяти → рост heap → падение. - Профилирование:
--inspect+ Chrome DevTools,clinic.js, heap snapshots, flame graphs (0x). - Утечки — типичные причины: не убранные слушатели событий, замыкания, глобальные кэши без ограничения, незакрытые соединения.
- Кэширование (Redis), пул соединений с БД, не блокировать event loop, стримить большие ответы.
- Мониторинг event loop lag — метрика задержки цикла (если растёт — блокируется).
Безопасность
- Валидация входных данных (Joi, zod, class-validator в Nest).
- Защита от инъекций (параметризованные запросы), XSS (экранирование), CSRF для сессий.
- Заголовки безопасности — helmet.
- Rate limiting — express-rate-limit (защита от brute force/DDoS).
- Хранить секреты в переменных окружения (dotenv), не в коде.
- Регулярный аудит зависимостей (
npm audit) — уязвимости в пакетах частая проблема. - Не запускать процесс от root; ограничивать CORS.
npm и зависимости
- package.json — манифест: зависимости, скрипты, метаданные.
- package-lock.json — фиксирует точные версии всего дерева зависимостей (воспроизводимые сборки).
npm ciставит строго по lock (для CI). - Semver (
^1.2.3— совместимые в мажоре,~1.2.3— в миноре, точная версия). dependenciesvsdevDependencies(только для разработки/сборки) vspeerDependencies.- Альтернативы npm: yarn, pnpm (быстрее, экономит место через симлинки/хардлинки).
ORM: Prisma и TypeORM
В Node для работы с БД используют ORM/query-builder. Два самых популярных — Prisma и TypeORM (оба на TypeScript).
Prisma
Prisma — современный тулкит: схема в отдельном файле schema.prisma, генерация типобезопасного клиента, миграции.
// schema.prisma
model User {
id Int @id @default(autoincrement())
email String @unique
name String?
posts Post[]
}
model Post {
id Int @id @default(autoincrement())
title String
author User @relation(fields: [authorId], references: [id])
authorId Int
}
const prisma = new PrismaClient();
const user = await prisma.user.create({ data: { email: "a@b.c", name: "Вася" } });
const users = await prisma.user.findMany({
where: { name: { contains: "Вас" } },
include: { posts: true }, // eager-загрузка связи
});
Плюсы: полная типобезопасность (клиент генерируется из схемы), удобные миграции (prisma migrate), понятный API, отличный DX. Минус: своя схема-DSL (не декораторы), меньше гибкости в очень сложных запросах (есть $queryRaw).
TypeORM
TypeORM — классический ORM с моделями-сущностями через декораторы (Data Mapper или Active Record). Часто идёт с NestJS.
@Entity()
export class User {
@PrimaryGeneratedColumn() id: number;
@Column({ unique: true }) email: string;
@OneToMany(() => Post, (post) => post.author) posts: Post[];
}
const repo = dataSource.getRepository(User);
const user = await repo.findOne({ where: { email }, relations: { posts: true } });
await repo.save(repo.create({ email: "a@b.c" }));
Плюсы: гибкость, поддержка Active Record и Data Mapper, интеграция с Nest (@nestjs/typeorm). Минусы: типобезопасность слабее Prisma, исторически были нестабильности, миграции менее удобные. Третий вариант — Sequelize (зрелый, но без сильной типизации).
Общее: обе решают маппинг объектов на таблицы, связи (relations), миграции, защиту от SQL-инъекций (параметризация). Проблема N+1 актуальна и тут — грузить связи через include/relations, а не в цикле.
Аутентификация (кратко)
Способы аутентификации в Node/Express/Nest:
- Сессии (session-based) — сервер хранит сессию (в памяти/Redis), клиент носит cookie с session id. Подходит для классических веб-приложений (
express-session). Stateful. - JWT (token-based) — сервер выдаёт подписанный токен, клиент шлёт его в
Authorization: Bearer <token>; сервер не хранит состояние (stateless). Подходит для API/SPA/мобильных.
import jwt from "jsonwebtoken";
// выдать токен при логине
const token = jwt.sign({ userId: user.id, role: user.role }, process.env.JWT_SECRET, { expiresIn: "15m" });
// проверить в middleware
const payload = jwt.verify(token, process.env.JWT_SECRET); // бросит, если невалиден/истёк
- Passport.js — популярная библиотека-абстракция над «стратегиями» аутентификации (local — логин/пароль, JWT, OAuth — Google/GitHub и др.). В NestJS —
@nestjs/passport+@nestjs/jwt. - Хеширование паролей —
bcrypt/argon2(никогда не хранить в открытом виде). - Access + Refresh токены — короткоживущий access + долгоживущий refresh для обновления без релогина; выданный JWT нельзя отозвать «на лету» (валиден до истечения) — при необходимости blacklist/смена ключа.
Аутентификация — «кто ты», авторизация — «что тебе можно» (роли/права; в Nest — Guards).
Express
Минималистичный веб-фреймворк. Даёт роутинг и middleware, всё остальное — на выбор разработчика.
const express = require('express');
const app = express();
app.use(express.json()); // middleware: парсинг JSON-тела
// Логирование (кастомный middleware)
app.use((req, res, next) => {
console.log(`${req.method} ${req.url}`);
next(); // передать управление дальше
});
app.get('/users/:id', (req, res) => {
res.json({ id: req.params.id });
});
// Обработчик ошибок — ровно 4 аргумента (err, req, res, next)
app.use((err, req, res, next) => {
res.status(500).json({ error: err.message });
});
app.listen(3000);
Ключевое: middleware (цепочка функций (req, res, next)), роутинг (app.get/post/..., express.Router()), обработка ошибок (middleware с 4 параметрами), парсеры тела. Express не навязывает структуру — гибко, но архитектуру строишь сам. Более быстрая альтернатива с похожим духом — Fastify.
NestJS
Прогрессивный фреймворк на TypeScript со строгой архитектурой (вдохновлён Angular). Под капотом по умолчанию — Express (можно Fastify). Даёт готовую структуру: модули, DI, декораторы.
Основные строительные блоки:
- Module — группирует связанный функционал (
@Module). - Controller — обрабатывает HTTP-запросы (
@Controller,@Get,@Post). - Provider / Service — бизнес-логика, внедряется через DI (
@Injectable). - DTO — объекты передачи данных + валидация (class-validator).
- Pipes — трансформация/валидация входных данных.
- Guards — авторизация/аутентификация (можно ли выполнить запрос).
- Interceptors — обёртка вокруг обработчика (логирование, трансформация ответа, кэш).
- Filters — обработка исключений (
@Catch). - Middleware — как в Express.
// user.controller.ts
import { Controller, Get, Param } from '@nestjs/common';
@Controller('users')
export class UserController {
constructor(private readonly userService: UserService) {} // DI через конструктор
@Get(':id')
findOne(@Param('id') id: string) {
return this.userService.findOne(id);
}
}
// user.service.ts
import { Injectable } from '@nestjs/common';
@Injectable()
export class UserService {
findOne(id: string) { return { id }; }
}
// user.module.ts
import { Module } from '@nestjs/common';
@Module({
controllers: [UserController],
providers: [UserService],
})
export class UserModule {}
Dependency Injection — сердце Nest: сервисы регистрируются как провайдеры и внедряются по типу в конструктор (свой IoC-контейнер, как в Symfony/Angular). Это даёт слабую связанность и лёгкое тестирование (подмена моков).
Порядок обработки запроса в Nest: Middleware → Guards → Interceptors (до) → Pipes → Controller/Handler → Interceptors (после) → Exception Filters (при ошибке).
Экосистема: @nestjs/typeorm/@nestjs/mongoose (БД), @nestjs/config, @nestjs/jwt/Passport (auth), встроенная поддержка microservices, GraphQL, WebSockets, очередей (Bull), Swagger.
NestJS глубже: pipes, guards, interceptors, filters
Nest даёт «слои» обработки запроса, каждый со своей ответственностью (важно понимать разницу и порядок).
Pipes — трансформация и валидация входных данных перед контроллером. Частый приём — ValidationPipe + DTO с декораторами class-validator:
export class CreateUserDto {
@IsEmail() email: string;
@MinLength(8) password: string;
}
@Post()
create(@Body() dto: CreateUserDto) { // ValidationPipe проверит dto по декораторам
return this.userService.create(dto);
}
// глобально: app.useGlobalPipes(new ValidationPipe({ whitelist: true }));
Встроенные pipes: ParseIntPipe, ParseUUIDPipe и др. (@Param('id', ParseIntPipe) id: number).
Guards — авторизация: решают, можно ли выполнить запрос (canActivate возвращает boolean, Promise<boolean> или Observable<boolean>; false → 403 ForbiddenException, можно и самим бросить исключение, например UnauthorizedException). Используются для аутентификации (JWT) и проверки ролей/прав. Выполняются до pipes.
@Injectable()
export class JwtAuthGuard implements CanActivate {
canActivate(ctx: ExecutionContext): boolean {
const req = ctx.switchToHttp().getRequest();
return Boolean(req.headers.authorization); // упрощённо
}
}
@UseGuards(JwtAuthGuard)
@Get('profile')
getProfile() { /* ... */ }
Interceptors — обёртка вокруг обработчика (до и после): трансформация ответа, логирование, кэш, замер времени, маппинг ошибок. Работают с RxJS-потоком.
@Injectable()
export class LoggingInterceptor implements NestInterceptor {
intercept(ctx: ExecutionContext, next: CallHandler) {
const now = Date.now();
return next.handle().pipe(tap(() => console.log(`${Date.now() - now}ms`)));
}
}
Exception Filters — централизованная обработка исключений и формирование ответа об ошибке (@Catch):
@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
catch(exception: HttpException, host: ArgumentsHost) {
const res = host.switchToHttp().getResponse();
res.status(exception.getStatus()).json({ error: exception.message });
}
}
Middleware — как в Express (до всего остального), для сквозных задач (логирование, cors).
Порядок обработки запроса: Middleware → Guards → Interceptors (до) → Pipes → Controller → Interceptors (после) → Exception Filters (при ошибке). Всё это можно применять на уровне метода, контроллера или глобально, и всё внедряется через DI (можно инжектить сервисы). Custom-декораторы (@CurrentUser()) — для извлечения данных из запроса.
Express vs NestJS
| Аспект | Express | NestJS |
|---|---|---|
| Тип | минималистичная библиотека | полноценный фреймворк |
| Язык | JS (можно TS) | TypeScript (из коробки) |
| Архитектура | свободная (сам строишь) | навязанная (модули, DI) |
| DI-контейнер | нет | есть (встроенный) |
| Кривая входа | низкая | выше |
| Под капотом | — | Express (по умолч.) / Fastify |
| Когда | небольшие сервисы, максимум гибкости, прототипы | средние/крупные приложения, командная разработка, строгая структура |
Кратко: Express — свобода и простота, всё собираешь сам; Nest — структура, DI, декораторы, лучше масштабируется на больших командах/проектах. Nest под капотом использует Express, так что знание Express полезно и там.
Вероятные вопросы
Что такое Node.js и на чём построен? Среда выполнения JS на сервере: движок V8 + libuv (event loop, thread pool, асинхронный I/O). Однопоточная событийная модель, хороша для I/O-bound.
Как работает Event Loop в Node? Крутится по фазам (timers, pending, poll, check, close); между колбэками опустошает микроочереди (nextTick, затем промисы). Позволяет неблокирующий I/O при одном потоке JS.
Порядок: setTimeout, setImmediate, nextTick, промис? process.nextTick → промисы → фазы loop. Внутри I/O-колбэка setImmediate раньше setTimeout.
Почему нельзя блокировать event loop? JS в одном потоке: тяжёлая синхронная операция останавливает обработку всех запросов. CPU-bound выносят в worker_threads.
CommonJS vs ESM? CJS — require/module.exports, синхронный, рантайм; ESM — import/export, статический, асинхронный, top-level await, лучше tree-shaking.
Что такое Streams и зачем? Обработка данных по частям без загрузки всего в память (большие файлы/сеть); типы Readable/Writable/Duplex/Transform; pipe/pipeline управляют backpressure.
Что такое backpressure? Ситуация, когда источник быстрее приёмника; pipe/pipeline притормаживают чтение автоматически.
Что такое Buffer? Область памяти для бинарных данных вне V8-кучи (файлы, сеть, бинарь).
Как масштабировать Node по ядрам? cluster (несколько процессов на один порт) для I/O-bound; worker_threads для CPU-bound; в проде — PM2/контейнеры.
cluster vs worker_threads? cluster — отдельные процессы (не делят память), балансировка соединений; worker_threads — потоки в одном процессе, могут делить память, для вычислений.
Как обрабатывать ошибки? try/catch (sync/await), .catch (промисы), error-first (callbacks), событие error (EventEmitter); централизованный обработчик; при фатальной — логировать и перезапустить процесс.
Что такое graceful shutdown? По SIGTERM/SIGINT закрыть сервер, дождаться активных запросов, закрыть соединения с БД перед выходом.
Как искать утечки памяти? heap snapshots, --inspect + DevTools, clinic.js; частые причины — незакрытые слушатели/соединения, растущие глобальные кэши.
Зачем package-lock.json? Фиксирует точные версии всего дерева зависимостей → воспроизводимые сборки; npm ci ставит строго по нему.
Что такое middleware в Express? Функция (req, res, next) в цепочке обработки запроса; вызывает next() для передачи дальше; обработчик ошибок — 4 аргумента.
Основные строительные блоки NestJS? Модули, контроллеры, провайдеры/сервисы (DI), DTO, pipes, guards, interceptors, filters, middleware.
Что такое DI в Nest и зачем? Внедрение зависимостей через конструктор из IoC-контейнера — слабая связанность, заменяемость, лёгкое тестирование (моки).
Порядок обработки запроса в Nest? Middleware → Guards → Interceptors → Pipes → Handler → Interceptors → Exception Filters.
Express или NestJS — что выбрать? Express — простые/гибкие сервисы, прототипы; Nest — крупные приложения, строгая архитектура, TS и DI из коробки. Nest под капотом — Express.
Node подходит для CPU-bound? Плохо в одном потоке (блокирует loop). Решение — worker_threads, отдельный сервис или другой рантайм для тяжёлых вычислений.
Prisma vs TypeORM? Prisma — своя схема-DSL, генерируемый типобезопасный клиент, удобные миграции, отличный DX. TypeORM — сущности через декораторы (Active Record/Data Mapper), гибче, тесная интеграция с Nest, но типобезопасность слабее.
Сессии vs JWT? Сессии — сервер хранит состояние, клиент носит cookie (stateful, для веба). JWT — подписанный токен, сервер не хранит состояние (stateless, для API/SPA/мобильных). JWT нельзя отозвать до истечения — нужен blacklist/смена ключа.
Pipes vs Guards vs Interceptors vs Filters в Nest? Pipes — валидация/трансформация входа; Guards — авторизация (можно ли выполнить); Interceptors — обёртка вокруг обработчика (лог/трансформация ответа/кэш); Filters — обработка исключений. Порядок: Middleware→Guards→Interceptors→Pipes→Handler→Interceptors→Filters.
Как валидировать вход в NestJS? DTO + декораторы class-validator + ValidationPipe (глобально или на метод); whitelist: true отсекает лишние поля.