HTTP/1.1 200 OK
HTTP/1.1 201 Created
HTTP/1.1 404 Not Found
HTTP/1.1 500 Internal Server Error

GET /users/123 → 200 OK + тіло з даними користувача
PUT /users/123 → 200 OK + оновлені дані
PATCH /users/123 → 200 OK + оновлені дані

POST /users → 201 Created
Location: /users/456
Body: { "id": 456, "name": "Alice", ... }

DELETE /users/123 → 204 No Content
(порожнє тіло відповіді)

POST /users
Body: { "email": "invalid-email" }
→ 400 Bad Request
Body: { "errors": ["email must be a valid email address"] }

GET /profile (без заголовка Authorization)
→ 401 Unauthorized
WWW-Authenticate: Bearer realm="API"

GET /users/999 (користувача з ID 999 не існує)
→ 404 Not Found

POST /users
Body: { "email": "john@example.com" } (email вже існує у БД)
→ 409 Conflict
Body: { "error": "Email already exists", "field": "email" }

PUT /articles/123
Body: { "version": 5, ... } (поточна версія у БД = 6)
→ 409 Conflict
Body: { "error": "Version conflict. Resource was modified by another user." }

POST /orders
Body: { "quantity": -5 } (від'ємна кількість неможлива)
→ 422 Unprocessable Entity
Body: { "error": "Quantity must be a positive number" }

POST /accounts/transfer
Body: { "amount": 10000 } (недостатньо коштів)
→ 422 Unprocessable Entity
Body: { "error": "Insufficient funds" }

GET /users/123 (виникла помилка БД)
→ 500 Internal Server Error
Body: { "error": "Internal Server Error" }
(деталі помилки НЕ повертаються клієнту з міркувань безпеки)

import { Controller, Get } from '@nestjs/common';

@Controller('users')
export class UsersController {
  @Get()
  findAll() {
    // NestJS автоматично встановлює статус 200 OK
    return [
      { id: 1, name: 'Alice' },
      { id: 2, name: 'Bob' },
    ];
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    // Також 200 OK
    return { id, name: 'Alice', email: 'alice@example.com' };
  }
}

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 65

[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]

@Controller('users')
export class UsersController {
  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    const newUser = this.usersService.create(createUserDto);
    
    // NestJS автоматично встановлює статус 201 Created
    return newUser;
  }
}

HTTP/1.1 201 Created
Content-Type: application/json
Location: /users/456

{"id":456,"name":"Alice","email":"alice@example.com"}

@Controller('users')
export class UsersController {
  @Put(':id')
  update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto) {
    const updatedUser = this.usersService.update(id, updateUserDto);
    
    // Статус 200 OK за замовчуванням
    return updatedUser;
  }

  @Patch(':id')
  partialUpdate(@Param('id') id: string, @Body() patchDto: Partial<UpdateUserDto>) {
    const updatedUser = this.usersService.partialUpdate(id, patchDto);
    
    // Також 200 OK за замовчуванням
    return updatedUser;
  }
}

@Controller('users')
export class UsersController {
  @Delete(':id')
  remove(@Param('id') id: string) {
    this.usersService.remove(id);
    
    // Статус 200 OK за замовчуванням
    return { message: 'User deleted successfully' };
  }
}

// ❌ Без NestJS: Express (явне встановлення статусу)
app.post('/users', (req, res) => {
  const user = createUser(req.body);
  res.status(201).json(user); // Ручне встановлення 201
});

// ✅ З NestJS: автоматичний 201 для POST
@Post()
create(@Body() dto: CreateUserDto) {
  return this.usersService.create(dto);
  // Статус 201 встановлюється автоматично
}

import { Controller, Delete, HttpCode } from '@nestjs/common';

@Controller('users')
export class UsersController {
  @Delete(':id')
  @HttpCode(204)  // Явно встановлюємо 204 No Content
  remove(@Param('id') id: string) {
    this.usersService.remove(id);
    // Тіло відповіді можна не повертати (204 означає "немає тіла")
  }
}

