인증·인가와 서버 실행

npm install @nestjs/passport passport passport-jwt @types/passport-jwt @types/passport bcryptjs
npm install --save-dev @types/bcryptjs

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { UserService } from '../user/user.service';
import { JwtService } from '@nestjs/jwt';
import * as bcrypt from 'bcrypt';
import { User } from '../user/entities/user.entity';

@Injectable()
export class AuthService {
  constructor(
    private userService: UserService,
    private jwtService: JwtService, // JwtService 주입
  ) {}

  async validateUser(email: string, pass: string): Promise<User | null> {
    const user = await this.userService.findOneByEmail(email);
    if (user && (await bcrypt.compare(pass, user.password))) {
      // 비밀번호는 제외하고 반환
      const { password, ...result } = user;
      return result as User; // Partial<User>를 User로 캐스팅
    }
    return null;
  }

  async login(user: User) {
    const payload = { email: user.email, sub: user.id, isAdmin: user.isAdmin }; // JWT 페이로드
    return {
      accessToken: this.jwtService.sign(payload),
    };
  }
}

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

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(private configService: ConfigService) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(), // Bearer 토큰에서 JWT 추출
      ignoreExpiration: false, // 만료된 토큰 무시 안 함
      secretOrKey: configService.get<string>('JWT_SECRET'), // .env에서 JWT 비밀 키 가져오기
    });
  }

  async validate(payload: any) { // payload는 JWT에 서명된 데이터
    // 이 부분에서 실제 사용자 정보를 DB에서 가져오거나, 페이로드만 반환할 수 있습니다.
    // req.user 에 페이로드가 저장됩니다.
    return { userId: payload.sub, email: payload.email, isAdmin: payload.isAdmin };
  }
}

import { Module } from '@nestjs/common';
import { PassportModule } from '@nestjs/passport';
import { JwtModule } from '@nestjs/jwt';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { AuthService } from './auth.service';
import { UserModule } from '../user/user.module';
import { LocalStrategy } from './local.strategy'; // 로컬 전략 (사용자 이름/비밀번호)
import { JwtStrategy } from './jwt.strategy';
import { AuthController } from './auth.controller';

@Module({
  imports: [
    UserModule, // UserService를 사용하기 위해 UserModule 임포트
    PassportModule,
    JwtModule.registerAsync({ // 비동기로 JWT 설정 (ConfigService 주입)
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        secret: configService.get<string>('JWT_SECRET'),
        signOptions: { expiresIn: '60m' }, // 토큰 만료 시간
      }),
      inject: [ConfigService],
    }),
  ],
  controllers: [AuthController],
  providers: [AuthService, LocalStrategy, JwtStrategy], // 전략 등록
  exports: [AuthService], // AuthService를 다른 모듈에서 사용 가능하도록 내보내기
})
export class AuthModule {}

import { Controller, Post, Request, UseGuards, Body, HttpCode, HttpStatus } from '@nestjs/common';
import { AuthService } from './auth.service';
import { LocalAuthGuard } from './local-auth.guard'; // 로컬 인증 가드 (추후 생성)
import { CreateUserDto } from '../user/dto/create-user.dto';
import { UserService } from '../user/user.service';

@Controller('auth')
export class AuthController {
  constructor(
    private authService: AuthService,
    private userService: UserService, // 회원가입을 위해 UserService 사용
  ) {}

  @Post('register')
  @HttpCode(HttpStatus.CREATED)
  async register(@Body() createUserDto: CreateUserDto) {
    return this.userService.create(createUserDto);
  }

  @UseGuards(LocalAuthGuard) // LocalAuthGuard를 사용하여 로컬 전략 실행
  @Post('login')
  @HttpCode(HttpStatus.OK) // 200 OK 응답
  async login(@Request() req: any) { // @Request() 데코레이터로 요청 객체 접근
    // LocalAuthGuard가 req.user에 사용자 정보를 저장합니다.
    return this.authService.login(req.user);
  }
}

import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class LocalAuthGuard extends AuthGuard('local') {} // 'local' 전략 사용

import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {} // 'jwt' 전략 사용

import { SetMetadata } from '@nestjs/common';
// import { UserRole } from '@my-fullstack-app/shared/interfaces'; // shared 패키지에서 역할 정의

export const ROLES_KEY = 'roles';
export const Roles = (...roles: string[]) => SetMetadata(ROLES_KEY, roles);

export enum UserRole {
  User = 'user',
  Admin = 'admin',
}

export interface IUser {
  id: number;
  email: string;
  name: string;
  isAdmin: boolean; // 또는 role: UserRole;
}

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { ROLES_KEY } from './roles.decorator';
// import { UserRole } from '@my-fullstack-app/shared/interfaces';

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

  canActivate(context: ExecutionContext): boolean {
    const requiredRoles = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [
      context.getHandler(), // 메서드 레벨 데코레이터
      context.getClass(),   // 클래스 레벨 데코레이터
    ]);
    if (!requiredRoles) {
      return true; // 역할 제한이 없으면 접근 허용
    }

    const { user } = context.switchToHttp().getRequest();
    // req.user에 저장된 사용자의 역할(isAdmin 또는 role)을 확인
    // 여기서는 예시로 isAdmin 필드를 사용
    return requiredRoles.some((role) => {
      if (role === 'admin') {
        return user.isAdmin === true;
      }
      // 다른 역할 검증 로직 추가
      return false;
    });
  }
}

// ...
import { JwtAuthGuard } from '../auth/jwt-auth.guard';
import { RolesGuard } from '../auth/roles.guard';
import { Roles } from '../auth/roles.decorator';
import { UserRole } from '@my-fullstack-app/shared/interfaces/user'; // shared 인터페이스 임포트

@Controller('users')
@UseGuards(JwtAuthGuard, RolesGuard) // JwtAuthGuard 먼저 실행 후 RolesGuard 실행
export class UserController {
  // ...
  @Get()
  @Roles(UserRole.Admin) // 관리자 역할만 접근 가능
  async findAll() {
    return this.userService.findAll();
  }
  // ...
}