1
(Clint) --(1)-->  (API 서버) --(3)--> (Database)
2
        <-(4)--       (2)
3

4
(1) ID/PW 전송
5
(2) 검증
6
(3) 세션 생성 및 저장
7
(4) 쿠키 전송

1
(Clint) --(1)-->  (API 서버) ---(3, 5)--> (Database)
2
        <-(7)--       (2)   <--(4, 6)---
3

4
(1) 쿠키전송
5
(2) 검증
6
(3) 해당 세션 검색
7
(4) 유저 정보 응답
8
(5) 데이터 요청
9
(6) 데이터 응답
10
(7) 데이터 전송

1
(Clint) --(1)-->  (API 서버)
2
        <-(3)--       (2)
3

4
(1) ID/PW 전송
5
(2) 검증
6
(3) Token 전송

1
(Clint) --(1)-->  (API 서버) ---(3)--> (Database)
2
        <-(5)--       (2)   <--(4)---
3

4
(1) Token 전송
5
(2) 검증
6
(3) 데이터 요청
7
(4) 결과 응답
8
(5) 데이터 전송

1
$ nest g resource
2
? auth
3
? REST API
4
? No

1
import { Injectable } from '@nestjs/common'
2

3
/** 만들려는 기능
4
 * 1) registerWithEmail
5
 * - email, nickname, password를 입력받고 사용자를 생성한다
6
 * - 생성이 완료되면, accessToken과 refreshToken을 반환한다
7
 * 회원가입 후 다시 로그인해주세요 <- 쓸데없는 과정을 방지하기 위해서
8
 *
9
 * 2) loginWithEmail
10
 * - email, password를 입력하면, 사용자 검증을 진행한다.
11
 * - 검증이 완료되면, accessToken과 refreshToken을 반환한다.
12
 *
13
 * 3) loginUser
14
 * - (1)과 (2)에서 필요한 accessToken과 refreshToken을 반환하는 로직
15
 *
16
 * 4) signToken
17
 * - (3)에서 필요한 accessToken과 refreshToken을 sign하는 로직
18
 *
19
 * 5) authenticateWithEmailAndPassword
20
 * - (2)에서 로그인을 진행할 떄, 필요한 기본적인 검증 진행
21
 * -- 1. 사용자가 존재하는 확인(email)
22
 * -- 2. 비밀번호가 맞는지 확인
23
 * -- 3. 모두 통과되면 사용자 정보 반환
24
 * -- 4. loginWithEmail에서 반환된 데이터를 기반으로 토큰 생성
25
 */
26
@Injectable()
27
export class AuthService {}

1
yarn add @nestjs/jwt bcrypt

1
import { Module } from '@nestjs/common'
2
import { AuthService } from './auth.service'
3
import { AuthController } from './auth.controller'
4
import { JwtModule } from '@nestjs/jwt'
5

6
@Module({
7
  imports: [JwtModule.register({})],
8
  controllers: [AuthController],
9
  providers: [AuthService],
10
})
11
export class AuthModule {}

1
@Injectable()
2
export class AuthService {
3
  constructor(private readonly jwtService: JwtService) {}
4

5
  /** Payload에 들어갈 정보
6
   * 1) email
7
   * 2) sub -> 사용자 id
8
   * 3) type -> 'access' | 'refresh'
9
   */
10
  signToken(user: Pick<UsersModel, 'email' | 'id'>, isRefreshToken: boolean) {
11
    const payload = {
12
      email: user.email,
13
      sub: user.id,
14
      type: isRefreshToken ? 'refresh' : 'access',
15
    }
16

17
    return this.jwtService.sign(payload, {
18
      secret: JWT_SECRET,
19
      expiresIn: isRefreshToken ? 3600 : 300, // 3600초(1시간) 초단위로 설정
20
    })
21
  }
22
}

1
export const JWT_SECRET = 'berenickt'

1
// auth.module.ts 생략
2
@Module({
3
  imports: [
4
    // JwtModule.register({}), //
5
  ],
6
  controllers: [AuthController],
7
  providers: [AuthService],
8
})
9
export class AuthModule {}

