[Deploy] 4주차 스프린트 배포

.gitignore

@@ -7,4 +7,9 @@ node_modules
 
 # husky 관련
 .husky/_
-.husky/.gitignore
+.husky/.gitignore
+
+# docker-compose 관련 파일
+
+mysql-data
+redis-data

backend/package.json

@@ -22,22 +22,37 @@
   "dependencies": {
     "@nestjs/common": "^10.0.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.6",
+    "@nestjs/typeorm": "^10.0.2",
     "@nestjs/websockets": "^10.4.6",
+    "@types/passport-jwt": "^4.0.1",
+    "axios": "^1.7.7",
+    "cookie-parser": "^1.4.7",
     "dotenv": "^16.4.5",
     "ioredis": "^5.4.1",
+    "mysql2": "^3.11.4",
+    "passport": "^0.7.0",
+    "passport-custom": "^1.1.1",
+    "passport-jwt": "^4.0.1",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.8.1",
-    "socket.io": "^4.8.1"
+    "socket.io": "^4.8.1",
+    "typeorm": "^0.3.20",
+    "typeorm-naming-strategies": "^4.1.0",
+    "typeorm-transactional": "^0.5.0"
   },
   "devDependencies": {
     "@nestjs/cli": "^10.0.0",
     "@nestjs/schematics": "^10.0.0",
     "@nestjs/testing": "^10.0.0",
+    "@types/cookie-parser": "^1.4.7",
     "@types/express": "^5.0.0",
     "@types/jest": "^29.5.2",
     "@types/node": "^20.3.1",
+    "@types/passport-github": "^1.1.12",
     "@types/supertest": "^6.0.0",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",

backend/src/app.module.ts

@@ -1,14 +1,33 @@
 import { Module } from "@nestjs/common";
+
 import { AppController } from "./app.controller";
 import { AppService } from "./app.service";
+
 import { SocketModule } from "./signaling-server/socket.module";
 import { RoomModule } from "./room/room.module";
 import { RedisModule } from "./redis/redis.module";
+import { AuthModule } from "./auth/auth.module";
+import { UserModule } from "./user/user.module";
+import { TypeOrmModule } from "@nestjs/typeorm";
 
 import "dotenv/config";
 
+import { createDataSource, typeOrmConfig } from "./config/typeorm.config";
+import { QuestionListModule } from "./question-list/question-list.module";
+
 @Module({
-    imports: [SocketModule, RoomModule, RedisModule],
+    imports: [
+        TypeOrmModule.forRootAsync({
+            useFactory: async () => typeOrmConfig, // 설정 객체를 직접 반환
+            dataSourceFactory: async () => await createDataSource(), // 분리된 데이터소스 생성 함수 사용
+        }),
+        SocketModule,
+        RoomModule,
+        RedisModule,
+        AuthModule,
+        UserModule,
+        QuestionListModule,
+    ],
     controllers: [AppController],
     providers: [AppService],
 })

backend/src/auth/auth.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { AuthController } from "./auth.controller";
+
+describe("AuthController", () => {
+    let controller: AuthController;
+
+    beforeEach(async () => {
+        const module: TestingModule = await Test.createTestingModule({
+            controllers: [AuthController],
+        }).compile();
+
+        controller = module.get<AuthController>(AuthController);
+    });
+
+    it("should be defined", () => {
+        expect(controller).toBeDefined();
+    });
+});

backend/src/auth/auth.controller.ts

@@ -0,0 +1,65 @@
+import { Controller, Get, Post, Res, Req, UseGuards } from "@nestjs/common";
+import { AuthGuard } from "@nestjs/passport";
+import { Request, Response } from "express";
+import { AuthService } from "./auth.service";
+import { GithubProfile } from "./github/gitub-profile.decorator";
+import { Profile } from "passport-github";
+import { setCookieConfig } from "../config/cookie.config";
+import { JwtPayload, JwtTokenPair } from "./jwt/jwt.decorator";
+import { IJwtPayload, IJwtTokenPair } from "./jwt/jwt.model";
+
+@Controller("auth")
+export class AuthController {
+    private static ACCESS_TOKEN = "accessToken";
+    private static REFRESH_TOKEN = "refreshToken";
+
+    constructor(private readonly authService: AuthService) {}
+
+    @Post("github")
+    @UseGuards(AuthGuard("github"))
+    async githubCallback(
+        @Req() req: Request,
+        @Res({ passthrough: true }) res: Response,
+        @GithubProfile() profile: Profile
+    ) {
+        const id = parseInt(profile.id);
+
+        const result = await this.authService.getTokenByGithubId(id);
+
+        res.cookie("accessToken", result.accessToken.token, {
+            maxAge: result.accessToken.expireTime,
+            ...setCookieConfig,
+        });
+
+        res.cookie("refreshToken", result.refreshToken.token, {
+            maxAge: result.refreshToken.expireTime,
+            ...setCookieConfig,
+        });
+
+        return {
+            success: true,
+        };
+    }
+
+    @Get("whoami")
+    @UseGuards(AuthGuard("jwt"))
+    async handleWhoami(@Req() req: Request, @JwtPayload() token: IJwtPayload) {
+        return token;
+    }
+
+    @Get("refresh")
+    @UseGuards(AuthGuard("jwt-refresh"))
+    async handleRefresh(
+        @Res({ passthrough: true }) res: Response,
+        @JwtTokenPair() token: IJwtTokenPair
+    ) {
+        res.cookie("accessToken", token.accessToken.token, {
+            maxAge: token.accessToken.expireTime,
+            ...setCookieConfig,
+        });
+
+        return {
+            success: true,
+        };
+    }
+}

backend/src/auth/auth.module.ts

@@ -0,0 +1,13 @@
+import { Module } from "@nestjs/common";
+import { AuthController } from "./auth.controller";
+import { AuthService } from "./auth.service";
+import { GithubStrategy } from "./github/github.strategy";
+import { UserRepository } from "../user/user.repository";
+import { JwtModule } from "./jwt/jwt.module";
+
+@Module({
+    imports: [JwtModule],
+    controllers: [AuthController],
+    providers: [AuthService, GithubStrategy, UserRepository],
+})
+export class AuthModule {}

backend/src/auth/auth.service.spec.ts

@@ -0,0 +1,129 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { AuthService } from "./auth.service";
+import { UserRepository } from "../user/user.repository";
+import { Profile } from "passport-github";
+
+// typeorm-transactional 모킹
+jest.mock("typeorm-transactional", () => ({
+    Transactional: () => () => ({}),
+    runOnTransactionCommit: () => () => ({}),
+    runOnTransactionRollback: () => () => ({}),
+    runOnTransactionComplete: () => () => ({}),
+    initializeTransactionalContext: () => ({}),
+}));
+
+describe("AuthService", () => {
+    let authService: AuthService;
+    let userRepository: UserRepository;
+
+    // Mock GitHub 프로필 데이터
+    const mockGithubProfile: Profile = {
+        id: "12345",
+        displayName: "Test User",
+        username: "testuser",
+        profileUrl: "https://abcd/",
+        photos: [],
+        provider: "github",
+        _raw: "",
+        _json: {},
+    };
+
+    // Mock 유저 데이터
+    const mockUser = {
+        id: 1,
+        loginId: null,
+        passwordHash: null,
+        githubId: 12345,
+        username: "camper_12345",
+    };
+
+    beforeEach(async () => {
+        // Mock Repository 생성
+        const mockUserRepository = {
+            getUserByGithubId: jest.fn(),
+            createUser: jest.fn(),
+        };
+
+        const module: TestingModule = await Test.createTestingModule({
+            providers: [
+                AuthService,
+                {
+                    provide: UserRepository,
+                    useValue: mockUserRepository,
+                },
+            ],
+        }).compile();
+
+        authService = module.get<AuthService>(AuthService);
+        userRepository = module.get<UserRepository>(UserRepository);
+    });
+
+    describe("githubLogin", () => {
+        it("기존 사용자가 있을 경우 해당 사용자를 반환해야 한다", async () => {
+            // Given
+            jest.spyOn(userRepository, "getUserByGithubId").mockResolvedValue(
+                mockUser
+            );
+
+            // When
+            const result = await authService.githubLogin(mockGithubProfile);
+
+            // Then
+            expect(userRepository.getUserByGithubId).toHaveBeenCalledWith(
+                parseInt(mockGithubProfile.id)
+            );
+            expect(result).toEqual(mockUser);
+            expect(userRepository.createUser).not.toHaveBeenCalled();
+        });
+
+        it("새로운 사용자의 경우 새 계정을 생성해야 한다", async () => {
+            // Given
+            jest.spyOn(userRepository, "getUserByGithubId").mockResolvedValue(
+                null
+            );
+            jest.spyOn(userRepository, "createUser").mockResolvedValue(
+                mockUser
+            );
+
+            // When
+            const result = await authService.githubLogin(mockGithubProfile);
+
+            // Then
+            expect(userRepository.getUserByGithubId).toHaveBeenCalledWith(
+                parseInt(mockGithubProfile.id)
+            );
+            expect(userRepository.createUser).toHaveBeenCalledWith({
+                githubId: parseInt(mockGithubProfile.id),
+                username: `camper_${mockGithubProfile.id}`,
+            });
+            expect(result).toEqual(mockUser);
+        });
+
+        it("getUserByGithubId 에러 발생 시 예외를 던져야 한다", async () => {
+            // Given
+            const error = new Error("Database error");
+            jest.spyOn(userRepository, "getUserByGithubId").mockRejectedValue(
+                error
+            );
+
+            // When & Then
+            await expect(
+                authService.githubLogin(mockGithubProfile)
+            ).rejects.toThrow(error);
+        });
+
+        it("createUser 에러 발생 시 예외를 던져야 한다", async () => {
+            // Given
+            const error = new Error("Database error");
+            jest.spyOn(userRepository, "getUserByGithubId").mockResolvedValue(
+                null
+            );
+            jest.spyOn(userRepository, "createUser").mockRejectedValue(error);
+
+            // When & Then
+            await expect(
+                authService.githubLogin(mockGithubProfile)
+            ).rejects.toThrow(error);
+        });
+    });
+});

backend/src/auth/auth.service.ts

@@ -0,0 +1,31 @@
+import { Injectable, UnauthorizedException } from "@nestjs/common";
+import { UserRepository } from "../user/user.repository";
+import { Transactional } from "typeorm-transactional";
+import "dotenv/config";
+import { DAY, HOUR } from "../utils/time";
+import { JwtService } from "./jwt/jwt.service";
+
+@Injectable()
+export class AuthService {
+    private static ACCESS_TOKEN_EXPIRATION_TIME = 3 * HOUR;
+    private static ACCESS_TOKEN_EXPIRATION = 30 * DAY;
+
+    constructor(
+        private readonly userRepository: UserRepository,
+        private readonly jwtService: JwtService
+    ) {}
+
+    @Transactional()
+    public async getTokenByGithubId(id: number) {
+        let user = await this.userRepository.getUserByGithubId(id);
+
+        if (!user) {
+            user = await this.userRepository.createUser({
+                githubId: id,
+                username: `camper_${id}`,
+            });
+        }
+
+        return await this.jwtService.createJwtToken(user.id);
+    }
+}

backend/src/auth/github/github.strategy.ts

@@ -0,0 +1,51 @@
+// github-auth.strategy.ts
+import { Injectable, UnauthorizedException } from "@nestjs/common";
+import { PassportStrategy } from "@nestjs/passport";
+import { Strategy } from "passport-custom";
+import { Request } from "express";
+import axios from "axios";
+import "dotenv/config";
+
+@Injectable()
+export class GithubStrategy extends PassportStrategy(Strategy, "github") {
+    private static REQUEST_ACCESS_TOKEN_URL =
+        "https://github.com/login/oauth/access_token";
+    private static REQUEST_USER_URL = "https://api.github.com/user";
+
+    constructor() {
+        super();
+    }
+
+    async validate(req: Request, done: any) {
+        const { code } = req.body;
+
+        if (!code) {
+            throw new UnauthorizedException("Authorization code not found");
+        }
+
+        const tokenResponse = await axios.post(
+            GithubStrategy.REQUEST_ACCESS_TOKEN_URL,
+            {
+                client_id: process.env.OAUTH_GITHUB_ID,
+                client_secret: process.env.OAUTH_GITHUB_SECRET,
+                code: code,
+            },
+            {
+                headers: { Accept: "application/json" },
+            }
+        );
+
+        const { access_token } = tokenResponse.data;
+
+        // GitHub 사용자 정보 조회
+        const userResponse = await axios.get(GithubStrategy.REQUEST_USER_URL, {
+            headers: {
+                Authorization: `Bearer ${access_token}`,
+            },
+        });
+
+        return done(null, {
+            profile: userResponse.data,
+        });
+    }
+}