HTTP/1.1 204 No Content
Content-Length: 0

(порожнє тіло)

import { Controller, Post, HttpCode, HttpStatus } from '@nestjs/common';

@Controller('orders')
export class OrdersController {
  @Post()
  @HttpCode(HttpStatus.ACCEPTED) // 202 Accepted
  createOrder(@Body() createOrderDto: CreateOrderDto) {
    // Асинхронна обробка замовлення
    this.ordersService.queueOrder(createOrderDto);
    
    return {
      message: 'Order accepted for processing',
      estimatedTime: '5 minutes',
    };
  }
}

HttpStatus.OK                    // 200
HttpStatus.CREATED               // 201
HttpStatus.ACCEPTED              // 202
HttpStatus.NO_CONTENT            // 204

HttpStatus.MOVED_PERMANENTLY     // 301
HttpStatus.FOUND                 // 302
HttpStatus.NOT_MODIFIED          // 304

HttpStatus.BAD_REQUEST           // 400
HttpStatus.UNAUTHORIZED          // 401
HttpStatus.FORBIDDEN             // 403
HttpStatus.NOT_FOUND             // 404
HttpStatus.UNPROCESSABLE_ENTITY  // 422
HttpStatus.TOO_MANY_REQUESTS     // 429

HttpStatus.INTERNAL_SERVER_ERROR // 500
HttpStatus.BAD_GATEWAY           // 502
HttpStatus.SERVICE_UNAVAILABLE   // 503

import { Controller, Delete, Param, HttpCode, HttpStatus } from '@nestjs/common';

@Controller('articles')
export class ArticlesController {
  constructor(private readonly articlesService: ArticlesService) {}

  @Delete(':id')
  @HttpCode(HttpStatus.NO_CONTENT)
  async remove(@Param('id') id: string): Promise<void> {
    await this.articlesService.remove(id);
    
    // Немає return — 204 означає порожнє тіло
  }
}

import { Controller, Post, Body, HttpCode, HttpStatus } from '@nestjs/common';

@Controller('reports')
export class ReportsController {
  constructor(
    private readonly reportsService: ReportsService,
    private readonly queueService: QueueService,
  ) {}

  @Post('generate')
  @HttpCode(HttpStatus.ACCEPTED)
  async generateReport(@Body() reportDto: GenerateReportDto) {
    // Додаємо завдання у чергу для асинхронної обробки
    const jobId = await this.queueService.addJob('generate-report', reportDto);
    
    return {
      message: 'Report generation accepted',
      jobId,
      status: 'pending',
      estimatedCompletion: '10 minutes',
      checkStatusUrl: `/reports/status/${jobId}`,
    };
  }

  @Get('status/:jobId')
  async checkStatus(@Param('jobId') jobId: string) {
    const status = await this.queueService.getJobStatus(jobId);
    
    return {
      jobId,
      status: status.state, // pending, processing, completed, failed
      progress: status.progress,
      result: status.result,
    };
  }
}

import { Controller, Post, Body, HttpCode, HttpStatus } from '@nestjs/common';

@Controller('subscriptions')
export class SubscriptionsController {
  constructor(private readonly subscriptionsService: SubscriptionsService) {}

  @Post('subscribe')
  @HttpCode(HttpStatus.OK) // Замість 201 Created
  async subscribe(@Body() subscribeDto: SubscribeDto) {
    // Якщо підписка вже існує, не створюємо нову
    const subscription = await this.subscriptionsService.findOrCreate(subscribeDto);
    
    return {
      message: subscription.isNew ? 'Subscribed successfully' : 'Already subscribed',
      subscription,
      isNew: subscription.isNew,
    };
  }
}

import { Controller, Get, Param, Res, HttpStatus } from '@nestjs/common';
import { Response } from 'express';