1
[Nest] 84803  -
2
ERROR [ExceptionHandler]
3
Nest can't resolve dependencies of the AuthService (?).
4
Please make sure
5
that the argument JwtService at index [0] is available
6
in the AuthModule context.
7

8
Potential solutions:
9
- Is AuthModule a valid NestJS module?
10
- If JwtService is a provider, is it part of the current AuthModule?
11
- If JwtService is exported from a separate @Module, is that module imported within AuthModule?
12
  @Module({
13
    imports: [ /* the Module containing JwtService */ ]
14
  })

1
// auth.service.ts 생략
2
loginUser(user: Pick<UsersModel, 'email' | 'id'>) {
3
  return {
4
    accessToken: this.signToken(user, false),
5
    refreshToken: this.signToken(user, true),
6
  }
7
}

1
// users.service.ts  생략
2
async getUserByEmail(email: string) {
3
  return this.userRepository.findOne({
4
    where: { email },
5
  })
6
}

1
// users.module.ts 생략
2
@Module({
3
  // 이 모듈 안에서 UsersModel을 어디서든 사용 가능
4
  imports: [TypeOrmModule.forFeature([UsersModel])],
5
  exports: [UsersService], // 추가
6
  controllers: [UsersController],
7
  providers: [UsersService],
8
})

1
@Module({
2
  imports: [
3
    JwtModule.register({}), //
4
    UsersModule,
5
  ],
6
  controllers: [AuthController],
7
  providers: [AuthService],
8
})

1
/***
2
 * 1. 사용자가 존재하는 확인(email)
3
 * 2. 비밀번호가 맞는지 확인
4
 * 3. 모두 통과되면 사용자 정보 반환
5
 */
6
async authenticateWithEmailAndPassword(user: Pick<UsersModel, 'email' | 'password'>) {
7
  const existingUser = await this.usersService.getUserByEmail(user.email)
8

9
  if (!existingUser) throw new UnauthorizedException('존재하지 않는 사용자입니다.')
10

11
  /*** 파라미터, campare : 두 비밀번호를 비교해서 boolean값 반환
12
   * 1) 입력된 비밀번호
13
   * 2) 기존 해시(hash) -> 사용자 정보에 저장돼있는 hash
14
   */
15
  const passOk = bcrypt.compare(user.password, existingUser.password)
16

17
  if (!passOk) throw new UnauthorizedException('비밀번호가 틀렸습니다.')
18

19
  return existingUser
20
}

1
async loginWithEmail(user: Pick<UsersModel, 'email' | 'password'>) {
2
  const existingUser = await this.authenticateWithEmailAndPassword(user)
3
  return this.loginUser(existingUser)
4
}

1
export const JWT_SECRET = 'berenickt'
2
export const HASH_ROUNDS = 10

1
// 생략
2
/***
3
 * 1) nickname 중복이 없는지 확인
4
 * - exist() : 만약 조건에 해당되는 값이 있으면 true 반환
5
 */
6
async createUser(user: Pick<UsersModel, 'nickname' | 'email' | 'password'>) {
7
  const nicknameExists = await this.userRepository.exist({
8
    where: { nickname: user.nickname },
9
  })
10
  if (nicknameExists) throw new BadRequestException('이미 존재하는 nickname입니다.')
11

12
  const emailExists = await this.userRepository.exist({
13
    where: { nickname: user.email },
14
  })
15
  if (emailExists) throw new BadRequestException('이미 가입한 이메일입니다.')
16

17
  const userObject = this.userRepository.create({
18
    nickname: user.nickname,
19
    email: user.email,
20
    password: user.password,
21
  })
22
  const newUser = await this.userRepository.save(userObject)
23
  return newUser
24
}

1
@Post()
2
postUser(
3
  @Body('nickname') nickname: string, //
4
  @Body('email') email: string,
5
  @Body('password') password: string,
6
) {
7
  return this.usersService.createUser({ nickname, email, password })
8
}

