[Feat] 스터디 세션 기능 서버측 기능 추가

backend/package.json

@@ -25,6 +25,8 @@
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/platform-socket.io": "^10.4.6",
     "@nestjs/websockets": "^10.4.6",
+    "dotenv": "^16.4.5",
+    "ioredis": "^5.4.1",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.8.1",
     "socket.io": "^4.8.1"

backend/src/app.module.ts

@@ -1,10 +1,14 @@
 import { Module } from "@nestjs/common";
 import { AppController } from "./app.controller";
 import { AppService } from "./app.service";
-import { SocketModule } from "./socket/socket.module";
+import { SocketModule } from "./signaling-server/socket.module";
+import { RoomModule } from "./room/room.module";
+import { RedisModule } from "./redis/redis.module";
+
+import "dotenv/config";
 
 @Module({
-    imports: [SocketModule],
+    imports: [SocketModule, RoomModule, RedisModule],
     controllers: [AppController],
     providers: [AppService],
 })

backend/src/config/redis.config.ts

@@ -0,0 +1,7 @@
+import "dotenv/config";
+
+export const redisConfig = {
+    host: process.env.REDIS_HOST,
+    port: parseInt(process.env.REDIS_PORT),
+    password: process.env.REDIS_PASSWORD,
+};

backend/src/redis/redis.module.ts

@@ -0,0 +1,7 @@
+import { Module } from "@nestjs/common";
+import { RedisService } from "./redis.service";
+
+@Module({
+    providers: [RedisService],
+})
+export class RedisModule {}

backend/src/redis/redis.service.spec.ts

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

backend/src/redis/redis.service.ts

@@ -0,0 +1,79 @@
+import { Injectable } from "@nestjs/common";
+import Redis from "ioredis";
+import { redisConfig } from "../config/redis.config";
+import { stringify } from "ts-jest";
+
+@Injectable()
+export class RedisService {
+    private readonly client: Redis = new Redis({
+        host: redisConfig.host,
+        port: redisConfig.port,
+        password: redisConfig.password,
+    });
+
+    async set(key: string, value: any, ttl: number = 0) {
+        if (typeof value === "object") value = JSON.stringify(value);
+
+        await this.client.set(key, value, "KEEPTTL");
+        await this.client.expire(key, ttl);
+    }
+
+    async get(key: string) {
+        return this.client.get(key);
+    }
+
+    async getTTL(key: string) {
+        return this.client.ttl(key);
+    }
+
+    async getKeys(query: string) {
+        const keys: string[] = [];
+        let cursor = "0";
+
+        do {
+            const [nextCursor, matchedKeys] = await this.client.scan(
+                cursor,
+                "MATCH",
+                query,
+                "COUNT",
+                "100"
+            );
+            cursor = nextCursor;
+            keys.push(...matchedKeys);
+        } while (cursor !== "0");
+        return keys;
+    }
+
+    async getHashValueByField(key: string, field: string) {
+        return this.client.hget(key, field);
+    }
+
+    async setHashValueByField(key: string, field: string, value: any) {
+        if (typeof value !== "string") value = stringify(value);
+        return this.client.hset(key, field, value);
+    }
+
+    async delete(...keys: string[]) {
+        return this.client.del(...keys);
+    }
+
+    async getValues(query: string) {
+        const keys = await this.getKeys(query);
+        if (!keys.length) return null;
+        return this.client.mget(keys);
+    }
+
+    async getMap(query: string, valueType: "object" | "primitive" = "object") {
+        const keys = await this.getKeys(query);
+        const values = await this.getValues(query);
+        if (!values) return null;
+
+        return keys.reduce((acc, key, index) => {
+            acc[key] =
+                valueType === "object"
+                    ? JSON.parse(values[index])
+                    : values[index];
+            return acc;
+        }, {});
+    }
+}

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

@@ -0,0 +1,7 @@
+export interface CreateRoomDto {
+    title: string;
+    status: "PUBLIC" | "PRIVATE";
+    nickname: string;
+    socketId: string;
+    maxParticipants?: number;
+}

backend/src/room/room.gateway.spec.ts

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

backend/src/room/room.gateway.ts

