tk-factory-services/system1-factory/web/js/api-config.js

// api-config.js - nginx 프록시 대응 API 설정
import { config } from './config.js';
import { redirectToLogin } from './navigation.js';

function getApiBaseUrl() {
  const hostname = window.location.hostname;
  const protocol = window.location.protocol;
  const port = window.location.port;


  // 🔗 외부 도메인 (Cloudflare Tunnel) - Gateway nginx가 /api/를 프록시
  if (hostname.includes('technicalkorea.net')) {
    const baseUrl = `${protocol}//${hostname}${config.api.path}`;
    return baseUrl;
  }

  // 🔗 로컬/내부 네트워크 - API 포트 직접 접근
  if (hostname.startsWith('192.168.') || hostname.startsWith('10.') || hostname.startsWith('172.') ||
      hostname === 'localhost' || hostname === '127.0.0.1' ||
      hostname.includes('.local') || hostname.includes('hyungi')) {
    const baseUrl = `${protocol}//${hostname}:${config.api.port}${config.api.path}`;
    return baseUrl;
  }

  // 🚨 기타: 포트 없이 상대 경로
  const baseUrl = `${protocol}//${hostname}${config.api.path}`;
  return baseUrl;
}

// API 설정
const API_URL = getApiBaseUrl();

// 전역 변수로 설정 (api-base.js가 이미 설정한 경우 유지)
if (!window.API) window.API = API_URL;
if (!window.API_BASE_URL) window.API_BASE_URL = API_URL;

function ensureAuthenticated() {
  const token = localStorage.getItem('sso_token');
  if (!token || token === 'undefined' || token === 'null') {
    clearAuthData(); // 만약을 위해 한번 더 정리
    redirectToLogin();
    return false; // 이후 코드 실행 방지
  }
  
  // 토큰 만료 확인
  if (isTokenExpired(token)) {
    clearAuthData();
    alert('세션이 만료되었습니다. 다시 로그인해주세요.');
    redirectToLogin();
    return false;
  }
  
  return token;
}

// 토큰 만료 확인 함수
function isTokenExpired(token) {
  try {
    const b = atob(token.split('.')[1].replace(/-/g,'+').replace(/_/g,'/'));
    const payload = JSON.parse(new TextDecoder().decode(Uint8Array.from(b, c => c.charCodeAt(0))));
    const currentTime = Math.floor(Date.now() / 1000);
    return payload.exp < currentTime;
  } catch (error) {
    console.error('토큰 파싱 오류:', error);
    return true; // 파싱 실패 시 만료된 것으로 간주
  }
}

// 인증 데이터 정리 함수
function clearAuthData() {
  localStorage.removeItem('sso_token');
  localStorage.removeItem('sso_user');
  // SSO 쿠키도 삭제 (로그인 페이지 자동 리다이렉트 방지)
  var cookieDomain = window.location.hostname.includes('technicalkorea.net')
    ? '; domain=.technicalkorea.net' : '';
  document.cookie = 'sso_token=; path=/; max-age=0' + cookieDomain;
  document.cookie = 'sso_user=; path=/; max-age=0' + cookieDomain;
  document.cookie = 'sso_refresh_token=; path=/; max-age=0' + cookieDomain;
}

function getAuthHeaders() {
  const token = localStorage.getItem('sso_token');
  return {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${token}`
  };
}

// 🔧 개선된 API 호출 함수 (에러 처리 강화)
async function apiCall(url, method = 'GET', data = null) {
  // 상대 경로를 절대 경로로 변환
  const fullUrl = url.startsWith('http') ? url : `${API}${url}`;
  
  const options = {
    method: method,
    headers: {
      'Content-Type': 'application/json',
      ...getAuthHeaders()
    }
  };

  // POST/PUT 요청시 데이터 추가
  if (data && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
    options.body = JSON.stringify(data);
  }

  try {
    const response = await fetch(fullUrl, options);
    
    // 인증 만료 처리
    if (response.status === 401) {
      clearAuthData();
      alert('세션이 만료되었습니다. 다시 로그인해주세요.');
      redirectToLogin();
      throw new Error('인증에 실패했습니다.');
    }

    // 응답 실패 처리
    if (!response.ok) {
      let errorMessage = `HTTP ${response.status}`;
      try {
        const contentType = response.headers.get('content-type');

        if (contentType && contentType.includes('application/json')) {
          const errorData = await response.json();
  
          // 에러 메시지 추출 (여러 형식 지원)
          if (typeof errorData === 'string') {
            errorMessage = errorData;
          } else if (errorData.error) {
            errorMessage = typeof errorData.error === 'string'
              ? errorData.error
              : JSON.stringify(errorData.error);
          } else if (errorData.message) {
            errorMessage = errorData.message;
          } else if (errorData.details) {
            errorMessage = errorData.details;
          } else {
            errorMessage = `HTTP ${response.status}: ${JSON.stringify(errorData)}`;
          }
        } else {
          const errorText = await response.text();
            errorMessage = errorText || errorMessage;
        }
      } catch (e) {
        // 파싱 실패해도 HTTP 상태 코드는 전달
      }
      throw new Error(errorMessage);
    }

    const result = await response.json();
    return result;

  } catch (error) {

    // 네트워크 오류 vs 서버 오류 구분
    if (error.name === 'TypeError' && error.message.includes('fetch')) {
      throw new Error('네트워크 연결 오류입니다. 인터넷 연결을 확인해주세요.');
    }

    throw error;
  }
}


// API 헬퍼 함수들
async function apiGet(url) {
  return apiCall(url, 'GET');
}

async function apiPost(url, data) {
  return apiCall(url, 'POST', data);
}

async function apiPut(url, data) {
  return apiCall(url, 'PUT', data);
}

async function apiDelete(url) {
  return apiCall(url, 'DELETE');
}

// 전역 함수로 설정 (api-base.js가 이미 등록한 것은 덮어쓰지 않음)
window.ensureAuthenticated = ensureAuthenticated;
if (!window.getAuthHeaders) window.getAuthHeaders = getAuthHeaders;
if (!window.apiCall) window.apiCall = apiCall;
window.apiGet = apiGet;
window.apiPost = apiPost;
window.apiPut = apiPut;
window.apiDelete = apiDelete;
window.isTokenExpired = isTokenExpired;
if (!window.clearAuthData) window.clearAuthData = clearAuthData;

// 주기적으로 토큰 만료 확인 (5분마다)
setInterval(() => {
  const token = localStorage.getItem('sso_token');
  if (token && isTokenExpired(token)) {
    clearAuthData();
    alert('세션이 만료되었습니다. 다시 로그인해주세요.');
    redirectToLogin();
  }
}, config.app.tokenRefreshInterval);

// ES6 모듈 export
export { API_URL as API_BASE_URL, API_URL as API, apiCall, getAuthHeaders };