一个可爱的闭包

closure.js

// 闭包更加好嘛
// 就是新手看不懂了

const urls = {
    getApp: '/api/app/get',
    delApp: '/api/app/del'
}

const getAppList = reqWrapper((params) => request.get(urls.getApp, { params }), (res) => {
  // ...
  return newRes;
});

const delApp = reqWrapper((data) => request.post(urls.delApp, data));

function reqWrapper(reqFunc, resultTransformation) {
  return async(data) => {
    try {
      const res = await reqFunc(data);
      if (res.ResponseMetadata && !res.ResponseMetadata.Error) {
        const result = res.Result;
        if (resultTransformation) {
          return resultTransformation(result);
        }
        return result;
      }
      emitLog(safeGet(res, 'ResponseMetadata.Error.Code'), 'error');
      return Promise.reject(res);
    } catch (err) {
      Promise.reject(err);
    }
  };
}

const apis = {
  getApp,
  delApp,
};

export async function callAppAPI(name, data) {
  try {
    return await apis[name](data);
  } catch (err) {
    return Promise.reject(err);
  }
}

wrapper.js

// 原来的wrapper

const urls = {
    getApp: '/api/app/get',
    delApp: '/api/app/del'
}

const apis = {
    getApp,
    delApp
}

async function getApp(params) {
    const res = await request.get(urls.getApp, { params });
    const successFunc = (oldRes) => {
        // ...
        return newRes
    }
    return reqWrapper(res, successFunc)
}

async function delApp(data) {
    const res = await request.post(urls.delApp, data);
    return reqWrapper(res);
}

async function reqWrapper(res, successFunc, failFunc) {
    if (res.ResponseMetadata && !res.ResponseMetadata.Error) {
        if (successFunc) {
            return successFunc(res.Result);
        }
        return res.Result;
    }
    emitLog(safeGet(res, 'ResponseMetadata.Error.Code'), 'error');
    throw new Error(res);
}


export function callAppAPI(name, data) {
    try {
        return await apis[name](data);
    } catch (err) {
        return Promise.reject(err);
    }
}

中间还用过有点像反射的
(懒得改了，这是业务线上的一段逻辑)

import request from './lib/request.js';
import safeGet from '@arsenal/arsenal/modules/safeGet';
import { emitLog } from '../utils/logger';
import { GET_APP_LIST, DELETE_APP, UPDATE_APP_INFO, CREATE_APP, CREATE_PARTNER } from './lib/urlConst.js';
import { serviceStatus, systemKVMap } from '@/constant/service';

const Apis = {
  getAppList,
  delApp,
  updateAppInfo,
  createApp,
  createPartner
};

/**
 * 额外做一层wrap
 * @param {*} name 函数名称
 * @param {*} data 参数
 */
export async function callApplicationApi(name, data = {}) {
  try {
    const res = await Apis[name](data);
    const mode = res.requestResult ? 1 : 0; // mode===1: callback mode
    if (!mode) {
      if (res.ResponseMetadata && !res.ResponseMetadata.Error) {
        return res.Result;
      }
      emitLog(safeGet(res, 'ResponseMetadata.Error.Code'), 'error');
      return Promise.reject(res);
    }
    // callback mode
    const {
      requestResult,
      successCallback,
      failCallBack
    } = res;
    if (requestResult.ResponseMetadata && !requestResult.ResponseMetadata.Error) {
      if (successCallback) {
        // 请求成功后可以对返回数据进行统一的预处理
        return successCallback(requestResult.Result);
      }
      return requestResult.Result;
    }
    emitLog(safeGet(requestResult, 'ResponseMetadata.Error.Code'), 'error');
    if (failCallBack) {
      // 请求失败的统一处理
      return Promise.reject(failCallBack(requestResult));
    }
    return Promise.reject(requestResult);
  } catch (err) {
    return Promise.reject(err);
  }
}

export async function getAppList(params) {
  function getServiceInfo(partners, serviceName) {
    for (let i = 0; i < partners.length; i++) {
      if (partners[i].partner_type === serviceName) {
        return partners[i];
      }
    }
    return {
      status: serviceStatus.initial
    };
  };
  function successCallback(res) {
    return res.map(item => Object.assign(item, {
      cnName: item.oc_app_name,
      engName: item.oc_app_key,
      appId: item.oc_app_id,
      intelligentContent: getServiceInfo(item.partners, 'content'),
      recommendAlgorithm: getServiceInfo(item.partners, 'recommend'),
      osName: systemKVMap[item.os]
    }));
  };
  return {
    requestResult: await request.get(GET_APP_LIST, { params }),
    successCallback
  };
}

export async function delApp(data) {
  return request.post(DELETE_APP, data);
}

export async function updateAppInfo(data) {
  return request.post(UPDATE_APP_INFO, data);
}

export async function createApp(data) {
  return request.post(CREATE_APP, data);
}

export async function createPartner(data) {
  return request.post(CREATE_PARTNER, data);
}