TeoreticQuiz

Node.js, Express, NestJS

Материал для подготовки к собеседованию (Middle / Senior). Node.js — среда выполнения JavaScript на сервере (V8 + libuv). Дополнительно — фреймворки Express (минималистичный) и NestJS (структурный, на TypeScript). Термины на английском там, где это принято.

Содержание


Что такое 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 — в миноре, точная версия).
  • dependencies vs devDependencies (только для разработки/сборки) vs peerDependencies.
  • Альтернативы 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 отсекает лишние поля.