Project-based server-side performance optimization and error detection (fault-tolerant processing)

import LRUCache from 'lru-cache'

const cache = new LRUCache({
 maxAge: 1000 * 60 * 2, // Valid for 2 minutes max: 1000 // Maximum cache number})

export default function(req, res, next) {
 // The local development environment does not perform page cache if (.NODE_ENV !== 'development') {
 try {
  const cacheKey = 
  const cacheData = (cacheKey)
  if (cacheData) {
  return (cacheData, 'utf8')
  }
  const originalEnd = 
   = function(data) {
  (cacheKey, data)
  (res, ...arguments)
  }
 } catch(error) {
  // (`page-cache-middleware: ${error}`)
  next()
 }
 }
 next()
}

// ～/plugins/axios/

import md5 from 'md5'

/**
  * According to the request configuration, whether it is a request interceptor Create a cache key
  * @param {Object} config
  * @param {Boolean} isRequest
  */

export default function createCacheKey(
 config = {},
 isRequest = false
) {
 const {
 url,
 data,
 params,
 method,
 baseURL,
 } = config || {}

 let commonUrl = url

 /**
  * The baseURL is not spliced ​​in the request interceptor, and the baseURL is spliced ​​in the response interceptor.
  * In order to maintain uniformity, use the commonUrl of the unified splicing baseURL; pay attention to the following if condition judgment
  */
 if (isRequest && !(baseURL) && !(/^https?/)) {
 commonUrl = !!(/.+\/$/) ? `${(/\/$/, '')}${url}` : `${baseURL}${url}`
 }

 // Generate rules according to request instructions, url, body body, parameter const rule = `method=${method}-url=${commonUrl}-data=${(data || {})}-params=${(params || {})}`

 // md5 encryption return md5(rule)
}

import LRUCache from 'lru-cache'
import axios from 'axios'
import globalConfig from '../../global-config'
import createCacheKey from './createCacheKey'

const cache = new LRUCache({
 maxAge: 1000 * 60, // Valid for 60 seconds. If there is a page cache, the API cache time should be smaller than the page cache time, so that the content of the API response is kept up to date. max: 1000 // Maximum cache number})

/**
  * matchCacheCondition meets the persistent cache conditions: server runtime && non-local development environment && api request is the get request method
  * @param {Object} config Request configuration
  */
function matchCacheCondition(config = {}) {
 return  && .NODE_ENV !== 'development' && () === 'get'
}

/**
  * If all pages are cached, the API cache is not necessary
  */
export default function({ $axios, redirect }) {
 $(config => {
 const { baseUrl } = globalConfig
  = baseUrl[] || baseUrl['other']

 // Return config directly if the cache condition is not met if (!matchCacheCondition(config)) {
  return config
 }

 const cacheKey = createCacheKey(config, true)
 const cacheData = (cacheKey)

 if (cacheData) {
  const source = ()
   = 
  ({ cacheData, cacheKey, url:  })
  return config
 }

 return config
 })

 $(response => {
 if (matchCacheCondition()) {
  (createCacheKey(), response)
 }
 return response
 }, (error) => {
 if ((error) && matchCacheCondition()) {
  // (`The interface url cached in the current page component asyncData or fetch function is: ${}`)  return ()
 }

 // Server prints the API interface request error log if () {
  try {
  const {
   config: {
   url
   },
   message
  } = error || {}
  (`askurl：${url}，Error message：${message}`)
  } catch(error) {
  // (error)
  }
 }

 // The server and client unified the reject error object, so the page component asyncData and fetch function must handle the API interface to request the AsyncData interface. return (error)
 })
}

serverCacheKey: props =>  + '::' + .last_updated

{
 async asyncData({ $axios }) {
 // 1. Add catch processing to enable the server and the client to not report errors when running, especially to prevent the server from reporting errors when running, otherwise the page will hang up. // 2. The catch function returns a Promise of a resolve empty literal object, indicating that the state of dataPromise1 will always be resolved in the future. const dataPromise1 = $('/api/data1').catch(() => ({}))

 const dataPromise2 = $('/api/data2').catch(() => ({}))
 const dataPromise3 = $('/api/data3').catch(() => ({}))
 const dataPromise4 = $('/api/data4').catch(() => ({}))
 const dataPromise5 = $('/api/data5').catch(() => ({}))
 const dataPromise6 = $('/api/data6').catch(() => ({}))
 const dataPromise7 = $('/api/data7').catch(() => ({}))
 const dataPromise8 = $('/api/data8').catch(() => ({}))

 // Ensure that apiData has data const apiData = await new Promise(resolve => {
  ([
  dataPromise1, dataPromise2, dataPromise3, dataPromise4,
  dataPromise5, dataPromise6, dataPromise7, dataPromise8,
  ])
  .then(dataGather => {
   resolve({
   data1: dataGather[0],
   data2: dataGather[1],
   data3: dataGather[2],
   data4: dataGather[3],
   data5: dataGather[4],
   data6: dataGather[5],
   data7: dataGather[6],
   data8: dataGather[7],
   })
  })
 })

 return apiData
 }
}

$(config => {
 // TODO
 // Detect node application errors caused by failed requesting java interface  += '/xxxx'

 return config
})