1
// auth.service.ts 생략
2
/*** hash 파라미터 (salt값은 자동 생성됨)
3
 * 1) hash로 만들고 싶은 비밀번호
4
 * 2) round 돌릴 횟수, 너무 많으면 시간이 기하급수적으로 올라감
5
 * @see https://www.npmjs.com/package/bcrypt#a-note-on-rounds
6
 */
7
async registerWithEmail(user: Pick<UsersModel, 'nickname' | 'email' | 'password'>) {
8
  const hash = await bcrypt.hash(user.password, HASH_ROUNDS)
9
  const newUser = await this.usersService.createUser({
10
    ...user, //
11
    password: hash,
12
  })
13
  return this.loginUser(newUser)
14
}

1
import { Body, Controller, Post } from '@nestjs/common'
2
import { AuthService } from './auth.service'
3

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

8
  @Post('login/email')
9
  loginEmail(@Body('email') email: string, @Body('password') password: string) {
10
    return this.authService.loginWithEmail({
11
      email,
12
      password,
13
    })
14
  }
15

16
  @Post('register/email')
17
  registerEmail(@Body('nickname') nickname: string, @Body('email') email: string, @Body('password') password: string) {
18
    return this.authService.registerWithEmail({
19
      nickname,
20
      email,
21
      password,
22
    })
23
  }
24
}

1
@Controller('users')
2
export class UsersController {
3
  constructor(private readonly usersService: UsersService) {}
4

5
  @Get()
6
  getUsers() {
7
    return this.usersService.getAllUsers()
8
  }
9

10
  // @Post()
11
  // postUser(
12
  //   @Body('nickname') nickname: string, //
13
  //   @Body('email') email: string,
14
  //   @Body('password') password: string,
15
  // ) {
16
  //   return this.usersService.createUser({ nickname, email, password })
17
  // }
18
}

1
// auth.service.ts 생략
2
/*** 토큰을 사용하게 되는 방식
3
 * 1) 사용자가 로그인 또는 회원가입을 진행하면
4
 *    accessToken과 refreshToken을 발급받는다
5
 * 2) 로그인 할때는 Basic 토큰과 함께 요청을 보낸다
6
 *    Basic 토큰은 '이메일:비밀번호'를 Base64로 인코딩한 형태이다.
7
 *    e.g.) {authorization: 'Basic {token}'}
8
 * 3) 아무나 접근할 수 없는 정보 (private route)를 접근할 떄는
9
 *    accessToken을 Header에 추가해서 요청과 함께 보낸다.
10
 *    e.g.) {authorization: 'Bearer {token}'}
11
 * 4) 토큰과 요청을 함께 받은 서버는 토큰 검증을 통해 현재 요청을 보낸
12
 *    사용자가 누구인지 알 수 있다.
13
 *    e.g.) 현재 로그인한 사용자가 작성한 포스트만 가져오려면
14
 *    토큰의 sub 값에 입력돼있는 사용자의 포스트만 따로 필터링할 수 있다.
15
 *    특정 사용자의 토큰이 없다면, 다른 사용자의 데이터를 접근 못한다.
16
 * 5) 모든 토큰은 만료 기간이 있다. 만료기간이 지나면, 새로 토큰을 발급받아야 한다.
17
 *    그렇지 않으면 jwtService.verify()에서 인증이 통과안된다.
18
 *    그러니 access 토큰을 새로 발급받을 수 있는 /auth/token/access와
19
 *    refresh 토큰을 새로 발급받을 수 있는 /auth/token/refresh가 필요하다.
20
 * 6) 토큰이 만료되면, 각각의 토큰을 새로 발급받을 수 있는 엔드포인트에 요청을 해서
21
 *    새로운 토큰을 발급받고, 새로운 토큰을 사용해서 private route에 접근한다.
22
 */

1
/** Header로부터 토큰을 받을 떄
2
 * {authorization: 'Basic {token}'} - 로그인
3
 * {authorization: 'Bearer {token}'} - 발급받은 토큰을 그대로 넣었을 떄
4
 */
