AuthModule, AuthController, AuthService로 이해한 로그인 흐름

프론트에서 로그인 요청
  ↓
POST /auth/login
  ↓
AuthController.login()
  ↓
AuthService.validateUser()
  ↓
UsersService.findByEmail()
  ↓
bcrypt.compare()
  ↓
AuthService.login()
  ↓
JWT access_token 반환

AuthModule
→ 인증 기능에 필요한 모듈과 서비스를 조립한다.

AuthController
→ 로그인 요청을 받는다.

AuthService
→ 이메일/비밀번호를 검증하고 JWT를 발급한다.

1. validateUser()
   → 이메일과 비밀번호가 맞는지 확인한다.

2. login()
   → 검증된 사용자에게 JWT access_token을 발급한다.

@Module({
  imports: [
    UsersModule,
    PassportModule,
    JwtModule.registerAsync({
      inject: [ConfigService],
      useFactory: async (configService: ConfigService) => ({
        secret: configService.getOrThrow<string>('JWT_SECRET'),
        signOptions: {
          expiresIn: configService.getOrThrow<string>('JWT_EXPIRES_IN') as any,
        },
      }),
    }),
  ],
  providers: [AuthService, JwtStrategy],
  controllers: [AuthController],
  exports: [AuthService],
})
export class AuthModule {}

UsersModule
→ 로그인할 때 유저를 찾기 위해 필요하다.

PassportModule
→ JWT 인증 Guard와 Strategy 기반으로 사용된다.

JwtModule
→ JWT 토큰 발급에 필요하다.

AuthService
→ 로그인 검증과 토큰 발급 로직을 담당한다.

JwtStrategy
→ 요청에 포함된 JWT 토큰을 검증하는 전략이다.

AuthController
→ 로그인 API 요청을 받는다.

imports: [
  UsersModule,
  ...
]

{
  "email": "test@example.com",
  "password": "password1234"
}

이메일로 유저 조회
  ↓
유저가 있으면 비밀번호 비교
  ↓
비밀번호가 맞으면 JWT 발급

this.usersService.findByEmail(email)

UsersModule에서 UsersService를 exports
  ↓
AuthModule에서 UsersModule을 imports
  ↓
AuthService에서 UsersService를 주입받을 수 있음

JwtModule.registerAsync({
  inject: [ConfigService],
  useFactory: async (configService: ConfigService) => ({
    secret: configService.getOrThrow<string>('JWT_SECRET'),
    signOptions: {
      expiresIn: configService.getOrThrow<string>('JWT_EXPIRES_IN') as any,
    },
  }),
})

JWT_SECRET
→ 토큰을 서명하고 검증할 때 사용하는 비밀키

JWT_EXPIRES_IN
→ 토큰 만료 시간

JwtModule.register({
  secret: 'my-secret',
  signOptions: { expiresIn: '1h' },
})

configService.getOrThrow<string>('JWT_SECRET')

signOptions: {
  expiresIn: configService.getOrThrow<string>('JWT_EXPIRES_IN') as any,
}

JWT_EXPIRES_IN=1h

JWT_EXPIRES_IN=5s

너무 짧으면 사용자가 자주 로그아웃된다.
너무 길면 토큰이 탈취되었을 때 위험이 커진다.

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @Post('login')
  @HttpCode(HttpStatus.OK)
  async login(@Body() loginDto: LocalLoginDto) {
    const user = await this.authService.validateUser(loginDto);

    return this.authService.login(user);
  }
}

POST /auth/login

POST /auth/login
  ↓
AuthController.login()

async login(@Body() loginDto: LocalLoginDto)

export class LocalLoginDto {
  @IsEmail()
  @IsNotEmpty()
  email: string;

  @IsString()
  @IsNotEmpty()
  password: string;
}

email
→ 이메일 형식이어야 하고 비어 있으면 안 된다.

password
→ 문자열이어야 하고 비어 있으면 안 된다.

프론트 로그인 요청
  ↓
ValidationPipe
  ↓
LocalLoginDto 검증
  ↓
AuthController.login() 실행

@Post('login')

{
  "email": "test@example.com",
  "password": "password1234"
}

GET /auth/login?email=test@example.com&password=password1234

POST /auth/login
body: { email, password }

@HttpCode(HttpStatus.OK)

@HttpCode(HttpStatus.OK)

로그인 성공 시 200 OK로 응답한다.

const user = await this.authService.validateUser(loginDto);

return this.authService.login(user);

this.authService.validateUser(loginDto)

this.authService.login(user)

AuthController
→ 로그인 요청을 받고 DTO를 전달한다.

AuthService
→ 이메일/비밀번호 검증과 JWT 발급을 처리한다.

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

  async validateUser(loginDto: LocalLoginDto): Promise<any> {
    const user = await this.usersService.findByEmail(loginDto.email);

    if (user && user.password) {
      const isMatch = await bcrypt.compare(loginDto.password, user.password);

      if (isMatch) {
        const { password, ...result } = user;
        return result;
      }
    }

    throw new UnauthorizedException('이메일 또는 비밀번호가 일치하지 않습니다.');
  }

  async login(user: any) {
    const payload = {
      email: user.email,
      sub: user.id,
      role: user.role,
    };

    return {
      access_token: this.jwtService.sign(payload),
    };
  }
}

UsersService
→ 이메일로 유저를 찾기 위해 필요하다.

JwtService
→ JWT access_token을 발급하기 위해 필요하다.

constructor(
  private readonly usersService: UsersService,
  private readonly jwtService: JwtService,
) {}

