미들웨어, 인터셉터, 파이프, 가드

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`Request... ${req.method} ${req.originalUrl}`);
    next(); // 다음 미들웨어 또는 라우트 핸들러로 제어를 넘깁니다.
  }
}

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { LoggerMiddleware } from './common/middleware/logger.middleware';

@Module({
  imports: [],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware) // LoggerMiddleware를 적용합니다.
      .forRoutes('*'); // 모든 경로에 적용합니다. 특정 경로만 지정할 수도 있습니다.
      // .forRoutes({ path: 'cats', method: RequestMethod.GET }); // 특정 경로와 메서드에 적용
  }
}

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    const request = context.switchToHttp().getRequest();
    // 실제 로직: JWT 토큰 유효성 검사, 사용자 역할 확인 등
    // 예시: request.user 객체에 사용자가 있다면 true 반환
    return !!request.user; // 가짜 인증 로직
  }
}

import { Controller, Get, UseGuards } from '@nestjs/common';
import { AuthGuard } from '../auth/guards/auth.guard'; // 가드 임포트

@Controller('users')
export class UsersController {
  @UseGuards(AuthGuard) // 이 컨트롤러의 모든 라우트에 AuthGuard 적용
  @Get()
  findAll(): string {
    return 'This is a protected resource (all users).';
  }

  @UseGuards(AuthGuard) // 특정 라우트에만 AuthGuard 적용
  @Get(':id')
  findOne(): string {
    return 'This is a protected resource (single user).';
  }
}

import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';

@Injectable()
export class PositiveIntPipe implements PipeTransform<string, number> {
  transform(value: string, metadata: ArgumentMetadata): number {
    const val = parseInt(value, 10); // 문자열을 숫자로 변환
    if (isNaN(val) || val < 0) { // 변환 실패 또는 음수인 경우 예외 발생
      throw new BadRequestException('Validation failed: ID must be a positive integer.');
    }
    return val;
  }
}

import { Controller, Get, Param, UsePipes } from '@nestjs/common';
import { PositiveIntPipe } from '../common/pipes/positive-int.pipe';

@Controller('items')
export class ItemsController {
  // @UsePipes(PositiveIntPipe) // 컨트롤러 레벨에 적용
  @Get(':id')
  // 매개변수 레벨에 파이프 적용. id가 숫자이고 양수인지 검증합니다.
  findOne(@Param('id', PositiveIntPipe) id: number): string {
    return `Item with ID: ${id}`;
  }
}

import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

export interface Response<T> {
  statusCode: number;
  message: string;
  data: T;
}

@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
  intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>> {
    return next.handle().pipe(
      map(data => ({ // 컨트롤러가 반환한 데이터를 감싸서 응답합니다.
        statusCode: context.switchToHttp().getResponse().statusCode,
        message: 'Success',
        data: data,
      })),
    );
  }
}

import { Controller, Get, UseInterceptors } from '@nestjs/common';
import { AppService } from './app.service';
import { TransformInterceptor } from './common/interceptors/transform.interceptor';

@Controller()
@UseInterceptors(TransformInterceptor) // 이 컨트롤러의 모든 응답을 변환
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {
    return this.appService.getHello(); // "Hello World!" 문자열 반환
  }
}
// 결과 응답: { statusCode: 200, message: "Success", data: "Hello World!" }