535 lines
16 KiB
TypeScript
535 lines
16 KiB
TypeScript
import {
|
|
ExternalCallConfig,
|
|
ExternalCallResult,
|
|
ExternalCallRequest,
|
|
SlackSettings,
|
|
KakaoTalkSettings,
|
|
DiscordSettings,
|
|
GenericApiSettings,
|
|
EmailSettings,
|
|
SupportedExternalCallSettings,
|
|
TemplateOptions,
|
|
} from "../types/externalCallTypes";
|
|
import { DataMappingService } from "./dataMappingService";
|
|
import {
|
|
DataMappingConfig,
|
|
DataMappingResult,
|
|
} from "../types/dataMappingTypes";
|
|
|
|
/**
|
|
* 외부 호출 서비스
|
|
* REST API, 웹훅, 이메일 등 다양한 외부 시스템 호출을 처리
|
|
*/
|
|
export class ExternalCallService {
|
|
private readonly DEFAULT_TIMEOUT = 30000; // 30초
|
|
private readonly DEFAULT_RETRY_COUNT = 3;
|
|
private dataMappingService: DataMappingService;
|
|
private readonly DEFAULT_RETRY_DELAY = 1000; // 1초
|
|
|
|
constructor() {
|
|
this.dataMappingService = new DataMappingService();
|
|
}
|
|
|
|
/**
|
|
* 데이터 매핑과 함께 외부 호출 실행
|
|
*/
|
|
async executeWithDataMapping(
|
|
config: ExternalCallConfig,
|
|
dataMappingConfig?: DataMappingConfig,
|
|
triggerData?: any
|
|
): Promise<{
|
|
callResult: ExternalCallResult;
|
|
mappingResult?: DataMappingResult;
|
|
}> {
|
|
const startTime = Date.now();
|
|
|
|
console.log(`🚀 [ExternalCallService] 데이터 매핑 포함 외부 호출 시작:`, {
|
|
callType: config.callType,
|
|
hasMappingConfig: !!dataMappingConfig,
|
|
mappingDirection: dataMappingConfig?.direction,
|
|
});
|
|
|
|
try {
|
|
let requestData = config;
|
|
|
|
// Outbound 매핑 처리 (내부 → 외부)
|
|
if (
|
|
dataMappingConfig?.direction === "outbound" &&
|
|
dataMappingConfig.outboundMapping
|
|
) {
|
|
console.log(`📤 [ExternalCallService] Outbound 매핑 처리 시작`);
|
|
|
|
const outboundData = await this.dataMappingService.processOutboundData(
|
|
dataMappingConfig.outboundMapping,
|
|
triggerData
|
|
);
|
|
|
|
// API 요청 바디에 매핑된 데이터 포함
|
|
if (config.callType === "rest-api") {
|
|
// GenericApiSettings로 타입 캐스팅
|
|
const apiConfig = config as GenericApiSettings;
|
|
const bodyTemplate = apiConfig.body || "{}";
|
|
|
|
// 템플릿에 데이터 삽입
|
|
const processedBody = this.processTemplate(bodyTemplate, {
|
|
mappedData: outboundData,
|
|
triggerData,
|
|
...outboundData,
|
|
});
|
|
|
|
requestData = {
|
|
...config,
|
|
body: processedBody,
|
|
} as GenericApiSettings;
|
|
}
|
|
}
|
|
|
|
// 외부 호출 실행
|
|
const callRequest: ExternalCallRequest = {
|
|
diagramId: 0, // 임시값
|
|
relationshipId: "data-mapping", // 임시값
|
|
settings: requestData,
|
|
templateData: triggerData,
|
|
};
|
|
const callResult = await this.executeExternalCall(callRequest);
|
|
|
|
let mappingResult: DataMappingResult | undefined;
|
|
|
|
// Inbound 매핑 처리 (외부 → 내부)
|
|
if (
|
|
callResult.success &&
|
|
dataMappingConfig?.direction === "inbound" &&
|
|
dataMappingConfig.inboundMapping
|
|
) {
|
|
console.log(`📥 [ExternalCallService] Inbound 매핑 처리 시작`);
|
|
|
|
try {
|
|
// 응답 데이터 파싱
|
|
let responseData = callResult.response;
|
|
if (typeof responseData === "string") {
|
|
try {
|
|
responseData = JSON.parse(responseData);
|
|
} catch {
|
|
console.warn(
|
|
`⚠️ [ExternalCallService] 응답 데이터 JSON 파싱 실패, 문자열로 처리`
|
|
);
|
|
}
|
|
}
|
|
|
|
mappingResult = await this.dataMappingService.processInboundData(
|
|
responseData,
|
|
dataMappingConfig.inboundMapping
|
|
);
|
|
|
|
console.log(`✅ [ExternalCallService] Inbound 매핑 완료:`, {
|
|
recordsProcessed: mappingResult.recordsProcessed,
|
|
recordsInserted: mappingResult.recordsInserted,
|
|
});
|
|
} catch (error) {
|
|
console.error(`❌ [ExternalCallService] Inbound 매핑 실패:`, error);
|
|
mappingResult = {
|
|
success: false,
|
|
direction: "inbound",
|
|
errors: [error instanceof Error ? error.message : String(error)],
|
|
executionTime: Date.now() - startTime,
|
|
timestamp: new Date().toISOString(),
|
|
};
|
|
}
|
|
}
|
|
|
|
// 양방향 매핑 처리
|
|
if (dataMappingConfig?.direction === "bidirectional") {
|
|
// 필요한 경우 양방향 매핑 로직 구현
|
|
console.log(`🔄 [ExternalCallService] 양방향 매핑은 향후 구현 예정`);
|
|
}
|
|
|
|
const result = {
|
|
callResult,
|
|
mappingResult,
|
|
};
|
|
|
|
console.log(`✅ [ExternalCallService] 데이터 매핑 포함 외부 호출 완료:`, {
|
|
callSuccess: callResult.success,
|
|
mappingSuccess: mappingResult?.success,
|
|
totalExecutionTime: Date.now() - startTime,
|
|
});
|
|
|
|
return result;
|
|
} catch (error) {
|
|
console.error(
|
|
`❌ [ExternalCallService] 데이터 매핑 포함 외부 호출 실패:`,
|
|
error
|
|
);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 기존 외부 호출 실행 (매핑 없음)
|
|
*/
|
|
async executeExternalCall(
|
|
request: ExternalCallRequest
|
|
): Promise<ExternalCallResult> {
|
|
const startTime = Date.now();
|
|
|
|
try {
|
|
let result: ExternalCallResult;
|
|
|
|
switch (request.settings.callType) {
|
|
case "rest-api":
|
|
result = await this.executeRestApiCall(request);
|
|
break;
|
|
case "email":
|
|
result = await this.executeEmailCall(request);
|
|
break;
|
|
case "ftp":
|
|
throw new Error("FTP 호출은 아직 구현되지 않았습니다.");
|
|
case "queue":
|
|
throw new Error("메시지 큐 호출은 아직 구현되지 않았습니다.");
|
|
default:
|
|
throw new Error(
|
|
`지원되지 않는 호출 타입: ${request.settings.callType}`
|
|
);
|
|
}
|
|
|
|
result.executionTime = Date.now() - startTime;
|
|
result.timestamp = new Date();
|
|
|
|
return result;
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: error instanceof Error ? error.message : String(error),
|
|
executionTime: Date.now() - startTime,
|
|
timestamp: new Date(),
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* REST API 호출 실행
|
|
*/
|
|
private async executeRestApiCall(
|
|
request: ExternalCallRequest
|
|
): Promise<ExternalCallResult> {
|
|
const settings = request.settings as any; // 임시로 any 사용
|
|
|
|
switch (settings.apiType) {
|
|
case "slack":
|
|
return await this.executeSlackWebhook(
|
|
settings as SlackSettings,
|
|
request.templateData
|
|
);
|
|
case "kakao-talk":
|
|
return await this.executeKakaoTalkApi(
|
|
settings as KakaoTalkSettings,
|
|
request.templateData
|
|
);
|
|
case "discord":
|
|
return await this.executeDiscordWebhook(
|
|
settings as DiscordSettings,
|
|
request.templateData
|
|
);
|
|
case "generic":
|
|
default:
|
|
return await this.executeGenericApi(
|
|
settings as GenericApiSettings,
|
|
request.templateData
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 슬랙 웹훅 실행
|
|
*/
|
|
private async executeSlackWebhook(
|
|
settings: SlackSettings,
|
|
templateData?: Record<string, unknown>
|
|
): Promise<ExternalCallResult> {
|
|
const payload = {
|
|
text: this.processTemplate(settings.message, templateData),
|
|
channel: settings.channel,
|
|
username: settings.username || "DataFlow Bot",
|
|
icon_emoji: settings.iconEmoji || ":robot_face:",
|
|
};
|
|
|
|
return await this.makeHttpRequest({
|
|
url: settings.webhookUrl,
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify(payload),
|
|
timeout: settings.timeout || this.DEFAULT_TIMEOUT,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 카카오톡 API 실행
|
|
*/
|
|
private async executeKakaoTalkApi(
|
|
settings: KakaoTalkSettings,
|
|
templateData?: Record<string, unknown>
|
|
): Promise<ExternalCallResult> {
|
|
const payload = {
|
|
object_type: "text",
|
|
text: this.processTemplate(settings.message, templateData),
|
|
link: {
|
|
web_url: "https://developers.kakao.com",
|
|
mobile_web_url: "https://developers.kakao.com",
|
|
},
|
|
};
|
|
|
|
return await this.makeHttpRequest({
|
|
url: "https://kapi.kakao.com/v2/api/talk/memo/default/send",
|
|
method: "POST",
|
|
headers: {
|
|
Authorization: `Bearer ${settings.accessToken}`,
|
|
"Content-Type": "application/x-www-form-urlencoded",
|
|
},
|
|
body: `template_object=${encodeURIComponent(JSON.stringify(payload))}`,
|
|
timeout: settings.timeout || this.DEFAULT_TIMEOUT,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 디스코드 웹훅 실행
|
|
*/
|
|
private async executeDiscordWebhook(
|
|
settings: DiscordSettings,
|
|
templateData?: Record<string, unknown>
|
|
): Promise<ExternalCallResult> {
|
|
const payload = {
|
|
content: this.processTemplate(settings.message, templateData),
|
|
username: settings.username || "시스템 알리미",
|
|
avatar_url: settings.avatarUrl,
|
|
};
|
|
|
|
return await this.makeHttpRequest({
|
|
url: settings.webhookUrl,
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify(payload),
|
|
timeout: settings.timeout || this.DEFAULT_TIMEOUT,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 일반 REST API 실행
|
|
*/
|
|
private async executeGenericApi(
|
|
settings: GenericApiSettings,
|
|
templateData?: Record<string, unknown>
|
|
): Promise<ExternalCallResult> {
|
|
let body = settings.body;
|
|
if (body && templateData) {
|
|
body = this.processTemplate(body, templateData);
|
|
}
|
|
|
|
// 기본 헤더 준비
|
|
const headers = { ...(settings.headers || {}) };
|
|
|
|
// 인증 정보 처리
|
|
if (settings.authentication) {
|
|
switch (settings.authentication.type) {
|
|
case "api-key":
|
|
if (settings.authentication.apiKey) {
|
|
headers["X-API-Key"] = settings.authentication.apiKey;
|
|
}
|
|
break;
|
|
case "basic":
|
|
if (
|
|
settings.authentication.username &&
|
|
settings.authentication.password
|
|
) {
|
|
const credentials = Buffer.from(
|
|
`${settings.authentication.username}:${settings.authentication.password}`
|
|
).toString("base64");
|
|
headers["Authorization"] = `Basic ${credentials}`;
|
|
}
|
|
break;
|
|
case "bearer":
|
|
if (settings.authentication.token) {
|
|
headers["Authorization"] =
|
|
`Bearer ${settings.authentication.token}`;
|
|
}
|
|
break;
|
|
case "custom":
|
|
if (
|
|
settings.authentication.headerName &&
|
|
settings.authentication.headerValue
|
|
) {
|
|
headers[settings.authentication.headerName] =
|
|
settings.authentication.headerValue;
|
|
}
|
|
break;
|
|
// 'none' 타입은 아무것도 하지 않음
|
|
}
|
|
}
|
|
|
|
console.log(`🔐 [ExternalCallService] 인증 처리 완료:`, {
|
|
authType: settings.authentication?.type || "none",
|
|
hasAuthHeader: !!headers["Authorization"],
|
|
headers: Object.keys(headers),
|
|
});
|
|
|
|
return await this.makeHttpRequest({
|
|
url: settings.url,
|
|
method: settings.method,
|
|
headers: headers,
|
|
body: body,
|
|
timeout: settings.timeout || this.DEFAULT_TIMEOUT,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 이메일 호출 실행 (향후 구현)
|
|
*/
|
|
private async executeEmailCall(
|
|
request: ExternalCallRequest
|
|
): Promise<ExternalCallResult> {
|
|
// TODO: 이메일 발송 구현 (Java MailUtil 연동)
|
|
throw new Error("이메일 발송 기능은 아직 구현되지 않았습니다.");
|
|
}
|
|
|
|
/**
|
|
* HTTP 요청 실행 (공통)
|
|
*/
|
|
private async makeHttpRequest(options: {
|
|
url: string;
|
|
method: string;
|
|
headers?: Record<string, string>;
|
|
body?: string;
|
|
timeout: number;
|
|
}): Promise<ExternalCallResult> {
|
|
try {
|
|
const controller = new AbortController();
|
|
const timeoutId = setTimeout(() => controller.abort(), options.timeout);
|
|
|
|
// GET, HEAD 메서드는 body를 가질 수 없음
|
|
const method = options.method.toUpperCase();
|
|
const requestOptions: RequestInit = {
|
|
method: options.method,
|
|
headers: options.headers,
|
|
signal: controller.signal,
|
|
};
|
|
|
|
// GET, HEAD 메서드가 아닌 경우에만 body 추가
|
|
if (method !== "GET" && method !== "HEAD" && options.body) {
|
|
requestOptions.body = options.body;
|
|
}
|
|
|
|
const response = await fetch(options.url, requestOptions);
|
|
|
|
clearTimeout(timeoutId);
|
|
|
|
const responseText = await response.text();
|
|
|
|
// 디버깅을 위한 로그 추가
|
|
console.log(`🔍 [ExternalCallService] HTTP 응답:`, {
|
|
url: options.url,
|
|
method: options.method,
|
|
status: response.status,
|
|
statusText: response.statusText,
|
|
ok: response.ok,
|
|
headers: Object.fromEntries(response.headers.entries()),
|
|
responseText: responseText.substring(0, 500), // 처음 500자만 로그
|
|
});
|
|
|
|
return {
|
|
success: response.ok,
|
|
statusCode: response.status,
|
|
response: responseText,
|
|
executionTime: 0, // 상위에서 설정됨
|
|
timestamp: new Date(),
|
|
};
|
|
} catch (error) {
|
|
if (error instanceof Error) {
|
|
if (error.name === "AbortError") {
|
|
throw new Error(`요청 시간 초과 (${options.timeout}ms)`);
|
|
}
|
|
throw error;
|
|
}
|
|
throw new Error(`HTTP 요청 실패: ${String(error)}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 템플릿 문자열 처리
|
|
*/
|
|
private processTemplate(
|
|
template: string,
|
|
data?: Record<string, unknown>,
|
|
options: TemplateOptions = {}
|
|
): string {
|
|
if (!data || Object.keys(data).length === 0) {
|
|
return template;
|
|
}
|
|
|
|
const startDelimiter = options.startDelimiter || "{{";
|
|
const endDelimiter = options.endDelimiter || "}}";
|
|
|
|
let result = template;
|
|
|
|
Object.entries(data).forEach(([key, value]) => {
|
|
const placeholder = `${startDelimiter}${key}${endDelimiter}`;
|
|
const replacement = String(value ?? "");
|
|
result = result.replace(new RegExp(placeholder, "g"), replacement);
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* 외부 호출 설정 검증
|
|
*/
|
|
validateSettings(settings: SupportedExternalCallSettings): {
|
|
valid: boolean;
|
|
errors: string[];
|
|
} {
|
|
const errors: string[] = [];
|
|
|
|
if (settings.callType === "rest-api") {
|
|
switch (settings.apiType) {
|
|
case "slack":
|
|
const slackSettings = settings as SlackSettings;
|
|
if (!slackSettings.webhookUrl)
|
|
errors.push("슬랙 웹훅 URL이 필요합니다.");
|
|
if (!slackSettings.message) errors.push("슬랙 메시지가 필요합니다.");
|
|
break;
|
|
|
|
case "kakao-talk":
|
|
const kakaoSettings = settings as KakaoTalkSettings;
|
|
if (!kakaoSettings.accessToken)
|
|
errors.push("카카오톡 액세스 토큰이 필요합니다.");
|
|
if (!kakaoSettings.message)
|
|
errors.push("카카오톡 메시지가 필요합니다.");
|
|
break;
|
|
|
|
case "discord":
|
|
const discordSettings = settings as DiscordSettings;
|
|
if (!discordSettings.webhookUrl)
|
|
errors.push("디스코드 웹훅 URL이 필요합니다.");
|
|
if (!discordSettings.message)
|
|
errors.push("디스코드 메시지가 필요합니다.");
|
|
break;
|
|
|
|
case "generic":
|
|
default:
|
|
const genericSettings = settings as GenericApiSettings;
|
|
if (!genericSettings.url) errors.push("API URL이 필요합니다.");
|
|
if (!genericSettings.method) errors.push("HTTP 메서드가 필요합니다.");
|
|
break;
|
|
}
|
|
} else if (settings.callType === "email") {
|
|
const emailSettings = settings as EmailSettings;
|
|
if (!emailSettings.smtpHost) errors.push("SMTP 호스트가 필요합니다.");
|
|
if (!emailSettings.toEmail) errors.push("수신 이메일이 필요합니다.");
|
|
if (!emailSettings.subject) errors.push("이메일 제목이 필요합니다.");
|
|
}
|
|
|
|
return {
|
|
valid: errors.length === 0,
|
|
errors,
|
|
};
|
|
}
|
|
}
|