Belajar NestJS - Validation & Exception Handling

#Pendahuluan

Input dari luar tidak bisa dipercaya — validasi wajib dilakukan sebelum data masuk ke lapisan bisnis. Di sisi lain, error harus ditangani dengan konsisten agar klien aplikasi bisa menangani kegagalan dengan baik.

Episode 7 membahas dua sisi tersebut: validasi dengan class-validator dan class-transformer, serta exception handling dengan pipes, filters, dan struktur error response standar.

#Validasi dengan class-validator dan class-transformer

#Install Package

npm install class-validator class-transformer

Keduanya adalah library standar untuk validasi dan transformasi object di ekosistem NestJS.

#Membuat DTO dengan Validator

Data Transfer Object (DTO) mendefinisikan bentuk data dan aturan validasinya:

DTO dengan dekorator validasi

import { IsEmail, IsString, MinLength } from "class-validator";
 
export class CreateUserDto {
  @IsString()
  @MinLength(3)
  name: string;
 
  @IsEmail()
  email: string;
}

Dekorator @IsString, @MinLength, dan @IsEmail dipakai class-validator untuk memvalidasi properti saat object dikonversi.

#Memakai DTO di Controller

Menggunakan DTO di controller

@Controller("users")
export class UsersController {
  @Post()
  create(@Body() createUserDto: CreateUserDto): string {
    return `User ${createUserDto.name} dibuat`;
  }
}

Tanpa pipe validasi, DTO hanya berfungsi sebagai tipe TypeScript. Untuk mengaktifkan validasi, kita butuh ValidationPipe.

#Global Pipes dan Custom Validation Pipes

#ValidationPipe Global

Daftarkan ValidationPipe sebagai global pipe di main.ts:

Mengaktifkan ValidationPipe global

import { ValidationPipe } from "@nestjs/common";
import { NestFactory } from "@nestjs/core";
import { AppModule } from "./app.module";
 
async function bootstrap(): Promise<void> {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
      forbidNonWhitelisted: true,
      transform: true,
    }),
  );
  await app.listen(3000);
}
 
void bootstrap();

Dengan whitelist: true, properti yang tidak ada di DTO dibuang. forbidNonWhitelisted melempar error jika ada properti asing. transform: true mengubah payload menjadi instance class — membuat dekorator validasi bekerja.

#Custom Validation Pipe

Untuk validasi khusus, buat pipe sendiri:

Custom pipe validasi

import { ArgumentMetadata, Injectable, PipeTransform, BadRequestException } from "@nestjs/common";
 
@Injectable()
export class ParseIdPipe implements PipeTransform<string, number> {
  transform(value: string, metadata: ArgumentMetadata): number {
    const parsed = parseInt(value, 10);
    if (Number.isNaN(parsed)) {
      throw new BadRequestException("ID harus berupa angka");
    }
    return parsed;
  }
}

Pipe dipakai dengan menambahkan di parameter atau memakai @UsePipes.

#Exception Filters dan HTTP Exception

#HttpException Bawaan

NestJS menyediakan HttpException dan turunannya seperti BadRequestException, NotFoundException, dan ConflictException:

Melempar NotFoundException

import { NotFoundException } from "@nestjs/common";
 
@Get(":id")
findOne(@Param("id") id: string): string {
  const user = this.usersService.findOne(id);
  if (!user) {
    throw new NotFoundException(`User ${id} tidak ditemukan`);
  }
  return user;
}

Exception bawaan otomatis menghasilkan response dengan status code yang tepat.

#Custom Exception Filter

Untuk format error yang konsisten, buat filter sendiri:

Custom exception filter

import { ArgumentsHost, Catch, ExceptionFilter, HttpException } from "@nestjs/common";
import { Response } from "express";
 
@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost): void {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const status = exception.getStatus();
 
    response.status(status).json({
      statusCode: status,
      message: exception.message,
      timestamp: new Date().toISOString(),
    });
  }
}

Daftarkan filter ini global atau per-controller memakai @UseFilters.

#Standard Error Response

#Struktur Error yang Konsisten

Dengan filter di atas, semua error mengikuti struktur yang sama. Struktur yang konsisten memudahkan frontend menangani error dan memudahkan debugging di production:

{
  "statusCode": 404,
  "message": "User 99 tidak ditemukan",
  "timestamp": "2026-08-10T07:00:00.000Z"
}

#Penutup

Episode 7 menyempurnakan API kalian dari sisi keamanan dan pengalaman developer: validasi DTO dengan class-validator, global ValidationPipe, custom pipes, exception filters, dan error response yang konsisten.

Inti yang harus dibawa pulang:

• class-validator memvalidasi properti DTO lewat dekorator.
• whitelist dan transform membuat ValidationPipe bekerja optimal.
• DTO dipakai sebagai tipe @Body di controller.
• Custom pipe mengimplementasikan PipeTransform.
• HttpException dan turunannya menghasilkan status code otomatis.
• Exception filter memformat semua error secara konsisten.

Di episode 8 selanjutnya kita akan membahas configuration dan environment management — modul @nestjs/config, configuration modules, konfigurasi per environment, validation schema, externalized configuration, dan manajemen secrets di development serta production.