미들웨어, 가드, 인터셉터 — 요청 라이프사이클 이해하기

요청 수신
  │
  ▼
① Middleware          ← Express 미들웨어와 동일
  │
  ▼
② Guard              ← 인증/인가 판단 (true/false)
  │
  ▼
③ Interceptor (전)   ← 요청 가공, 로깅 시작
  │
  ▼
④ Pipe               ← 데이터 변환 + 검증
  │
  ▼
⑤ Route Handler      ← 컨트롤러 메서드 실행
  │
  ▼
⑥ Interceptor (후)   ← 응답 가공, 로깅 완료
  │
  ▼
⑦ ExceptionFilter    ← 예외 발생 시 에러 응답 처리
  │
  ▼
응답 반환

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`[${req.method}] ${req.url}`);
    next();
  }
}

// 모듈에서 등록
@Module({})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('*');  // 모든 경로에 적용
  }
}

@Injectable()
export class AuthGuard implements CanActivate {
  constructor(private readonly authService: AuthService) {}

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const token = request.headers.authorization;

    if (!token) return false;  // → 403 Forbidden

    const user = this.authService.validateToken(token);
    request.user = user;       // 요청 객체에 사용자 정보 부착
    return true;
  }
}

// 커스텀 데코레이터 + Guard 조합
@SetMetadata('roles', ['admin'])
@UseGuards(AuthGuard, RolesGuard)
@Delete(':id')
remove(@Param('id') id: string) {
  return this.userService.remove(id);
}

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const now = Date.now();
    const request = context.switchToHttp().getRequest();

    console.log(`[요청] ${request.method} ${request.url}`);

    return next.handle().pipe(
      tap(() => {
        console.log(`[응답] ${request.method} ${request.url} — ${Date.now() - now}ms`);
      }),
    );
  }
}

@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
  intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>> {
    return next.handle().pipe(
      map(data => ({
        data,
        statusCode: context.switchToHttp().getResponse().statusCode,
        timestamp: new Date().toISOString(),
      })),
    );
  }
}

@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    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(),
      path: ctx.getRequest<Request>().url,
    });
  }
}

실수하는 패턴:
  Interceptor(전) → Pipe에서 에러! → Interceptor(후) 실행 안 됨
                                    → ExceptionFilter에서 처리됨

올바른 패턴:
  에러 로깅이 필요하면 ExceptionFilter에서 하거나,
  Interceptor에서 catchError 오퍼레이터를 사용

// 전역 — 모든 요청에 적용
app.useGlobalGuards(new AuthGuard());

// 컨트롤러 — 해당 컨트롤러의 모든 메서드에 적용
@UseGuards(AuthGuard)
@Controller('users')
export class UserController {}

// 메서드 — 특정 메서드에만 적용
@UseGuards(RolesGuard)
@Delete(':id')
remove() {}