[#4] 2.03 로그인 기능 구현

BE/package.json

@@ -23,15 +23,23 @@
     "@nestjs/common": "^10.0.0",
     "@nestjs/config": "^3.3.0",
     "@nestjs/core": "^10.0.0",
+    "@nestjs/jwt": "^10.2.0",
+    "@nestjs/passport": "^10.0.3",
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/swagger": "^8.0.1",
     "@nestjs/typeorm": "^10.0.2",
+    "@types/passport-jwt": "^4.0.1",
     "axios": "^1.7.7",
+    "bcrypt": "^5.1.1",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
     "cross-env": "^7.0.3",
     "docker": "^1.0.0",
     "dotenv": "^16.4.5",
     "fastify-swagger": "^5.1.1",
     "mysql2": "^3.11.3",
+    "passport": "^0.7.0",
+    "passport-jwt": "^4.0.1",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.8.1",
     "swagger-ui-express": "^5.0.1",
@@ -41,6 +49,7 @@
     "@nestjs/cli": "^10.0.0",
     "@nestjs/schematics": "^10.0.0",
     "@nestjs/testing": "^10.0.0",
+    "@types/bcrypt": "^5.0.2",
     "@types/express": "^5.0.0",
     "@types/jest": "^29.5.2",
     "@types/node": "^20.3.1",

BE/src/app.module.ts

@@ -3,6 +3,8 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { ConfigModule } from '@nestjs/config';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
+import { AuthModule } from './auth/auth.module';
+import { User } from './auth/user.entity';
 
 @Module({
   imports: [
@@ -14,9 +16,10 @@ import { AppService } from './app.service';
       username: process.env.DB_USERNAME,
       password: process.env.DB_PASSWD,
       database: process.env.DB_DATABASE,
-      entities: [],
+      entities: [User],
       synchronize: true,
     }),
+    AuthModule,
   ],
   controllers: [AppController],
   providers: [AppService],

BE/src/auth/auth.controller.ts

@@ -0,0 +1,38 @@
+import {
+  Controller,
+  Post,
+  Get,
+  Body,
+  Req,
+  ValidationPipe,
+  UseGuards,
+} from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+import { AuthService } from './auth.service';
+import { AuthCredentialsDto } from './dto/authCredentials.dto';
+import { ApiOperation } from '@nestjs/swagger';
+
+@Controller('auth')
+export class AuthController {
+  constructor(private authService: AuthService) {}
+
+  @ApiOperation({ summary: '회원 가입 API' })
+  @Post('/signup')
+  signUp(@Body(ValidationPipe) authCredentialsDto: AuthCredentialsDto) {
+    return this.authService.signUp(authCredentialsDto);
+  }
+  @ApiOperation({ summary: '로그인 API' })
+  @Get('/login')
+  loginWithCredentials(
+    @Body(ValidationPipe) authCredentialsDto: AuthCredentialsDto,
+  ) {
+    return this.authService.loginUser(authCredentialsDto);
+  }
+
+  @ApiOperation({ summary: 'Token 인증 테스트 API' })
+  @Get('/test')
+  @UseGuards(AuthGuard())
+  test(@Req() req: Request) {
+    return req;
+  }
+}

BE/src/auth/auth.module.ts

@@ -0,0 +1,26 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { JwtModule } from '@nestjs/jwt';
+import { PassportModule } from '@nestjs/passport';
+import { AuthController } from './auth.controller';
+import { AuthService } from './auth.service';
+import { User } from './user.entity';
+import { UserRepository } from './user.repository';
+import { JwtStrategy } from './jwt.strategy';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([User]),
+    PassportModule.register({ defaultStrategy: 'jwt' }),
+    JwtModule.register({
+      secret: 'Juga16',
+      signOptions: {
+        expiresIn: 3600,
+      },
+    }),
+  ],
+  controllers: [AuthController],
+  providers: [AuthService, UserRepository, JwtStrategy],
+  exports: [JwtStrategy, PassportModule],
+})
+export class AuthModule {}

BE/src/auth/auth.service.ts

@@ -0,0 +1,33 @@
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { JwtService } from '@nestjs/jwt';
+import * as bcrypt from 'bcrypt';
+import { UserRepository } from './user.repository';
+import { AuthCredentialsDto } from './dto/authCredentials.dto';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    @InjectRepository(UserRepository)
+    private userRepository: UserRepository,
+    private jwtService: JwtService,
+  ) {}
+
+  async signUp(authCredentialsDto: AuthCredentialsDto): Promise<void> {
+    return this.userRepository.registerUser(authCredentialsDto);
+  }
+
+  async loginUser(
+    authCredentialsDto: AuthCredentialsDto,
+  ): Promise<{ accessToken: string }> {
+    const { email, password } = authCredentialsDto;
+    const user = await this.userRepository.findOne({ where: { email } });
+
+    if (user && (await bcrypt.compare(password, user.password))) {
+      const payload = { email };
+      const accessToken = this.jwtService.sign(payload);
+      return { accessToken };
+    }
+    throw new UnauthorizedException('Please check your login credentials');
+  }
+}

BE/src/auth/dto/authCredentials.dto.ts

@@ -0,0 +1,27 @@
+import { IsString, Matches, MaxLength, MinLength } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class AuthCredentialsDto {
+  @ApiProperty({
+    description: '유저 이메일',
+    minLength: 4,
+    maxLength: 20,
+    type: 'string',
+  })
+  @IsString()
+  @MinLength(4)
+  @MaxLength(20)
+  email: string;
+
+  @ApiProperty({
+    description: '유저 비밀번호',
+    minLength: 4,
+    maxLength: 20,
+    type: 'string',
+  })
+  @IsString()
+  @MinLength(4)
+  @MaxLength(20)
+  @Matches(/^[a-zA-Z0-9]*$/)
+  password: string;
+}

BE/src/auth/jwt.strategy.ts

@@ -0,0 +1,26 @@
+import { PassportStrategy } from '@nestjs/passport';
+import { InjectRepository } from '@nestjs/typeorm';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { UserRepository } from './user.repository';
+import { User } from './user.entity';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(
+    @InjectRepository(UserRepository) private userRepository: UserRepository,
+  ) {
+    super({
+      secretOrKey: 'Juga16',
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+    });
+  }
+
+  async validate(payload) {
+    const { email } = payload;
+    const user: User = await this.userRepository.findOne({ where: { email } });
+    if (!user) throw new UnauthorizedException();
+
+    return user;
+  }
+}

BE/src/auth/user.entity.ts

@@ -0,0 +1,19 @@
+import { BaseEntity, Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity()
+export class User extends BaseEntity {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  email: string;
+
+  @Column()
+  password: string;
+
+  @Column({ default: false })
+  tutorial: boolean;
+
+  @Column({ default: -1 })
+  kakaoId: number;
+}

BE/src/auth/user.repository.ts

@@ -0,0 +1,21 @@
+import { Injectable } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { DataSource, Repository } from 'typeorm';
+import * as bcrypt from 'bcrypt';
+import { User } from './user.entity';
+import { AuthCredentialsDto } from './dto/authCredentials.dto';
+
+@Injectable()
+export class UserRepository extends Repository<User> {
+  constructor(@InjectDataSource() dataSource: DataSource) {
+    super(User, dataSource.createEntityManager());
+  }
+
+  async registerUser(authCredentialsDto: AuthCredentialsDto) {
+    const { email, password } = authCredentialsDto;
+    const salt: string = await bcrypt.genSalt();
+    const hashedPassword: string = await bcrypt.hash(password, salt);
+    const user = this.create({ email, password: hashedPassword });
+    await this.save(user);
+  }
+}