스크롤 기능 포함

backend-node/package-lock.json

@@ -21,6 +21,7 @@
         "joi": "^17.11.0",
         "jsonwebtoken": "^9.0.2",
         "multer": "^1.4.5-lts.1",
+        "mysql2": "^3.15.0",
         "nodemailer": "^6.9.7",
         "pg": "^8.16.3",
         "prisma": "^5.7.1",
@@ -3612,6 +3613,15 @@
       "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
       "license": "MIT"
     },
+    "node_modules/aws-ssl-profiles": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/aws-ssl-profiles/-/aws-ssl-profiles-1.1.2.tgz",
+      "integrity": "sha512-NZKeq9AfyQvEeNlN0zSYAaWrmBffJh3IELMZfRpJVWgrpEbtEpnjvzqBPf+mxoI287JohRDoa+/nsfqqiZmF6g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
     "node_modules/axios": {
       "version": "1.11.0",
       "resolved": "https://registry.npmjs.org/axios/-/axios-1.11.0.tgz",
@@ -4457,6 +4467,15 @@
         "node": ">=0.4.0"
       }
     },
+    "node_modules/denque": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/denque/-/denque-2.1.0.tgz",
+      "integrity": "sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
     "node_modules/depd": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
@@ -5413,6 +5432,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/generate-function": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/generate-function/-/generate-function-2.3.1.tgz",
+      "integrity": "sha512-eeB5GfMNeevm/GRYq20ShmsaGcmI81kIX2K9XQx5miC8KdHaC6Jm0qQ8ZNeGOi7wYB8OsdxKs+Y2oVuTFuVwKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "is-property": "^1.0.2"
+      }
+    },
     "node_modules/generic-pool": {
       "version": "3.9.0",
       "resolved": "https://registry.npmjs.org/generic-pool/-/generic-pool-3.9.0.tgz",
@@ -5959,6 +5987,12 @@
         "node": ">=8"
       }
     },
+    "node_modules/is-property": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/is-property/-/is-property-1.0.2.tgz",
+      "integrity": "sha512-Ks/IoX00TtClbGQr4TWXemAnktAQvYB7HzcCxDGqEZU6oCmb2INHuOoKxbtR+HFkmYWBKv/dOZtGRiAjDhj92g==",
+      "license": "MIT"
+    },
     "node_modules/is-stream": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
@@ -6914,6 +6948,12 @@
         "node": ">= 12.0.0"
       }
     },
+    "node_modules/long": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
+      "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
+      "license": "Apache-2.0"
+    },
     "node_modules/lru-cache": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -6924,6 +6964,21 @@
         "yallist": "^3.0.2"
       }
     },
+    "node_modules/lru.min": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/lru.min/-/lru.min-1.1.2.tgz",
+      "integrity": "sha512-Nv9KddBcQSlQopmBHXSsZVY5xsdlZkdH/Iey0BlcBYggMd4two7cZnKOK9vmy3nY0O5RGH99z1PCeTpPqszUYg==",
+      "license": "MIT",
+      "engines": {
+        "bun": ">=1.0.0",
+        "deno": ">=1.30.0",
+        "node": ">=8.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wellwelwel"
+      }
+    },
     "node_modules/make-dir": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz",
@@ -7138,6 +7193,63 @@
         "node": ">= 6.0.0"
       }
     },
