fix: user-db,session-eventhandler 모듈화를 통한 책임 분리

Author: mintaek22

BE/src/query/query.controller.ts

@@ -13,7 +13,6 @@ import { ResponseDto } from '../common/response/response.dto';
 import { ApiExtraModels, ApiTags } from '@nestjs/swagger';
 import { ResQueryDto } from './dto/res-query.dto';
 import { ExecuteQuerySwagger } from '../config/swagger/query-swagger.decorator';
-import { Request } from 'express';
 import { Serialize } from '../interceptors/serialize.interceptor';
 import { ShellGuard } from '../guard/shell.guard';
 import { UserDBConnectionInterceptor } from '../interceptors/user-db-connection.interceptor';

BE/src/query/query.module.ts

@@ -3,14 +3,20 @@ import { QueryService } from './query.service';
 import { QueryController } from './query.controller';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Shell } from '../shell/shell.entity';
-import { ShellService } from '../shell/shell.service';
-import { UserDBManager } from '../config/query-database/user-db-manager.service';
 import { UsageModule } from '../usage/usage.module';
 import { RedisModule } from '../config/redis/redis.module';
+import { UserDBModule } from '../config/query-database/user-db.moudle';
+import { ShellModule } from '../shell/shell.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Shell]), UsageModule, RedisModule],
+  imports: [
+    TypeOrmModule.forFeature([Shell]),
+    UsageModule,
+    RedisModule,
+    UserDBModule,
+    ShellModule,
+  ],
   controllers: [QueryController],
-  providers: [QueryService, ShellService, UserDBManager],
+  providers: [QueryService],
 })
 export class QueryModule {}

DBManager/src/active-user/active-user.service.ts

