주요기능 Prisma ORM으로 변경

backend-node/src/controllers/multilangController.ts

@@ -2,7 +2,6 @@ import { Request, Response } from "express";
 import { logger } from "../utils/logger";
 import { AuthenticatedRequest } from "../types/auth";
 import { MultiLangService } from "../services/multilangService";
-import { Client } from "pg";
 import {
   CreateLanguageRequest,
   UpdateLanguageRequest,
@@ -25,29 +24,16 @@ export const getLanguages = async (
   try {
     logger.info("언어 목록 조회 요청", { user: req.user });
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    const languages = await multiLangService.getLanguages();
-      connectionString:
-        process.env.DATABASE_URL ||
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
-    });
 
-    await client.connect();
+    const response: ApiResponse<any[]> = {
+      success: true,
+      message: "언어 목록 조회 성공",
+      data: languages,
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      const languages = await multiLangService.getLanguages();
-
-      const response: ApiResponse<any[]> = {
-        success: true,
-        message: "언어 목록 조회 성공",
-        data: languages,
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("언어 목록 조회 실패:", error);
     res.status(500).json({
@@ -90,33 +76,20 @@ export const createLanguage = async (
       return;
     }
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    const createdLanguage = await multiLangService.createLanguage({
-      connectionString:
+      ...languageData,
-        process.env.DATABASE_URL ||
+      createdBy: req.user?.userId || "system",
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
+      updatedBy: req.user?.userId || "system",
     });
 
-    await client.connect();
+    const response: ApiResponse<any> = {
+      success: true,
+      message: "언어가 성공적으로 생성되었습니다.",
+      data: createdLanguage,
+    };
 
-    try {
+    res.status(201).json(response);
-      const multiLangService = new MultiLangService(client);
-      const createdLanguage = await multiLangService.createLanguage({
-        ...languageData,
-        createdBy: req.user?.userId || "system",
-        updatedBy: req.user?.userId || "system",
-      });
-
-      const response: ApiResponse<any> = {
-        success: true,
-        message: "언어가 성공적으로 생성되었습니다.",
-        data: createdLanguage,
-      };
-
-      res.status(201).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("언어 생성 실패:", error);
     res.status(500).json({
@@ -144,32 +117,19 @@ export const updateLanguage = async (
 
     logger.info("언어 수정 요청", { langCode, languageData, user: req.user });
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    const updatedLanguage = await multiLangService.updateLanguage(langCode, {
-      connectionString:
+      ...languageData,
-        process.env.DATABASE_URL ||
+      updatedBy: req.user?.userId || "system",
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
     });
 
-    await client.connect();
+    const response: ApiResponse<any> = {
+      success: true,
+      message: "언어가 성공적으로 수정되었습니다.",
+      data: updatedLanguage,
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      const updatedLanguage = await multiLangService.updateLanguage(langCode, {
-        ...languageData,
-        updatedBy: req.user?.userId || "system",
-      });
-
-      const response: ApiResponse<any> = {
-        success: true,
-        message: "언어가 성공적으로 수정되었습니다.",
-        data: updatedLanguage,
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("언어 수정 실패:", error);
     res.status(500).json({
@@ -195,29 +155,16 @@ export const toggleLanguage = async (
     const { langCode } = req.params;
     logger.info("언어 상태 토글 요청", { langCode, user: req.user });
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    const result = await multiLangService.toggleLanguage(langCode);
-      connectionString:
-        process.env.DATABASE_URL ||
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
-    });
 
-    await client.connect();
+    const response: ApiResponse<string> = {
+      success: true,
+      message: `언어가 ${result}되었습니다.`,
+      data: result,
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      const result = await multiLangService.toggleLanguage(langCode);
-
-      const response: ApiResponse<string> = {
-        success: true,
-        message: `언어가 ${result}되었습니다.`,
-        data: result,
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("언어 상태 토글 실패:", error);
     res.status(500).json({
@@ -246,34 +193,21 @@ export const getLangKeys = async (
       user: req.user,
     });
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    const langKeys = await multiLangService.getLangKeys({
-      connectionString:
+      companyCode: companyCode as string,
-        process.env.DATABASE_URL ||
+      menuCode: menuCode as string,
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
+      keyType: keyType as string,
+      searchText: searchText as string,
     });
 
-    await client.connect();
+    const response: ApiResponse<any[]> = {
+      success: true,
+      message: "다국어 키 목록 조회 성공",
+      data: langKeys,
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      const langKeys = await multiLangService.getLangKeys({
-        companyCode: companyCode as string,
-        menuCode: menuCode as string,
-        keyType: keyType as string,
-        searchText: searchText as string,
-      });
-
-      const response: ApiResponse<any[]> = {
-        success: true,
-        message: "다국어 키 목록 조회 성공",
-        data: langKeys,
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("다국어 키 목록 조회 실패:", error);
     res.status(500).json({
@@ -299,29 +233,16 @@ export const getLangTexts = async (
     const { keyId } = req.params;
     logger.info("다국어 텍스트 조회 요청", { keyId, user: req.user });
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    const langTexts = await multiLangService.getLangTexts(parseInt(keyId));
-      connectionString:
-        process.env.DATABASE_URL ||
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
-    });
 
-    await client.connect();
+    const response: ApiResponse<any[]> = {
+      success: true,
+      message: "다국어 텍스트 조회 성공",
+      data: langTexts,
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      const langTexts = await multiLangService.getLangTexts(parseInt(keyId));
-
-      const response: ApiResponse<any[]> = {
-        success: true,
-        message: "다국어 텍스트 조회 성공",
-        data: langTexts,
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("다국어 텍스트 조회 실패:", error);
     res.status(500).json({
@@ -360,33 +281,20 @@ export const createLangKey = async (
       return;
     }
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    const keyId = await multiLangService.createLangKey({
-      connectionString:
+      ...keyData,
-        process.env.DATABASE_URL ||
+      createdBy: req.user?.userId || "system",
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
+      updatedBy: req.user?.userId || "system",
     });
 
-    await client.connect();
+    const response: ApiResponse<number> = {
+      success: true,
+      message: "다국어 키가 성공적으로 생성되었습니다.",
+      data: keyId,
+    };
 
-    try {
+    res.status(201).json(response);
-      const multiLangService = new MultiLangService(client);
-      const keyId = await multiLangService.createLangKey({
-        ...keyData,
-        createdBy: req.user?.userId || "system",
-        updatedBy: req.user?.userId || "system",
-      });
-
-      const response: ApiResponse<number> = {
-        success: true,
-        message: "다국어 키가 성공적으로 생성되었습니다.",
-        data: keyId,
-      };
-
-      res.status(201).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("다국어 키 생성 실패:", error);
     res.status(500).json({
@@ -414,32 +322,19 @@ export const updateLangKey = async (
 
     logger.info("다국어 키 수정 요청", { keyId, keyData, user: req.user });
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    await multiLangService.updateLangKey(parseInt(keyId), {
-      connectionString:
+      ...keyData,
-        process.env.DATABASE_URL ||
+      updatedBy: req.user?.userId || "system",
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
     });
 
-    await client.connect();
+    const response: ApiResponse<string> = {
+      success: true,
+      message: "다국어 키가 성공적으로 수정되었습니다.",
+      data: "수정 완료",
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      await multiLangService.updateLangKey(parseInt(keyId), {
-        ...keyData,
-        updatedBy: req.user?.userId || "system",
-      });
-
-      const response: ApiResponse<string> = {
-        success: true,
-        message: "다국어 키가 성공적으로 수정되었습니다.",
-        data: "수정 완료",
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("다국어 키 수정 실패:", error);
     res.status(500).json({
@@ -465,29 +360,16 @@ export const deleteLangKey = async (
     const { keyId } = req.params;
     logger.info("다국어 키 삭제 요청", { keyId, user: req.user });
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    await multiLangService.deleteLangKey(parseInt(keyId));
-      connectionString:
-        process.env.DATABASE_URL ||
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
-    });
 
-    await client.connect();
+    const response: ApiResponse<string> = {
+      success: true,
+      message: "다국어 키가 성공적으로 삭제되었습니다.",
+      data: "삭제 완료",
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      await multiLangService.deleteLangKey(parseInt(keyId));
-
-      const response: ApiResponse<string> = {
-        success: true,
-        message: "다국어 키가 성공적으로 삭제되었습니다.",
-        data: "삭제 완료",
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("다국어 키 삭제 실패:", error);
     res.status(500).json({
@@ -513,29 +395,16 @@ export const toggleLangKey = async (
     const { keyId } = req.params;
     logger.info("다국어 키 상태 토글 요청", { keyId, user: req.user });
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    const result = await multiLangService.toggleLangKey(parseInt(keyId));
-      connectionString:
-        process.env.DATABASE_URL ||
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
-    });
 
-    await client.connect();
+    const response: ApiResponse<string> = {
+      success: true,
+      message: `다국어 키가 ${result}되었습니다.`,
+      data: result,
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      const result = await multiLangService.toggleLangKey(parseInt(keyId));
-
-      const response: ApiResponse<string> = {
-        success: true,
-        message: `다국어 키가 ${result}되었습니다.`,
-        data: result,
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("다국어 키 상태 토글 실패:", error);
     res.status(500).json({
@@ -580,35 +449,22 @@ export const saveLangTexts = async (
       return;
     }
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    await multiLangService.saveLangTexts(parseInt(keyId), {
-      connectionString:
+      texts: textData.texts.map((text) => ({
-        process.env.DATABASE_URL ||
+        ...text,
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
+        createdBy: req.user?.userId || "system",
+        updatedBy: req.user?.userId || "system",
+      })),
     });
 
-    await client.connect();
+    const response: ApiResponse<string> = {
+      success: true,
+      message: "다국어 텍스트가 성공적으로 저장되었습니다.",
+      data: "저장 완료",
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      await multiLangService.saveLangTexts(parseInt(keyId), {
-        texts: textData.texts.map((text) => ({
-          ...text,
-          createdBy: req.user?.userId || "system",
-          updatedBy: req.user?.userId || "system",
-        })),
-      });
-
-      const response: ApiResponse<string> = {
-        success: true,
-        message: "다국어 텍스트가 성공적으로 저장되었습니다.",
-        data: "저장 완료",
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("다국어 텍스트 저장 실패:", error);
     res.status(500).json({
@@ -654,34 +510,21 @@ export const getUserText = async (
       return;
     }
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    const langText = await multiLangService.getUserText({
-      connectionString:
+      companyCode,
-        process.env.DATABASE_URL ||
+      menuCode,
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
+      langKey,
+      userLang: userLang as string,
     });
 
-    await client.connect();
+    const response: ApiResponse<string> = {
+      success: true,
+      message: "사용자별 다국어 텍스트 조회 성공",
+      data: langText,
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      const langText = await multiLangService.getUserText({
-        companyCode,
-        menuCode,
-        langKey,
-        userLang: userLang as string,
-      });
-
-      const response: ApiResponse<string> = {
-        success: true,
-        message: "사용자별 다국어 텍스트 조회 성공",
-        data: langText,
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("사용자별 다국어 텍스트 조회 실패:", error);
     res.status(500).json({
@@ -713,33 +556,20 @@ export const getLangText = async (
       user: req.user,
     });
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    const langText = await multiLangService.getLangText(
-      connectionString:
+      companyCode,
-        process.env.DATABASE_URL ||
+      langKey,
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
+      langCode
-    });
+    );
 
-    await client.connect();
+    const response: ApiResponse<string> = {
+      success: true,
+      message: "특정 키의 다국어 텍스트 조회 성공",
+      data: langText,
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      const langText = await multiLangService.getLangText(
-        companyCode,
-        langKey,
-        langCode
-      );
-
-      const response: ApiResponse<string> = {
-        success: true,
-        message: "특정 키의 다국어 텍스트 조회 성공",
-        data: langText,
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("특정 키의 다국어 텍스트 조회 실패:", error);
     res.status(500).json({
@@ -777,29 +607,16 @@ export const deleteLanguage = async (
       return;
     }
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    await multiLangService.deleteLanguage(langCode);
-      connectionString:
-        process.env.DATABASE_URL ||
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
-    });
 
-    await client.connect();
+    const response: ApiResponse<string> = {
+      success: true,
+      message: "언어가 성공적으로 삭제되었습니다.",
+      data: "삭제 완료",
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      await multiLangService.deleteLanguage(langCode);
-
-      const response: ApiResponse<string> = {
-        success: true,
-        message: "언어가 성공적으로 삭제되었습니다.",
-        data: "삭제 완료",
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("언어 삭제 실패:", error);
     res.status(500).json({
@@ -866,34 +683,21 @@ export const getBatchTranslations = async (
       return;
     }
 
-    // PostgreSQL 클라이언트 생성
+    const multiLangService = new MultiLangService();
-    const client = new Client({
+    const translations = await multiLangService.getBatchTranslations({
-      connectionString:
+      companyCode: finalCompanyCode as string,
-        process.env.DATABASE_URL ||
+      menuCode: finalMenuCode as string,
-        "postgresql://postgres:postgres@localhost:5432/ilshin",
+      userLang: finalUserLang as string,
+      langKeys,
     });
 
-    await client.connect();
+    const response: ApiResponse<Record<string, string>> = {
+      success: true,
+      message: "다국어 텍스트 배치 조회 성공",
+      data: translations,
+    };
 
-    try {
+    res.status(200).json(response);
-      const multiLangService = new MultiLangService(client);
-      const translations = await multiLangService.getBatchTranslations({
-        companyCode: finalCompanyCode as string,
-        menuCode: finalMenuCode as string,
-        userLang: finalUserLang as string,
-        langKeys,
-      });
-
-      const response: ApiResponse<Record<string, string>> = {
-        success: true,
-        message: "다국어 텍스트 배치 조회 성공",
-        data: translations,
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("다국어 텍스트 배치 조회 실패:", error);
     res.status(500).json({

backend-node/src/controllers/tableManagementController.ts

@@ -2,7 +2,6 @@ import { Request, Response } from "express";
 import { logger } from "../utils/logger";
 import { AuthenticatedRequest } from "../types/auth";
 import { ApiResponse } from "../types/common";
-import { Client } from "pg";
 import { TableManagementService } from "../services/tableManagementService";
 import {
   TableInfo,
@@ -23,29 +22,18 @@ export async function getTableList(
   try {
     logger.info("=== 테이블 목록 조회 시작 ===");
 
-    // PostgreSQL 클라이언트 생성
+    const tableManagementService = new TableManagementService();
-    const client = new Client({
+    const tableList = await tableManagementService.getTableList();
-      connectionString: process.env.DATABASE_URL,
-    });
 
-    await client.connect();
+    logger.info(`테이블 목록 조회 결과: ${tableList.length}개`);
 
-    try {
+    const response: ApiResponse<TableInfo[]> = {
-      const tableManagementService = new TableManagementService(client);
+      success: true,
-      const tableList = await tableManagementService.getTableList();
+      message: "테이블 목록을 성공적으로 조회했습니다.",
+      data: tableList,
+    };
 
-      logger.info(`테이블 목록 조회 결과: ${tableList.length}개`);
+    res.status(200).json(response);
-
-      const response: ApiResponse<TableInfo[]> = {
-        success: true,
-        message: "테이블 목록을 성공적으로 조회했습니다.",
-        data: tableList,
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("테이블 목록 조회 중 오류 발생:", error);
 
@@ -86,29 +74,18 @@ export async function getColumnList(
       return;
     }
 
-    // PostgreSQL 클라이언트 생성
+    const tableManagementService = new TableManagementService();
-    const client = new Client({
+    const columnList = await tableManagementService.getColumnList(tableName);
-      connectionString: process.env.DATABASE_URL,
-    });
 
-    await client.connect();
+    logger.info(`컬럼 정보 조회 결과: ${tableName}, ${columnList.length}개`);
 
-    try {
+    const response: ApiResponse<ColumnTypeInfo[]> = {
-      const tableManagementService = new TableManagementService(client);
+      success: true,
-      const columnList = await tableManagementService.getColumnList(tableName);
+      message: "컬럼 목록을 성공적으로 조회했습니다.",
+      data: columnList,
+    };
 
-      logger.info(`컬럼 정보 조회 결과: ${tableName}, ${columnList.length}개`);
+    res.status(200).json(response);
-
-      const response: ApiResponse<ColumnTypeInfo[]> = {
-        success: true,
-        message: "컬럼 목록을 성공적으로 조회했습니다.",
-        data: columnList,
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("컬럼 정보 조회 중 오류 발생:", error);
 
@@ -164,32 +141,21 @@ export async function updateColumnSettings(
       return;
     }
 
-    // PostgreSQL 클라이언트 생성
+    const tableManagementService = new TableManagementService();
-    const client = new Client({
+    await tableManagementService.updateColumnSettings(
-      connectionString: process.env.DATABASE_URL,
+      tableName,
-    });
+      columnName,
+      settings
+    );
 
-    await client.connect();
+    logger.info(`컬럼 설정 업데이트 완료: ${tableName}.${columnName}`);
 
-    try {
+    const response: ApiResponse<null> = {
-      const tableManagementService = new TableManagementService(client);
+      success: true,
-      await tableManagementService.updateColumnSettings(
+      message: "컬럼 설정을 성공적으로 저장했습니다.",
-        tableName,
+    };
-        columnName,
-        settings
-      );
 
-      logger.info(`컬럼 설정 업데이트 완료: ${tableName}.${columnName}`);
+    res.status(200).json(response);
-
-      const response: ApiResponse<null> = {
-        success: true,
-        message: "컬럼 설정을 성공적으로 저장했습니다.",
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("컬럼 설정 업데이트 중 오류 발생:", error);
 
@@ -245,33 +211,22 @@ export async function updateAllColumnSettings(
       return;
     }
 
-    // PostgreSQL 클라이언트 생성
+    const tableManagementService = new TableManagementService();
-    const client = new Client({
+    await tableManagementService.updateAllColumnSettings(
-      connectionString: process.env.DATABASE_URL,
+      tableName,
-    });
+      columnSettings
+    );
 
-    await client.connect();
+    logger.info(
+      `전체 컬럼 설정 일괄 업데이트 완료: ${tableName}, ${columnSettings.length}개`
+    );
 
-    try {
+    const response: ApiResponse<null> = {
-      const tableManagementService = new TableManagementService(client);
+      success: true,
-      await tableManagementService.updateAllColumnSettings(
+      message: "모든 컬럼 설정을 성공적으로 저장했습니다.",
-        tableName,
+    };
-        columnSettings
-      );
 
-      logger.info(
+    res.status(200).json(response);
-        `전체 컬럼 설정 일괄 업데이트 완료: ${tableName}, ${columnSettings.length}개`
-      );
-
-      const response: ApiResponse<null> = {
-        success: true,
-        message: "모든 컬럼 설정을 성공적으로 저장했습니다.",
-      };
-
-      res.status(200).json(response);
-    } finally {
-      await client.end();
-    }
   } catch (error) {
     logger.error("전체 컬럼 설정 일괄 업데이트 중 오류 발생:", error);
 
@@ -312,43 +267,31 @@ export async function getTableLabels(
       return;
     }
 
-    // PostgreSQL 클라이언트 생성
+    const tableManagementService = new TableManagementService();
-    const client = new Client({
+    const tableLabels = await tableManagementService.getTableLabels(tableName);
-      connectionString: process.env.DATABASE_URL,
-    });
 
-    await client.connect();
+    if (!tableLabels) {
-
+      const response: ApiResponse<null> = {
-    try {
+        success: false,
-      const tableManagementService = new TableManagementService(client);
+        message: "테이블 라벨 정보를 찾을 수 없습니다.",
-      const tableLabels =
+        error: {
-        await tableManagementService.getTableLabels(tableName);
+          code: "TABLE_LABELS_NOT_FOUND",
-
+          details: `테이블 ${tableName}의 라벨 정보가 존재하지 않습니다.`,
-      if (!tableLabels) {
+        },
-        const response: ApiResponse<null> = {
-          success: false,
-          message: "테이블 라벨 정보를 찾을 수 없습니다.",
-          error: {
-            code: "TABLE_LABELS_NOT_FOUND",
-            details: `테이블 ${tableName}의 라벨 정보가 존재하지 않습니다.`,
-          },
-        };
-        res.status(404).json(response);
-        return;
-      }
-
-      logger.info(`테이블 라벨 정보 조회 완료: ${tableName}`);
-
-      const response: ApiResponse<any> = {
-        success: true,
-        message: "테이블 라벨 정보를 성공적으로 조회했습니다.",
-        data: tableLabels,
       };
-
+      res.status(404).json(response);
-      res.status(200).json(response);
+      return;
-    } finally {
-      await client.end();
     }
+
+    logger.info(`테이블 라벨 정보 조회 완료: ${tableName}`);
+
+    const response: ApiResponse<any> = {
+      success: true,
+      message: "테이블 라벨 정보를 성공적으로 조회했습니다.",
+      data: tableLabels,
+    };
+
+    res.status(200).json(response);
   } catch (error) {
     logger.error("테이블 라벨 정보 조회 중 오류 발생:", error);
 
@@ -389,45 +332,34 @@ export async function getColumnLabels(
       return;
     }
 
-    // PostgreSQL 클라이언트 생성
+    const tableManagementService = new TableManagementService();
-    const client = new Client({
+    const columnLabels = await tableManagementService.getColumnLabels(
-      connectionString: process.env.DATABASE_URL,
+      tableName,
-    });
+      columnName
+    );
 
-    await client.connect();
+    if (!columnLabels) {
-
+      const response: ApiResponse<null> = {
-    try {
+        success: false,
-      const tableManagementService = new TableManagementService(client);
+        message: "컬럼 라벨 정보를 찾을 수 없습니다.",
-      const columnLabels = await tableManagementService.getColumnLabels(
+        error: {
-        tableName,
+          code: "COLUMN_LABELS_NOT_FOUND",
-        columnName
+          details: `컬럼 ${tableName}.${columnName}의 라벨 정보가 존재하지 않습니다.`,
-      );
+        },
-
-      if (!columnLabels) {
-        const response: ApiResponse<null> = {
-          success: false,
-          message: "컬럼 라벨 정보를 찾을 수 없습니다.",
-          error: {
-            code: "COLUMN_LABELS_NOT_FOUND",
-            details: `컬럼 ${tableName}.${columnName}의 라벨 정보가 존재하지 않습니다.`,
-          },
-        };
-        res.status(404).json(response);
-        return;
-      }
-
-      logger.info(`컬럼 라벨 정보 조회 완료: ${tableName}.${columnName}`);
-
-      const response: ApiResponse<any> = {
-        success: true,
-        message: "컬럼 라벨 정보를 성공적으로 조회했습니다.",
-        data: columnLabels,
       };
-
+      res.status(404).json(response);
-      res.status(200).json(response);
+      return;
-    } finally {
-      await client.end();
     }
+
+    logger.info(`컬럼 라벨 정보 조회 완료: ${tableName}.${columnName}`);
+
+    const response: ApiResponse<any> = {
+      success: true,
+      message: "컬럼 라벨 정보를 성공적으로 조회했습니다.",
+      data: columnLabels,
+    };
+
+    res.status(200).json(response);
   } catch (error) {
     logger.error("컬럼 라벨 정보 조회 중 오류 발생:", error);
 

backend-node/src/services/tableManagementService.ts

@@ -1,4 +1,4 @@
-import { Client } from "pg";
+import { PrismaClient } from "@prisma/client";
 import { logger } from "../utils/logger";
 import {
   TableInfo,
@@ -8,21 +8,21 @@ import {
   ColumnLabels,
 } from "../types/tableManagement";
 
-export class TableManagementService {
+const prisma = new PrismaClient();
-  private client: Client;
 
-  constructor(client: Client) {
+export class TableManagementService {
-    this.client = client;
+  constructor() {}
-  }
 
   /**
    * 테이블 목록 조회 (PostgreSQL information_schema 활용)
+   * 메타데이터 조회는 Prisma로 변경 불가
    */
   async getTableList(): Promise<TableInfo[]> {
     try {
       logger.info("테이블 목록 조회 시작");
 
-      const query = `
+      // information_schema는 여전히 $queryRaw 사용
+      const tables = await prisma.$queryRaw<TableInfo[]>`
         SELECT 
           t.table_name as "tableName",
           COALESCE(tl.table_label, t.table_name) as "displayName",
@@ -38,10 +38,8 @@ export class TableManagementService {
         ORDER BY t.table_name
       `;
 
-      const result = await this.client.query(query);
+      logger.info(`테이블 목록 조회 완료: ${tables.length}개`);
-      logger.info(`테이블 목록 조회 완료: ${result.rows.length}개`);
+      return tables;
-
-      return result.rows;
     } catch (error) {
       logger.error("테이블 목록 조회 중 오류 발생:", error);
       throw new Error(
@@ -52,12 +50,14 @@ export class TableManagementService {
 
   /**
    * 테이블 컬럼 정보 조회
+   * 메타데이터 조회는 Prisma로 변경 불가
    */
   async getColumnList(tableName: string): Promise<ColumnTypeInfo[]> {
     try {
       logger.info(`컬럼 정보 조회 시작: ${tableName}`);
 
-      const query = `
+      // information_schema는 여전히 $queryRaw 사용
+      const columns = await prisma.$queryRaw<ColumnTypeInfo[]>`
         SELECT 
           c.column_name as "columnName",
           COALESCE(cl.column_label, c.column_name) as "displayName",
@@ -78,14 +78,12 @@ export class TableManagementService {
           cl.is_visible as "isVisible"
         FROM information_schema.columns c
         LEFT JOIN column_labels cl ON c.table_name = cl.table_name AND c.column_name = cl.column_name
-        WHERE c.table_name = $1
+        WHERE c.table_name = ${tableName}
         ORDER BY c.ordinal_position
       `;
 
-      const result = await this.client.query(query, [tableName]);
+      logger.info(`컬럼 정보 조회 완료: ${tableName}, ${columns.length}개`);
-      logger.info(`컬럼 정보 조회 완료: ${tableName}, ${result.rows.length}개`);
+      return columns;
-
-      return result.rows;
     } catch (error) {
       logger.error(`컬럼 정보 조회 중 오류 발생: ${tableName}`, error);
       throw new Error(
@@ -96,18 +94,22 @@ export class TableManagementService {
 
   /**
    * 테이블이 table_labels에 없으면 자동 추가
+   * Prisma ORM으로 변경
    */
   async insertTableIfNotExists(tableName: string): Promise<void> {
     try {
       logger.info(`테이블 라벨 자동 추가 시작: ${tableName}`);
 
-      const query = `
+      await prisma.table_labels.upsert({
-        INSERT INTO table_labels (table_name, table_label, description)
+        where: { table_name: tableName },
-        VALUES ($1, $1, '')
+        update: {}, // 이미 존재하면 변경하지 않음
-        ON CONFLICT (table_name) DO NOTHING
+        create: {
-      `;
+          table_name: tableName,
+          table_label: tableName,
+          description: "",
+        },
+      });
 
-      await this.client.query(query, [tableName]);
       logger.info(`테이블 라벨 자동 추가 완료: ${tableName}`);
     } catch (error) {
       logger.error(`테이블 라벨 자동 추가 중 오류 발생: ${tableName}`, error);
@@ -119,6 +121,7 @@ export class TableManagementService {
 
   /**
    * 컬럼 설정 업데이트 (UPSERT 방식)
+   * Prisma ORM으로 변경
    */
   async updateColumnSettings(
     tableName: string,
@@ -131,38 +134,42 @@ export class TableManagementService {
       // 테이블이 table_labels에 없으면 자동 추가
       await this.insertTableIfNotExists(tableName);
 
-      const query = `
+      // column_labels 업데이트 또는 생성
-        INSERT INTO column_labels (
+      await prisma.column_labels.upsert({
-          table_name, column_name, column_label, web_type, 
+        where: {
-          detail_settings, code_category, code_value, 
+          table_name_column_name: {
-          reference_table, reference_column, display_order, is_visible
+            table_name: tableName,
-        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+            column_name: columnName,
-        ON CONFLICT (table_name, column_name) DO UPDATE SET
+          },
-          column_label = EXCLUDED.column_label,
+        },
-          web_type = EXCLUDED.web_type,
+        update: {
-          detail_settings = EXCLUDED.detail_settings,
+          column_label: settings.columnLabel,
-          code_category = EXCLUDED.code_category,
+          web_type: settings.webType,
-          code_value = EXCLUDED.code_value,
+          detail_settings: settings.detailSettings,
-          reference_table = EXCLUDED.reference_table,
+          code_category: settings.codeCategory,
-          reference_column = EXCLUDED.reference_column,
+          code_value: settings.codeValue,
-          display_order = EXCLUDED.display_order,
+          reference_table: settings.referenceTable,
-          is_visible = EXCLUDED.is_visible,
+          reference_column: settings.referenceColumn,
-          updated_date = now()
+          display_order: settings.displayOrder || 0,
-      `;
+          is_visible:
-
+            settings.isVisible !== undefined ? settings.isVisible : true,
-      await this.client.query(query, [
+          updated_date: new Date(),
-        tableName,
+        },
-        columnName,
+        create: {
-        settings.columnLabel,
+          table_name: tableName,
-        settings.webType,
+          column_name: columnName,
-        settings.detailSettings,
+          column_label: settings.columnLabel,
-        settings.codeCategory,
+          web_type: settings.webType,
-        settings.codeValue,
+          detail_settings: settings.detailSettings,
-        settings.referenceTable,
+          code_category: settings.codeCategory,
-        settings.referenceColumn,
+          code_value: settings.codeValue,
-        settings.displayOrder || 0,
+          reference_table: settings.referenceTable,
-        settings.isVisible !== undefined ? settings.isVisible : true,
+          reference_column: settings.referenceColumn,
-      ]);
+          display_order: settings.displayOrder || 0,
+          is_visible:
+            settings.isVisible !== undefined ? settings.isVisible : true,
+        },
+      });
 
       logger.info(`컬럼 설정 업데이트 완료: ${tableName}.${columnName}`);
     } catch (error) {
@@ -178,6 +185,7 @@ export class TableManagementService {
 
   /**
    * 전체 컬럼 설정 일괄 업데이트
+   * Prisma 트랜잭션으로 변경
    */
   async updateAllColumnSettings(
     tableName: string,
@@ -188,10 +196,8 @@ export class TableManagementService {
         `전체 컬럼 설정 일괄 업데이트 시작: ${tableName}, ${columnSettings.length}개`
       );
 
-      // 트랜잭션 시작
+      // Prisma 트랜잭션 사용
-      await this.client.query("BEGIN");
+      await prisma.$transaction(async (tx) => {
-
-      try {
         // 테이블이 table_labels에 없으면 자동 추가
         await this.insertTableIfNotExists(tableName);
 
@@ -207,15 +213,9 @@ export class TableManagementService {
             );
           }
         }
+      });
 
-        // 트랜잭션 커밋
+      logger.info(`전체 컬럼 설정 일괄 업데이트 완료: ${tableName}`);
-        await this.client.query("COMMIT");
-        logger.info(`전체 컬럼 설정 일괄 업데이트 완료: ${tableName}`);
-      } catch (error) {
-        // 트랜잭션 롤백
-        await this.client.query("ROLLBACK");
-        throw error;
-      }
     } catch (error) {
       logger.error(
         `전체 컬럼 설정 일괄 업데이트 중 오류 발생: ${tableName}`,
@@ -229,30 +229,37 @@ export class TableManagementService {
 
   /**
    * 테이블 라벨 정보 조회
+   * Prisma ORM으로 변경
    */
   async getTableLabels(tableName: string): Promise<TableLabels | null> {
     try {
       logger.info(`테이블 라벨 정보 조회 시작: ${tableName}`);
 
-      const query = `
+      const tableLabel = await prisma.table_labels.findUnique({
-        SELECT 
+        where: { table_name: tableName },
-          table_name as "tableName",
+        select: {
-          table_label as "tableLabel",
+          table_name: true,
-          description,
+          table_label: true,
-          created_date as "createdDate",
+          description: true,
-          updated_date as "updatedDate"
+          created_date: true,
-        FROM table_labels
+          updated_date: true,
-        WHERE table_name = $1
+        },
-      `;
+      });
 
-      const result = await this.client.query(query, [tableName]);
+      if (!tableLabel) {
-
-      if (result.rows.length === 0) {
         return null;
       }
 
+      const result: TableLabels = {
+        tableName: tableLabel.table_name,
+        tableLabel: tableLabel.table_label || undefined,
+        description: tableLabel.description || undefined,
+        createdDate: tableLabel.created_date || undefined,
+        updatedDate: tableLabel.updated_date || undefined,
+      };
+
       logger.info(`테이블 라벨 정보 조회 완료: ${tableName}`);
-      return result.rows[0];
+      return result;
     } catch (error) {
       logger.error(`테이블 라벨 정보 조회 중 오류 발생: ${tableName}`, error);
       throw new Error(
@@ -263,6 +270,7 @@ export class TableManagementService {
 
   /**
    * 컬럼 라벨 정보 조회
+   * Prisma ORM으로 변경
    */
   async getColumnLabels(
     tableName: string,
@@ -271,35 +279,56 @@ export class TableManagementService {
     try {
       logger.info(`컬럼 라벨 정보 조회 시작: ${tableName}.${columnName}`);
 
-      const query = `
+      const columnLabel = await prisma.column_labels.findUnique({
-        SELECT 
+        where: {
-          id,
+          table_name_column_name: {
-          table_name as "tableName",
+            table_name: tableName,
-          column_name as "columnName",
+            column_name: columnName,
-          column_label as "columnLabel",
+          },
-          web_type as "webType",
+        },
-          detail_settings as "detailSettings",
+        select: {
-          description,
+          id: true,
-          display_order as "displayOrder",
+          table_name: true,
-          is_visible as "isVisible",
+          column_name: true,
-          code_category as "codeCategory",
+          column_label: true,
-          code_value as "codeValue",
+          web_type: true,
-          reference_table as "referenceTable",
+          detail_settings: true,
-          reference_column as "referenceColumn",
+          description: true,
-          created_date as "createdDate",
+          display_order: true,
-          updated_date as "updatedDate"
+          is_visible: true,
-        FROM column_labels
+          code_category: true,
-        WHERE table_name = $1 AND column_name = $2
+          code_value: true,
-      `;
+          reference_table: true,
+          reference_column: true,
+          created_date: true,
+          updated_date: true,
+        },
+      });
 
-      const result = await this.client.query(query, [tableName, columnName]);
+      if (!columnLabel) {
-
-      if (result.rows.length === 0) {
         return null;
       }
 
+      const result: ColumnLabels = {
+        id: columnLabel.id,
+        tableName: columnLabel.table_name || "",
+        columnName: columnLabel.column_name || "",
+        columnLabel: columnLabel.column_label || undefined,
+        webType: columnLabel.web_type || undefined,
+        detailSettings: columnLabel.detail_settings || undefined,
+        description: columnLabel.description || undefined,
+        displayOrder: columnLabel.display_order || undefined,
+        isVisible: columnLabel.is_visible || undefined,
+        codeCategory: columnLabel.code_category || undefined,
+        codeValue: columnLabel.code_value || undefined,
+        referenceTable: columnLabel.reference_table || undefined,
+        referenceColumn: columnLabel.reference_column || undefined,
+        createdDate: columnLabel.created_date || undefined,
+        updatedDate: columnLabel.updated_date || undefined,
+      };
+
       logger.info(`컬럼 라벨 정보 조회 완료: ${tableName}.${columnName}`);
-      return result.rows[0];
+      return result;
     } catch (error) {
       logger.error(
         `컬럼 라벨 정보 조회 중 오류 발생: ${tableName}.${columnName}`,