[Refactor] useSession 리팩토링

.gitignore

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

backend/src/config/typeorm.config.ts

@@ -26,6 +26,40 @@ export const createDataSource = async (): Promise<DataSource> => {
         transactionalDataSource = addTransactionalDataSource(
             new DataSource(typeOrmConfig)
         );
+
+        await transactionalDataSource.initialize();
+        await seedDatabase(transactionalDataSource);
     }
     return transactionalDataSource;
 };
+
+const seedDatabase = async (dataSource: DataSource) => {
+    const categoryRepository = dataSource.getRepository(Category);
+
+    const categories = [
+        "자료구조",
+        "운영체제",
+        "데이터베이스",
+        "컴퓨터구조",
+        "네트워크",
+        "백엔드",
+        "프론트엔드",
+        "알고리즘",
+        "보안",
+    ];
+
+    // 이미 데이터가 있을 경우 시딩하지 않음
+    const existingCount = await categoryRepository.count();
+    if (existingCount > 0) {
+        return;
+    }
+
+    // 카테고리 데이터 삽입
+    const categoryEntities = categories.map((name) => {
+        const category = new Category();
+        category.name = name;
+        return category;
+    });
+
+    await categoryRepository.save(categoryEntities);
+};

backend/src/question-list/dto/create-question-list.dto.ts