@@ -5,7 +5,7 @@ import { Cron, CronExpression } from '@nestjs/schedule';
 @Injectable()
 export class ActiveUserService implements OnModuleInit {
   private activeUserVariation = new Map<string, number>();
-  private redisService: RedisService;
+  constructor(private readonly redisService: RedisService) {}
 
   onModuleInit() {
     this.countUp();

…r/src/user-db/user-session-db.service.ts …ger/src/session/session-event.handler.tsDBManager/src/user-db/user-session-db.service.ts renamed to DBManager/src/session/session-event.handler.ts DBManager/src/user-db/user-session-db.service.ts renamed to DBManager/src/session/session-event.handler.ts

@@ -1,10 +1,13 @@
 import { RedisService } from '../config/redis/redis.service';
-import { OnModuleInit } from '@nestjs/common';
-import { UserDBConnectionService } from './user-db-connection.service';
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { UserDBService } from '../user-db/user-db.service';
 
-export class UserSessionDBService implements OnModuleInit {
-  private redisService: RedisService;
-  private dbService: UserDBConnectionService;
+@Injectable()
+export class SessionEventHandler implements OnModuleInit {
+  constructor(
+    private readonly redisService: RedisService,
+    private readonly userDBService: UserDBService,
+  ) {}
 
   onModuleInit() {
     this.createDB();
@@ -15,15 +18,15 @@ export class UserSessionDBService implements OnModuleInit {
     const channel = '__keyspace@0__:APPEND';
     this.redisService.subscribeSession(channel, async (sessionId) => {
       const pod = await this.redisService.hgetSession(sessionId, 'pod');
-      this.dbService.initUserDatabase(pod, sessionId);
+      this.userDBService.initUserDatabase(pod, sessionId);
     });
   }
 
   private removeDB() {
     const channel = '__keyspace@0__:EXPIRE';
     this.redisService.subscribeSession(channel, async (sessionId) => {
       const pod = await this.redisService.hgetSession(sessionId, 'pod');
-      this.dbService.removeDatabase(pod, sessionId);
+      this.userDBService.removeDatabase(pod, sessionId);
     });
   }
 }

DBManager/src/session/session-event.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { RedisModule } from '../config/redis/redis.module';
+import { UserDBModule } from '../user-db/user-db.module';
+import { SessionEventHandler } from './session-event.handler';
+
+@Module({
+  imports: [RedisModule, UserDBModule],
+  providers: [SessionEventHandler],
+})
+export class SessionEventModule {}

DBManager/src/user-db/user-db.connector.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { Connection, createConnection } from 'mysql2/promise';
+
+@Injectable()
+export class UserDBConnector {
+  private connectionMap = new Map<string, Connection>();
+
+  constructor(private readonly configService: ConfigService) {}
+
+  public async getConnection(pod: string) {
+    if (!this.connectionMap.has(pod)) {
+      const connection = await this.createConnectionByPod(pod);
+      this.connectionMap.set(pod, connection);
+    }
+    return this.connectionMap.get(pod);
+  }
+
+  private async createConnectionByPod(pod: string) {
+    return createConnection({
+      host: pod,
+      user: this.configService.get<string>('QUERY_DB_USER'),
+      password: this.configService.get<string>('QUERY_DB_PASSWORD'),
+      port: this.configService.get<number>('QUERY_DB_PORT'),
+    });
+  }
+}

DBManager/src/user-db/user-db.module.ts

@@ -1,7 +1,10 @@
 import { Module } from '@nestjs/common';
-import { UserSessionDBService } from './user-session-db.service';
+import { RedisModule } from '../config/redis/redis.module';
+import { UserDBService } from './user-db.service';
+import { UserDBConnector } from './user-db.connector';
 
 @Module({
-  providers: [UserSessionDBService],
+  imports: [RedisModule],
+  providers: [UserDBService, UserDBConnector],
 })
 export class UserDBModule {}

…rc/user-db/user-db-connection.service.ts DBManager/src/user-db/user-db.service.tsDBManager/src/user-db/user-db-connection.service.ts renamed to DBManager/src/user-db/user-db.service.ts DBManager/src/user-db/user-db-connection.service.ts renamed to DBManager/src/user-db/user-db.service.ts

@@ -1,29 +1,10 @@
+import { UserDBConnector } from './user-db.connector';
 import { Injectable } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { Connection, createConnection } from 'mysql2/promise';
+import * as console from 'node:console';
 
 @Injectable()
-export class UserDBConnectionService {
-  private connectionMap = new Map<string, Connection>();
-
-  constructor(private readonly configService: ConfigService) {}
-
-  private async getConnection(pod: string) {
-    if (!this.connectionMap.has(pod)) {
-      const connection = await this.createConnectionByPod(pod);
-      this.connectionMap.set(pod, connection);
-    }
-    return this.connectionMap.get(pod);
-  }
-
-  private async createConnectionByPod(pod: string) {
-    return createConnection({
-      host: pod,
-      user: this.configService.get<string>('QUERY_DB_USER'),
-      password: this.configService.get<string>('QUERY_DB_PASSWORD'),
-      port: this.configService.get<number>('QUERY_DB_PORT'),
-    });
-  }
+export class UserDBService {
+  constructor(private readonly userDBConnector: UserDBConnector) {}
 
   public async initUserDatabase(pod: string, sessionId: string) {
     try {
@@ -35,7 +16,7 @@ export class UserDBConnectionService {
         database: identify,
       };
 
-      const connection = await this.getConnection(pod);
+      const connection = await this.userDBConnector.getConnection(pod);
 
       await connection.query(`create database ${connectInfo.database};`);
       await connection.query(
@@ -51,7 +32,7 @@ export class UserDBConnectionService {
 
   public async removeDatabase(pod: string, sessionId: string) {
     try {
-      const connection = await this.getConnection(pod);
+      const connection = await this.userDBConnector.getConnection(pod);
 
       const identify = sessionId.substring(0, 10);
 
@@ -63,4 +44,4 @@ export class UserDBConnectionService {
       console.error(e);
     }
   }
-}
+}