스크롤 기능 포함

backend-node/src/services/externalDbConnectionService.ts

@@ -9,6 +9,7 @@ import {
   TableInfo,
 } from "../types/externalDbTypes";
 import { PasswordEncryption } from "../utils/passwordEncryption";
+import { DbConnectionManager } from "./dbConnectionManager";
 
 const prisma = new PrismaClient();
 
@@ -321,8 +322,6 @@ export class ExternalDbConnectionService {
   static async testConnectionById(
     id: number
   ): Promise<import("../types/externalDbTypes").ConnectionTestResult> {
-    const startTime = Date.now();
-
     try {
       // 저장된 연결 정보 조회
       const connection = await prisma.external_db_connections.findUnique({
@@ -353,40 +352,20 @@ export class ExternalDbConnectionService {
         };
       }
 
-      // 테스트용 데이터 준비
-      const testData = {
-        db_type: connection.db_type,
+      // 연결 설정 준비
+      const config = {
         host: connection.host,
         port: connection.port,
-        database_name: connection.database_name,
-        username: connection.username,
+        database: connection.database_name,
+        user: connection.username,
         password: decryptedPassword,
-        connection_timeout: connection.connection_timeout || undefined,
-        ssl_enabled: connection.ssl_enabled || undefined
+        connectionTimeoutMillis: connection.connection_timeout != null ? connection.connection_timeout * 1000 : undefined,
+        queryTimeoutMillis: connection.query_timeout != null ? connection.query_timeout * 1000 : undefined,
+        ssl: connection.ssl_enabled === "Y" ? { rejectUnauthorized: false } : false
       };
 
-      // 실제 연결 테스트 수행
-      switch (connection.db_type.toLowerCase()) {
-        case "postgresql":
-          return await this.testPostgreSQLConnection(testData, startTime);
-        case "mysql":
-          return await this.testMySQLConnection(testData, startTime);
-        case "oracle":
-          return await this.testOracleConnection(testData, startTime);
-        case "mssql":
-          return await this.testMSSQLConnection(testData, startTime);
-        case "sqlite":
-          return await this.testSQLiteConnection(testData, startTime);
-        default:
-          return {
-            success: false,
-            message: `지원하지 않는 데이터베이스 타입입니다: ${testData.db_type}`,
-            error: {
-              code: "UNSUPPORTED_DB_TYPE",
-              details: `${testData.db_type} 타입은 현재 지원하지 않습니다.`,
-            },
-          };
-      }
+      // DbConnectionManager를 통한 연결 테스트
+      return await DbConnectionManager.testConnection(id, connection.db_type, config);
     } catch (error) {
       return {
         success: false,
@@ -399,132 +378,6 @@ export class ExternalDbConnectionService {
     }
   }
 
-  /**
-   * PostgreSQL 연결 테스트
-   */
-  private static async testPostgreSQLConnection(
-    testData: any,
-    startTime: number
-  ): Promise<import("../types/externalDbTypes").ConnectionTestResult> {
-    const { Client } = await import("pg");
-    const client = new Client({
-      host: testData.host,
-      port: testData.port,
-      database: testData.database_name,
-      user: testData.username,
-      password: testData.password,
-      connectionTimeoutMillis: (testData.connection_timeout || 30) * 1000,
-      ssl: testData.ssl_enabled === "Y" ? { rejectUnauthorized: false } : false,
-    });
-
-    try {
-      await client.connect();
-      const result = await client.query(
-        "SELECT version(), pg_database_size(current_database()) as size"
-      );
-      const responseTime = Date.now() - startTime;
-
-      await client.end();
-
-      return {
-        success: true,
-        message: "PostgreSQL 연결이 성공했습니다.",
-        details: {
-          response_time: responseTime,
-          server_version: result.rows[0]?.version || "알 수 없음",
-          database_size: this.formatBytes(
-            parseInt(result.rows[0]?.size || "0")
-          ),
-        },
-      };
-    } catch (error) {
-      try {
-        await client.end();
-      } catch (endError) {
-        // 연결 종료 오류는 무시
-      }
-
-      return {
-        success: false,
-        message: "PostgreSQL 연결에 실패했습니다.",
-        error: {
-          code: "CONNECTION_FAILED",
-          details: error instanceof Error ? error.message : "알 수 없는 오류",
-        },
-      };
-    }
-  }
-
-  /**
-   * MySQL 연결 테스트 (모의 구현)
-   */
-  private static async testMySQLConnection(
-    testData: any,
-    startTime: number
-  ): Promise<import("../types/externalDbTypes").ConnectionTestResult> {
-    // MySQL 라이브러리가 없으므로 모의 구현
-    return {
-      success: false,
-      message: "MySQL 연결 테스트는 현재 지원하지 않습니다.",
-      error: {
-        code: "NOT_IMPLEMENTED",
-        details: "MySQL 라이브러리가 설치되지 않았습니다.",
-      },
-    };
-  }
-
-  /**
-   * Oracle 연결 테스트 (모의 구현)
-   */
-  private static async testOracleConnection(
-    testData: any,
-    startTime: number
-  ): Promise<import("../types/externalDbTypes").ConnectionTestResult> {
-    return {
-      success: false,
-      message: "Oracle 연결 테스트는 현재 지원하지 않습니다.",
-      error: {
-        code: "NOT_IMPLEMENTED",
-        details: "Oracle 라이브러리가 설치되지 않았습니다.",
-      },
-    };
-  }
-
-  /**
-   * SQL Server 연결 테스트 (모의 구현)
-   */
-  private static async testMSSQLConnection(
-    testData: any,
-    startTime: number
-  ): Promise<import("../types/externalDbTypes").ConnectionTestResult> {
-    return {
-      success: false,
-      message: "SQL Server 연결 테스트는 현재 지원하지 않습니다.",
-      error: {
-        code: "NOT_IMPLEMENTED",
-        details: "SQL Server 라이브러리가 설치되지 않았습니다.",
-      },
-    };
-  }
-
-  /**
-   * SQLite 연결 테스트 (모의 구현)
-   */
-  private static async testSQLiteConnection(
-    testData: any,
-    startTime: number
-  ): Promise<import("../types/externalDbTypes").ConnectionTestResult> {
-    return {
-      success: false,
-      message: "SQLite 연결 테스트는 현재 지원하지 않습니다.",
-      error: {
-        code: "NOT_IMPLEMENTED",
-        details:
-          "SQLite는 파일 기반이므로 네트워크 연결 테스트가 불가능합니다.",
-      },
-    };
-  }
-
   /**
    * 바이트 크기를 읽기 쉬운 형태로 변환
    */
@@ -622,36 +475,26 @@ export class ExternalDbConnectionService {
         };
       }
 
-      // DB 타입에 따른 쿼리 실행
-      switch (connection.db_type.toLowerCase()) {
-        case "postgresql":
-          return await this.executePostgreSQLQuery(connection, decryptedPassword, query);
-        case "mysql":
-          return {
-            success: false,
-            message: "MySQL 쿼리 실행은 현재 지원하지 않습니다."
-          };
-        case "oracle":
-          return {
-            success: false,
-            message: "Oracle 쿼리 실행은 현재 지원하지 않습니다."
-          };
-        case "mssql":
-          return {
-            success: false,
-            message: "SQL Server 쿼리 실행은 현재 지원하지 않습니다."
-          };
-        case "sqlite":
-          return {
-            success: false,
-            message: "SQLite 쿼리 실행은 현재 지원하지 않습니다."
-          };
-        default:
-          return {
-            success: false,
-            message: `지원하지 않는 데이터베이스 타입입니다: ${connection.db_type}`
-          };
-      }
+      // 연결 설정 준비
+      const config = {
+        host: connection.host,
+        port: connection.port,
+        database: connection.database_name,
+        user: connection.username,
+        password: decryptedPassword,
+        connectionTimeoutMillis: connection.connection_timeout != null ? connection.connection_timeout * 1000 : undefined,
+        queryTimeoutMillis: connection.query_timeout != null ? connection.query_timeout * 1000 : undefined,
+        ssl: connection.ssl_enabled === "Y" ? { rejectUnauthorized: false } : false
+      };
+
+      // DbConnectionManager를 통한 쿼리 실행
+      const result = await DbConnectionManager.executeQuery(id, connection.db_type, config, query);
+      
+      return {
+        success: true,
+        message: "쿼리가 성공적으로 실행되었습니다.",
+        data: result.rows
+      };
     } catch (error) {
       console.error("쿼리 실행 오류:", error);
       return {
@@ -740,15 +583,26 @@ export class ExternalDbConnectionService {
         };
       }
 
-      switch (connection.db_type.toLowerCase()) {
-        case "postgresql":
-          return await this.getPostgreSQLTables(connection, decryptedPassword);
-        default:
-          return {
-            success: false,
-            message: `지원하지 않는 데이터베이스 타입입니다: ${connection.db_type}`
-          };
-      }
+      // 연결 설정 준비
+      const config = {
+        host: connection.host,
+        port: connection.port,
+        database: connection.database_name,
+        user: connection.username,
+        password: decryptedPassword,
+        connectionTimeoutMillis: connection.connection_timeout != null ? connection.connection_timeout * 1000 : undefined,
+        queryTimeoutMillis: connection.query_timeout != null ? connection.query_timeout * 1000 : undefined,
+        ssl: connection.ssl_enabled === "Y" ? { rejectUnauthorized: false } : false
+      };
+
+      // DbConnectionManager를 통한 테이블 목록 조회
+      const tables = await DbConnectionManager.getTables(id, connection.db_type, config);
+      
+      return {
+        success: true,
+        message: "테이블 목록을 조회했습니다.",
+        data: tables
+      };
     } catch (error) {
       console.error("테이블 목록 조회 오류:", error);
       return {