async validateUser(loginDto: LocalLoginDto): Promise<any> {
  const user = await this.usersService.findByEmail(loginDto.email);

  if (user && user.password) {
    const isMatch = await bcrypt.compare(loginDto.password, user.password);

    if (isMatch) {
      const { password, ...result } = user;
      return result;
    }
  }

  throw new UnauthorizedException('이메일 또는 비밀번호가 일치하지 않습니다.');
}

LocalLoginDto를 받는다.
  ↓
loginDto.email로 유저를 찾는다.
  ↓
유저가 있고 password도 있으면
  ↓
bcrypt.compare()로 비밀번호를 비교한다.
  ↓
비밀번호가 맞으면 password를 제거한 유저 정보를 반환한다.
  ↓
실패하면 401 UnauthorizedException을 던진다.

validateUser()는 로그인 요청으로 들어온 이메일과 비밀번호가 실제 DB의 유저 정보와 일치하는지 확인하는 메서드다.

const user = await this.usersService.findByEmail(loginDto.email);

{
  "email": "test@example.com",
  "password": "password1234"
}

AuthService.validateUser()
  ↓
UsersService.findByEmail(email)
  ↓
Prisma user.findUnique()
  ↓
User 테이블에서 email이 같은 유저 조회

if (user && user.password) {

1. 이메일에 해당하는 유저가 있는가?
2. 그 유저에게 password가 저장되어 있는가?

null.password

일반 이메일 로그인 사용자
→ password 있음

게스트 사용자
→ password 없을 수 있음

소셜 로그인 사용자
→ password 없을 수 있음

const isMatch = await bcrypt.compare(loginDto.password, user.password);

loginDto.password = "password1234"

user.password = "$2b$10$..."

loginDto.password === user.password

bcrypt.compare(입력한 비밀번호, DB에 저장된 해시)

비밀번호가 맞으면 true
틀리면 false

const { password, ...result } = user;
return result;

const user = {
  id: 'user-id',
  email: 'test@example.com',
  password: '$2b$10$...',
  name: '사용자',
  role: 'USER',
};

const { password, ...result } = user;

password = '$2b$10$...'

result = {
  id: 'user-id',
  email: 'test@example.com',
  name: '사용자',
  role: 'USER',
}

throw new UnauthorizedException('이메일 또는 비밀번호가 일치하지 않습니다.');

이메일에 해당하는 유저가 없음
유저는 있지만 password가 없음
비밀번호가 일치하지 않음

이메일 또는 비밀번호가 일치하지 않습니다.

이 이메일은 가입되어 있지 않습니다.

비밀번호가 틀렸습니다.

이메일 또는 비밀번호가 일치하지 않습니다.

return this.authService.login(user);

async login(user: any) {
  const payload = {
    email: user.email,
    sub: user.id,
    role: user.role,
  };

  return {
    access_token: this.jwtService.sign(payload),
  };
}

1. JWT payload를 만든다.
2. jwtService.sign(payload)로 access_token을 발급한다.

const payload = {
  email: user.email,
  sub: user.id,
  role: user.role,
};

email
→ 사용자 이메일

sub
→ 사용자 id

role
→ 사용자 권한

sub = user.id

role이 ADMIN이면 허용
role이 USER이면 거부

this.jwtService.sign(payload)

JWT_SECRET
→ 토큰 서명에 사용

JWT_EXPIRES_IN
→ 토큰 만료 시간에 사용

{
  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6..."
}

Authorization: Bearer access_token

fetch('/users', {
  headers: {
    Authorization: `Bearer ${accessToken}`,
  },
});

1. 프론트에서 POST /auth/login 요청
   body: { email, password }

2. ValidationPipe가 LocalLoginDto 검증

3. AuthController.login() 실행

4. AuthService.validateUser(loginDto) 호출

5. UsersService.findByEmail(loginDto.email)로 유저 조회

6. 유저가 있고 password도 있으면 bcrypt.compare() 실행

7. 비밀번호가 맞으면 password 제거한 user 반환

8. AuthService.login(user) 호출

9. payload 생성
   {
     email,
     sub: user.id,
     role
   }

10. jwtService.sign(payload)로 access_token 생성

11. 프론트에 access_token 반환

DTO 검증
  ↓
유저 조회
  ↓
비밀번호 해시 비교
  ↓
민감 정보 제거
  ↓
JWT payload 구성
  ↓
access_token 발급

async login(@Body() loginDto: LocalLoginDto)

async validateUser(loginDto: LocalLoginDto): Promise<any>

async login(user: any)

password가 제거된 유저 타입 정의
JWT payload 타입 정의
로그인 응답 DTO 정의

UsersModule
→ 로그인할 때 유저 조회를 위해 필요

PassportModule
→ JWT 인증 Guard/Strategy 기반

JwtModule
→ JWT 토큰 발급을 위해 필요

AuthService
→ 이메일/비밀번호 검증과 JWT 발급 담당

JwtStrategy
→ JWT 토큰 검증 전략

AuthController
→ 로그인 요청 입구

POST /auth/login

AuthController.login()
  ↓
AuthService.validateUser(loginDto)
  ↓
AuthService.login(user)

validateUser()
→ 이메일로 유저를 찾고
→ bcrypt로 비밀번호를 비교하고
→ 성공하면 password를 제거한 유저를 반환하고
→ 실패하면 401 에러를 던진다.

login()
→ 검증된 유저로 JWT payload를 만들고
→ jwtService.sign()으로 access_token을 발급한다.