@Controller('cache')
export class CacheController {
  constructor(private readonly cacheService: CacheService) {}

  @Get('resource/:id')
  async getResource(
    @Param('id') id: string,
    @Res({ passthrough: true }) res: Response,
  ) {
    const resource = await this.cacheService.findById(id);
    
    if (!resource) {
      // Динамічно встановлюємо 404
      res.status(HttpStatus.NOT_FOUND);
      return { error: 'Resource not found' };
    }
    
    if (!resource.isModified) {
      // Динамічно встановлюємо 304 Not Modified
      res.status(HttpStatus.NOT_MODIFIED);
      return; // Порожнє тіло для 304
    }
    
    // За замовчуванням 200 OK
    return resource;
  }
}

import { Controller, Get, Param, Headers, Res, HttpStatus } from '@nestjs/common';
import { Response } from 'express';

@Controller('articles')
export class ArticlesController {
  constructor(private readonly articlesService: ArticlesService) {}

  @Get(':id')
  async findOne(
    @Param('id') id: string,
    @Headers('if-none-match') ifNoneMatch: string,
    @Res({ passthrough: true }) res: Response,
  ) {
    const article = await this.articlesService.findById(id);
    
    if (!article) {
      res.status(HttpStatus.NOT_FOUND);
      return { error: 'Article not found' };
    }

    // Генеруємо ETag на основі версії ресурсу
    const etag = `"${article.version}"`;
    res.header('ETag', etag);

    // Клієнт має актуальну версію?
    if (ifNoneMatch === etag) {
      res.status(HttpStatus.NOT_MODIFIED);
      return; // Порожнє тіло — клієнт використає кешовану версію
    }

    // Ресурс змінився — повертаємо повні дані
    res.header('Cache-Control', 'private, must-revalidate');
    return article;
  }
}

import { Controller, Post, Body, Res, HttpStatus } from '@nestjs/common';
import { Response } from 'express';

@Controller('payments')
export class PaymentsController {
  constructor(
    private readonly paymentsService: PaymentsService,
    private readonly queueService: QueueService,
  ) {}

  @Post('process')
  async processPayment(
    @Body() paymentDto: ProcessPaymentDto,
    @Res({ passthrough: true }) res: Response,
  ) {
    const systemLoad = await this.queueService.getCurrentLoad();

    if (systemLoad > 0.8) {
      // Система перевантажена — приймаємо до асинхронної обробки
      const jobId = await this.queueService.addJob('payment', paymentDto);
      
      res.status(HttpStatus.ACCEPTED); // 202 Accepted
      return {
        message: 'Payment accepted for processing',
        jobId,
        checkStatusUrl: `/payments/status/${jobId}`,
      };
    }

    // Система має ресурси — обробляємо синхронно
    const result = await this.paymentsService.process(paymentDto);

    if (result.requiresConfirmation) {
      // Потрібне підтвердження 3D-Secure
      res.status(HttpStatus.OK); // 200 OK
      return {
        message: 'Confirmation required',
        confirmationUrl: result.confirmationUrl,
      };
    }

    // Платіж успішно виконано
    res.status(HttpStatus.CREATED); // 201 Created
    return {
      message: 'Payment processed successfully',
      transactionId: result.transactionId,
      amount: result.amount,
    };
  }
}

import {
  Controller,
  Get,
  Post,
  Put,
  Patch,
  Delete,
  Param,
  Body,
  Query,
  HttpCode,
  HttpStatus,
  NotFoundException,
  ConflictException,
} from '@nestjs/common';
import { ArticlesService } from './articles.service';
import { CreateArticleDto } from './dto/create-article.dto';
import { UpdateArticleDto } from './dto/update-article.dto';
import { FilterArticlesDto } from './dto/filter-articles.dto';

@Controller('articles')
export class ArticlesController {
  constructor(private readonly articlesService: ArticlesService) {}