5
extractTokenFromHeader(header: string, isBearer: boolean) {
6
  const splitToken = header.split(' ')
7
  const prefix = isBearer ? 'Bearer' : 'Basic'
8

9
  if (splitToken.length !== 2 || splitToken[0] !== prefix) {
10
    throw new UnauthorizedException('잘못된 토큰입니다!')
11
  }
12

13
  const token = splitToken[1]
14
  return token
15
}

1
// auth.service.ts 생략
2
/*** email:password 형태로 바꾸기
3
 * 1) dafklmlfa:askdmklasmda -> email:password
4
 * 2) email:password -> [email, password]
5
 * 3) {email: email, password: password}
6
 */
7
decodeBasicToken(base64String: string) {
8
  const decoded = Buffer.from(base64String, 'base64').toString('utf8')
9
  const split = decoded.split(':')
10
  if (split.length !== 2) {
11
    throw new UnauthorizedException('잘못된 유형의 토큰입니다.')
12
  }
13
  const email = split[0]
14
  const password = split[1]
15
  return {
16
    email,
17
    password,
18
  }
19
}

1
import { Body, Controller, Headers, Post } from '@nestjs/common'
2
import { AuthService } from './auth.service'
3

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

8
  @Post('login/email')
9
  loginEmail(@Headers('authorization') rawToken: string) {
10
    const token = this.authService.extractTokenFromHeader(rawToken, false)
11
    const credentials = this.authService.decodeBasicToken(token)
12
    return this.authService.loginWithEmail(credentials)
13
  }
14

15
  @Post('register/email')
16
  registerEmail(
17
    @Body('nickname') nickname: string, //
18
    @Body('email') email: string,
19
    @Body('password') password: string,
20
  ) {
21
    return this.authService.registerWithEmail({
22
      nickname,
23
      email,
24
      password,
25
    })
26
  }
27
}

1
// auth.service.ts 생략
2
/*** 토큰 검증
3
 *
4
 */
5
verifyToken(token: string) {
6
  return this.jwtService.verify(token, {
7
    secret: JWT_SECRET,
8
  })
9
}
10

11
rotateToken(token: string, isRefreshToken: boolean) {
12
  const decoded = this.jwtService.verify(token, {
13
    secret: JWT_SECRET,
14
  })
15

16
  /***
17
   * sub : id
18
   * email : email
19
   * type : 'access' | 'refresh'
20
   */
21
  if (decoded.type !== 'refresh') {
22
    throw new UnauthorizedException('토큰 재발급은 Refresh 토큰으로만 가능합니다.')
23
  }
24

25
  return this.signToken({ ...decoded }, isRefreshToken)
26
}

1
import { Body, Controller, Headers, Post } from '@nestjs/common'
2
import { AuthService } from './auth.service'
3

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

8
  @Post('token/access')
9
  postTokenAccess(@Headers('authorization') rawToken: string) {
10
    const token = this.authService.extractTokenFromHeader(rawToken, true)
11
    const newToken = this.authService.rotateToken(token, false)
12

13
    /***
14
     * {accessToken : {token}}
15
     */
16
    return {
17
      accessToken: newToken,
18
    }
19
  }
20

21
  @Post('token/refresh')
22
  postTokenRefresh(@Headers('authorization') rawToken: string) {
23
    const token = this.authService.extractTokenFromHeader(rawToken, true)
24
    const newToken = this.authService.rotateToken(token, true)
25

26
    /***
27
     * {refreshToken : {token}}
28
     */
29
    return {
30
      refreshToken: newToken,
31
    }
32
  }
33

34
  @Post('login/email')
35
  postLoginEmail(@Headers('authorization') rawToken: string) {
36
    const token = this.authService.extractTokenFromHeader(rawToken, false)
37
    const credentials = this.authService.decodeBasicToken(token)
38
    return this.authService.loginWithEmail(credentials)
39
  }
40

41
  @Post('register/email')
42
  postRegisterEmail(
43
    @Body('nickname') nickname: string, //
44
    @Body('email') email: string,
45
    @Body('password') password: string,
46
  ) {
47
    return this.authService.registerWithEmail({
48
      nickname,
49
      email,
50
      password,
51
    })
52
  }
53
}