역할 기반 접근 제어 (RBAC) 구현

import { Injectable } from '@nestjs/common';
import { UsersService } from '../users/users.service';
import { JwtService } from '@nestjs/jwt';

@Injectable()
export class AuthService {
  constructor(
    private usersService: UsersService,
    private jwtService: JwtService,
  ) {}

  async validateUser(username: string, pass: string): Promise<any> {
    const user = await this.usersService.findOne(username);
    if (user && user.password === pass) {
      const { password, ...result } = user;
      return result;
    }
    return null;
  }

  async login(user: any) {
    // JWT 페이로드에 'roles' 포함
    const payload = { username: user.username, sub: user.userId, roles: user.roles };
    return {
      access_token: this.jwtService.sign(payload),
    };
  }
}

import { ExtractJwt, Strategy } from 'passport-jwt';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(private configService: ConfigService) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: configService.get<string>('JWT_SECRET'),
    });
  }

  async validate(payload: any) {
    // 반환되는 객체는 req.user에 주입됩니다. roles가 포함되어야 합니다.
    return { userId: payload.sub, username: payload.username, roles: payload.roles };
  }
}

import { SetMetadata } from '@nestjs/common';

export const ROLES_KEY = 'roles'; // 메타데이터 키를 상수로 정의하여 오타 방지 및 재사용성 향상
export const Roles = (...roles: string[]) => SetMetadata(ROLES_KEY, roles);

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core'; // 메타데이터를 읽기 위한 Reflector 임포트

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {} // Reflector 주입

  canActivate(context: ExecutionContext): boolean {
    // 1. @Roles() 데코레이터로부터 필요한 역할(roles) 메타데이터를 가져옵니다.
    // getAllAndOverride는 현재 핸들러(메서드)에 붙은 메타데이터가 있으면 그것을, 없으면 클래스에 붙은 메타데이터를 가져옵니다.
    const requiredRoles = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [
      context.getHandler(), // 메서드 레벨
      context.getClass(),   // 클래스 레벨
    ]);

    // 2. 만약 @Roles() 데코레이터가 붙어있지 않다면 (requiredRoles가 undefined),
    // 해당 라우트는 역할 제한이 없으므로 접근을 허용합니다.
    if (!requiredRoles) {
      return true;
    }

    // 3. 현재 요청의 사용자 객체를 가져옵니다.
    // 이 user 객체는 JwtStrategy.validate()에서 반환되어 req.user에 주입된 것입니다.
    const { user } = context.switchToHttp().getRequest();

    // 4. 사용자의 역할(user.roles)이 필요한 역할(requiredRoles) 중 하나라도 포함하는지 확인합니다.
    // 예를 들어, user.roles = ['user', 'admin'], requiredRoles = ['admin'] 이면 true
    // user.roles = ['user'], requiredRoles = ['admin'] 이면 false
    return requiredRoles.some((role) => user.roles.includes(role));
  }
}

import { Module } from '@nestjs/common';
import { AuthService } from './auth.service';
import { LocalStrategy } from './strategies/local.strategy';
import { JwtStrategy } from './strategies/jwt.strategy';
import { UsersModule } from '../users/users.module';
import { PassportModule } from '@nestjs/passport';
import { JwtModule } from '@nestjs/jwt';
import { AuthController } from './auth.controller';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { APP_GUARD } from '@nestjs/core'; // 전역 가드 등록을 위해 필요
import { RolesGuard } from './guards/roles.guard'; // RolesGuard 임포트

@Module({
  imports: [
    UsersModule,
    PassportModule,
    ConfigModule,
    JwtModule.registerAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        secret: configService.get<string>('JWT_SECRET'),
        signOptions: { expiresIn: '600s' }, // 테스트를 위해 10분으로 늘림
      }),
      inject: [ConfigService],
    }),
  ],
  providers: [
    AuthService,
    LocalStrategy,
    JwtStrategy,
    // { // 이 부분을 주석 처리하면 개별 라우트에 @UseGuards로 명시적으로 적용해야 합니다.
    //   provide: APP_GUARD, // 전역 가드로 등록 (필요에 따라 주석 해제)
    //   useClass: RolesGuard,
    // },
  ],
  controllers: [AuthController],
  exports: [AuthService],
})
export class AuthModule {}

import { Controller, Get, UseGuards, Request } from '@nestjs/common';
import { AppService } from './app.service';
import { AuthGuard } from '@nestjs/passport'; // JWT 인증 가드
import { RolesGuard } from './auth/guards/roles.guard'; // 권한 부여 가드
import { Roles } from './common/decorators/roles.decorator'; // 커스텀 데코레이터

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }

  // JWT 인증만 필요한 라우트 (누구나 로그인하면 접근 가능)
  @UseGuards(AuthGuard('jwt'))
  @Get('profile')
  getProfile(@Request() req) {
    return req.user; // JwtStrategy에서 반환된 사용자 정보 (roles 포함)
  }

  // 'admin' 역할만 접근 가능한 라우트
  @UseGuards(AuthGuard('jwt'), RolesGuard) // JWT 인증 후 RolesGuard로 권한 확인
  @Roles('admin') // 이 라우트에 접근하려면 'admin' 역할을 가지고 있어야 합니다.
  @Get('admin-dashboard')
  getAdminDashboard(@Request() req) {
    return `Welcome, ${req.user.username}! You are an admin and can access this dashboard.`;
  }

  // 'user' 또는 'editor' 역할만 접근 가능한 라우트
  @UseGuards(AuthGuard('jwt'), RolesGuard)
  @Roles('user', 'editor') // 이 라우트에 접근하려면 'user' 또는 'editor' 역할 중 하나를 가지고 있어야 합니다.
  @Get('user-content')
  getUserContent(@Request() req) {
    return `Hello, ${req.user.username}! You can view user content.`;
  }
}