nuxt-cache-module v2.0.0

nuxt-cache-module

nuxt page cache module. lightweight and straightforward

usage

npm i nuxt-cache-module -S

// nuxt.config.js

modules: [
  ['nuxt-cache-module', 
    {
      hashKey: true,
      keyBuilder: (route, context) => {
        return ''
      },
      expireTime: 1000,
      cacheBuilder: (context) => {
        // build your cache or get it from somewhere
        return cache
      },
      hitHeader: 'x-page-cache',
      shouldCache: (route, context) => {
        return true
      },
      shouldSave: (context) => {
        // error flag found
        return !context.req.pageRenderError
      }
  }]
]

options

caveat

• shouldCache called before page render, shouldSave called after page render.
• your cache instance should support get and set method which used as follows:

cache.get(key).then((res) => {}).catch(() => {})

cache.set(key, val, 'EX', expireTime).then(() => {}).catch(() => {})

example

this cache is up to the user to provide.

the example below use koa and ioredis.

server.js

const Redis = require('ioredis')

// build the cache instance before server start listen
const redisClient = await new Promise((resolve, reject) => {
    const client = new Redis({
      host: config.redis.host,
      port: config.redis.port,
      connectTimeout: 10000,
      maxRetriesPerRequest: 1,
      // set app version in the key prefix
      keyPrefix: `${yourproject}${yourversion}`,
      retry_strategy (times) {
        // reconnect after
        return 100
      }
    })
    client.on('connect', () => {
      resolve(client)
    })
    client.on('error', (e) => {
      reject(e)
    })
  }).catch((e) => {
  })

 // inject cache to ctx in server app middleware, so the cache builder can get it.
 app.use(async (ctx, next) => {
    if (redisClient) {
      ctx.cache = redisClient
    }
    await next()
 })

nuxt.config.js

['nuxt-cache-module', {
      hashKey: true,
      keyBuilder: (route, context) => {
      },
      expireTime: 1800,
      hitHeader: 'x-page-cache',
      cacheBuilder: (context) => {
        // get cache from ctx
        return context.req && context.req.ctx.cache
      },
      shouldCache: (route, context) => {
          const r = route.split(/[?#]/)[0]
          // I use regex to check the route, only home page is allowed to cache
          if (pageRegex.home.test(r)) {
            return true
          }
      },
      shouldSave: (context) => {
      }
    }]