enhance-axios 1.0.4 → 1.1.0

package/dist/cjs/index.js

@@ -39,7 +39,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "1.0.4";
+var version = "1.1.0";
 
 // src/core/index.ts
 var import_axios = __toESM(require("axios"));
@@ -271,52 +271,89 @@ var CONTENT_TYPE_MAP = {
   form: "application/x-www-form-urlencoded"
 };
 
-// src/core/index.ts
-var DEFAULT_PREVENT_CONFIG = {
-  enabled: true,
-  methods: ["POST", "PUT", "PATCH", "DELETE"],
-  intervalMs: 1e3
-};
-var DEFAULT_CANCEL_CONFIG = {
-  enabled: true,
-  methods: ["GET"]
-};
-function defaultRetryCondition(error) {
-  if (!error.response) {
-    return true;
+// src/core/tokenManager.ts
+function formatHeader(token, fmt) {
+  if (typeof fmt === "function") return fmt(token).trim();
+  if (typeof fmt === "string") {
+    const tpl = fmt.includes("{token}") ? fmt : `${fmt} {token}`;
+    return tpl.replace("{token}", token).trim();
+  }
+  return `Bearer ${token}`;
+}
+function setHeader(config, token, auth) {
+  config.headers = config.headers || {};
+  config.headers[auth.headerName || "Authorization"] = formatHeader(token, auth.headerFormat);
+}
+function shouldUseToken(config, instanceNeedToken) {
+  if (config.needToken !== void 0) return config.needToken;
+  if (typeof instanceNeedToken === "function") return instanceNeedToken(config);
+  if (instanceNeedToken !== void 0) return instanceNeedToken;
+  return true;
+}
+function defaultShouldRefresh(err) {
+  return err?.response?.status === 401 || err?.response?.data?.code === 401;
+}
+var TokenManager = class {
+  constructor(auth, needTokenDefault) {
+    this.auth = auth;
+    this.needTokenDefault = needTokenDefault;
+    this.pendingRefresh = null;
+  }
+  /** 请求拦截器：注入 token header */
+  async handleRequest(config) {
+    if (!shouldUseToken(config, this.needTokenDefault)) return;
+    if (this.pendingRefresh) {
+      try {
+        const info = await this.pendingRefresh;
+        setHeader(config, info.accessToken, this.auth);
+        return;
+      } catch {
+        this.pendingRefresh = null;
+      }
+    }
+    try {
+      const local = await Promise.resolve(this.auth.getLocalToken());
+      if (local) {
+        setHeader(config, local.accessToken, this.auth);
+      }
+    } catch {
+    }
   }
-  const status = error.response.status;
-  if (status === 408 || status === 429) {
+  /**
+   * 响应拦截器（resolve / reject）：
+   * 检测到 token 过期则刷新并注入新 token。
+   * 返回 true 表示调用方需要调用 instance.request(config) 重试。
+   * 抛出异常表示刷新失败，调用方应 reject。
+   */
+  async handleAuthError(responseOrError, config) {
+    if (!shouldUseToken(config, this.needTokenDefault)) return false;
+    const check = this.auth.shouldRefreshToken || defaultShouldRefresh;
+    if (!check(responseOrError)) return false;
+    if (!this.pendingRefresh) {
+      this.pendingRefresh = this.auth.refreshToken().then(async (info2) => {
+        if (this.auth.setLocalToken) {
+          await Promise.resolve(this.auth.setLocalToken(info2)).catch(() => {
+          });
+        }
+        return info2;
+      });
+    }
+    const info = await this.pendingRefresh;
+    this.pendingRefresh = null;
+    setHeader(config, info.accessToken, this.auth);
     return true;
   }
-  if (status >= 500 && status < 600) {
-    return true;
+  /** 刷新失败时调用 */
+  handleRefreshFailure(err) {
+    this.pendingRefresh = null;
+    const handler = this.auth.tokenFailureHandler;
+    if (handler) {
+      handler("refresh", err);
+    }
   }
-  return false;
-}
-var DEFAULT_RETRY_CONFIG = {
-  enabled: true,
-  retries: 3,
-  retryDelay: 1e3,
-  retryCondition: defaultRetryCondition,
-  exponential: true,
-  maxDelay: 3e4
 };
-function shouldApply(method, methods) {
-  if (methods == null) return true;
-  if (methods.length === 0) return false;
-  return methods.includes(method?.toUpperCase() || "GET");
-}
-function calculateRetryDelay(retryConfig, retryCount) {
-  let delay = retryConfig.retryDelay;
-  if (retryConfig.exponential) {
-    delay = Math.min(
-      retryConfig.retryDelay * Math.pow(2, retryCount),
-      retryConfig.maxDelay
-    );
-  }
-  return delay;
-}
+
+// src/core/dataTransform.ts
 function getDataFormat(config) {
   const headers = config.headers || {};
   const ctKey = Object.keys(headers).find((k) => k.toLowerCase() === "content-type");
@@ -346,9 +383,74 @@ function injectDataTransform(config, format, instance) {
   }
   config.transformRequest = [ourTransform, ...chain];
 }
+
+// src/core/helpers.ts
+function shouldApply(method, methods) {
+  if (methods == null) return true;
+  if (methods.length === 0) return false;
+  return methods.includes(method?.toUpperCase() || "GET");
+}
 function isConfigSet(config) {
   return config != null;
 }
+
+// src/core/retry.ts
+function defaultRetryCondition(error) {
+  if (!error.response) return true;
+  const status = error.response.status;
+  if (status === 408 || status === 429) return true;
+  if (status >= 500 && status < 600) return true;
+  return false;
+}
+var DEFAULT_RETRY_CONFIG = {
+  enabled: true,
+  retries: 3,
+  retryDelay: 1e3,
+  retryCondition: defaultRetryCondition,
+  exponential: true,
+  maxDelay: 3e4
+};
+function calculateRetryDelay(config, retryCount) {
+  if (!config.exponential) return config.retryDelay;
+  return Math.min(config.retryDelay * Math.pow(2, retryCount), config.maxDelay);
+}
+function normalizeRetryConfig(config, defaults) {
+  if (!isConfigSet(config)) return defaults;
+  if (typeof config === "boolean") return { ...defaults, enabled: config };
+  if (typeof config === "number") return { ...defaults, enabled: true, retries: config };
+  if (typeof config === "function") return { ...defaults, enabled: true, retryCondition: config };
+  if (Array.isArray(config)) {
+    const codes = config;
+    return {
+      ...defaults,
+      enabled: true,
+      retryCondition: (error) => {
+        if (!error.response) return true;
+        return codes.includes(error.response.status);
+      }
+    };
+  }
+  return {
+    enabled: config.enabled ?? true,
+    retries: config.retries ?? defaults.retries,
+    retryDelay: config.retryDelay ?? defaults.retryDelay,
+    retryCondition: config.retryCondition ?? defaults.retryCondition,
+    exponential: config.exponential ?? defaults.exponential,
+    maxDelay: config.maxDelay ?? defaults.maxDelay,
+    methods: config.methods != null ? config.methods : defaults.methods
+  };
+}
+
+// src/core/index.ts
+var DEFAULT_PREVENT_CONFIG = {
+  enabled: true,
+  methods: ["POST", "PUT", "PATCH", "DELETE"],
+  intervalMs: 1e3
+};
+var DEFAULT_CANCEL_CONFIG = {
+  enabled: true,
+  methods: ["GET"]
+};
 function normalizePreventConfig(config, defaults) {
   if (!isConfigSet(config)) {
     return defaults;
@@ -397,40 +499,6 @@ function normalizeCancelConfig(config, defaults) {
     methods: config.methods != null ? config.methods : defaults.methods
   };
 }
-function normalizeRetryConfig(config, defaults) {
-  if (!isConfigSet(config)) {
-    return defaults;
-  }
-  if (typeof config === "boolean") {
-    return { ...defaults, enabled: config };
-  }
-  if (typeof config === "number") {
-    return { ...defaults, enabled: true, retries: config };
-  }
-  if (typeof config === "function") {
-    return { ...defaults, enabled: true, retryCondition: config };
-  }
-  if (Array.isArray(config)) {
-    const codes = config;
-    return {
-      ...defaults,
-      enabled: true,
-      retryCondition: (error) => {
-        if (!error.response) return true;
-        return codes.includes(error.response.status);
-      }
-    };
-  }
-  return {
-    enabled: config.enabled ?? true,
-    retries: config.retries ?? defaults.retries,
-    retryDelay: config.retryDelay ?? defaults.retryDelay,
-    retryCondition: config.retryCondition ?? defaults.retryCondition,
-    exponential: config.exponential ?? defaults.exponential,
-    maxDelay: config.maxDelay ?? defaults.maxDelay,
-    methods: config.methods != null ? config.methods : defaults.methods
-  };
-}
 function getEffectiveConfig(config, instanceDefaults) {
   const prevent = isConfigSet(config.preventDuplicate) ? normalizePreventConfig(config.preventDuplicate, instanceDefaults.prevent) : { ...instanceDefaults.prevent };
   const cancel = isConfigSet(config.cancelRequest) ? normalizeCancelConfig(config.cancelRequest, instanceDefaults.cancel) : { ...instanceDefaults.cancel };
@@ -475,7 +543,8 @@ function resolveAndCleanup(config, rm, pr, data) {
   if (ck && ck !== pk) rm.unregisterRequest(ck, "cancel");
 }
 function createEnhanceInstance(options = {}) {
-  const instance = import_axios.default.create(options);
+  const { tokenAuth: _ta, needToken: _nt, ...axiosOptions } = options;
+  const instance = import_axios.default.create(axiosOptions);
   const defaultPrevent = { ...DEFAULT_PREVENT_CONFIG };
   const defaultCancel = { ...DEFAULT_CANCEL_CONFIG };
   const defaultRetry = { ...DEFAULT_RETRY_CONFIG };
@@ -492,6 +561,7 @@ function createEnhanceInstance(options = {}) {
     Object.assign(defaultRetry, normalized);
   }
   const needCacheBust = options.needCacheBust ?? true;
+  const tokenManager = _ta ? new TokenManager(_ta, _nt) : null;
   const requestManager = new RequestManager();
   const pendingReturns = /* @__PURE__ */ new Map();
   const enhanceInstance = {
@@ -510,9 +580,10 @@ function createEnhanceInstance(options = {}) {
     getRequestStatus: (key) => requestManager.getRequestStatus(key)
   };
   instance.interceptors.request.use(
-    (config) => {
+    async (config) => {
       const method = config.method?.toUpperCase() || "GET";
       const { prevent, cancel } = getEffectiveConfig(config, { prevent: defaultPrevent, cancel: defaultCancel });
+      if (tokenManager) await tokenManager.handleRequest(config);
       const headers = config.headers || {};
       const hasContentType = typeof headers === "object" && Object.keys(headers).some((k) => k.toLowerCase() === "content-type");
       if (!hasContentType) {
@@ -609,6 +680,18 @@ function createEnhanceInstance(options = {}) {
     // ─────────────────────────────────────────────────────────────────────────
     async (response) => {
       const config = response.config;
+      if (tokenManager) {
+        try {
+          if (await tokenManager.handleAuthError(response, config)) {
+            cleanupRegistered(config, requestManager);
+            return instance.request(config);
+          }
+        } catch (err) {
+          tokenManager.handleRefreshFailure(err);
+          rejectAndCleanup(config, requestManager, pendingReturns, err);
+          return Promise.reject(err);
+        }
+      }
       const retryConfig = normalizeRetryConfig(config.retry, defaultRetry);
       if (retryConfig.enabled && shouldApply(config.method, retryConfig.methods)) {
         const syntheticError = new Error("Business logic error");
@@ -641,6 +724,18 @@ function createEnhanceInstance(options = {}) {
         rejectAndCleanup(config, requestManager, pendingReturns, error);
         return Promise.reject(error);
       }
+      if (tokenManager) {
+        try {
+          if (await tokenManager.handleAuthError(error, config)) {
+            cleanupRegistered(config, requestManager);
+            return instance.request(config);
+          }
+        } catch (err) {
+          tokenManager.handleRefreshFailure(err);
+          rejectAndCleanup(config, requestManager, pendingReturns, err);
+          return Promise.reject(err);
+        }
+      }
       const retryConfig = normalizeRetryConfig(config.retry, defaultRetry);
       if (retryConfig.enabled && shouldApply(config.method, retryConfig.methods)) {
         const retryCount = config.__retryCount || 0;