q-koa 13.8.54 → 13.8.55

package/core/file/services/weixinMP.js

@@ -5,7 +5,8 @@
  * 1. 删除 Singleton.instance + lodash.isEqual 的假单例
  * 2. 新增 static _instanceMap = new Map()，key 为 config.appid
  * 3. 构造函数按 appid 直接命中缓存，不再做深比较
- * 4. 其余逻辑（url 常量 / cache LRU / 所有方法）保持不变
+ * 4. 新增内部 _withTokenRetry：遇 40001/40014/42001 强刷当前 appid 的
+ *    access_token 并重试一次，公共方法签名不暴露任何重试参数
  */
 
 const util = require('util')
@@ -198,16 +199,23 @@ module.exports = class Singleton {
     return access_token
   }
 
-  async getExpress(_retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(getExpressUrl, access_token)
-    const result = await wxAxios.post(url).then((res) => res.data)
+  // access_token 失效/过期统一重试：强刷当前 appid 的 token 后重试一次
+  async _withTokenRetry(request) {
+    let access_token = await this.getAccessToken()
+    let result = await request(access_token)
+    if (result.errcode && [40001, 40014, 42001].includes(result.errcode)) {
+      access_token = await this.getAccessToken(true)
+      result = await request(access_token)
+    }
+    return result
+  }
+
+  async getExpress() {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(getExpressUrl, access_token)
+      return await wxAxios.post(url).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.getExpress(true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
@@ -225,10 +233,7 @@ module.exports = class Singleton {
     shop,
     insured,
     service,
-  }, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(addOrderUrl, access_token)
-
+  }) {
     const formatOptions = {
       order_id,
       openid,
@@ -242,72 +247,42 @@ module.exports = class Singleton {
       service,
     }
 
-    const result = await wxAxios.post(url, formatOptions).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(addOrderUrl, access_token)
+      return await wxAxios.post(url, formatOptions).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.addOrder({
-          add_source,
-          order_id,
-          openid,
-          delivery_id,
-          biz_id,
-          sender,
-          receiver,
-          cargo,
-          shop,
-          insured,
-          service,
-        }, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async addSubanchor({ roomId, username }, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(addSubanchorUrl, access_token)
-
+  async addSubanchor({ roomId, username }) {
     const formatOptions = {
       roomId,
       username,
     }
 
-    const result = await wxAxios.post(url, formatOptions).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(addSubanchorUrl, access_token)
+      return await wxAxios.post(url, formatOptions).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.addSubanchor({
-          roomId,
-          username,
-        }, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async addRole({ username, role = 2 }, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(addRoleUrl, access_token)
-
+  async addRole({ username, role = 2 }) {
     const formatOptions = {
       username,
       role,
     }
-    const result = await wxAxios.post(url, formatOptions).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(addRoleUrl, access_token)
+      return await wxAxios.post(url, formatOptions).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.addRole({
-          username,
-          role,
-        }, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
@@ -325,10 +300,7 @@ module.exports = class Singleton {
     anchorWechat = '',
     anchorName = '',
     closeReplay = 1,
-  }, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(createLiveUrl, access_token)
-
+  }) {
     const formatOptions = {
       name,
       coverImg,
@@ -349,69 +321,44 @@ module.exports = class Singleton {
       closeShare: 1,
       closeKf: 1,
     }
-    const result = await wxAxios.post(url, formatOptions).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(createLiveUrl, access_token)
+      return await wxAxios.post(url, formatOptions).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.createLive({
-          name,
-          createrWechat,
-          coverImg,
-          startTime,
-          endTime,
-          shareImg,
-          feedsImg,
-          subAnchorWechat,
-          anchorWechat,
-          anchorName,
-          closeReplay,
-        }, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async getLive(start = 0, limit = 10, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(getLiveUrl, access_token)
-
+  async getLive(start = 0, limit = 10) {
     const formatOptions = {
       start,
       limit,
     }
-    const result = await wxAxios.post(url, formatOptions).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(getLiveUrl, access_token)
+      return await wxAxios.post(url, formatOptions).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.getLive(start, limit, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result.room_info
   }
 
-  async getPhoneNumber(code, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(getPhoneNumberUrl, access_token)
-    const result = await wxAxios.post(url, { code }).then((res) => res.data)
+  async getPhoneNumber(code) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(getPhoneNumberUrl, access_token)
+      return await wxAxios.post(url, { code }).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.getPhoneNumber(code, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result.phone_info
   }
 
-  async createUrlLink(options, _retried = false) {
+  async createUrlLink(options) {
     const { page, scene, ...rest } = options
-    const access_token = await this.getAccessToken()
-    const url = util.format(createUrlLinkUrl, access_token)
     const payLoad = {
       ...rest,
       path: options.page,
@@ -422,35 +369,28 @@ module.exports = class Singleton {
         : '',
     }
 
-    const result = await wxAxios.post(url, payLoad).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(createUrlLinkUrl, access_token)
+      return await wxAxios.post(url, payLoad).then((res) => res.data)
+    })
 
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.createUrlLink(options, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result.url_link
   }
 
-  async queryUrlLink(url_link, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(queryUrlLinkUrl, access_token)
-
-    const result = await wxAxios
-      .post(url, {
-        url_link,
-      })
-      .then((res) => res.data)
+  async queryUrlLink(url_link) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(queryUrlLinkUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          url_link,
+        })
+        .then((res) => res.data)
+    })
 
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.queryUrlLink(url_link, true)
-      }
       if (result.errcode === 85403) {
         return {
           expire_time: 0,
@@ -461,10 +401,8 @@ module.exports = class Singleton {
     return result.url_link_info
   }
 
-  async createShortLink(options, _retried = false) {
+  async createShortLink(options) {
     const { page, scene, title, ...rest } = options
-    const access_token = await this.getAccessToken()
-    const url = util.format(createShortLinkUrl, access_token)
     const query = options.scene
       ? Object.keys(options.scene)
           .map((item) => `${item}=${options.scene[item]}`)
@@ -477,23 +415,19 @@ module.exports = class Singleton {
       is_permanent: true,
     }
 
-    const result = await wxAxios.post(url, payLoad).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(createShortLinkUrl, access_token)
+      return await wxAxios.post(url, payLoad).then((res) => res.data)
+    })
 
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.createShortLink(options, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result.link
   }
 
-  async createUrlscheme(options, _retried = false) {
+  async createUrlscheme(options) {
     const { page, scene, ...rest } = options
-    const access_token = await this.getAccessToken()
-    const url = util.format(createUrlschemeUrl, access_token)
     const payLoad = {
       ...rest,
       jump_wxa: {
@@ -506,23 +440,19 @@ module.exports = class Singleton {
       },
     }
 
-    const result = await wxAxios.post(url, payLoad).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(createUrlschemeUrl, access_token)
+      return await wxAxios.post(url, payLoad).then((res) => res.data)
+    })
 
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.createUrlscheme(options, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result.openlink
   }
 
-  async createQR(options, _retried = false) {
+  async createQR(options) {
     if (!this.config.targetPath) throw new Error('没有配置文件夹')
-    const access_token = await this.getAccessToken()
-    const url = util.format(createQRCodeUrl, access_token)
     const payLoad = {
       ...options,
       scene: options.scene
@@ -533,22 +463,20 @@ module.exports = class Singleton {
     }
     const creatuuid = uuid.v1()
 
-    const bufferResult = await wxAxios
-      .post(url, payLoad, {
-        responseType: 'arraybuffer',
-      })
-      .then((res) => {
-        if (res.headers['content-type'].includes('json')) {
-          return JSON.parse(Buffer.from(res.data).toString('utf8'))
-        }
-        return res.data
-      })
+    const bufferResult = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(createQRCodeUrl, access_token)
+      return await wxAxios
+        .post(url, payLoad, {
+          responseType: 'arraybuffer',
+        })
+        .then((res) => {
+          if (res.headers['content-type'].includes('json')) {
+            return JSON.parse(Buffer.from(res.data).toString('utf8'))
+          }
+          return res.data
+        })
+    })
     if (bufferResult.errcode) {
-      if ([40001, 40014, 42001].includes(bufferResult.errcode)) {
-        if (_retried) throw new Error(`${bufferResult.errcode};${bufferResult.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.createQR(options, true)
-      }
       throw new Error(bufferResult.errmsg)
     }
     await fsPromise.writeFile(
@@ -558,9 +486,7 @@ module.exports = class Singleton {
     return `${creatuuid}.png`
   }
 
-  async createQRBuffer(options, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(createQRCodeUrl, access_token)
+  async createQRBuffer(options) {
     const payLoad = {
       ...options,
       scene: options.scene
@@ -570,30 +496,26 @@ module.exports = class Singleton {
         : '',
     }
 
-    const bufferResult = await wxAxios
-      .post(url, payLoad, {
-        responseType: 'arraybuffer',
-      })
-      .then((res) => {
-        if (res.headers['content-type'].includes('json')) {
-          return JSON.parse(Buffer.from(res.data).toString('utf8'))
-        }
-        return res.data
-      })
+    const bufferResult = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(createQRCodeUrl, access_token)
+      return await wxAxios
+        .post(url, payLoad, {
+          responseType: 'arraybuffer',
+        })
+        .then((res) => {
+          if (res.headers['content-type'].includes('json')) {
+            return JSON.parse(Buffer.from(res.data).toString('utf8'))
+          }
+          return res.data
+        })
+    })
     if (bufferResult.errcode) {
-      if ([40001, 40014, 42001].includes(bufferResult.errcode)) {
-        if (_retried) throw new Error(`${bufferResult.errcode};${bufferResult.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.createQRBuffer(options, true)
-      }
       throw new Error(bufferResult.errmsg)
     }
     return bufferResult
   }
 
-  async sendMessage(options, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(sendMessageUrl, access_token)
+  async sendMessage(options) {
     const formatOptions = {
       ...options,
       data: lodash.mapValues(options.data, (item) => {
@@ -602,411 +524,323 @@ module.exports = class Singleton {
         }
       }),
     }
-    const result = await wxAxios.post(url, formatOptions).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(sendMessageUrl, access_token)
+      return await wxAxios.post(url, formatOptions).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.sendMessage(options, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async handleMessage(options, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(handleMessageUrl, access_token)
-    const result = await wxAxios.post(url, options).then((res) => res.data)
+  async handleMessage(options) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(handleMessageUrl, access_token)
+      return await wxAxios.post(url, options).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.handleMessage(options, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async handleTyping({ touser, is_typing = true }, _retried = false) {
+  async handleTyping({ touser, is_typing = true }) {
     const options = {
       touser,
       command: is_typing ? 'Typing' : 'CancelTyping',
     }
-    const access_token = await this.getAccessToken()
-    const url = util.format(handleTypingUrl, access_token)
-    const result = await wxAxios.post(url, options).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(handleTypingUrl, access_token)
+      return await wxAxios.post(url, options).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.handleTyping({ touser, is_typing }, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async uploadFile(imgUrl, _retried = false) {
+  async uploadFile(imgUrl) {
     if (!imgUrl || !imgUrl.includes('//')) throw new Error('检查imgUrl是否链接')
 
-    const access_token = await this.getAccessToken()
-    const url = util.format(uploadFile, access_token, 'image')
     const fullUrl = imgUrl.startsWith('//') ? `http:${imgUrl}` : imgUrl
-    const stream = (await wxAxios.get(fullUrl, { responseType: 'stream' })).data
-    const formData = new FormData()
-    formData.append('media', stream)
-    const uploadResult = await uploadPromise(url, formData)
+    const uploadResult = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(uploadFile, access_token, 'image')
+      const stream = (await wxAxios.get(fullUrl, { responseType: 'stream' }))
+        .data
+      const formData = new FormData()
+      formData.append('media', stream)
+      return await uploadPromise(url, formData)
+    })
     if (uploadResult.errcode) {
-      if ([40001, 40014, 42001].includes(uploadResult.errcode)) {
-        if (_retried) throw new Error(`${uploadResult.errcode};${uploadResult.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.uploadFile(imgUrl, true)
-      }
       throw new Error(`${uploadResult.errcode};${uploadResult.errmsg}`)
     }
     return uploadResult.media_id
   }
 
-  async invokeService(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(serviceMarketUrl, access_token)
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async invokeService(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(serviceMarketUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.invokeService(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result.data
   }
 
-  async createOrder(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(createOrderUrl, access_token)
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async createOrder(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(createOrderUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
 
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.createOrder(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result.payment_params
   }
 
-  async getOrder(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(getOrderUrl, access_token)
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async getOrder(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(getOrderUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
 
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.getOrder(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result.order
   }
 
-  async refundOrder(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(refundOrderUrl, access_token)
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async refundOrder(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(refundOrderUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
 
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.refundOrder(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result.data
   }
 
-  async addGood(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(addGoodUrl, access_token)
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async addGood(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(addGoodUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.addGood(payLoad, true)
-      }
       // return payLoad
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result.data
   }
 
-  async getCategory(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(getCategoryUrl, access_token)
-
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async getCategory(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(getCategoryUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.getCategory(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async getBrandList(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(getBrandListUrl, access_token)
-
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async getBrandList(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(getBrandListUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.getBrandList(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result.data
   }
 
-  async getShipTemplate(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(getShipTemplateUrl, access_token)
-
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async getShipTemplate(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(getShipTemplateUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.getShipTemplate(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async uploadShip(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(uploadShipUrl, access_token)
-
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async uploadShip(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(uploadShipUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.uploadShip(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async uploadPreShip(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(uploadPreShipUrl, access_token)
-
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async uploadPreShip(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(uploadPreShipUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.uploadPreShip(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async getShipOrderList(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(getShipOrderListUrl, access_token)
-
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async getShipOrderList(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(getShipOrderListUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.getShipOrderList(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async uploadImage(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
+  async uploadImage(payLoad) {
     const { upload_type, resp_type, ...rest } = payLoad
 
-    const url = util.format(
-      uploadImageUrl,
-      access_token,
-      upload_type,
-      resp_type
-    )
-
-    const result = await wxAxios
-      .post(url, {
-        ...rest,
-      })
-      .then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(
+        uploadImageUrl,
+        access_token,
+        upload_type,
+        resp_type
+      )
+      return await wxAxios
+        .post(url, {
+          ...rest,
+        })
+        .then((res) => res.data)
+    })
 
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.uploadImage(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result.pic_file
   }
 
-  async setMsgJumpPath(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(setMsgJumpPathUrl, access_token)
-
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async setMsgJumpPath(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(setMsgJumpPathUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.setMsgJumpPath(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async getDeliveryList(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(getDeliveryListUrl, access_token)
-
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async getDeliveryList(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(getDeliveryListUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.getDeliveryList(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async getUserPortrait(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(getUserPortraitUrl, access_token)
-
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
+  async getUserPortrait(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(getUserPortraitUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.getUserPortrait(payLoad, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async getVisitTrend(payLoad, _retried = false) {
-    const access_token = await this.getAccessToken()
-    let url = ''
-    if (payLoad.type === 'month') {
-      url = util.format(
-        'https://api.weixin.qq.com/datacube/getweanalysisappidmonthlyvisittrend?access_token=%s',
-        access_token
-      )
-    } else if (payLoad.type === 'week') {
-      url = util.format(
-        'https://api.weixin.qq.com/datacube/getweanalysisappidweeklyvisittrend?access_token=%s',
-        access_token
-      )
-    } else if (payLoad.type === 'day') {
-      url = util.format(
-        'https://api.weixin.qq.com/datacube/getweanalysisappiddailyvisittrend?access_token=%s',
-        access_token
-      )
-    }
-
-    const result = await wxAxios
-      .post(url, {
-        ...payLoad,
-      })
-      .then((res) => res.data)
-    if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.getVisitTrend(payLoad, true)
+  async getVisitTrend(payLoad) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      let url = ''
+      if (payLoad.type === 'month') {
+        url = util.format(
+          'https://api.weixin.qq.com/datacube/getweanalysisappidmonthlyvisittrend?access_token=%s',
+          access_token
+        )
+      } else if (payLoad.type === 'week') {
+        url = util.format(
+          'https://api.weixin.qq.com/datacube/getweanalysisappidweeklyvisittrend?access_token=%s',
+          access_token
+        )
+      } else if (payLoad.type === 'day') {
+        url = util.format(
+          'https://api.weixin.qq.com/datacube/getweanalysisappiddailyvisittrend?access_token=%s',
+          access_token
+        )
       }
+      return await wxAxios
+        .post(url, {
+          ...payLoad,
+        })
+        .then((res) => res.data)
+    })
+    if (result.errcode) {
       if (result.errcode === 61503) {
         return null
       }
@@ -1015,17 +849,12 @@ module.exports = class Singleton {
     return result
   }
 
-  async getCommentInfo(commentId, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(getCommentInfoUrl, commentId, access_token)
-
-    const result = await wxAxios.get(url).then((res) => res.data)
+  async getCommentInfo(commentId) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(getCommentInfoUrl, commentId, access_token)
+      return await wxAxios.get(url).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.getCommentInfo(commentId, true)
-      }
       if (result.errcode === 61503) {
         return null
       }
@@ -1034,23 +863,18 @@ module.exports = class Singleton {
     return result
   }
 
-  async createActivity(_retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(createActivityUrl, access_token)
-
-    const result = await wxAxios.get(url).then((res) => res.data)
+  async createActivity() {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(createActivityUrl, access_token)
+      return await wxAxios.get(url).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.createActivity(true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async setUpdatableMsg(target, _retried = false) {
+  async setUpdatableMsg(target) {
     let {
       activity_id,
       target_state,
@@ -1069,8 +893,6 @@ module.exports = class Singleton {
       version_type = ''
       path = ''
     }
-    const access_token = await this.getAccessToken()
-    const url = util.format(setUpdatableMsgUrl, access_token)
     const postData = {
       activity_id,
       target_state,
@@ -1106,13 +928,11 @@ module.exports = class Singleton {
     if (!postData.template_info.parameter_list.length) {
       throw new ServiceError('?parameter_list length 0')
     }
-    const result = await wxAxios.post(url, postData).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(setUpdatableMsgUrl, access_token)
+      return await wxAxios.post(url, postData).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.setUpdatableMsg(target, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
@@ -1149,11 +969,9 @@ module.exports = class Singleton {
     }
   }
 
-  async b2bRefund({ mchid, app_key, data }, _retried = false) {
+  async b2bRefund({ mchid, app_key, data }) {
     const requestUrl = b2bRefundUrl
 
-    const access_token = await this.getAccessToken()
-
     const uri = requestUrl.split('api.weixin.qq.com')[1].split('?')[0]
 
     const signData = {
@@ -1163,24 +981,19 @@ module.exports = class Singleton {
 
     const pay_sig = hmacSha256(`${uri}&${JSON.stringify(signData)}`, app_key)
 
-    const url = util.format(requestUrl, access_token, pay_sig)
-    const result = await wxAxios.post(url, signData).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(requestUrl, access_token, pay_sig)
+      return await wxAxios.post(url, signData).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.b2bRefund({ mchid, app_key, data }, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async b2bCheckRefund({ mchid, app_key, out_refund_no }, _retried = false) {
+  async b2bCheckRefund({ mchid, app_key, out_refund_no }) {
     const requestUrl = b2bCheckRefundUrl
 
-    const access_token = await this.getAccessToken()
-
     const uri = requestUrl.split('api.weixin.qq.com')[1].split('?')[0]
 
     const signData = {
@@ -1190,24 +1003,19 @@ module.exports = class Singleton {
 
     const pay_sig = hmacSha256(`${uri}&${JSON.stringify(signData)}`, app_key)
 
-    const url = util.format(requestUrl, access_token, pay_sig)
-    const result = await wxAxios.post(url, signData).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(requestUrl, access_token, pay_sig)
+      return await wxAxios.post(url, signData).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.b2bCheckRefund({ mchid, app_key, out_refund_no }, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async b2bCheckOrder({ mchid, app_key, out_trade_no }, _retried = false) {
+  async b2bCheckOrder({ mchid, app_key, out_trade_no }) {
     const requestUrl = b2bCheckOrderUrl
 
-    const access_token = await this.getAccessToken()
-
     const uri = requestUrl.split('api.weixin.qq.com')[1].split('?')[0]
 
     const signData = {
@@ -1217,44 +1025,34 @@ module.exports = class Singleton {
 
     const pay_sig = hmacSha256(`${uri}&${JSON.stringify(signData)}`, app_key)
 
-    const url = util.format(requestUrl, access_token, pay_sig)
-    const result = await wxAxios.post(url, signData).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(requestUrl, access_token, pay_sig)
+      return await wxAxios.post(url, signData).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.b2bCheckOrder({ mchid, app_key, out_trade_no }, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async b2bPreStore(list, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(b2bPreStoreUrl, access_token)
-
-    const result = await wxAxios
-      .post(url, {
-        retail_info_list: list,
-      })
-      .then((res) => res.data)
+  async b2bPreStore(list) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(b2bPreStoreUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          retail_info_list: list,
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.b2bPreStore(list, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async b2bFinish({ mchid, app_key, out_trade_no }, _retried = false) {
+  async b2bFinish({ mchid, app_key, out_trade_no }) {
     const requestUrl = b2bFinishUrl
 
-    const access_token = await this.getAccessToken()
-
     const uri = requestUrl.split('api.weixin.qq.com')[1].split('?')[0]
 
     const signData = {
@@ -1264,36 +1062,28 @@ module.exports = class Singleton {
 
     const pay_sig = hmacSha256(`${uri}&${JSON.stringify(signData)}`, app_key)
 
-    const url = util.format(requestUrl, access_token, pay_sig)
-    const result = await wxAxios.post(url, signData).then((res) => res.data)
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(requestUrl, access_token, pay_sig)
+      return await wxAxios.post(url, signData).then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.b2bFinish({ mchid, app_key, out_trade_no }, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result
   }
 
-  async b2bSendMessage({ type = 2, to_user_list = [], data = {} }, _retried = false) {
-    const access_token = await this.getAccessToken()
-    const url = util.format(b2bSendMessageUrl, access_token)
-
-    const result = await wxAxios
-      .post(url, {
-        type,
-        to_user_list,
-        content: JSON.stringify(data),
-      })
-      .then((res) => res.data)
+  async b2bSendMessage({ type = 2, to_user_list = [], data = {} }) {
+    const result = await this._withTokenRetry(async (access_token) => {
+      const url = util.format(b2bSendMessageUrl, access_token)
+      return await wxAxios
+        .post(url, {
+          type,
+          to_user_list,
+          content: JSON.stringify(data),
+        })
+        .then((res) => res.data)
+    })
     if (result.errcode) {
-      if ([40001, 40014, 42001].includes(result.errcode)) {
-        if (_retried) throw new Error(`${result.errcode};${result.errmsg}`)
-        await this.getAccessToken(true)
-        return await this.b2bSendMessage({ type, to_user_list, data }, true)
-      }
       throw new Error(`${result.errcode};${result.errmsg}`)
     }
     return result

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "q-koa",
-  "version": "13.8.54",
+  "version": "13.8.55",
   "description": "",
   "main": "index.js",
   "scripts": {