  // GET /articles — Отримання списку статей
  @Get()
  async findAll(@Query() filterDto: FilterArticlesDto) {
    const articles = await this.articlesService.findAll(filterDto);
    
    // ✅ 200 OK (за замовчуванням)
    // Навіть якщо масив порожній — це не помилка!
    return {
      data: articles,
      total: articles.length,
      page: filterDto.page || 1,
      limit: filterDto.limit || 10,
    };
  }

  // GET /articles/:id — Отримання однієї статті
  @Get(':id')
  async findOne(@Param('id') id: string) {
    const article = await this.articlesService.findById(id);
    
    if (!article) {
      // ✅ 404 Not Found якщо ресурс не існує
      throw new NotFoundException(`Article with ID ${id} not found`);
    }
    
    // ✅ 200 OK (за замовчуванням)
    return article;
  }

  // POST /articles — Створення нової статті
  @Post()
  // ✅ 201 Created встановлюється автоматично для POST
  // Але можна явно вказати для наочності:
  @HttpCode(HttpStatus.CREATED)
  async create(@Body() createArticleDto: CreateArticleDto) {
    // Перевірка унікальності slug
    const existing = await this.articlesService.findBySlug(createArticleDto.slug);
    
    if (existing) {
      // ✅ 409 Conflict для дублікату унікального поля
      throw new ConflictException(`Article with slug "${createArticleDto.slug}" already exists`);
    }
    
    const article = await this.articlesService.create(createArticleDto);
    
    // ✅ Повертаємо створений ресурс з ID
    return article;
  }

  // PUT /articles/:id — Повна заміна статті
  @Put(':id')
  async replace(
    @Param('id') id: string,
    @Body() updateArticleDto: UpdateArticleDto,
  ) {
    const article = await this.articlesService.findById(id);
    
    if (!article) {
      // ✅ 404 Not Found для неіснуючого ресурсу
      throw new NotFoundException(`Article with ID ${id} not found`);
    }
    
    const updated = await this.articlesService.replace(id, updateArticleDto);
    
    // ✅ 200 OK (за замовчуванням) з оновленими даними
    return updated;
  }

  // PATCH /articles/:id — Часткове оновлення статті
  @Patch(':id')
  async update(
    @Param('id') id: string,
    @Body() patchDto: Partial<UpdateArticleDto>,
  ) {
    const article = await this.articlesService.findById(id);
    
    if (!article) {
      // ✅ 404 Not Found для неіснуючого ресурсу
      throw new NotFoundException(`Article with ID ${id} not found`);
    }
    
    const updated = await this.articlesService.update(id, patchDto);
    
    // ✅ 200 OK (за замовчуванням) з оновленими даними
    return updated;
  }

  // DELETE /articles/:id — Видалення статті
  @Delete(':id')
  @HttpCode(HttpStatus.NO_CONTENT) // ✅ 204 No Content
  async remove(@Param('id') id: string): Promise<void> {
    const article = await this.articlesService.findById(id);
    
    if (!article) {
      // ✅ 404 Not Found для неіснуючого ресурсу
      throw new NotFoundException(`Article with ID ${id} not found`);
    }
    
    await this.articlesService.remove(id);
    
    // ✅ Немає return — порожнє тіло для 204
  }

  // POST /articles/:id/publish — Спеціальна операція (публікація)
  @Post(':id/publish')
  @HttpCode(HttpStatus.OK) // ✅ 200 OK замість 201 (не створюємо ресурс)
  async publish(@Param('id') id: string) {
    const article = await this.articlesService.findById(id);
    
    if (!article) {
      throw new NotFoundException(`Article with ID ${id} not found`);
    }
    
    if (article.published) {
      // ✅ 409 Conflict якщо вже опубліковано
      throw new ConflictException('Article is already published');
    }
    
    const published = await this.articlesService.publish(id);
    
    return {
      message: 'Article published successfully',
      article: published,
    };
  }
}