@@ -1,5 +1,6 @@
 export interface CreateQuestionListDto {
     title: string;
+    contents: string[];
     categoryNames: string[];
     isPublic: boolean;
     userId: number;

backend/src/question-list/question-list.controller.ts

@@ -62,29 +62,18 @@ export class QuestionListController {
             // 질문지 DTO 준비
             const createQuestionListDto: CreateQuestionListDto = {
                 title,
+                contents,
                 categoryNames,
                 isPublic,
                 userId: token.userId,
             };
 
             // 질문지 생성
-            const createdQuestionList =
+            const { createdQuestionList, createdQuestions } =
                 await this.questionListService.createQuestionList(
                     createQuestionListDto
                 );
 
-            // 질문 DTO 준비
-            const createQuestionDto: CreateQuestionDto = {
-                contents,
-                questionListId: createdQuestionList.id,
-            };
-
-            // 질문 생성
-            const createdQuestions =
-                await this.questionListService.createQuestions(
-                    createQuestionDto
-                );
-
             return res.send({
                 success: true,
                 message: "Question list created successfully.",

backend/src/question-list/question-list.module.ts

@@ -6,5 +6,6 @@ import { QuestionListRepository } from "./question-list.repository";
 @Module({
     controllers: [QuestionListController],
     providers: [QuestionListService, QuestionListRepository],
+    exports: [QuestionListRepository],
 })
 export class QuestionListModule {}

backend/src/question-list/question-list.repository.ts

@@ -2,9 +2,7 @@ import { Injectable } from "@nestjs/common";
 import { DataSource, In } from "typeorm";
 import { QuestionList } from "./question-list.entity";
 import { Question } from "./question.entity";
-import { QuestionDto } from "./dto/question.dto";
 import { Category } from "./category.entity";
-import { QuestionListDto } from "./dto/question-list.dto";
 import { User } from "../user/user.entity";
 
 @Injectable()
@@ -49,16 +47,6 @@ export class QuestionListRepository {
             : [];
     }
 
-    createQuestionList(questionListDto: QuestionListDto) {
-        return this.dataSource
-            .getRepository(QuestionList)
-            .save(questionListDto);
-    }
-
-    async createQuestions(questionDtos: QuestionDto[]) {
-        return this.dataSource.getRepository(Question).save(questionDtos);
-    }
-
     async findCategoriesByNames(categoryNames: string[]) {
         return this.dataSource.getRepository(Category).find({
             where: {
@@ -75,7 +63,7 @@ export class QuestionListRepository {
 
     getContentsByQuestionListId(questionListId: number) {
         return this.dataSource.getRepository(Question).find({
-            where: { questionListId: questionListId },
+            where: { questionListId },
         });
     }
 

backend/src/question-list/question-list.service.ts

@@ -1,16 +1,17 @@
 import { Injectable } from "@nestjs/common";
 import { QuestionListRepository } from "./question-list.repository";
 import { CreateQuestionListDto } from "./dto/create-question-list.dto";
-import { CreateQuestionDto } from "./dto/create-question.dto";
-import { QuestionDto } from "./dto/question.dto";
-import { QuestionListDto } from "./dto/question-list.dto";
 import { GetAllQuestionListDto } from "./dto/get-all-question-list.dto";
 import { QuestionListContentsDto } from "./dto/question-list-contents.dto";
 import { MyQuestionListDto } from "./dto/my-question-list.dto";
+import { DataSource } from "typeorm";
+import { QuestionList } from "./question-list.entity";
+import { Question } from "./question.entity";
 
 @Injectable()
 export class QuestionListService {
     constructor(
+        private readonly dataSource: DataSource,
         private readonly questionListRepository: QuestionListRepository
     ) {}
 
@@ -85,40 +86,45 @@ export class QuestionListService {
 
     // 질문 생성 메서드
     async createQuestionList(createQuestionListDto: CreateQuestionListDto) {
-        const { title, categoryNames, isPublic, userId } =
+        const { title, contents, categoryNames, isPublic, userId } =
             createQuestionListDto;
-        const categories =
-            await this.questionListRepository.findCategoriesByNames(
-                categoryNames
-            );
 
-        if (categories.length !== categoryNames.length) {
-            throw new Error("Some category names were not found.");
-        }
+        const categories = await this.findCategoriesByNames(categoryNames);
 
-        const questionListDto: QuestionListDto = {
-            title,
-            categories,
-            isPublic,
-            userId,
-        };
+        const queryRunner = this.dataSource.createQueryRunner();
+        await queryRunner.startTransaction();
 
-        return this.questionListRepository.createQuestionList(questionListDto);
-    }
+        try {
+            const questionListDto = new QuestionList();
+            questionListDto.title = title;
+            questionListDto.categories = categories;
+            questionListDto.isPublic = isPublic;
+            questionListDto.userId = userId;
 
-    async createQuestions(createQuestionDto: CreateQuestionDto) {
-        const { contents, questionListId } = createQuestionDto;
-        const questionDtos = contents.map((content, index) => {
-            const question: QuestionDto = {
-                content,
-                index,
-                questionListId,
-            };
+            const createdQuestionList =
+                await queryRunner.manager.save(questionListDto);
+
+            const questions = contents.map((content, index) => {
+                const question = new Question();
+                question.content = content;
+                question.index = index;
+                question.questionList = createdQuestionList;
+
+                return question;
+            });
 
-            return question;
-        });
+            const createdQuestions =
+                await queryRunner.manager.save(questions);
 
-        return await this.questionListRepository.createQuestions(questionDtos);
+            await queryRunner.commitTransaction();
+
+            return { createdQuestionList, createdQuestions };
+        } catch (error) {
+            await queryRunner.rollbackTransaction();
+            throw new Error(error.message);
+        } finally {
+            await queryRunner.release();
+        }
     }
 
     async getQuestionListContents(questionListId: number) {
@@ -182,4 +188,17 @@ export class QuestionListService {
         }
         return myQuestionLists;
     }
+
+    async findCategoriesByNames(categoryNames: string[]) {
+        const categories =
+            await this.questionListRepository.findCategoriesByNames(
+                categoryNames
+            );
+
+        if (categories.length !== categoryNames.length) {
+            throw new Error("Some category names were not found.");
+        }
+
+        return categories;
+    }
 }

backend/src/question-list/question.entity.ts

@@ -3,7 +3,7 @@ import { QuestionList } from "./question-list.entity";
 
 @Entity()
 export class Question {
-    private static CONTENT_MAX_LEN = 20;
+    private static CONTENT_MAX_LEN = 200;
 
     @PrimaryGeneratedColumn()
     id: number;

backend/src/room/dto/create-room.dto.ts

@@ -4,4 +4,5 @@ export interface CreateRoomDto {
     nickname: string;
     socketId: string;
     maxParticipants?: number;
+    questionListId: number;
 }

backend/src/room/room.gateway.ts

@@ -51,14 +51,16 @@ export class RoomGateway implements OnGatewayConnection, OnGatewayDisconnect {
 
     @SubscribeMessage(EVENT_NAME.CREATE_ROOM)
     async handleCreateRoom(client: Socket, data: any) {
-        const { title, nickname, status, maxParticipants } = data; // unknown 으로 받고, Dto와 Pipe로 검증받기
+        const { title, nickname, status, maxParticipants, questionListId } =
+            data; // unknown 으로 받고, Dto와 Pipe로 검증받기
         try {
             const roomData = await this.roomService.createRoom({
                 title,
                 status,
                 socketId: client.id,
                 nickname,
                 maxParticipants,
+                questionListId,
             });
 
             client.join(roomData.roomId);

backend/src/room/room.model.ts

@@ -6,6 +6,7 @@ export interface Room {
     maxParticipants: number;
     createdAt: number;
     host: string;
+    questionListId;
 }
 
 export interface MemberConnection {

backend/src/room/room.module.ts

@@ -4,8 +4,10 @@ import { RoomGateway } from "./room.gateway";
 import { RedisService } from "../redis/redis.service";
 import { RoomRepository } from "./room.repository";
 import { RoomController } from "./room.controller";
+import { QuestionListModule } from "../question-list/question-list.module";
 
 @Module({
+    imports: [QuestionListModule],
     providers: [RoomService, RoomGateway, RedisService, RoomRepository],
     controllers: [RoomController],
 })

backend/src/room/room.repository.ts

@@ -15,11 +15,8 @@ export class RoomRepository {
 
     async getAllRoom(): Promise<Record<string, Room>> {
         const redisMap = await this.redisService.getMap("room:*");
-        console.log(redisMap);
 
-        if (!redisMap) return {};
-
-        return Object.entries(redisMap).reduce(
+        return Object.entries(redisMap ?? {}).reduce(
             (acc, [roomId, room]) => {
                 acc[roomId.split(":")[1]] = room as Room;
                 return acc;
@@ -117,7 +114,8 @@ export class RoomRepository {
     }
 
     async createRoom(dto: CreateRoomDto) {
-        const { title, socketId, maxParticipants, status } = dto;
+        const { title, socketId, maxParticipants, status, questionListId } =
+            dto;
         const roomId = generateRoomId();
 
         await this.redisService.set(
@@ -128,6 +126,7 @@ export class RoomRepository {
                 host: socketId,
                 maxParticipants,
                 status,
+                questionListId,
             } as Room,
             6 * HOUR
         );

backend/src/room/room.service.spec.ts

@@ -58,6 +58,7 @@ describe("RoomService", () => {
                 title: "Test Room",
                 socketId: "socket-123",
                 nickname: "User1",
+                questionListId: 1,
             };
             const mockRoomId = "room-123";