+    "node_modules/mysql2": {
+      "version": "3.15.0",
+      "resolved": "https://registry.npmjs.org/mysql2/-/mysql2-3.15.0.tgz",
+      "integrity": "sha512-tT6pomf5Z/I7Jzxu8sScgrYBMK9bUFWd7Kbo6Fs1L0M13OOIJ/ZobGKS3Z7tQ8Re4lj+LnLXIQVZZxa3fhYKzA==",
+      "license": "MIT",
+      "dependencies": {
+        "aws-ssl-profiles": "^1.1.1",
+        "denque": "^2.1.0",
+        "generate-function": "^2.3.1",
+        "iconv-lite": "^0.7.0",
+        "long": "^5.2.1",
+        "lru.min": "^1.0.0",
+        "named-placeholders": "^1.1.3",
+        "seq-queue": "^0.0.5",
+        "sqlstring": "^2.3.2"
+      },
+      "engines": {
+        "node": ">= 8.0"
+      }
+    },
+    "node_modules/mysql2/node_modules/iconv-lite": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.0.tgz",
+      "integrity": "sha512-cf6L2Ds3h57VVmkZe+Pn+5APsT7FpqJtEhhieDCvrE2MK5Qk9MyffgQyuxQTm6BChfeZNtcOLHp9IcWRVcIcBQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/named-placeholders": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/named-placeholders/-/named-placeholders-1.1.3.tgz",
+      "integrity": "sha512-eLoBxg6wE/rZkJPhU/xRX1WTpkFEwDJEN96oxFrTsqBdbT5ec295Q+CoHrL9IT0DipqKhmGcaZmwOt8OON5x1w==",
+      "license": "MIT",
+      "dependencies": {
+        "lru-cache": "^7.14.1"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/named-placeholders/node_modules/lru-cache": {
+      "version": "7.18.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+      "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/natural-compare": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
@@ -8226,6 +8338,11 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/seq-queue": {
+      "version": "0.0.5",
+      "resolved": "https://registry.npmjs.org/seq-queue/-/seq-queue-0.0.5.tgz",
+      "integrity": "sha512-hr3Wtp/GZIc/6DAGPDcV4/9WoZhjrkXsi5B/07QgX8tsdc6ilr7BFM6PM6rbdAX1kFSDYeZGLipIZZKyQP0O5Q=="
+    },
     "node_modules/serve-static": {
       "version": "1.16.2",
       "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz",
@@ -8431,6 +8548,15 @@
       "dev": true,
       "license": "BSD-3-Clause"
     },
