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

BE/package.json

@@ -23,28 +23,43 @@
     "@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/platform-socket.io": "^10.4.7",
+    "@nestjs/schedule": "^4.1.1",
     "@nestjs/swagger": "^8.0.1",
     "@nestjs/typeorm": "^10.0.2",
+    "@types/passport-jwt": "^4.0.1",
+    "@nestjs/websockets": "^10.4.7",
     "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",
+    "socket.io": "^4.8.1",
     "swagger-ui-express": "^5.0.1",
-    "typeorm": "^0.3.20"
+    "typeorm": "^0.3.20",
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@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",
     "@types/supertest": "^6.0.0",
+    "@types/ws": "^8.5.13",
     "eslint": "^8.0.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-airbnb-typescript": "^18.0.0",

BE/src/app.module.ts

@@ -1,11 +1,19 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { ConfigModule } from '@nestjs/config';
+import { ScheduleModule } from '@nestjs/schedule';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
+import { AuthModule } from './auth/auth.module';
+import { User } from './auth/user.entity';
+import { StockIndexModule } from './stock/index/stock.index.module';
+import { SocketService } from './websocket/socket.service';
+import { SocketGateway } from './websocket/socket.gateway';
+import { TopfiveModule } from './stocks/topfive/topfive.module';
 
 @Module({
   imports: [
+    ScheduleModule.forRoot(),
     ConfigModule.forRoot(),
     TypeOrmModule.forRoot({
       type: 'mysql', // 데이터베이스 타입
@@ -14,11 +22,14 @@ 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,
+    StockIndexModule,
+    TopfiveModule,
   ],
   controllers: [AppController],
-  providers: [AppService],
+  providers: [AppService, SocketService, SocketGateway],
 })
 export class AppModule {}

BE/src/auth/auth.controller.spec.ts

@@ -0,0 +1,31 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AuthController } from './auth.controller';
+import { AuthService } from './auth.service';
+import { UserRepository } from './user.repository';
+
+describe('AuthController', () => {
+  let controller: AuthController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [AuthController],
+      providers: [
+        AuthService,
+        {
+          provide: UserRepository,
+          useValue: {
+            find: jest.fn(),
+            findOne: jest.fn(),
+            save: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    controller = module.get<AuthController>(AuthController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

BE/src/auth/auth.controller.ts

@@ -0,0 +1,39 @@
+import {
+  Controller,
+  Post,
+  Get,
+  Body,
+  Req,
+  ValidationPipe,
+  UseGuards,
+} from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+import { ApiOperation } from '@nestjs/swagger';
+import { AuthService } from './auth.service';
+import { AuthCredentialsDto } from './dto/authCredentials.dto';
+
+@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.spec.ts

@@ -0,0 +1,31 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AuthService } from './auth.service';
+import { AuthController } from './auth.controller';
+import { UserRepository } from './user.repository';
+
+describe('AuthService', () => {
+  let service: AuthService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [AuthController],
+      providers: [
+        AuthService,
+        {
+          provide: UserRepository,
+          useValue: {
+            find: jest.fn(),
+            findOne: jest.fn(),
+            save: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    service = module.get<AuthService>(AuthService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

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);
+  }
+}

BE/src/stock/index/dto/stock.index.list.chart.element.dto.ts

@@ -0,0 +1,14 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class StockIndexListChartElementDto {
+  constructor(time: string, value: string) {
+    this.time = time;
+    this.value = value;
+  }
+
+  @ApiProperty({ description: 'HHMMSS', example: '130500' })
+  time: string;
+
+  @ApiProperty({ description: '주가 지수' })
+  value: string;
+}

BE/src/stock/index/dto/stock.index.list.element.dto.ts

@@ -0,0 +1,17 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { StockIndexListChartElementDto } from './stock.index.list.chart.element.dto';
+
+export class StockIndexListElementDto {
+  constructor(code: string, chart: StockIndexListChartElementDto[]) {
+    this.code = code;
+    this.chart = chart;
+  }
+
+  @ApiProperty({
+    description: '코스피: 0001, 코스닥: 1001, 코스피200: 2001, KSQ150: 3003',
+  })
+  code: string;
+
+  @ApiProperty({ type: [StockIndexListChartElementDto] })
+  chart: StockIndexListChartElementDto[];
+}