@uniai-fe/util-functions 0.0.1

package/src/functions/api.ts

@@ -0,0 +1,515 @@
+import { dateFormat } from "./format";
+import { convertObjectToSearchParams } from "./convert";
+import type { CommonPostResponseType } from "@uniai/types";
+
+/**
+ * API; 인프라에 따른 도메인 추출
+ * @desc
+ * - 환경변수 값을 반환
+ * - PUBLIC_NEXT가 붙지 않았으므로 서버에서만 사용 가능
+ * - 별도의 도메인 지정시, URL을 그대로 입력
+ */
+const infraDomain = (infra: "ai" | "db" | "uniai" | string) => {
+  switch (infra) {
+    case "ai":
+      return process.env.AI_API_BASE;
+    case "db":
+      return process.env.DB_API_BASE;
+    case "uniai":
+      return process.env.UNIAI_API_BASE;
+    default:
+      return infra;
+  }
+};
+
+/**
+ * API; 쿼리스트링 생성
+ * @util
+ * @param {unknown} [searchParams] 쿼리스트링으로 변환할 객체
+ * @return {string} 쿼리스트링
+ */
+export const getQueryString = (searchParams?: unknown): string =>
+  typeof searchParams !== "undefined" &&
+  convertObjectToSearchParams(searchParams).toString()
+    ? `?${convertObjectToSearchParams(searchParams).toString()}`
+    : "";
+
+/**
+ * API; POST/DELETE method option
+ */
+const getFetchOptions = ({
+  method,
+  headers,
+  body,
+}: {
+  method: string;
+} & Partial<{
+  headers: HeadersInit;
+  body: BodyInit | null;
+}>): RequestInit => {
+  const option: RequestInit = { method };
+  // API fetch Headers
+  if (typeof headers !== "undefined") Object.assign(option, { headers });
+  // API fetch Body
+  if (typeof body !== "undefined") Object.assign(option, { body });
+  return option;
+};
+
+/**
+ * API 요청 url 생성; GET 타입
+ * @util
+ * @param {object} props
+ * @param {"ai" | "db" | string} props.infra API 인프라
+ * @param {string} props.routeUrl Next.js /app/api 라우트 주소
+ * @param {string} props.queryUrl 백엔드 API url
+ * @param {URLSearchParams} [props.searchParams] 쿼리 스트링 추출
+ * @param {object} [props.log] 디버깅용 서버 로그 정보
+ * @param {boolean} [props.logDisabled] 로그 비활성화
+ * @return {string} GET API 요청 full url
+ */
+export const generateBackendQueryUrl_GET = ({
+  infra,
+  routeUrl,
+  queryUrl,
+  searchParams, // 가공이 완료된 파라미터
+  log,
+  logDisabled,
+}: {
+  /**
+   * API 인프라
+   * - ai: AI API
+   * - db: DB API
+   * - uniai: UNIAI API
+   * - string: 직접 입력한 도메인
+   */
+  infra: "ai" | "db" | "uniai" | string;
+  /**
+   * Next.js /app/api 라우트 주소
+   */
+  routeUrl: string;
+  /**
+   * 백엔드 API url
+   */
+  queryUrl: string;
+} & Partial<{
+  /**
+   * 쿼리 스트링
+   * @desc
+   * - URLSearchParams 객체로 가공된 파라미터
+   */
+  searchParams: URLSearchParams | object;
+  /**
+   * 디버깅용 서버 로그 정보
+   */
+  log: object;
+  /**
+   * 로그 비활성화
+   * @default false
+   */
+  logDisabled: boolean;
+}>): string => {
+  // API 인프라에 따른 요청 도메인 추출
+  const DOMAIN = infraDomain(infra);
+
+  // url 생성
+  const url = `${DOMAIN}${queryUrl}${getQueryString(searchParams)}`;
+
+  // 서버 로그 출력
+  if (!logDisabled)
+    nextAPILog("get", routeUrl, url, {
+      ...log,
+      ...(searchParams ? searchParams : {}),
+    });
+
+  return url;
+};
+
+/**
+ * API fetch 요청; POST/DELETE 타입
+ * @util
+ * @param {object} props
+ * @param {"ai" | "db" | string} props.infra API 인프라
+ * @param {"POST" | "DELETE"} props.method POST, DELETE
+ * @param {string} props.routeUrl Next.js /app/api 라우트 주소
+ * @param {string} props.queryUrl 백엔드 API url
+ * @param {HeadersInit} [props.headers] fetch Headers
+ * @param {BodyInit | null} [props.body] post/delete body (이대로 바로 전송됨)
+ * @param {object} [props.bodyData] body로 전송하기 위해 가공이 필요한 데이터 객체
+ * @param {object} [props.queryStringData] url에 쿼리스트링으로 요청하는 경우에 대한 데이터 객체
+ * @param {object} [props.log] 디버깅용 서버 로그 정보
+ * @param {boolean} [props.logDisabled] 로그 비활성화
+ * @param {boolean} [props.fetchDisabled] fetch 실행 비활성화
+ * @return {Promise<MutateAPICommonResponseType>} POST, DELETE 응답
+ */
+export const fetchBackendQuery = async <
+  FetchRequestType extends object,
+  FetchResponseType extends CommonPostResponseType,
+>({
+  infra,
+  method,
+  routeUrl,
+  queryUrl,
+  headers,
+  body,
+  bodyOriginData,
+  queryStringData,
+  log,
+  logDisabled,
+  fetchDisabled,
+}: {
+  /**
+   * API 인프라
+   * - ai: AI API
+   * - db: DB API
+   * - uniai: UNIAI API
+   * - string: 직접 입력한 도메인
+   */
+  infra: "ai" | "db" | "uniai" | string;
+  /**
+   * 요청 방식
+   * POST, DELETE
+   */
+  method: "POST" | "DELETE";
+  /**
+   * 프론트 API URL
+   */
+  routeUrl: string;
+  /**
+   * 백엔드 API 요청 URL
+   */
+  queryUrl: string;
+} & Partial<{
+  /**
+   * fetch Headers
+   */
+  headers: HeadersInit;
+  /**
+   * fetch Body
+   */
+  body: BodyInit | null;
+  /**
+   * fetch Body 를 SearchParams 전환할 데이터
+   */
+  bodyOriginData: FetchRequestType;
+  /**
+   * URL 쿼리 스트링
+   */
+  queryStringData: FetchRequestType;
+  /**
+   * 디버그용 로그 객체
+   */
+  log: object;
+  /**
+   * 로그 비활성화
+   */
+  logDisabled: boolean;
+  /**
+   * fetch 비활성화
+   */
+  fetchDisabled: boolean;
+}>): Promise<FetchResponseType> => {
+  // API 인프라에 따른 요청 도메인 추출
+  const DOMAIN = infraDomain(infra);
+
+  // 쿼리 url 생성
+  const url = `${DOMAIN}${queryUrl}${getQueryString(queryStringData)}`;
+
+  // 에러 응답
+  const errRes: FetchResponseType = {
+    is_ok: false,
+    idx: "",
+    error: "",
+  } as FetchResponseType;
+
+  const bodyData = convertObjectToSearchParams(bodyOriginData);
+
+  // bodyOriginData가 undefined가 아닌데도, bodyOriginData의 데이터가 유효하지 않은 경우
+  if (typeof bodyOriginData !== "undefined" && bodyData.toString() === "") {
+    if (!logDisabled) {
+      nextAPILog(method.toLowerCase(), routeUrl, url, {
+        state: "ERROR (BODY - ORIGIN DATA)",
+        error: "데이터가 유효하지 않습니다.",
+        bodyOriginData,
+        ...log,
+      });
+    }
+    errRes.error = "데이터가 유효하지 않습니다.";
+    return errRes;
+  }
+
+  // 쿼리 옵션 생성
+  const option: RequestInit = getFetchOptions({
+    method,
+    headers,
+    body,
+  });
+  if (!body && typeof bodyOriginData !== "undefined")
+    Object.assign(option, { body: bodyData });
+
+  // 로그 옵션
+  if (!logDisabled) {
+    // 쿼리 전 로그 출력
+    nextAPILog(method.toLowerCase(), routeUrl, url, {
+      state: "READY",
+      ...option,
+      ...log,
+    });
+  }
+
+  // 디버깅을 위한 fetch 요청 제한
+  if (fetchDisabled) {
+    errRes.error = "API 요청제한 활성화됨.";
+    return errRes;
+  }
+
+  try {
+    const res: FetchResponseType = await (await fetch(url, option)).json();
+
+    if (!logDisabled) {
+      // API 응답 성공 여부
+      const isSuccess =
+        "is_ok" in res && typeof res?.is_ok === "boolean" && res.is_ok === true;
+
+      nextAPILog(method.toLowerCase(), routeUrl, url, {
+        state: isSuccess ? "SUCCESS" : "FAIL",
+        ...res,
+      });
+    }
+
+    return res;
+  } catch (error: unknown) {
+    errRes.error =
+      error instanceof Error
+        ? error.message || "알 수 없는 오류가 발생하였습니다."
+        : String(error);
+
+    if (!logDisabled) {
+      nextAPILog(method.toLowerCase(), routeUrl, url, {
+        state: "ERROR (RESPONSE)",
+        error,
+        ...log,
+      });
+    }
+
+    return errRes;
+  }
+};
+
+/**
+ * 콘솔로그; Next.js API Route 디버깅용
+ * @util
+ * @param {string} method GET, POST, DELETE
+ * @param {string} routeUrl Next.js route API route URL
+ * @param {string} [queryUrl] DB API route URL
+ * @param {unknown[]} [messages] 로그 데이터
+ */
+export const nextAPILog = (
+  method: string,
+  routeUrl: string,
+  queryUrl?: string,
+  ...messages: unknown[]
+) => {
+  if (process.env.NODE_ENV === "production") return;
+
+  const DATE = dateFormat(new Date());
+  const TIME =
+    new Intl.DateTimeFormat("en-US", {
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric",
+      hour12: false,
+    }).format(new Date()) +
+    "." +
+    new Date().getMilliseconds();
+
+  const REQUEST_METHOD = method.split("-")[0]?.toUpperCase() || "-";
+  const RESPONSE_METHOD = method.split("-")[1]
+    ? method.split("-")[1]?.toUpperCase() || "-"
+    : REQUEST_METHOD;
+
+  return console.log(
+    // `⚡️`,
+    `\n`,
+    `[Next Server API] ⏱ ${DATE} ( ${TIME} )`,
+    `\n  λ [${REQUEST_METHOD}] FE route`,
+    `\n   ${routeUrl}`,
+    ...(queryUrl
+      ? [`\n  ═⏵ Ω [${RESPONSE_METHOD}] BE url`, `\n   ${queryUrl}`, `\n`]
+      : []),
+    ...(messages?.[0] ? [` ◇-`, ...messages] : []),
+    `\n`,
+  );
+};
+
+/**
+ * API; POST/DELETE method fetch
+ * @util
+ * @param {object} props
+ * @param {"ai" | "db" | string} props.infra API 인프라
+ * @param {"POST" | "DELETE"} props.method POST, DELETE
+ * @param {string} props.routeUrl Next.js /app/api 라우트 주소
+ * @param {string} props.queryUrl 백엔드 API url
+ * @param {HeadersInit} [props.headers] fetch Headers
+ * @param {BodyInit | null} [props.body] post/delete body (이대로 바로 전송됨)
+ * @param {object} [props.bodyData] body로 전송하기 위해 가공이 필요한 데이터 객체
+ * @param {object} [props.log] 디버깅용 서버 로그 정보
+ * @param {boolean} [props.logDisabled] 로그 비활성화
+ * @param {boolean} [props.fetchDisabled] fetch 실행 비활성화
+ * @param {object} [props.alternateResponse] fetch 실패 시 대체 응답
+ * @return {Promise<ResponseType>} POST, DELETE 응답
+ */
+export const fetchWithBody = async <
+  BodyDataType = object,
+  ResponseType extends object | Response = Response,
+>({
+  infra,
+  method,
+  routeUrl,
+  queryUrl,
+  searchParams,
+  headers,
+  body,
+  bodyData,
+  isRawResponse,
+  alternateResponse,
+  debug,
+  disabled,
+  disabledLog,
+}: {
+  /**
+   * API 인프라
+   * - ai: AI API
+   * - db: DB API
+   * - string: 직접 입력한 도메인
+   */
+  infra: "ai" | "db" | "uniai" | string;
+  /**
+   * 요청 방식
+   * POST, DELETE
+   */
+  method: string;
+  /**
+   * 프론트 API URL
+   */
+  routeUrl: string;
+  /**
+   * 백엔드 API 요청 URL
+   */
+  queryUrl: string;
+  /**
+   * fetch 실패 시 대체 응답
+   */
+  alternateResponse: ResponseType;
+} & Partial<{
+  searchParams: URLSearchParams | object;
+  /**
+   * fetch Headers
+   */
+  headers: HeadersInit;
+  /**
+   * fetch Body
+   */
+  body: BodyInit | null;
+  /**
+   * fetch Body Data
+   */
+  bodyData: BodyDataType;
+  /**
+   * 응답값 원본으로 return
+   * const responseRaw = await fetch(api);
+   */
+  isRawResponse: boolean;
+  /**
+   * 디버그용 로그 객체
+   */
+  debug: object;
+  /**
+   * fetch 비활성화
+   */
+  disabled: boolean;
+  /**
+   * 로그 비활성화
+   */
+  disabledLog: boolean;
+}>): Promise<ResponseType> => {
+  // ------------------------------------- API 요청 URL 생성
+  // API 인프라에 따른 요청 도메인 추출
+  const DOMAIN = infraDomain(infra);
+
+  // url 생성
+  const url = `${DOMAIN}${queryUrl}${getQueryString(searchParams)}`;
+
+  // ------------------------------------- 쿼리 옵션 생성
+  const option: RequestInit = getFetchOptions({
+    method,
+    headers,
+    body,
+  });
+
+  // ------------------------------------- body data 적용
+  // 완성된 body가 없고, body 데이터는 있는 경우
+  if (!body && typeof bodyData !== "undefined") {
+    // bodyData가 undefined가 아닌데도, bodyData의 데이터가 유효하지 않은 경우
+    if (typeof bodyData !== "undefined" && String(bodyData) === "") {
+      nextAPILog(method.toLowerCase(), routeUrl, url, {
+        state: "ERROR (BODY - DATA)",
+        error: "데이터가 유효하지 않습니다.",
+        bodyData,
+        ...debug,
+      });
+
+      return alternateResponse;
+    }
+
+    // option에 bodyData 적용
+    Object.assign(option, { body: bodyData });
+  }
+
+  // option 준비가 완료되면, READY 상태
+  if (!disabledLog)
+    nextAPILog(method.toLowerCase(), routeUrl, url, {
+      state: "READY",
+      ...option,
+      ...debug,
+    });
+
+  // ------------------------------------- fetch 요청
+  if (disabled) {
+    // fetch 요청 비활성화
+    nextAPILog(method.toLowerCase(), routeUrl, url, {
+      state: "FETCH DISABLED",
+      message: "API 요청제한 활성화됨.",
+    });
+    return alternateResponse;
+  }
+
+  try {
+    const responseRaw = await fetch(url, option);
+
+    // API 응답 상태 코드
+    const resCode = responseRaw.status;
+
+    // API 응답 성공 여부
+    if (!disabledLog) {
+      nextAPILog(method.toLowerCase(), routeUrl, url, {
+        state: resCode === 200 ? "SUCCESS" : "FAIL",
+        code: resCode,
+      });
+    }
+
+    if (isRawResponse) return responseRaw as ResponseType;
+
+    const res = await responseRaw.json();
+    return res;
+  } catch (error: unknown) {
+    // 에러 응답
+    if (!disabledLog)
+      nextAPILog(method.toLowerCase(), routeUrl, url, {
+        state: "ERROR (RESPONSE)",
+        error,
+        ...debug,
+      });
+
+    return alternateResponse;
+  }
+};