+    "node_modules/sqlstring": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/sqlstring/-/sqlstring-2.3.3.tgz",
+      "integrity": "sha512-qC9iz2FlN7DQl3+wjwn3802RTyjCx7sDvfQEXchwa6CWOx07/WVfh91gBmQ9fahw8snwGEWU3xGzOt4tFyHLxg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/stack-trace": {
       "version": "0.0.10",
       "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz",

backend-node/package.json

@@ -39,6 +39,7 @@
     "joi": "^17.11.0",
     "jsonwebtoken": "^9.0.2",
     "multer": "^1.4.5-lts.1",
+    "mysql2": "^3.15.0",
     "nodemailer": "^6.9.7",
     "pg": "^8.16.3",
     "prisma": "^5.7.1",

backend-node/src/database/DatabaseConnectorFactory.ts

@@ -0,0 +1,52 @@
+import { DatabaseConnector, ConnectionConfig } from '../interfaces/DatabaseConnector';
+import { PostgreSQLConnector } from './PostgreSQLConnector';
+
+export class DatabaseConnectorFactory {
+  private static connectors = new Map<string, DatabaseConnector>();
+
+  static async createConnector(
+    type: string,
+    config: ConnectionConfig,
+    connectionId: number // Added connectionId for unique key
+  ): Promise<DatabaseConnector> {
+    const key = `${type}-${connectionId}`; // Use connectionId for unique key
+    if (this.connectors.has(key)) {
+      return this.connectors.get(key)!;
+    }
+
+    let connector: DatabaseConnector;
+
+    switch (type.toLowerCase()) {
+      case 'postgresql':
+        connector = new PostgreSQLConnector(config);
+        break;
+      // Add other database types here
+      default:
+        throw new Error(`지원하지 않는 데이터베이스 타입: ${type}`);
+    }
+
+    this.connectors.set(key, connector);
+    return connector;
+  }
+
+  static async getConnector(connectionId: number, type: string): Promise<DatabaseConnector | undefined> {
+    const key = `${type}-${connectionId}`;
+    return this.connectors.get(key);
+  }
+
+  static async closeConnector(connectionId: number, type: string): Promise<void> {
+    const key = `${type}-${connectionId}`;
+    const connector = this.connectors.get(key);
+    if (connector) {
+      await connector.disconnect();
+      this.connectors.delete(key);
+    }
+  }
+
+  static async closeAll(): Promise<void> {
+    for (const connector of this.connectors.values()) {
+      await connector.disconnect();
+    }
+    this.connectors.clear();
+  }
+}

backend-node/src/database/MySQLConnector.ts

@@ -0,0 +1,175 @@
+import * as mysql from 'mysql2/promise';
+import { DatabaseConnector, ConnectionConfig, QueryResult } from '../interfaces/DatabaseConnector';
+import { ConnectionTestResult, TableInfo } from '../types/externalDbTypes';
+
+export class MySQLConnector implements DatabaseConnector {
+  private connection: mysql.Connection | null = null;
+  private config: ConnectionConfig;
+
+  constructor(config: ConnectionConfig) {
+    this.config = config;
+  }
+
+  async connect(): Promise<void> {
+    if (this.connection) {
+      throw new Error('이미 연결되어 있습니다.');
+    }
+
+    this.connection = await mysql.createConnection({
+      host: this.config.host,
+      port: this.config.port,
+      database: this.config.database,
+      user: this.config.username,
+      password: this.config.password,
+      connectTimeout: this.config.connectionTimeout || 30000,
+      ssl: this.config.sslEnabled ? { rejectUnauthorized: false } : undefined,
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.connection) {
+      await this.connection.end();
+      this.connection = null;
+    }
+  }
+
+  async testConnection(): Promise<ConnectionTestResult> {
+    const startTime = Date.now();
+    try {
+      await this.connect();
+      
+      const [versionResult] = await this.connection!.query('SELECT VERSION() as version');
+      const [sizeResult] = await this.connection!.query(
+        'SELECT SUM(data_length + index_length) as size FROM information_schema.tables WHERE table_schema = DATABASE()'
+      );
+      
+      const responseTime = Date.now() - startTime;
+
+      return {
+        success: true,
+        message: 'MySQL 연결이 성공했습니다.',
+        details: {
+          response_time: responseTime,
+          server_version: (versionResult as any)[0]?.version || '알 수 없음',
+          database_size: this.formatBytes(parseInt((sizeResult as any)[0]?.size || '0')),
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: 'MySQL 연결에 실패했습니다.',
+        error: {
+          code: 'CONNECTION_FAILED',
+          details: error instanceof Error ? error.message : '알 수 없는 오류',
+        },
+      };
+    } finally {
+      await this.disconnect();
+    }
+  }
+
+  async executeQuery(query: string): Promise<QueryResult> {
+    if (!this.connection) {
+      await this.connect();
+    }
+
+    try {
+      const [rows, fields] = await this.connection!.query(query);
+      return {
+        rows: rows as any[],
+        rowCount: Array.isArray(rows) ? rows.length : 0,
+        fields: (fields as mysql.FieldPacket[]).map(field => ({
+          name: field.name,
+          dataType: field.type.toString(),
+        })),
+      };
+    } finally {
+      await this.disconnect();
+    }
+  }
+
+  async getTables(): Promise<TableInfo[]> {
+    if (!this.connection) {
+      await this.connect();
+    }
+
+    try {
+      const [tables] = await this.connection!.query(`
+        SELECT 
+          t.TABLE_NAME as table_name,
+          t.TABLE_COMMENT as table_description
+        FROM information_schema.TABLES t
+        WHERE t.TABLE_SCHEMA = DATABASE()
+        ORDER BY t.TABLE_NAME
+      `);
+
+      const result: TableInfo[] = [];
+
+      for (const table of tables as any[]) {
+        const [columns] = await this.connection!.query(`
+          SELECT 
+            COLUMN_NAME as column_name,
+            DATA_TYPE as data_type,
+            IS_NULLABLE as is_nullable,
+            COLUMN_DEFAULT as column_default
+          FROM information_schema.COLUMNS
+          WHERE TABLE_SCHEMA = DATABASE()
+            AND TABLE_NAME = ?
+          ORDER BY ORDINAL_POSITION
+        `, [table.table_name]);
+
+        result.push({
+          table_name: table.table_name,
+          description: table.table_description || null,
+          columns: columns as any[],
+        });
+      }
+
+      return result;
+    } finally {
+      await this.disconnect();
+    }
+  }
+
+  async getColumns(tableName: string): Promise<Array<{
+    name: string;
+    dataType: string;
+    isNullable: boolean;
+    defaultValue?: string;
+  }>> {
+    if (!this.connection) {
+      await this.connect();
+    }
+
+    try {
+      const [columns] = await this.connection!.query(`
+        SELECT 
+          COLUMN_NAME as name,
+          DATA_TYPE as dataType,
+          IS_NULLABLE = 'YES' as isNullable,
+          COLUMN_DEFAULT as defaultValue
+        FROM information_schema.COLUMNS
+        WHERE TABLE_SCHEMA = DATABASE()
+          AND TABLE_NAME = ?
+        ORDER BY ORDINAL_POSITION
+      `, [tableName]);
+
+      return (columns as any[]).map(col => ({
+        name: col.name,
+        dataType: col.dataType,
+        isNullable: col.isNullable,
+        defaultValue: col.defaultValue,
+      }));
+    } finally {
+      await this.disconnect();
+    }
+  }
+
+  private formatBytes(bytes: number): string {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+  }
+}

backend-node/src/database/PostgreSQLConnector.ts

@@ -0,0 +1,145 @@
+import { Client } from 'pg';
+import { DatabaseConnector, ConnectionConfig, QueryResult } from '../interfaces/DatabaseConnector';
+import { ConnectionTestResult, TableInfo } from '../types/externalDbTypes';
+
+export class PostgreSQLConnector implements DatabaseConnector {
+  private client: Client | null = null;
+  private config: ConnectionConfig;
+
+  constructor(config: ConnectionConfig) {
+    this.config = config;
+  }
+
+  async connect(): Promise<void> {
+    if (this.client) {
+      await this.disconnect();
+    }
+    const clientConfig: any = {
+      host: this.config.host,
+      port: this.config.port,
+      database: this.config.database,
+      user: this.config.user,
+      password: this.config.password,
+    };
+
+    if (this.config.connectionTimeoutMillis != null) {
+      clientConfig.connectionTimeoutMillis = this.config.connectionTimeoutMillis;
+    }
+
+    if (this.config.queryTimeoutMillis != null) {
+      clientConfig.query_timeout = this.config.queryTimeoutMillis;
+    }
+
+    if (this.config.ssl != null) {
+      clientConfig.ssl = this.config.ssl;
+    }
+
+    this.client = new Client(clientConfig);
+    await this.client.connect();
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.client) {
+      await this.client.end();
+      this.client = null;
+    }
+  }
+
+  async testConnection(): Promise<ConnectionTestResult> {
+    const startTime = Date.now();
+    try {
+      await this.connect();
+      const result = await this.client!.query("SELECT version(), pg_database_size(current_database()) as size");
+      const responseTime = Date.now() - startTime;
+      await this.disconnect();
+      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: any) {
+      await this.disconnect();
+      return {
+        success: false,
+        message: "PostgreSQL 연결에 실패했습니다.",
+        error: {
+          code: "CONNECTION_FAILED",
+          details: error.message || "알 수 없는 오류",
+        },
+      };
+    }
+  }
+
+  async executeQuery(query: string): Promise<QueryResult> {
+    try {
+      await this.connect();
+      const result = await this.client!.query(query);
+      await this.disconnect();
+      return {
+        rows: result.rows,
+        rowCount: result.rowCount ?? undefined,
+        fields: result.fields ?? undefined,
+      };
+    } catch (error: any) {
+      await this.disconnect();
+      throw new Error(`PostgreSQL 쿼리 실행 실패: ${error.message}`);
+    }
+  }
+
+  async getTables(): Promise<TableInfo[]> {
+    try {
+      await this.connect();
+      const result = await this.client!.query(`
+        SELECT
+          t.table_name,
+          obj_description(quote_ident(t.table_name)::regclass::oid, 'pg_class') as table_description
+        FROM information_schema.tables t
+        WHERE t.table_schema = 'public'
+          AND t.table_type = 'BASE TABLE'
+        ORDER BY t.table_name;
+      `);
+      await this.disconnect();
+      return result.rows.map((row) => ({
+        table_name: row.table_name,
+        description: row.table_description,
+        columns: [], // Columns will be fetched by getColumns
+      }));
+    } catch (error: any) {
+      await this.disconnect();
+      throw new Error(`PostgreSQL 테이블 목록 조회 실패: ${error.message}`);
+    }
+  }
+
+  async getColumns(tableName: string): Promise<any[]> {
+    try {
+      await this.connect();
+      const result = await this.client!.query(`
+        SELECT
+          column_name,
+          data_type,
+          is_nullable,
+          column_default
+        FROM information_schema.columns
+        WHERE table_schema = 'public' AND table_name = $1
+        ORDER BY ordinal_position;
+      `, [tableName]);
+      await this.disconnect();
+      return result.rows;
+    } catch (error: any) {
+      await this.disconnect();
+      throw new Error(`PostgreSQL 컬럼 정보 조회 실패: ${error.message}`);
+    }
+  }
+
+  private formatBytes(bytes: number): string {
+    if (bytes === 0) return "0 Bytes";
+    const k = 1024;
+    const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+  }
+}

backend-node/src/interfaces/DatabaseConnector.ts

@@ -0,0 +1,27 @@
+import { ConnectionTestResult, TableInfo } from '../types/externalDbTypes';
+
+export interface ConnectionConfig {
+  host: string;
+  port: number;
+  database: string;
+  user: string;
+  password: string;
+  connectionTimeoutMillis?: number;
+  queryTimeoutMillis?: number;
+  ssl?: boolean | { rejectUnauthorized: boolean };
+}
+
+export interface QueryResult {
+  rows: any[];
+  rowCount?: number;
+  fields?: any[];
+}
+
+export interface DatabaseConnector {
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  testConnection(): Promise<ConnectionTestResult>;
+  executeQuery(query: string): Promise<QueryResult>;
+  getTables(): Promise<TableInfo[]>;
+  getColumns(tableName: string): Promise<any[]>; // 특정 테이블의 컬럼 정보 조회
+}

backend-node/src/services/dbConnectionManager.ts

@@ -0,0 +1,59 @@
+import { DatabaseConnectorFactory } from '../database/DatabaseConnectorFactory';
+import { ConnectionConfig, QueryResult } from '../interfaces/DatabaseConnector';
+import { ConnectionTestResult, TableInfo } from '../types/externalDbTypes';
+
+export class DbConnectionManager {
+  static async testConnection(
+    connectionId: number,
+    dbType: string,
+    config: ConnectionConfig
+  ): Promise<ConnectionTestResult> {
+    const connector = await DatabaseConnectorFactory.createConnector(dbType, config, connectionId);
+    try {
+      return await connector.testConnection();
+    } finally {
+      await DatabaseConnectorFactory.closeConnector(connectionId, dbType); // Close after test
+    }
+  }
+
+  static async executeQuery(
+    connectionId: number,
+    dbType: string,
+    config: ConnectionConfig,
+    query: string
+  ): Promise<QueryResult> {
+    const connector = await DatabaseConnectorFactory.createConnector(dbType, config, connectionId);
+    try {
+      return await connector.executeQuery(query);
+    } finally {
+      await DatabaseConnectorFactory.closeConnector(connectionId, dbType);
+    }
+  }
+
+  static async getTables(
+    connectionId: number,
+    dbType: string,
+    config: ConnectionConfig
+  ): Promise<TableInfo[]> {
+    const connector = await DatabaseConnectorFactory.createConnector(dbType, config, connectionId);
+    try {
+      return await connector.getTables();
+    } finally {
+      await DatabaseConnectorFactory.closeConnector(connectionId, dbType);
+    }
+  }
+
+  static async getColumns(
+    connectionId: number,
+    dbType: string,
+    config: ConnectionConfig,
+    tableName: string
+  ): Promise<any[]> {
+    const connector = await DatabaseConnectorFactory.createConnector(dbType, config, connectionId);
+    try {
+      return await connector.getColumns(tableName);
+    } finally {
+      await DatabaseConnectorFactory.closeConnector(connectionId, dbType);
+    }
+  }
+}

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 = {
+      const config = {
-        db_type: connection.db_type,
         host: connection.host,
         port: connection.port,
-        database_name: connection.database_name,
+        database: connection.database_name,
-        username: connection.username,
+        user: connection.username,
         password: decryptedPassword,
-        connection_timeout: connection.connection_timeout || undefined,
+        connectionTimeoutMillis: connection.connection_timeout != null ? connection.connection_timeout * 1000 : undefined,
-        ssl_enabled: connection.ssl_enabled || undefined
+        queryTimeoutMillis: connection.query_timeout != null ? connection.query_timeout * 1000 : undefined,
+        ssl: connection.ssl_enabled === "Y" ? { rejectUnauthorized: false } : false
       };
 
-      // 실제 연결 테스트 수행
+      // DbConnectionManager를 통한 연결 테스트
-      switch (connection.db_type.toLowerCase()) {
+      return await DbConnectionManager.testConnection(id, connection.db_type, config);
-        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} 타입은 현재 지원하지 않습니다.`,
-            },
-          };
-      }
     } 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()) {
+      const config = {
-        case "postgresql":
+        host: connection.host,
-          return await this.executePostgreSQLQuery(connection, decryptedPassword, query);
+        port: connection.port,
-        case "mysql":
+        database: connection.database_name,
-          return {
+        user: connection.username,
-            success: false,
+        password: decryptedPassword,
-            message: "MySQL 쿼리 실행은 현재 지원하지 않습니다."
+        connectionTimeoutMillis: connection.connection_timeout != null ? connection.connection_timeout * 1000 : undefined,
-          };
+        queryTimeoutMillis: connection.query_timeout != null ? connection.query_timeout * 1000 : undefined,
-        case "oracle":
+        ssl: connection.ssl_enabled === "Y" ? { rejectUnauthorized: false } : false
-          return {
+      };
-            success: false,
+
-            message: "Oracle 쿼리 실행은 현재 지원하지 않습니다."
+      // DbConnectionManager를 통한 쿼리 실행
-          };
+      const result = await DbConnectionManager.executeQuery(id, connection.db_type, config, query);
-        case "mssql":
+      
-          return {
+      return {
-            success: false,
+        success: true,
-            message: "SQL Server 쿼리 실행은 현재 지원하지 않습니다."
+        message: "쿼리가 성공적으로 실행되었습니다.",
-          };
+        data: result.rows
-        case "sqlite":
+      };
-          return {
-            success: false,
-            message: "SQLite 쿼리 실행은 현재 지원하지 않습니다."
-          };
-        default:
-          return {
-            success: false,
-            message: `지원하지 않는 데이터베이스 타입입니다: ${connection.db_type}`
-          };
-      }
     } catch (error) {
       console.error("쿼리 실행 오류:", error);
       return {
@@ -740,15 +583,26 @@ export class ExternalDbConnectionService {
         };
       }
 
-      switch (connection.db_type.toLowerCase()) {
+      // 연결 설정 준비
-        case "postgresql":
+      const config = {
-          return await this.getPostgreSQLTables(connection, decryptedPassword);
+        host: connection.host,
-        default:
+        port: connection.port,
-          return {
+        database: connection.database_name,
-            success: false,
+        user: connection.username,
-            message: `지원하지 않는 데이터베이스 타입입니다: ${connection.db_type}`
+        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 {

frontend/components/admin/SqlQueryModal.tsx

@@ -122,7 +122,7 @@ export const SqlQueryModal: React.FC<SqlQueryModalProps> = ({ isOpen, onClose, c
 
   return (
     <Dialog open={isOpen} onOpenChange={onClose}>
-      <DialogContent className="max-h-[90vh] max-w-5xl" aria-describedby="modal-description">
+      <DialogContent className="max-h-[90vh] max-w-5xl overflow-y-auto" aria-describedby="modal-description">
         <DialogHeader>
           <DialogTitle>{connectionName} - SQL 쿼리 실행</DialogTitle>
           <DialogDescription>
@@ -131,7 +131,7 @@ export const SqlQueryModal: React.FC<SqlQueryModalProps> = ({ isOpen, onClose, c
         </DialogHeader>
         
         {/* 쿼리 입력 영역 */}
-        <div className="mb-4 space-y-4">
+        <div className="space-y-4">
           <div className="space-y-2">
             {/* 테이블 선택 */}
             <div className="flex flex-col gap-4">
@@ -168,28 +168,32 @@ export const SqlQueryModal: React.FC<SqlQueryModalProps> = ({ isOpen, onClose, c
               {/* 테이블 정보 */}
               <div className="bg-muted/50 rounded-md border p-4">
                 <h3 className="mb-2 font-medium">사용 가능한 테이블</h3>
-                <div className="space-y-4">
+                <div className="space-y-4 max-h-[300px] overflow-y-auto">
-                  {tables.map((table) => (
+                  <div className="pr-2">
-                    <div key={table.table_name} className="border-b pb-2 last:border-b-0 last:pb-0">
+                    {tables.map((table) => (
-                      <div className="flex items-center justify-between">
+                      <div key={table.table_name} className="mb-4 bg-white rounded-lg shadow-sm border last:mb-0">
-                        <h4 className="font-mono font-bold">{table.table_name}</h4>
+                        <div className="p-3">
-                <Button variant="ghost" size="sm" onClick={() => setQuery(`SELECT * FROM ${table.table_name}`)}>
+                          <div className="flex items-center justify-between">
-                          선택
+                            <h4 className="font-mono font-bold">{table.table_name}</h4>
-                        </Button>
+                            <Button variant="ghost" size="sm" onClick={() => setQuery(`SELECT * FROM ${table.table_name}`)}>
-                      </div>
+                              선택
-                      {table.description && (
+                            </Button>
-                        <p className="text-muted-foreground mt-1 text-sm">{table.description}</p>
-                      )}
-                      <div className="mt-2 grid grid-cols-3 gap-2">
-                        {table.columns.map((column: TableColumn) => (
-                          <div key={column.column_name} className="text-sm">
-                            <span className="font-mono">{column.column_name}</span>
-                            <span className="text-muted-foreground ml-1">({column.data_type})</span>
                           </div>
-                        ))}
+                          {table.description && (
+                            <p className="text-muted-foreground mt-1 text-sm">{table.description}</p>
+                          )}
+                          <div className="mt-2 grid grid-cols-3 gap-2">
+                            {table.columns.map((column: TableColumn) => (
+                              <div key={column.column_name} className="text-sm">
+                                <span className="font-mono">{column.column_name}</span>
+                                <span className="text-muted-foreground ml-1">({column.data_type})</span>
+                              </div>
+                            ))}
+                          </div>
+                        </div>
                       </div>
-                    </div>
+                    ))}
-                  ))}
+                  </div>
                 </div>
               </div>
             </div>
@@ -218,7 +222,7 @@ export const SqlQueryModal: React.FC<SqlQueryModalProps> = ({ isOpen, onClose, c
         </div>
 
         {/* 결과 섹션 */}
-        <div className="mt-4 space-y-4">
+        <div className="space-y-4">
           <div className="flex items-center justify-between">
             <div className="text-muted-foreground text-sm">
               {loading ? "쿼리 실행 중..." : results.length > 0 ? `${results.length}개의 결과가 있습니다.` : "실행된 쿼리가 없습니다."}
@@ -227,45 +231,49 @@ export const SqlQueryModal: React.FC<SqlQueryModalProps> = ({ isOpen, onClose, c
           
           {/* 결과 그리드 */}
           <div className="rounded-md border">
-            <div className="max-h-[400px] overflow-auto">
+            <div className="max-h-[300px] overflow-y-auto">
-              <Table>
+              <div className="min-w-full inline-block align-middle">
-                {results.length > 0 ? (
+                <div className="overflow-x-auto">
-                  <>
+                  <Table>
-                    <TableHeader className="sticky top-0 bg-white">
+                    {results.length > 0 ? (
-                      <TableRow>
+                      <>
-                        {Object.keys(results[0]).map((key) => (
+                        <TableHeader className="sticky top-0 bg-white z-10">
-                          <TableHead key={key} className="font-mono font-bold">
+                          <TableRow>
-                            {key}
+                            {Object.keys(results[0]).map((key) => (
-                          </TableHead>
+                              <TableHead key={key} className="font-mono font-bold">
-                        ))}
+                                {key}
-                      </TableRow>
+                              </TableHead>
-                    </TableHeader>
+                            ))}
-                    <TableBody>
+                          </TableRow>
-                      {results.map((row: QueryResult, i: number) => (
+                        </TableHeader>
-                        <TableRow key={i} className="hover:bg-muted/50">
+                        <TableBody>
-                          {Object.values(row).map((value, j) => (
+                          {results.map((row: QueryResult, i: number) => (
-                            <TableCell key={j} className="font-mono">
+                            <TableRow key={i} className="hover:bg-muted/50">
-                              {value === null ? (
+                              {Object.values(row).map((value, j) => (
-                                <span className="text-muted-foreground italic">NULL</span>
+                                <TableCell key={j} className="font-mono whitespace-nowrap">
-                              ) : (
+                                  {value === null ? (
-                                String(value)
+                                    <span className="text-muted-foreground italic">NULL</span>
-                              )}
+                                  ) : (
-                            </TableCell>
+                                    String(value)
+                                  )}
+                                </TableCell>
+                              ))}
+                            </TableRow>
                           ))}
+                        </TableBody>
+                      </>
+                    ) : (
+                      <TableBody>
+                        <TableRow>
+                          <TableCell className="text-muted-foreground h-32 text-center">
+                            {loading ? "쿼리 실행 중..." : "쿼리를 실행하면 결과가 여기에 표시됩니다."}
+                          </TableCell>
                         </TableRow>
-                      ))}
+                      </TableBody>
-                    </TableBody>
+                    )}
-                  </>
+                  </Table>
-                ) : (
+                </div>
-                  <TableBody>
+              </div>
-                    <TableRow>
-                      <TableCell className="text-muted-foreground h-32 text-center">
-                        {loading ? "쿼리 실행 중..." : "쿼리를 실행하면 결과가 여기에 표시됩니다."}
-                      </TableCell>
-                    </TableRow>
-                  </TableBody>
-                )}
-              </Table>
             </div>
           </div>
         </div>