@wheeparam/library 0.0.4 → 0.0.6

package/dist/client/index.js

@@ -1,166 +1,305 @@
-// src/client/axios.ts
-import axios from "axios";
-function createLocalStorageTokenAccess(keys) {
-  const accessTokenKey = keys?.accessTokenKey ?? "accessToken";
-  const refreshTokenKey = keys?.refreshTokenKey ?? "refreshToken";
+// src/client/createAxiosClient.ts
+import axios, {
+  AxiosHeaders
+} from "axios";
+
+// src/client/error.ts
+var defaultShouldRefresh = (error) => {
+  return error.response?.status === 401;
+};
+function defaultParseRefreshResponse(data) {
+  const source = typeof data === "object" && data !== null ? data : {};
+  const accessToken = typeof source.result?.accessToken === "string" && source.result.accessToken || typeof source.accessToken === "string" && source.accessToken || typeof source.result?.token === "string" && source.result.token || typeof source.token === "string" && source.token || "";
+  const refreshToken = typeof source.result?.refreshToken === "string" && source.result.refreshToken || typeof source.refreshToken === "string" && source.refreshToken || void 0;
+  if (!accessToken) {
+    throw new Error("Refresh response does not contain accessToken");
+  }
   return {
-    get() {
-      return {
-        accessToken: window.localStorage.getItem(accessTokenKey),
-        refreshToken: window.localStorage.getItem(refreshTokenKey)
-      };
+    accessToken,
+    refreshToken
+  };
+}
+function getDefaultErrorMessage(error) {
+  const axiosError = error;
+  const status = axiosError.response?.status;
+  const serverMessage = axiosError.response?.data?.error;
+  if (serverMessage && serverMessage.trim().length > 0) {
+    return serverMessage;
+  }
+  switch (status) {
+    case 0:
+      return "REST API \uC11C\uBC84\uC5D0 \uC811\uADFC\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.\n\uC11C\uBC84 \uAD00\uB9AC\uC790\uC5D0\uAC8C \uBB38\uC758\uD558\uC138\uC694.";
+    case 400:
+      return "\uC798\uBABB\uB41C \uC694\uCCAD\uC785\uB2C8\uB2E4.";
+    case 401:
+      return "\uC778\uC99D\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.";
+    case 403:
+      return "\uC811\uADFC \uAD8C\uD55C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.";
+    case 404:
+      return "[404] REST API \uC694\uCCAD\uC5D0 \uC2E4\uD328\uD558\uC600\uC2B5\uB2C8\uB2E4.";
+    case 500:
+      return "\uC11C\uBC84\uC5D0\uC11C \uCC98\uB9AC \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD558\uC600\uC2B5\uB2C8\uB2E4.";
+    default:
+      return "";
+  }
+}
+
+// src/client/refreshManager.ts
+var RefreshManager = class {
+  constructor() {
+    this.isRefreshing = false;
+    this.subscribers = [];
+  }
+  /**
+   * 현재 refresh 진행 중인지 반환합니다.
+   */
+  get refreshing() {
+    return this.isRefreshing;
+  }
+  /**
+   * refresh 시작 상태로 전환합니다.
+   */
+  begin() {
+    this.isRefreshing = true;
+  }
+  /**
+   * refresh 종료 상태로 전환합니다.
+   */
+  end() {
+    this.isRefreshing = false;
+  }
+  /**
+   * refresh 완료를 기다리는 subscriber를 등록합니다.
+   *
+   * @param callback refresh 완료 후 호출될 함수
+   */
+  subscribe(callback) {
+    this.subscribers.push(callback);
+  }
+  /**
+   * 대기 중인 subscriber들에게 결과를 알리고 큐를 초기화합니다.
+   *
+   * @param token 새 access token
+   */
+  notify(token) {
+    this.subscribers.forEach((callback) => callback(token));
+    this.subscribers = [];
+  }
+};
+async function requestRefresh(params) {
+  const {
+    refreshUrl,
+    withCredentials,
+    refreshStrategy,
+    refreshToken,
+    parseRefreshResponse
+  } = params;
+  const requestInit = {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
     },
-    set(data) {
-      if (data.accessToken !== void 0) {
-        window.localStorage.setItem(accessTokenKey, data.accessToken ?? "");
+    credentials: withCredentials ? "include" : "same-origin"
+  };
+  if (refreshStrategy === "body") {
+    if (!refreshToken) {
+      throw new Error("Refresh token not found");
+    }
+    requestInit.body = JSON.stringify({ refreshToken });
+  }
+  const response = await fetch(refreshUrl, requestInit);
+  if (!response.ok) {
+    throw new Error("Token refresh failed");
+  }
+  const json = await response.json();
+  return parseRefreshResponse(json);
+}
+
+// src/client/tokenStorage.ts
+function createAccessTokenAccess(mode, key = "accessToken") {
+  let memoryToken = null;
+  if (mode === "localStorage") {
+    return {
+      get: () => window.localStorage.getItem(key),
+      set: (token) => {
+        if (!token) {
+          window.localStorage.removeItem(key);
+        } else {
+          window.localStorage.setItem(key, token);
+        }
+      },
+      clear: () => {
+        window.localStorage.removeItem(key);
       }
-      if (data.refreshToken !== void 0) {
-        window.localStorage.setItem(refreshTokenKey, data.refreshToken ?? "");
+    };
+  }
+  if (mode === "memory") {
+    return {
+      get: () => memoryToken,
+      set: (token) => {
+        memoryToken = token;
+      },
+      clear: () => {
+        memoryToken = null;
       }
+    };
+  }
+  return {
+    get: () => null,
+    set: () => {
     },
-    clear() {
-      window.localStorage.removeItem(accessTokenKey);
-      window.localStorage.removeItem(refreshTokenKey);
+    clear: () => {
     }
   };
 }
-function createCookieModeTokenAccess(keys) {
-  const refreshTokenKey = keys?.refreshTokenKey ?? "refreshToken";
+function createRefreshTokenAccess(key = "refreshToken") {
   return {
-    get() {
-      return {
-        accessToken: null,
-        // 쿠키 기반이면 JS에서 accessToken을 직접 읽지 않는 전제를 둔다.
-        refreshToken: window.localStorage.getItem(refreshTokenKey)
-      };
-    },
-    set(data) {
-      if (data.refreshToken !== void 0) {
-        window.localStorage.setItem(refreshTokenKey, data.refreshToken ?? "");
+    get: () => window.localStorage.getItem(key),
+    set: (token) => {
+      if (!token) {
+        window.localStorage.removeItem(key);
+      } else {
+        window.localStorage.setItem(key, token);
       }
     },
-    clear() {
-      window.localStorage.removeItem(refreshTokenKey);
+    clear: () => {
+      window.localStorage.removeItem(key);
     }
   };
 }
+
+// src/client/createAxiosClient.ts
+function setAuthorizationHeader(config, accessToken) {
+  const headers = new AxiosHeaders();
+  if (config.headers) {
+    const current = config.headers instanceof AxiosHeaders ? config.headers.toJSON() : config.headers;
+    for (const [key, value] of Object.entries(current)) {
+      if (value !== void 0) {
+        headers.set(key, String(value));
+      }
+    }
+  }
+  headers.set("Authorization", `Bearer ${accessToken}`);
+  config.headers = headers;
+  return config;
+}
 function createAxiosClient(options) {
   const {
     baseURL,
     timeout = 1e4,
     withCredentials = true,
     refreshUrl,
-    storage = "localStorage",
+    accessTokenStorage = "localStorage",
+    refreshStrategy = "body",
     storageKeys,
     onAuthStateChange,
     onError,
-    getErrorMessage
+    getErrorMessage,
+    shouldRefresh = defaultShouldRefresh,
+    parseRefreshResponse = defaultParseRefreshResponse
   } = options;
-  const instance = axios.create({ baseURL, timeout, withCredentials });
-  const tokenAccess = storage === "localStorage" ? createLocalStorageTokenAccess(storageKeys) : createCookieModeTokenAccess({ refreshTokenKey: storageKeys?.refreshTokenKey });
-  let isRefreshing = false;
-  let subscribers = [];
-  const notifySubscribers = (token) => {
-    subscribers.forEach((cb) => cb(token));
-    subscribers = [];
-  };
+  const accessTokenKey = storageKeys?.accessTokenKey ?? "accessToken";
+  const refreshTokenKey = storageKeys?.refreshTokenKey ?? "refreshToken";
+  const instance = axios.create({
+    baseURL,
+    timeout,
+    withCredentials
+  });
+  const accessTokenAccess = createAccessTokenAccess(accessTokenStorage, accessTokenKey);
+  const refreshTokenAccess = createRefreshTokenAccess(refreshTokenKey);
+  const refreshManager = new RefreshManager();
   const clearAuth = () => {
-    tokenAccess.clear();
+    accessTokenAccess.clear();
+    if (refreshStrategy === "body") {
+      refreshTokenAccess.clear();
+    }
     onAuthStateChange?.("unauthenticated");
   };
-  const requestRefresh = async (refreshToken) => {
-    const res = await fetch(refreshUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ refreshToken }),
-      credentials: withCredentials ? "include" : "same-origin"
-    });
-    if (!res.ok) {
-      throw new Error("Token refresh failed");
+  const getToken = () => {
+    return {
+      accessToken: accessTokenAccess.get(),
+      refreshToken: refreshStrategy === "body" ? refreshTokenAccess.get() : null
+    };
+  };
+  const setToken = (data) => {
+    if (data.accessToken !== void 0) {
+      accessTokenAccess.set(data.accessToken ?? null);
+    }
+    if (refreshStrategy === "body" && data.refreshToken !== void 0) {
+      refreshTokenAccess.set(data.refreshToken ?? null);
     }
-    return await res.json();
   };
   instance.interceptors.request.use(
     (config) => {
-      const { accessToken } = tokenAccess.get();
+      const accessToken = accessTokenAccess.get();
       if (accessToken) {
-        config.headers = config.headers ?? {};
-        config.headers.Authorization = `Bearer ${accessToken}`;
+        setAuthorizationHeader(config, accessToken);
       }
       return config;
     },
-    (e) => Promise.reject(e)
+    (error) => Promise.reject(error)
   );
   instance.interceptors.response.use(
-    (res) => res,
+    (response) => response,
     async (error) => {
-      const response = error.response;
-      const status = response?.status;
       const originalRequest = error.config ?? {};
-      if (status !== 401) {
-        let message = getErrorMessage?.(error) ?? response?.data?.error ?? "";
-        if (!message && typeof status === "number") {
-          switch (status) {
-            case 0:
-              message = "REST API \uC11C\uBC84\uC5D0 \uC811\uADFC\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4\n\uC11C\uBC84 \uAD00\uB9AC\uC790\uC5D0\uAC8C \uBB38\uC758\uD558\uC138\uC694";
-              break;
-            case 400:
-              message = "\uC798\uBABB\uB41C \uC694\uCCAD\uC785\uB2C8\uB2E4.";
-              break;
-            case 404:
-              message = "[404] REST API \uC694\uCCAD\uC5D0 \uC2E4\uD328\uD558\uC600\uC2B5\uB2C8\uB2E4";
-              break;
-            case 500:
-              message = "\uC11C\uBC84\uC5D0\uC11C \uCC98\uB9AC \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD558\uC600\uC2B5\uB2C8\uB2E4.";
-              break;
-          }
+      if (!shouldRefresh(error)) {
+        const message = getErrorMessage?.(error) ?? getDefaultErrorMessage(error);
+        if (message) {
+          onError?.(message, error);
         }
-        if (message) onError?.(message, error);
         return Promise.reject(error);
       }
-      if (originalRequest._retry) {
+      const requestUrl = originalRequest.url ?? "";
+      if (typeof requestUrl === "string" && requestUrl.includes(refreshUrl)) {
         clearAuth();
         return Promise.reject(error);
       }
-      originalRequest._retry = true;
-      const { refreshToken } = tokenAccess.get();
-      if (!refreshToken) {
+      if (originalRequest._retry) {
         clearAuth();
         return Promise.reject(error);
       }
-      if (isRefreshing) {
+      originalRequest._retry = true;
+      if (refreshManager.refreshing) {
         return new Promise((resolve, reject) => {
-          subscribers.push((newToken) => {
-            if (!newToken) return reject(error);
-            originalRequest.headers = originalRequest.headers ?? {};
-            originalRequest.headers.Authorization = `Bearer ${newToken}`;
-            resolve(instance(originalRequest));
+          refreshManager.subscribe((newAccessToken) => {
+            if (!newAccessToken) {
+              reject(error);
+              return;
+            }
+            const retryRequest = setAuthorizationHeader(originalRequest, newAccessToken);
+            resolve(instance(retryRequest));
           });
         });
       }
-      isRefreshing = true;
+      refreshManager.begin();
       try {
-        const newTokens = await requestRefresh(refreshToken);
-        tokenAccess.set(newTokens);
+        const newTokens = await requestRefresh({
+          refreshUrl,
+          withCredentials,
+          refreshStrategy,
+          refreshToken: refreshStrategy === "body" ? refreshTokenAccess.get() : null,
+          parseRefreshResponse
+        });
+        setToken(newTokens);
         onAuthStateChange?.("authenticated");
-        isRefreshing = false;
-        notifySubscribers(newTokens.accessToken);
-        originalRequest.headers = originalRequest.headers ?? {};
-        originalRequest.headers.Authorization = `Bearer ${newTokens.accessToken}`;
-        return instance(originalRequest);
-      } catch (e) {
-        isRefreshing = false;
-        notifySubscribers(null);
+        refreshManager.end();
+        refreshManager.notify(newTokens.accessToken);
+        const retryRequest = setAuthorizationHeader(originalRequest, newTokens.accessToken);
+        return instance(retryRequest);
+      } catch (refreshError) {
+        refreshManager.end();
+        refreshManager.notify(null);
         clearAuth();
-        return Promise.reject(error);
+        return Promise.reject(refreshError);
       }
     }
   );
   return {
     axios: instance,
-    setToken: (data) => tokenAccess.set(data),
-    getToken: () => tokenAccess.get(),
-    clearToken: () => clearAuth()
+    setToken,
+    getToken,
+    clearToken: clearAuth
   };
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wheeparam/library",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",