web-temp/layers/utils/apiUtil.ts

import { ref } from "vue";

/**
 * 공통 API 호출
 *
 * @param {string} method - 요청 메소드 (GET, POST 등)
 * @param {string} url - API URL
 * @param {object} query - 요청 쿼리 파라미터
 * @param {object} headers - 요청 헤더
 * @param {object} body - 요청 본문
 * @param {string} key - 캐시 키
 * @param {object} loading - 로딩 설정
 */
export const commonFetch = async (
  method:
    | "GET"
    | "HEAD"
    | "PATCH"
    | "POST"
    | "PUT"
    | "DELETE"
    | "CONNECT"
    | "OPTIONS"
    | "TRACE" = "GET", // Required
  url: string, // Required
  {
    query, // Optional
    headers, // Optional
    body, // Optional
    key, // Optional
    loading = false, // Optional
  }: {
    query?: object | null;
    headers?: object | null;
    body?: object | null;
    key?: string | null;
    loading?: { localId?: string } | boolean;
  } = {}
) => {
  let result = null;
  const currCallerId = ref("");
  const currCallerDetail = ref("");

  // 로딩 스토어 가져오기 (클라이언트에서만)
  let loadingStore: ReturnType<typeof useLoadingStore> | null = null;
  if (import.meta.client) {
    try {
      loadingStore = useLoadingStore();
      // 로딩 시작
      loadingStore.setLoading(true);
      if (loading && loadingStore) {
        if (typeof loading === "object" && loading.localId) {
          loadingStore.startLocalLoading(loading.localId);
        } else {
          loadingStore.startFullLoading();
        }
      }
    } catch (e) {
      console.warn("[Warning] Loading store not available:", e);
    }
  }

  try {
    const { callerId, callerDetail } = storeToRefs(useCallerInfoStore());
    currCallerId.value = `${callerId.value}`;
    currCallerDetail.value = `${callerDetail.value}`;
  } catch (e) {
    // SSR: pinia store 생성 전이므로 빈 값('') 세팅
  }

  try {
    const options: {
      method:
        | "GET"
        | "HEAD"
        | "PATCH"
        | "POST"
        | "PUT"
        | "DELETE"
        | "CONNECT"
        | "OPTIONS"
        | "TRACE";
      headers: Record<string, string>;
      query?: object;
      body?: object;
      key?: string;
    } = {
      method,
      headers: {
        "Content-Type": "application/json;charset=UTF-8",
      },
    };

    if (query) {
      options.query = query;
    }
    // 플랫폼 환경 API 호출 시 Caller-Id, Caller-Detail 헤더 추가
    if (url.includes(".onstove.com") || url.includes(".gate8.com")) {
      const callerInfo = {
        "Caller-Id": `${currCallerId.value}`,
        "Caller-Detail": `${currCallerDetail.value}`,
      };
      options.headers = { ...options.headers, ...callerInfo };
    }
    if (headers) {
      options.headers = { ...options.headers, ...headers };
    }
    if (body) {
      options.body = body;
    }
    if (key) {
      options.key = key;
    }

    result = await $fetch(url, options);
  } catch (e: unknown) {
    console.error("[Exception] apiUtil.commonFetch: ", e);
    const error = e as {
      data?: unknown;
      statusCode?: number;
      statusMessage?: string;
    };
    result = error.data || {
      code: error.statusCode,
      message: error.statusMessage,
    };
  } finally {
    // 로딩 종료
    if (loadingStore) {
      loadingStore.setLoading(false);
      if (loading) {
        if (typeof loading === "object" && loading.localId) {
          loadingStore.stopLocalLoading(loading.localId);
        } else {
          loadingStore.stopFullLoading();
        }
      }
    }
  }
  return result;
};

/**
 * 사용자 IP 조회
 *
 * @param {object} request - 요청 객체
 */
export const getTrueClientIp = (request: {
  headers: Record<string, string>;
  socket: { remoteAddress?: string };
}) => {
  const requestHeaders = request.headers;
  const targetHeaders = [
    "True-Client-IP",
    "X-Real-IP",
    "X-Forwarded-For",
    "Proxy-Client-IP",
    "WL-Proxy-Client-IP",
    "HTTP_CLIENT_IP",
    "HTTP_X_FORWARDED_FOR",
  ];
  for (const targetHeader of targetHeaders) {
    let ip =
      requestHeaders[targetHeader] ||
      requestHeaders[targetHeader.toLowerCase()];
    if (ip !== undefined && ip != null && ip !== "") {
      if (ip.includes(",")) {
        ip = ip.split(",")[0];
      }
      return ip;
    }
  }
  if (
    request.socket.remoteAddress !== undefined &&
    request.socket.remoteAddress != null &&
    request.socket.remoteAddress !== ""
  ) {
    return request.socket.remoteAddress;
  }
  return "";
};