sales-frontend-api 0.0.1 → 0.0.3

package/dist/server.js

@@ -0,0 +1,742 @@
+import axios from 'axios';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/http-client/custom-error.ts
+var CustomError = class extends Error {
+  constructor({
+    elapsedTime,
+    errorCode,
+    errorMsg,
+    returnCode,
+    returnData,
+    returnMsg,
+    error,
+    config,
+    requestData
+  }) {
+    super();
+    __publicField(this, "elapsedTime");
+    __publicField(this, "errorCode");
+    __publicField(this, "errorMsg");
+    __publicField(this, "returnCode");
+    __publicField(this, "returnData");
+    __publicField(this, "returnMsg");
+    __publicField(this, "error");
+    __publicField(this, "config");
+    __publicField(this, "requestData");
+    this.elapsedTime = elapsedTime;
+    this.errorCode = errorCode;
+    this.errorMsg = errorMsg;
+    this.returnCode = returnCode;
+    this.returnData = returnData;
+    this.returnMsg = returnMsg;
+    this.error = error;
+    this.config = config;
+    this.requestData = requestData;
+  }
+};
+
+// src/http-client/fetch/ssr-error-handler-fetch.ts
+var SsrErrorHandlerFetch = class {
+  constructor() {
+    __publicField(this, "localThrow");
+    __publicField(this, "globalCheck");
+    this.globalCheck = false;
+  }
+  setGlobalCheck(global) {
+    this.globalCheck = !!global;
+  }
+  /**
+   * ssr용 에러 throw
+   * 에러코드에 맞는 ServerError에러 객체를 throw 및 Sentry 리포팅 영역
+   */
+  globalThrow(error, config) {
+    const { returnCode, requestData, returnData } = error;
+    if (returnData) {
+      if (!!returnCode && returnCode >= 400 && returnCode < 500) {
+        if (returnCode === 401) {
+          error.errorMsg = "\uC778\uC99D \uC2E4\uD328";
+          return error;
+        }
+        if (returnCode === 403) {
+          error.errorMsg = "\uAD8C\uD55C \uC5C6\uC74C: \uC811\uADFC \uAC70\uBD80";
+          return error;
+        }
+      }
+      if (!!returnCode && returnCode >= 500 && returnCode < 600) {
+        error.errorMsg = `\uC11C\uBC84 \uC624\uB958 \uBC1C\uC0DD: ${returnCode}`;
+        return error;
+      }
+      error.errorMsg = `\uC54C \uC218 \uC5C6\uB294 \uC624\uB958 \uCF54\uB4DC: ${returnCode}`;
+      return error;
+    } else if (requestData) {
+      error.errorMsg = "\uC694\uCCAD\uC774 \uC774\uB8E8\uC5B4 \uC84C\uC73C\uB098 \uC751\uB2F5\uC744 \uBC1B\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.";
+      return error;
+    }
+  }
+  setLocalHandler(func) {
+    this.localThrow = func;
+  }
+  do(error, config) {
+    const defaultError = new CustomError({
+      elapsedTime: "",
+      errorCode: "",
+      errorMsg: "default Error",
+      requestData: "",
+      returnData: "",
+      returnCode: 0,
+      returnMsg: "",
+      error,
+      config
+    });
+    const result = this.localThrow && this.localThrow(error, config);
+    if (this.globalCheck) {
+      throw result || this.globalThrow(error, config) || defaultError;
+    }
+    throw defaultError;
+  }
+  /**
+   * serverError 설정값에 따른 에러 처리 추가영역
+   */
+  errorHandler(e) {
+    if (e instanceof CustomError) {
+      const { returnData, requestData, message, returnCode } = e;
+      if (returnData) {
+        console.error("\uC694\uCCAD\uC774 \uC774\uB8E8\uC5B4\uC84C\uC73C\uBA70 \uC11C\uBC84\uAC00 2xx\uC758 \uBC94\uC704\uB97C \uBC97\uC5B4\uB098\uB294 \uC0C1\uD0DC \uCF54\uB4DC\uB85C \uC751\uB2F5\uD588\uC2B5\uB2C8\uB2E4.");
+        console.error("HTTP data, status, headers:::", returnData, returnCode);
+      } else if (requestData) {
+        console.error("\uC694\uCCAD\uC774 \uC774\uB8E8\uC5B4\uC84C\uC73C\uB098 \uC751\uB2F5\uC744 \uBC1B\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.");
+        console.error(requestData);
+      } else {
+        console.error("\uC624\uB958\uB97C \uBC1C\uC0DD\uC2DC\uD0A8 \uC694\uCCAD\uC744 \uC124\uC815\uD558\uB294 \uC911\uC5D0 \uBB38\uC81C\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.");
+        console.error("Error", message);
+      }
+      switch (e.returnCode) {
+              }
+    }
+  }
+};
+var ssrErrorHandlerFetch = new SsrErrorHandlerFetch();
+
+// src/http-client/abstract-http-client.ts
+var AbstractHttpClient = class {
+};
+
+// src/http-client/fetch/fetch-instance.ts
+var FetchInstance = class {
+  constructor(config) {
+    /**
+     * fetch 인스턴스 생성시 기본설정값 및 기타 필요한 정보들을 추가 가능
+     */
+    __publicField(this, "config");
+    __publicField(this, "interceptors", {
+      request: [],
+      response: []
+    });
+    this.config = config;
+  }
+  async doFetch(config) {
+    const finalConfig = await this.handleRequest(config);
+    const { headers, method, fetchOptions, body } = finalConfig;
+    const url = config.baseURL + this.getUrlWithParams(finalConfig);
+    const finalHeaders = new Headers(headers);
+    const options = {
+      method,
+      mode: "same-origin",
+      //동일사이트만 허용
+      cache: "no-store",
+      //민감정보를 다룰경우: 캐시에 데이터저장없이, 항상 최신 데이터유지
+      credentials: "same-origin",
+      referrerPolicy: "same-origin",
+      ...fetchOptions,
+      headers: finalHeaders
+    };
+    if (!!body) {
+      if (typeof body === "object" && body !== null && !(body instanceof FormData) && !(body instanceof Blob) && !(body instanceof URLSearchParams)) {
+        finalHeaders.set("Content-Type", "application/json");
+        options.body = JSON.stringify(body);
+      } else {
+        options.body = body;
+      }
+    }
+    const result = new Promise((resolve, reject) => {
+      fetch(url, options).then(async (response) => {
+        const customResponse = {
+          response,
+          config: finalConfig,
+          data: await response.json()
+        };
+        return this.handleResponse(customResponse);
+      }).then((interceptedCustomResponse) => {
+        resolve(interceptedCustomResponse.data);
+      }).catch((e) => {
+        if (e instanceof Error) {
+          reject(
+            this.handleResponseError(
+              new CustomError({
+                elapsedTime: "",
+                errorCode: "",
+                errorMsg: e.message,
+                returnCode: 0,
+                returnData: "",
+                returnMsg: "",
+                error: e,
+                config: finalConfig,
+                requestData: finalConfig.body
+              })
+            )
+          );
+        }
+      });
+    });
+    return result;
+  }
+  getUrlWithParams(config) {
+    const { params } = config || {};
+    const url = config?.url || "";
+    if (!params) {
+      return url;
+    }
+    const sanitizedParams = {};
+    for (const [key, value] of Object.entries(params)) {
+      if (typeof value !== "undefined" && value !== null) {
+        sanitizedParams[key] = String(value);
+      }
+    }
+    const queryString = new URLSearchParams(sanitizedParams).toString();
+    const delimiter = url.indexOf("?") === -1 ? "?" : "&";
+    return queryString ? `${url}${delimiter}${queryString}` : url;
+  }
+  async get(url, config) {
+    const finalConfig = {
+      ...this.config,
+      ...config,
+      url,
+      method: "GET"
+    };
+    return this.doFetch(finalConfig);
+  }
+  async post(url, data, config) {
+    const finalConfig = {
+      ...this.config,
+      ...config,
+      url,
+      method: "POST",
+      body: data
+    };
+    return this.doFetch(finalConfig);
+  }
+  async put(url, data, config) {
+    const finalConfig = {
+      ...this.config,
+      ...config,
+      url,
+      method: "PUT",
+      body: data
+    };
+    return this.doFetch(finalConfig);
+  }
+  async delete(url, data, config) {
+    const finalConfig = {
+      ...this.config,
+      ...config,
+      url,
+      method: "DELETE",
+      body: data
+    };
+    return this.doFetch(finalConfig);
+  }
+  addRequestInterceptor(onFulfilled, onRejected = (e) => e) {
+    this.interceptors.request.push({
+      onFulfilled,
+      onRejected
+    });
+  }
+  addResponseInterceptor(onFulfilled, onRejected = (e) => e) {
+    this.interceptors.response.push({
+      onFulfilled,
+      onRejected
+    });
+  }
+  async getValue(val) {
+    if (typeof val.then === "function") {
+      return await val;
+    } else {
+      return val;
+    }
+  }
+  async handleRequest(config) {
+    let _config = config;
+    for (const interceptor of this.interceptors.request) {
+      const { onFulfilled, onRejected } = interceptor;
+      try {
+        _config = {
+          ...this.config,
+          ..._config,
+          ...await this.getValue(onFulfilled(_config))
+        };
+      } catch (e) {
+        if (e instanceof Error) {
+          await onRejected(
+            new CustomError({
+              elapsedTime: "",
+              errorCode: "",
+              errorMsg: e.message,
+              returnCode: 0,
+              returnData: "",
+              returnMsg: "",
+              error: e,
+              config: _config,
+              requestData: _config.body
+            })
+          );
+        }
+      }
+    }
+    return _config;
+  }
+  async handleResponse(customResponse) {
+    let _customResponse = customResponse;
+    for (const interceptor of this.interceptors.response) {
+      const { onFulfilled } = interceptor;
+      _customResponse = {
+        ..._customResponse,
+        ...await this.getValue(onFulfilled(_customResponse))
+      };
+    }
+    return _customResponse;
+  }
+  async handleResponseError(e) {
+    for (const interceptor of this.interceptors.response) {
+      const { onRejected } = interceptor;
+      await onRejected(e);
+    }
+  }
+};
+
+// src/http-client/fetch/http-client-fetch.ts
+var defaultConfig = {
+  method: "GET"
+};
+var HttpClientFetch = class extends AbstractHttpClient {
+  constructor(config) {
+    super();
+    __publicField(this, "errorHandler");
+    /**
+     * HttpClientFetch request interceptor 동작시, 헤더에 주입될 헤더의 key,value
+     */
+    __publicField(this, "headers");
+    /**
+     * fetch 인스턴스 생성시 기본설정값 및 기타 필요한 정보들을 추가 가능
+     */
+    __publicField(this, "config");
+    /**
+     * api연동을 수행할 실제 객체(axios, fetch 등의 다른 라이브러리로 교체가능한 영역)
+     * 현재 버전에서는 axios를 사용하여 구현됨.
+     */
+    __publicField(this, "api");
+    if (!this.headers) {
+      this.headers = {};
+    }
+    this.config = config || defaultConfig;
+    this.errorHandler = null;
+    this.api = new FetchInstance(this.config);
+    this.api.addRequestInterceptor((config2) => {
+      const headerEntries = Object.entries(this.headers);
+      const headers = new Headers();
+      headerEntries.forEach(([key, value]) => {
+        headers.set(key, value);
+      });
+      config2.headers = headers;
+      return config2;
+    });
+    this.api.addResponseInterceptor((res) => {
+      return res;
+    });
+  }
+  async put(url, data, config) {
+    try {
+      const res = await this.api.put(url, data, config);
+      return res;
+    } catch (e) {
+      throw this.errorHandler && this.errorHandler(e);
+    }
+  }
+  async get(url, config) {
+    try {
+      const res = await this.api.get(url, config);
+      return res;
+    } catch (e) {
+      throw this.errorHandler && this.errorHandler(e);
+    }
+  }
+  async delete(url, config) {
+    try {
+      const res = await this.api.delete(url, config);
+      return res;
+    } catch (e) {
+      throw this.errorHandler && this.errorHandler(e);
+    }
+  }
+  async post(url, data, config) {
+    try {
+      const res = await this.api.post(url, data, config);
+      return res;
+    } catch (e) {
+      throw this.errorHandler && this.errorHandler(e);
+    }
+  }
+  setHeader(key, value) {
+    this.headers[key] = value;
+  }
+};
+
+// src/http-client/fetch/ssr-http-client-fetch.ts
+var initConfig = {
+  baseURL: ""
+};
+var SsrHttpClientFetch = class extends HttpClientFetch {
+  constructor(config) {
+    super({
+      ...initConfig,
+      ...config
+    });
+    this.errorHandler = ssrErrorHandlerFetch.errorHandler;
+    this.api.addRequestInterceptor(
+      (config2) => {
+        return config2;
+      },
+      (e) => {
+        if (e instanceof CustomError) {
+          if (e) {
+            throw ssrErrorHandlerFetch.do(e, this.config);
+          }
+        }
+      }
+    );
+    this.api.addResponseInterceptor(
+      (res) => {
+        return res;
+      },
+      (e) => {
+        if (e instanceof CustomError) {
+          if (e) {
+            throw ssrErrorHandlerFetch.do(e, this.config);
+          }
+        }
+      }
+    );
+  }
+  /**
+   * API 연동 실패시, 에러핸들러 셋팅 (특정페이지에서만 동작하는 개별 핸들러)
+   * @param handler ssrErrorHandler
+   */
+  setLocalErrorHandler(handler) {
+    ssrErrorHandlerFetch.setLocalHandler(handler);
+  }
+};
+__publicField(SsrHttpClientFetch, "query");
+
+// src/http-client/auth/auth-server.ts
+var AuthServer = class {
+  /**
+   * App인지 확인
+   * @returns boolean
+   * @todo 보완필요
+   */
+  isApp(userAgent) {
+    return /mobile|iphone|android/i.test(userAgent);
+  }
+  /**
+   * RT를 이용하여 신규 AT/RT발행
+   * 기존토큰은 무효화처리
+   * 쿠키에 저장.
+   * @returns Promise<string> 액세스토큰
+   */
+  async refreshToken() {
+    const ssrHttpClient = new SsrHttpClientFetch({
+      baseURL: ""
+    });
+    const res = await ssrHttpClient.get("/internal/api/auth/refresh");
+    return res?.data.accessToken;
+  }
+};
+
+// src/http-client/axios/error-handler.ts
+var ErrorHandler = class {
+  constructor() {
+    __publicField(this, "localThrow");
+    /** 개별처리 + 글로벌처리 모두 사용할경우 : true ,  개별처리만 사용할 경우 : false */
+    __publicField(this, "globalCheck");
+    this.globalCheck = true;
+  }
+  /**
+   * csr용 에러 throw
+   * 에러코드에 맞는 ClientError에러 객체를 throw 및 Sentry 리포팅 영역
+   * @todo 에러 응답에 data가 없다면 , config.data(=payload) 를 에러로그로 넣는건 어떨까요?
+   */
+  globalThrow(error, config) {
+    const { response, request, code } = error;
+    if (response) {
+      const { data, status, statusText } = response;
+      const err = new CustomError({
+        elapsedTime: "",
+        errorCode: code || "",
+        errorMsg: "",
+        requestData: config.data,
+        returnData: data,
+        returnCode: status,
+        returnMsg: statusText,
+        error,
+        config
+      });
+      if (status >= 400 && status < 500) {
+        if (status === 401) {
+          err.errorMsg = "\uC778\uC99D \uC2E4\uD328";
+          return err;
+        }
+        if (status === 403) {
+          err.errorMsg = "\uAD8C\uD55C \uC5C6\uC74C: \uC811\uADFC \uAC70\uBD80";
+          return err;
+        }
+      }
+      if (status >= 500 && status < 600) {
+        err.errorMsg = `\uC11C\uBC84 \uC624\uB958 \uBC1C\uC0DD: ${status}`;
+        return err;
+      }
+      err.errorMsg = `\uC54C \uC218 \uC5C6\uB294 \uC624\uB958 \uCF54\uB4DC: ${status}`;
+      return err;
+    } else if (request) {
+      return new CustomError({
+        elapsedTime: "",
+        errorCode: code || "",
+        errorMsg: "\uC694\uCCAD\uC774 \uC774\uB8E8\uC5B4 \uC84C\uC73C\uB098 \uC751\uB2F5\uC744 \uBC1B\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.",
+        requestData: config.data,
+        returnData: "",
+        returnCode: 0,
+        returnMsg: "",
+        error,
+        config
+      });
+    }
+  }
+  setLocalHandler(func) {
+    this.localThrow = func;
+  }
+  do(error, config) {
+    const dialog = config.dialog;
+    if (!dialog) {
+      return;
+    }
+    const res = this.localThrow && this.localThrow(error, config);
+    if (this.globalCheck) {
+      return res || this.globalThrow(error, config);
+    }
+    return res;
+  }
+};
+
+// src/http-client/helper.ts
+var HTTP_STATUS = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  INTERNAL_SERVER_ERROR: 500
+};
+var ApiError = class extends Error {
+  constructor(error, message) {
+    super(message ?? error.message);
+    __publicField(this, "config");
+    __publicField(this, "code");
+    __publicField(this, "request");
+    __publicField(this, "response");
+    __publicField(this, "isAxiosError");
+    __publicField(this, "toJSON");
+    __publicField(this, "cause");
+    const errorStatus = error.response?.status || 0;
+    let name = "apiError";
+    switch (errorStatus) {
+      case HTTP_STATUS.BAD_REQUEST:
+        name = "apiBadRequestError";
+        break;
+      case HTTP_STATUS.UNAUTHORIZED:
+        name = "apiUnauthorizedError";
+        break;
+      case HTTP_STATUS.FORBIDDEN:
+        name = "apiForbiddenError";
+        break;
+      case HTTP_STATUS.NOT_FOUND:
+        name = "apiNotFoundError";
+        break;
+      case HTTP_STATUS.INTERNAL_SERVER_ERROR:
+        name = "apiInternalServerError";
+        break;
+    }
+    this.name = name;
+    this.stack = error.stack;
+    this.config = error.config;
+    this.code = error.code;
+    this.request = error.request;
+    this.response = error.response;
+    this.isAxiosError = error.isAxiosError;
+    this.toJSON = error.toJSON;
+  }
+};
+function logApiErrorToSentry(response) {
+  new ApiError(
+    response,
+    `Request failed:: [${response.config.method?.toUpperCase()}] url: ${response.config.url} ${response.data?.errorCode && `| errorCode: ${response.data?.errorCode} | errorMsg: ${response.data?.errorMsg}`}`
+  );
+}
+
+// src/http-client/axios/ssr-error-handler.ts
+var SsrErrorHandler = class extends ErrorHandler {
+  constructor() {
+    super();
+  }
+  setGlobalCheck(global) {
+    this.globalCheck = !!global;
+  }
+  /**
+   * throw된 serverError 설정값에 따른 에러 처리 추가영역
+   * 별도의 처리가 없다면 작성할 필요없음.
+   */
+  errorHandler(e) {
+    if (e instanceof CustomError) {
+      const { response, request, message } = e.error;
+      if (response) {
+        const { data, status, headers } = response;
+        console.error("\uC694\uCCAD\uC774 \uC774\uB8E8\uC5B4\uC84C\uC73C\uBA70 \uC11C\uBC84\uAC00 2xx\uC758 \uBC94\uC704\uB97C \uBC97\uC5B4\uB098\uB294 \uC0C1\uD0DC \uCF54\uB4DC\uB85C \uC751\uB2F5\uD588\uC2B5\uB2C8\uB2E4.");
+        console.error("HTTP data, status, headers:::", data, status, headers);
+        logApiErrorToSentry(response);
+      } else if (request) {
+        console.error("\uC694\uCCAD\uC774 \uC774\uB8E8\uC5B4\uC84C\uC73C\uB098 \uC751\uB2F5\uC744 \uBC1B\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.");
+        console.error(request);
+      } else {
+        console.error("\uC624\uB958\uB97C \uBC1C\uC0DD\uC2DC\uD0A8 \uC694\uCCAD\uC744 \uC124\uC815\uD558\uB294 \uC911\uC5D0 \uBB38\uC81C\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.");
+        console.error("Error", message);
+      }
+      switch (e.returnCode) {
+              }
+    }
+  }
+};
+var ssrErrorHandler = new SsrErrorHandler();
+var HttpClientAxios = class extends AbstractHttpClient {
+  constructor(config) {
+    super();
+    /**
+     * API연동 실패시, 공통 에러 핸들러
+     * extends된 런타임 동작환경에 맞는 SSR,CSR 방식으로 에러핸들링처리
+     */
+    __publicField(this, "errorHandler");
+    /**
+     * AxiosRequestConfig 를 확장한 interface
+     * axios create시 기본설정값 및 기타 필요한 정보들을 추가 가능
+     */
+    __publicField(this, "config");
+    /**
+     * axios의 request interceptor 동작시, 헤더에 주입될 헤더의 key,value
+     */
+    __publicField(this, "headers");
+    /**
+     * api연동을 수행할 실제 객체(axios, fetch 등의 다른 라이브러리로 교체가능한 영역)
+     * 현재 버전에서는 axios를 사용하여 구현됨.
+     */
+    __publicField(this, "api");
+    if (!this.headers) {
+      this.headers = {};
+    }
+    this.config = config;
+    this.errorHandler = null;
+    this.api = axios.create({
+      baseURL: "\uC804\uCCB4\uACF5\uD1B5URL\uC774 \uC788\uC73C\uBA74 \uC14B\uD305",
+      withCredentials: true,
+      ...config
+    });
+    this.api.interceptors.request.use(async (config2) => {
+      const headerEntries = Object.entries(this.headers);
+      headerEntries.forEach(([key, value]) => {
+        config2.headers.set(key, value);
+      });
+      return config2;
+    });
+  }
+  async put(url, data, config) {
+    try {
+      const res = await this.api.put(url, data, config);
+      return res;
+    } catch (e) {
+      throw this.errorHandler && this.errorHandler(e);
+    }
+  }
+  async get(url, config) {
+    try {
+      const res = await this.api.get(url, config);
+      return res;
+    } catch (e) {
+      throw this.errorHandler && this.errorHandler(e);
+    }
+  }
+  async delete(url, config) {
+    try {
+      const res = await this.api.delete(url, config);
+      return res;
+    } catch (e) {
+      throw this.errorHandler && this.errorHandler(e);
+    }
+  }
+  async post(url, data, config) {
+    try {
+      const res = await this.api.post(url, data, config);
+      return res;
+    } catch (e) {
+      throw this.errorHandler && this.errorHandler(e);
+    }
+  }
+  setHeader(key, value) {
+    this.headers[key] = value;
+  }
+};
+
+// src/http-client/axios/ssr-http-client-axios.ts
+var initConfig2 = {
+  baseURL: "",
+  dialog: true
+};
+var SsrHttpClientAxios = class extends HttpClientAxios {
+  constructor(config) {
+    super({
+      ...initConfig2,
+      ...config
+    });
+    this.errorHandler = ssrErrorHandler.errorHandler;
+    this.api.interceptors.request.use((config2) => {
+      return config2;
+    });
+    this.api.interceptors.response.use(
+      (response) => {
+        return response;
+      },
+      (error) => {
+        throw ssrErrorHandler.do(error, this.config);
+      }
+    );
+  }
+  /**
+   * API 연동 실패시, 에러핸들러 셋팅 (특정페이지에서만 동작하는 개별 핸들러)
+   * @param handler ssrErrorHandler
+   */
+  setLocalErrorHandler(handler) {
+    ssrErrorHandler.setLocalHandler(handler);
+  }
+};
+__publicField(SsrHttpClientAxios, "query");
+
+export { AuthServer, SsrHttpClientAxios, SsrHttpClientFetch, ssrErrorHandler, ssrErrorHandlerFetch };
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map