Безпечна обробка помилок

{
  "statusCode": 404,
  "message": "Користувача не знайдено",
  "error": "Not Found"
}

// Небезпечно: внутрішні деталі можуть потрапити у відповідь
throw new BadRequestException(databaseError.message);

// Безпечніше
logger.error(databaseError);

throw new BadRequestException('Не вдалося обробити запит');

import { HttpException, HttpStatus } from '@nestjs/common';

export class SafeHttpException extends HttpException {
  constructor(
    message: string,
    status: HttpStatus,
  ) {
    super({ message }, status);
  }
}

throw new SafeHttpException(
  'Користувача не знайдено',
  HttpStatus.NOT_FOUND,
);

// safe-exception.filter.ts
import {
  ArgumentsHost,
  Catch,
  ExceptionFilter,
  HttpException,
  HttpStatus,
  Logger,
} from '@nestjs/common';
import { Request, Response } from 'express';
import { SafeHttpException } from './safe-http.exception';

type ErrorResponse = {
  statusCode: number;
  message: string;
  timestamp: string;
  path: string;
};

@Catch()
export class SafeExceptionFilter implements ExceptionFilter {
  private readonly logger = new Logger(SafeExceptionFilter.name);

  catch(exception: unknown, host: ArgumentsHost): void {
    const context = host.switchToHttp();
    const response = context.getResponse<Response>();
    const request = context.getRequest<Request>();

    let statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
    let message = 'Внутрішня помилка сервера';

    if (exception instanceof SafeHttpException) {
      statusCode = exception.getStatus();

      const exceptionResponse = exception.getResponse();

      if (
        typeof exceptionResponse === 'object' &&
        exceptionResponse !== null &&
        'message' in exceptionResponse &&
        typeof exceptionResponse.message === 'string'
      ) {
        message = exceptionResponse.message;
      }
    } else if (exception instanceof HttpException) {
      statusCode = exception.getStatus();
      message = this.getSafeMessage(statusCode);
    } else {
      this.logUnknownException(exception);
    }

    const errorResponse: ErrorResponse = {
      statusCode,
      message,
      timestamp: new Date().toISOString(),
      path: request.url,
    };

    response.status(statusCode).json(errorResponse);
  }

  private getSafeMessage(statusCode: number): string {
    switch (statusCode) {
      case HttpStatus.BAD_REQUEST:
        return 'Некоректний запит';
      case HttpStatus.UNAUTHORIZED:
        return 'Потрібна авторизація';
      case HttpStatus.FORBIDDEN:
        return 'Доступ заборонено';
      case HttpStatus.NOT_FOUND:
        return 'Ресурс не знайдено';
      case HttpStatus.CONFLICT:
        return 'Операцію неможливо виконати';
      case HttpStatus.TOO_MANY_REQUESTS:
        return 'Забагато запитів';
      default:
        return statusCode >= 500
          ? 'Внутрішня помилка сервера'
          : 'Не вдалося обробити запит';
    }
  }

  private logUnknownException(exception: unknown): void {
    if (exception instanceof Error) {
      this.logger.error(exception.message, exception.stack);
      return;
    }

    this.logger.error('Невідома помилка');
  }
}

// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { SafeExceptionFilter } from './safe-exception.filter';

async function bootstrap(): Promise<void> {
  const app = await NestFactory.create(AppModule);

  app.useGlobalFilters(new SafeExceptionFilter());

  await app.listen(3000);
}

bootstrap();

// users.controller.ts
import {
  Controller,
  Get,
  HttpStatus,
  Param,
} from '@nestjs/common';
import { SafeHttpException } from './safe-http.exception';

@Controller('users')
export class UsersController {
  @Get(':id')
  findOne(@Param('id') id: string) {
    const userId = Number(id);

    if (!Number.isInteger(userId) || userId <= 0) {
      throw new SafeHttpException(
        'Ідентифікатор користувача має бути додатним числом',
        HttpStatus.BAD_REQUEST,
      );
    }

    if (userId === 404) {
      throw new SafeHttpException(
        'Користувача не знайдено',
        HttpStatus.NOT_FOUND,
      );
    }

    if (userId === 500) {
      // Імітація непередбаченої внутрішньої помилки
      throw new Error('Помилка з’єднання з внутрішнім сховищем');
    }

    return {
      id: userId,
      name: 'Олена',
    };
  }
}

{
  "statusCode": 404,
  "message": "Користувача не знайдено",
  "timestamp": "2026-09-01T10:00:00.000Z",
  "path": "/users/404"
}

{
  "statusCode": 500,
  "message": "Внутрішня помилка сервера",
  "timestamp": "2026-09-01T10:00:00.000Z",
  "path": "/users/500"
}

throw new SafeHttpException(
  'Поле email має бути коректною електронною адресою',
  HttpStatus.BAD_REQUEST,
);

try {
  await this.repository.save(user);
} catch (error) {
  this.logger.error(error);

  throw new SafeHttpException(
    'Не вдалося зберегти користувача',
    HttpStatus.INTERNAL_SERVER_ERROR,
  );
}

// Небезпечно
catch (error) {
  throw new BadRequestException(error.message);
}

// Небезпечно
return response.status(500).json({
  message: error.message,
  stack: error.stack,
});

// Погано
return {
  success: false,
  error: 'Користувача не знайдено',
};

this.logger.error('Помилка');

this.logger.error(
  `Не вдалося завантажити користувача з id=${userId}`,
  error.stack,
);