jiapu/utils/AxiosRequestUtil.js

(function (root, factory) {
  // Axios 请求工具同时支持浏览器页面和 Node 单元测试加载。
  if (typeof module === 'object' && module.exports) {
    module.exports = factory(root);
    return;
  }

  root.AxiosRequestUtil = factory(root);
})(typeof globalThis !== 'undefined' ? globalThis : window, function (root) {
  'use strict';

  function isFormData(body) {
    return typeof FormData !== 'undefined' && body instanceof FormData;
  }

  function createHttpError(message, detail) {
    var error = new Error(message);

    Object.keys(detail || {}).forEach(function (key) {
      error[key] = detail[key];
    });

    return error;
  }

  function unwrapResponse(payload) {
    if (!payload || typeof payload !== 'object') return payload;

    if (payload.code !== undefined && Number(payload.code) !== 200) {
      throw createHttpError(payload.msg || '接口请求失败', {
        code: payload.code,
        response: payload
      });
    }

    if (Object.prototype.hasOwnProperty.call(payload, 'data')) return payload.data;
    if (Object.prototype.hasOwnProperty.call(payload, 'rows')) {
      return {
        rows: payload.rows,
        total: payload.total
      };
    }

    return payload;
  }

  function getAxiosInstance(options) {
    var settings = options || {};
    var axios = settings.axiosInstance || root.axios;

    if (!axios || typeof axios.request !== 'function' && typeof axios.create !== 'function') {
      throw new Error('缺少 Axios 公共依赖');
    }

    if (typeof axios.create === 'function') {
      return axios.create({
        baseURL: settings.baseUrl
      });
    }

    return axios;
  }

  function createRequester(options) {
    var settings = options || {};
    var axiosInstance = getAxiosInstance(settings);

    function handleUnauthorized(status) {
      if (Number(status) === 401 && settings.onUnauthorized) settings.onUnauthorized();
    }

    return async function request(method, path, requestOptions) {
      var req = requestOptions || {};
      var headers = Object.assign({}, req.headers || {});
      var token = settings.getToken ? settings.getToken() : '';
      var tokenHeaderName = settings.tokenHeaderName || 'Authorization';
      var body = req.body;
      var response;

      headers.clientid = settings.clientId;
      if (token && req.auth !== false) headers[tokenHeaderName] = 'Bearer ' + token;

      if (body !== undefined && body !== null && !isFormData(body)) {
        headers['Content-Type'] = headers['Content-Type'] || 'application/json';
      }

      try {
        response = await axiosInstance.request({
          method: String(method || 'GET').toLowerCase(),
          url: path,
          params: req.query,
          data: body,
          headers: headers
        });
      } catch (error) {
        var responseData = error.response && error.response.data;
        var status = error.response && error.response.status;

        if (req.auth !== false) handleUnauthorized(status);

        throw createHttpError((responseData && responseData.msg) || error.message || '接口请求失败', {
          status: status,
          response: responseData,
          cause: error
        });
      }

      try {
        return unwrapResponse(response.data);
      } catch (error) {
        if (req.auth !== false) handleUnauthorized(error.code);
        throw error;
      }
    };
  }

  return {
    createRequester: createRequester,
    unwrapResponse: unwrapResponse
  };
});