feature connection

2025-09-22 17:28:31 +09:00
parent 3a96f9dc81
commit 1ae16bb690
16 changed files with 1332 additions and 100 deletions
--- a/backend-node/src/services/externalDbConnectionService.ts
+++ b/backend-node/src/services/externalDbConnectionService.ts
@@ -6,6 +6,7 @@ import {
  ExternalDbConnection,
  ExternalDbConnectionFilter,
  ApiResponse,
+  TableInfo,
 } from "../types/externalDbTypes";
 import { PasswordEncryption } from "../utils/passwordEncryption";

@@ -315,15 +316,57 @@ export class ExternalDbConnectionService {
  }

  /**
-   * 데이터베이스 연결 테스트
+   * 데이터베이스 연결 테스트 (ID 기반)
   */
-  static async testConnection(
-    testData: import("../types/externalDbTypes").ConnectionTestRequest
+  static async testConnectionById(
+    id: number
  ): Promise<import("../types/externalDbTypes").ConnectionTestResult> {
    const startTime = Date.now();

    try {
-      switch (testData.db_type.toLowerCase()) {
+      // 저장된 연결 정보 조회
+      const connection = await prisma.external_db_connections.findUnique({
+        where: { id }
+      });
+
+      if (!connection) {
+        return {
+          success: false,
+          message: "연결 정보를 찾을 수 없습니다.",
+          error: {
+            code: "CONNECTION_NOT_FOUND",
+            details: `ID ${id}에 해당하는 연결 정보가 없습니다.`
+          }
+        };
+      }
+
+      // 비밀번호 복호화
+      const decryptedPassword = await this.getDecryptedPassword(id);
+      if (!decryptedPassword) {
+        return {
+          success: false,
+          message: "비밀번호 복호화에 실패했습니다.",
+          error: {
+            code: "DECRYPTION_FAILED",
+            details: "저장된 비밀번호를 복호화할 수 없습니다."
+          }
+        };
+      }
+
+      // 테스트용 데이터 준비
+      const testData = {
+        db_type: connection.db_type,
+        host: connection.host,
+        port: connection.port,
+        database_name: connection.database_name,
+        username: connection.username,
+        password: decryptedPassword,
+        connection_timeout: connection.connection_timeout || undefined,
+        ssl_enabled: connection.ssl_enabled || undefined
+      };
+
+      // 실제 연결 테스트 수행
+      switch (connection.db_type.toLowerCase()) {
        case "postgresql":
          return await this.testPostgreSQLConnection(testData, startTime);
        case "mysql":
@@ -360,7 +403,7 @@ export class ExternalDbConnectionService {
   * PostgreSQL 연결 테스트
   */
  private static async testPostgreSQLConnection(
-    testData: import("../types/externalDbTypes").ConnectionTestRequest,
+    testData: any,
    startTime: number
  ): Promise<import("../types/externalDbTypes").ConnectionTestResult> {
    const { Client } = await import("pg");
@@ -416,7 +459,7 @@ export class ExternalDbConnectionService {
   * MySQL 연결 테스트 (모의 구현)
   */
  private static async testMySQLConnection(
-    testData: import("../types/externalDbTypes").ConnectionTestRequest,
+    testData: any,
    startTime: number
  ): Promise<import("../types/externalDbTypes").ConnectionTestResult> {
    // MySQL 라이브러리가 없으므로 모의 구현
@@ -434,7 +477,7 @@ export class ExternalDbConnectionService {
   * Oracle 연결 테스트 (모의 구현)
   */
  private static async testOracleConnection(
-    testData: import("../types/externalDbTypes").ConnectionTestRequest,
+    testData: any,
    startTime: number
  ): Promise<import("../types/externalDbTypes").ConnectionTestResult> {
    return {
@@ -451,7 +494,7 @@ export class ExternalDbConnectionService {
   * SQL Server 연결 테스트 (모의 구현)
   */
  private static async testMSSQLConnection(
-    testData: import("../types/externalDbTypes").ConnectionTestRequest,
+    testData: any,
    startTime: number
  ): Promise<import("../types/externalDbTypes").ConnectionTestResult> {
    return {
@@ -468,7 +511,7 @@ export class ExternalDbConnectionService {
   * SQLite 연결 테스트 (모의 구현)
   */
  private static async testSQLiteConnection(
-    testData: import("../types/externalDbTypes").ConnectionTestRequest,
+    testData: any,
    startTime: number
  ): Promise<import("../types/externalDbTypes").ConnectionTestResult> {
    return {
@@ -546,4 +589,237 @@ export class ExternalDbConnectionService {
      return null;
    }
  }
+
+  /**
+   * SQL 쿼리 실행
+   */
+  static async executeQuery(
+    id: number,
+    query: string
+  ): Promise<ApiResponse<any[]>> {
+    try {
+      // 연결 정보 조회
+      console.log("연결 정보 조회 시작:", { id });
+      const connection = await prisma.external_db_connections.findUnique({
+        where: { id }
+      });
+      console.log("조회된 연결 정보:", connection);
+
+      if (!connection) {
+        console.log("연결 정보를 찾을 수 없음:", { id });
+        return {
+          success: false,
+          message: "연결 정보를 찾을 수 없습니다."
+        };
+      }
+
+      // 비밀번호 복호화
+      const decryptedPassword = await this.getDecryptedPassword(id);
+      if (!decryptedPassword) {
+        return {
+          success: false,
+          message: "비밀번호 복호화에 실패했습니다."
+        };
+      }
+
+      // 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}`
+          };
+      }
+    } catch (error) {
+      console.error("쿼리 실행 오류:", error);
+      return {
+        success: false,
+        message: "쿼리 실행 중 오류가 발생했습니다.",
+        error: error instanceof Error ? error.message : "알 수 없는 오류"
+      };
+    }
+  }
+
+  /**
+   * PostgreSQL 쿼리 실행
+   */
+  private static async executePostgreSQLQuery(
+    connection: any,
+    password: string,
+    query: string
+  ): Promise<ApiResponse<any[]>> {
+    const { Client } = await import("pg");
+    const client = new Client({
+      host: connection.host,
+      port: connection.port,
+      database: connection.database_name,
+      user: connection.username,
+      password: password,
+      connectionTimeoutMillis: (connection.connection_timeout || 30) * 1000,
+      ssl: connection.ssl_enabled === "Y" ? { rejectUnauthorized: false } : false,
+    });
+
+    try {
+      await client.connect();
+      console.log("DB 연결 정보:", {
+        host: connection.host,
+        port: connection.port,
+        database: connection.database_name,
+        user: connection.username
+      });
+      console.log("쿼리 실행:", query);
+      const result = await client.query(query);
+      console.log("쿼리 결과:", result.rows);
+      await client.end();
+
+      return {
+        success: true,
+        message: "쿼리가 성공적으로 실행되었습니다.",
+        data: result.rows
+      };
+    } catch (error) {
+      try {
+        await client.end();
+      } catch (endError) {
+        // 연결 종료 오류는 무시
+      }
+
+      return {
+        success: false,
+        message: "쿼리 실행 중 오류가 발생했습니다.",
+        error: error instanceof Error ? error.message : "알 수 없는 오류"
+      };
+    }
+  }
+
+  /**
+   * 데이터베이스 테이블 목록 조회
+   */
+  static async getTables(id: number): Promise<ApiResponse<TableInfo[]>> {
+    try {
+      // 연결 정보 조회
+      const connection = await prisma.external_db_connections.findUnique({
+        where: { id }
+      });
+
+      if (!connection) {
+        return {
+          success: false,
+          message: "연결 정보를 찾을 수 없습니다."
+        };
+      }
+
+      // 비밀번호 복호화
+      const decryptedPassword = await this.getDecryptedPassword(id);
+      if (!decryptedPassword) {
+        return {
+          success: false,
+          message: "비밀번호 복호화에 실패했습니다."
+        };
+      }
+
+      switch (connection.db_type.toLowerCase()) {
+        case "postgresql":
+          return await this.getPostgreSQLTables(connection, decryptedPassword);
+        default:
+          return {
+            success: false,
+            message: `지원하지 않는 데이터베이스 타입입니다: ${connection.db_type}`
+          };
+      }
+    } catch (error) {
+      console.error("테이블 목록 조회 오류:", error);
+      return {
+        success: false,
+        message: "테이블 목록 조회 중 오류가 발생했습니다.",
+        error: error instanceof Error ? error.message : "알 수 없는 오류"
+      };
+    }
+  }
+
+  /**
+   * PostgreSQL 테이블 목록 조회
+   */
+  private static async getPostgreSQLTables(
+    connection: any,
+    password: string
+  ): Promise<ApiResponse<TableInfo[]>> {
+    const { Client } = await import("pg");
+    const client = new Client({
+      host: connection.host,
+      port: connection.port,
+      database: connection.database_name,
+      user: connection.username,
+      password: password,
+      connectionTimeoutMillis: (connection.connection_timeout || 30) * 1000,
+      ssl: connection.ssl_enabled === "Y" ? { rejectUnauthorized: false } : false
+    });
+
+    try {
+      await client.connect();
+      // 테이블 목록과 각 테이블의 컬럼 정보 조회
+      const result = await client.query(`
+        SELECT 
+          t.table_name,
+          array_agg(
+            json_build_object(
+              'column_name', c.column_name,
+              'data_type', c.data_type,
+              'is_nullable', c.is_nullable,
+              'column_default', c.column_default
+            )
+          ) as columns,
+          obj_description(quote_ident(t.table_name)::regclass::oid, 'pg_class') as table_description
+        FROM information_schema.tables t
+        LEFT JOIN information_schema.columns c 
+          ON c.table_name = t.table_name 
+          AND c.table_schema = t.table_schema
+        WHERE t.table_schema = 'public'
+          AND t.table_type = 'BASE TABLE'
+        GROUP BY t.table_name
+        ORDER BY t.table_name
+      `);
+      await client.end();
+
+      return {
+        success: true,
+        data: result.rows.map(row => ({
+          table_name: row.table_name,
+          columns: row.columns || [],
+          description: row.table_description
+        })) as TableInfo[],
+        message: "테이블 목록을 조회했습니다."
+      };
+    } catch (error) {
+      await client.end();
+      return {
+        success: false,
+        message: "테이블 목록 조회 중 오류가 발생했습니다.",
+        error: error instanceof Error ? error.message : "알 수 없는 오류"
+      };
+    }
+  }
+
 }