null로 저장되게 성공시킴

backend-node/src/services/externalRestApiConnectionService.ts

@@ -166,6 +166,9 @@ export class ExternalRestApiConnectionService {
         ? this.decryptSensitiveData(connection.auth_config)
         : null;
 
+      // 디버깅: 조회된 연결 정보 로깅
+      logger.info(`REST API 연결 조회 결과 (ID: ${id}): connection_name=${connection.connection_name}, default_method=${connection.default_method}, endpoint_path=${connection.endpoint_path}`);
+
       return {
         success: true,
         data: connection,
@@ -227,6 +230,15 @@ export class ExternalRestApiConnectionService {
         data.created_by || "system",
       ];
 
+      // 디버깅: 저장하려는 데이터 로깅
+      logger.info(`REST API 연결 생성 요청 데이터:`, {
+        connection_name: data.connection_name,
+        default_method: data.default_method,
+        endpoint_path: data.endpoint_path,
+        base_url: data.base_url,
+        default_body: data.default_body ? "있음" : "없음",
+      });
+
       const result: QueryResult<any> = await pool.query(query, params);
 
       logger.info(`REST API 연결 생성 성공: ${data.connection_name}`);
@@ -316,12 +328,14 @@ export class ExternalRestApiConnectionService {
         updateFields.push(`default_method = $${paramIndex}`);
         params.push(data.default_method);
         paramIndex++;
+        logger.info(`수정 요청 - default_method: ${data.default_method}`);
       }
 
       if (data.default_body !== undefined) {
         updateFields.push(`default_request_body = $${paramIndex}`);
-        params.push(data.default_body);
+        params.push(data.default_body); // null이면 DB에서 NULL로 저장됨
         paramIndex++;
+        logger.info(`수정 요청 - default_body: ${data.default_body ? "있음" : "삭제(null)"}`);
       }
 
       if (data.auth_type !== undefined) {
@@ -870,6 +884,166 @@ export class ExternalRestApiConnectionService {
     return decrypted;
   }
 
+  /**
+   * REST API 데이터 조회 (화면관리용 프록시)
+   * 저장된 연결 정보를 사용하여 외부 REST API를 호출하고 데이터를 반환
+   */
+  static async fetchData(
+    connectionId: number,
+    endpoint?: string,
+    jsonPath?: string,
+    userCompanyCode?: string
+  ): Promise<ApiResponse<any>> {
+    try {
+      // 연결 정보 조회
+      const connectionResult = await this.getConnectionById(connectionId, userCompanyCode);
+
+      if (!connectionResult.success || !connectionResult.data) {
+        return {
+          success: false,
+          message: "REST API 연결을 찾을 수 없습니다.",
+          error: {
+            code: "CONNECTION_NOT_FOUND",
+            details: `연결 ID ${connectionId}를 찾을 수 없습니다.`,
+          },
+        };
+      }
+
+      const connection = connectionResult.data;
+
+      // 비활성화된 연결인지 확인
+      if (connection.is_active !== "Y") {
+        return {
+          success: false,
+          message: "비활성화된 REST API 연결입니다.",
+          error: {
+            code: "CONNECTION_INACTIVE",
+            details: "연결이 비활성화 상태입니다.",
+          },
+        };
+      }
+
+      // 엔드포인트 결정 (파라미터 > 저장된 값)
+      const effectiveEndpoint = endpoint || connection.endpoint_path || "";
+
+      // API 호출을 위한 테스트 요청 생성
+      const testRequest: RestApiTestRequest = {
+        id: connection.id,
+        base_url: connection.base_url,
+        endpoint: effectiveEndpoint,
+        method: (connection.default_method as any) || "GET",
+        headers: connection.default_headers,
+        body: connection.default_body,
+        auth_type: connection.auth_type,
+        auth_config: connection.auth_config,
+        timeout: connection.timeout,
+      };
+
+      // API 호출
+      const result = await this.testConnection(testRequest, connection.company_code);
+
+      if (!result.success) {
+        return {
+          success: false,
+          message: result.message || "REST API 호출에 실패했습니다.",
+          error: {
+            code: "API_CALL_FAILED",
+            details: result.error_details,
+          },
+        };
+      }
+
+      // 응답 데이터에서 jsonPath로 데이터 추출
+      let extractedData = result.response_data;
+
+      logger.info(`REST API 원본 응답 데이터 타입: ${typeof result.response_data}`);
+      logger.info(`REST API 원본 응답 데이터 (일부): ${JSON.stringify(result.response_data)?.substring(0, 500)}`);
+
+      if (jsonPath && result.response_data) {
+        try {
+          // jsonPath로 데이터 추출 (예: "data", "data.items", "result.list")
+          const pathParts = jsonPath.split(".");
+          logger.info(`JSON Path 파싱: ${jsonPath} -> [${pathParts.join(", ")}]`);
+          
+          for (const part of pathParts) {
+            if (extractedData && typeof extractedData === "object") {
+              extractedData = (extractedData as any)[part];
+              logger.info(`JSON Path '${part}' 추출 결과 타입: ${typeof extractedData}, 배열?: ${Array.isArray(extractedData)}`);
+            } else {
+              logger.warn(`JSON Path '${part}' 추출 실패: extractedData가 객체가 아님`);
+              break;
+            }
+          }
+        } catch (pathError) {
+          logger.warn(`JSON Path 추출 실패: ${jsonPath}`, pathError);
+          // 추출 실패 시 원본 데이터 반환
+          extractedData = result.response_data;
+        }
+      }
+
+      // 데이터가 배열이 아닌 경우 배열로 변환
+      // null이나 undefined인 경우 빈 배열로 처리
+      let dataArray: any[] = [];
+      if (extractedData === null || extractedData === undefined) {
+        logger.warn("추출된 데이터가 null/undefined입니다. 원본 응답 데이터를 사용합니다.");
+        // jsonPath 추출 실패 시 원본 데이터에서 직접 컬럼 추출 시도
+        if (result.response_data && typeof result.response_data === "object") {
+          dataArray = Array.isArray(result.response_data) ? result.response_data : [result.response_data];
+        }
+      } else {
+        dataArray = Array.isArray(extractedData) ? extractedData : [extractedData];
+      }
+
+      logger.info(`최종 데이터 배열 길이: ${dataArray.length}`);
+      if (dataArray.length > 0) {
+        logger.info(`첫 번째 데이터 항목: ${JSON.stringify(dataArray[0])?.substring(0, 300)}`);
+      }
+
+      // 컬럼 정보 추출 (첫 번째 유효한 데이터 기준)
+      let columns: Array<{ columnName: string; columnLabel: string; dataType: string }> = [];
+      
+      // 첫 번째 유효한 객체 찾기
+      const firstValidItem = dataArray.find(item => item && typeof item === "object" && !Array.isArray(item));
+      
+      if (firstValidItem) {
+        columns = Object.keys(firstValidItem).map((key) => ({
+          columnName: key,
+          columnLabel: key,
+          dataType: typeof firstValidItem[key],
+        }));
+        logger.info(`추출된 컬럼 수: ${columns.length}, 컬럼명: [${columns.map(c => c.columnName).join(", ")}]`);
+      } else {
+        logger.warn("유효한 데이터 항목을 찾을 수 없어 컬럼을 추출할 수 없습니다.");
+      }
+
+      return {
+        success: true,
+        data: {
+          rows: dataArray,
+          columns,
+          total: dataArray.length,
+          connectionInfo: {
+            connectionId: connection.id,
+            connectionName: connection.connection_name,
+            baseUrl: connection.base_url,
+            endpoint: effectiveEndpoint,
+          },
+        },
+        message: `${dataArray.length}개의 데이터를 조회했습니다.`,
+      };
+    } catch (error) {
+      logger.error("REST API 데이터 조회 오류:", error);
+      return {
+        success: false,
+        message: "REST API 데이터 조회에 실패했습니다.",
+        error: {
+          code: "FETCH_ERROR",
+          details: error instanceof Error ? error.message : "알 수 없는 오류",
+        },
+      };
+    }
+  }
+
   /**
    * 연결 데이터 유효성 검증
    */