06. Guard와 유저 인증

// 글로벌 가드
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalGuards(new AuthGuard());
  await app.listen(3000);
}

// 컨트롤러 가드
@Controller('')
@UseGuards(AuthGuard)
export class Controller {
  @Get()
  findAll() {}
}

// 핸들러 가드
@Get()
@UseGuards(AuthGuard)
findAll() {}

import { Request } from 'express';
import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
import { AuthService } from './auth.service';

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

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    return this.validateRequest(request);
  }

  private validateRequest(request: Request): boolean {
    const accessToken = request.cookies['accessToken'];

    if (!accessToken) {
      throw new UnauthorizedException('로그인이 필요합니다');
    }

    try {
      request.user = this.authService.verify(accessToken, 'access');
      return true;
    } catch {
      throw new UnauthorizedException('로그인이 필요합니다');
    }
  }
}

import { User } from '@prisma/client';

@Controller('report')
export class ReportController {
  constructor(private reportService: ReportService) {}

  @Delete(':reportId')
  @UseGuards(AuthGuard)
  async deleteReport(
    @Param('reportId') reportId: string,
    @Req() req: Request,
  ) {
    const { id } = req.user as User;

    const isOwner = await this.reportService.checkIsOwner(reportId, id);

    if (!isOwner) {
      throw new ForbiddenException('권한이 없습니다.');
    }

    return this.reportService.deleteReport(reportId);
  }
}

import { PassportModule } from '@nestjs/passport';
import { JwtStrategy } from './jwt.strategy';

@Module({
  controllers: [AuthController],
  providers: [AuthService, AuthRepository, JwtStrategy],
  imports: [
    JwtModule.register({}),
    PassportModule.register({ defaultStrategy: 'jwt' }),
  ],
  exports: [JwtStrategy, PassportModule],
})
export class AuthModule {}

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

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(
    @Inject(jwtConfig.KEY) private jwt: ConfigType<typeof jwtConfig>,
    private authRepository: AuthRepository,
  ) {
    super({
      jwtFromRequest: ExtractJwt.fromExtractors([
        (request) =>
          request?.cookies?.['accessToken'] ?? '',
      ]),
      secretOrKey: jwt.accessSecret,
    });
  }

  async validate(payload: any) {
    const user = await this.authRepository.findUserByEmail(payload.email);

    if (!user) {
      throw new UnauthorizedException();
    }

    return user;
  }
}