@@ -0,0 +1,123 @@
+import {
+    WebSocketGateway,
+    WebSocketServer,
+    OnGatewayConnection,
+    OnGatewayDisconnect,
+    SubscribeMessage,
+} from "@nestjs/websockets";
+import { Server, Socket } from "socket.io";
+import { RoomService } from "./room.service";
+
+const EVENT_NAME = {
+    CREATE_ROOM: "create_room",
+    JOIN_ROOM: "join_room",
+    LEAVE_ROOM: "leave_room",
+    MASTER_CHANGED: "master_changed",
+    FINISH_ROOM: "finish_room",
+    REACTION: "reaction",
+
+    ROOM_CREATED: "room_created",
+    USER_EXIT: "user_exit",
+    ROOM_FULL: "room_full",
+    ALL_USERS: "all_users",
+    ROOM_FINISHED: "room_finished",
+} as const;
+
+/**
+ * 연결과 관련된 에러를 처리
+ *
+ * 보다 연결과 관련된 코드가 존재
+ */
+@WebSocketGateway({
+    cors: {
+        origin: "*", // CORS 설정
+    },
+})
+@WebSocketGateway()
+export class RoomGateway implements OnGatewayConnection, OnGatewayDisconnect {
+    @WebSocketServer()
+    server: Server;
+
+    constructor(private readonly roomService: RoomService) {}
+
+    handleConnection(client: Socket) {
+        console.log(`Client connected in room: ${client.id}`);
+    }
+
+    async handleDisconnect(client: Socket) {
+        console.log(`Client disconnected in room: ${client.id}`);
+        await this.handleLeaveRoom(client);
+    }
+
+    @SubscribeMessage(EVENT_NAME.CREATE_ROOM)
+    async handleCreateRoom(client: Socket, data: any) {
+        const { title, nickname, status, maxParticipants } = data; // unknown 으로 받고, Dto와 Pipe로 검증받기
+        try {
+            const roomId = await this.roomService.createRoom({
+                title,
+                status,
+                socketId: client.id,
+                nickname,
+                maxParticipants,
+            });
+            client.join(roomId);
+            this.server.to(roomId).emit(EVENT_NAME.ROOM_CREATED, { roomId });
+        } catch (error) {
+            console.error(error);
+        }
+    }
+
+    @SubscribeMessage(EVENT_NAME.JOIN_ROOM)
+    async handleJoinRoom(client: Socket, data: any) {
+        const { roomId, nickname } = data;
+
+        if (!(await this.roomService.checkAvailable(roomId))) {
+            // client joins full room
+            client.emit(EVENT_NAME.ROOM_FULL);
+            return;
+        }
+
+        await this.roomService.joinRoom(client.id, roomId, nickname);
+
+        client.join(roomId);
+
+        console.log(`[${data.roomId}]: ${client.id} enter`);
+
+        const usersInThisRoom = (
+            await this.roomService.getMemberSocket(roomId)
+        ).filter((user) => user !== client.id);
+
+        client.emit(EVENT_NAME.ALL_USERS, usersInThisRoom);
+    }
+
+    @SubscribeMessage(EVENT_NAME.LEAVE_ROOM)
+    async handleLeaveRoom(client: Socket) {
+        const roomId = await this.roomService.getRoomId(client.id);
+
+        const isHost = await this.roomService.checkHost(client.id);
+        const leftCount = await this.roomService.leaveRoom(client.id);
+
+        if (!leftCount) {
+            await this.roomService.deleteRoom(roomId);
+            return;
+        }
+
+        if (isHost) {
+            const hostConnection = await this.roomService.delegateHost(roomId);
+            this.server.to(roomId).emit(EVENT_NAME.MASTER_CHANGED, {
+                masterSocketId: hostConnection.socketId,
+                masterNickname: hostConnection.nickname,
+            });
+        }
+
+        this.server
+            .to(roomId)
+            .emit(EVENT_NAME.USER_EXIT, { socketId: client.id });
+    }
+
+    @SubscribeMessage(EVENT_NAME.FINISH_ROOM)
+    async handleFinishRoom(client: Socket) {
+        const roomId = await this.roomService.finishRoom(client.id);
+        this.server.to(roomId).emit(EVENT_NAME.ROOM_FINISHED);
+    }
+}

backend/src/room/room.model.ts

@@ -0,0 +1,15 @@
+export type RoomStatus = "PUBLIC" | "PRIVATE";
+
+export interface Room {
+    title: string;
+    status: RoomStatus;
+    maxParticipants: number;
+    createdAt: number;
+    host: string;
+}
+
+export interface MemberConnection {
+    joinTime: number;
+    isHost: boolean;
+    nickname: string;
+}

backend/src/room/room.module.ts

@@ -0,0 +1,10 @@
+import { Module } from "@nestjs/common";
+import { RoomService } from "./room.service";
+import { RoomGateway } from "./room.gateway";
+import { RedisService } from "../redis/redis.service";
+import { RoomRepository } from "./room.repository";
+
+@Module({
+    providers: [RoomService, RoomGateway, RedisService, RoomRepository],
+})
+export class RoomModule {}