🚀 First launch

Author: codeaholicguy

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true

.prettierrc

@@ -0,0 +1,14 @@
+{
+  "arrowParens": "always",
+  "bracketSpacing": false,
+  "semi": false,
+  "singleQuote": true,
+  "printWidth": 80,
+  "trailingComma": "es5",
+  "overrides": [
+    {
+      "files": ["*.json", ".prettierrc", ".babelrc"],
+      "options": { "parser": "json" }
+    }
+  ]
+}

index.js

@@ -0,0 +1,116 @@
+'use strict'
+
+const fp = require('fastify-plugin')
+const Keyv = require('keyv')
+const BPromise = require('bluebird')
+const crypto = require('crypto')
+
+const cache = new Keyv()
+
+const CACHEABLE_METHODS = ['GET']
+const INTERVAL = 200
+const X_RESPONSE_CACHE = 'x-response-cache'
+const X_RESPONSE_CACHE_HIT = 'hit'
+const X_RESPONSE_CACHE_MISS = 'miss'
+
+const isCacheableRequest = (req) => {
+  return CACHEABLE_METHODS.includes(req.raw.method)
+}
+
+const buildCacheKey = (req, {headers}) => {
+  const {url, headers: requestHeaders} = req.raw
+  const additionalCondition = headers.reduce((acc, header) => {
+    return `${acc}__${header}:${requestHeaders[header] || ''}`
+  }, '')
+  const data = `${url}__${additionalCondition}`
+  const encrytedData = crypto.createHash('md5').update(data)
+  const key = encrytedData.digest('hex')
+
+  return key
+}
+
+const waitForCacheFulfilled = async (key, timeout) => {
+  let cachedString = await cache.get(key)
+  let waitedFor = 0
+
+  while (!cachedString) {
+    await BPromise.delay(INTERVAL)
+    cachedString = await cache.get(key)
+
+    waitedFor += INTERVAL
+    if (!cachedString && waitedFor > timeout) {
+      return
+    }
+  }
+
+  return cachedString
+}
+
+const createOnRequestHandler = ({
+  ttl,
+  additionalCondition: {headers},
+}) => async (req, res) => {
+  if (!isCacheableRequest(req)) {
+    return
+  }
+
+  const key = buildCacheKey(req, {headers})
+  const requestKey = `${key}__requested`
+  const isRequestExisted = await cache.get(requestKey)
+
+  if (isRequestExisted) {
+    const cachedString = await waitForCacheFulfilled(key, ttl)
+
+    if (cachedString) {
+      const cached = JSON.parse(cachedString)
+      res.header(X_RESPONSE_CACHE, X_RESPONSE_CACHE_HIT)
+
+      return res.code(cached.statusCode).send(cached.payload)
+    } else {
+      res.header(X_RESPONSE_CACHE, X_RESPONSE_CACHE_MISS)
+    }
+  } else {
+    await cache.set(requestKey, 'cached', ttl)
+    res.header(X_RESPONSE_CACHE, X_RESPONSE_CACHE_MISS)
+  }
+}
+
+const createOnSendHandler = ({ttl, additionalCondition: {headers}}) => async (
+  req,
+  res,
+  payload
+) => {
+  if (!isCacheableRequest(req)) {
+    return
+  }
+
+  const key = buildCacheKey(req, {headers})
+
+  await cache.set(
+    key,
+    JSON.stringify({
+      statusCode: res.statusCode,
+      payload,
+    }),
+    ttl
+  )
+}
+
+const responseCachingPlugin = (
+  instance,
+  {ttl = 1000, additionalCondition = {}},
+  next
+) => {
+  const headers = additionalCondition.headers || []
+  const opts = {ttl, additionalCondition: {headers}}
+
+  instance.addHook('onRequest', createOnRequestHandler(opts))
+  instance.addHook('onSend', createOnSendHandler(opts))
+
+  return next()
+}
+
+module.exports = fp(responseCachingPlugin, {
+  fastify: '3.x',
+  name: 'fastify-response-caching',
+})

index.test.js

@@ -0,0 +1,184 @@
+'use strict'
+
+const test = require('tap').test
+
+const axios = require('axios')
+const fastify = require('fastify')
+const BPromise = require('bluebird')
+
+const plugin = require('./index.js')
+
+test('should cache the cacheable request', (t) => {
+  t.plan(6)
+  const instance = fastify()
+  instance.register(plugin, {ttl: 1000})
+  instance.get('/cache', (req, res) => {
+    res.send({hello: 'world'})
+  })
+  instance.listen(0, async (err) => {
+    if (err) t.threw(err)
+    instance.server.unref()
+    const portNum = instance.server.address().port
+    const address = `http://127.0.0.1:${portNum}/cache`
+    const [response1, response2] = await BPromise.all([
+      axios.get(address),
+      axios.get(address),
+    ])
+    t.is(response1.status, 200)
+    t.is(response2.status, 200)
+    t.is(response1.headers['x-response-cache'], 'miss')
+    t.is(response2.headers['x-response-cache'], 'hit')
+    t.deepEqual(response1.data, {hello: 'world'})
+    t.deepEqual(response2.data, {hello: 'world'})
+  })
+})
+
+test('should not cache the uncacheable request', (t) => {
+  t.plan(6)
+  const instance = fastify()
+  instance.register(plugin, {ttl: 1000})
+  instance.post('/no-cache', (req, res) => {
+    res.send({hello: 'world'})
+  })
+  instance.listen(0, async (err) => {
+    if (err) t.threw(err)
+    instance.server.unref()
+    const portNum = instance.server.address().port
+    const address = `http://127.0.0.1:${portNum}/no-cache`
+    const [response1, response2] = await BPromise.all([
+      axios.post(address, {}),
+      axios.post(address, {}),
+    ])
+    t.is(response1.status, 200)
+    t.is(response2.status, 200)
+    t.notOk(response1.headers['x-response-cache'])
+    t.notOk(response2.headers['x-response-cache'])
+    t.deepEqual(response1.data, {hello: 'world'})
+    t.deepEqual(response2.data, {hello: 'world'})
+  })
+})
+
+test('should apply ttl config', (t) => {
+  t.plan(9)
+  const instance = fastify()
+  instance.register(plugin, {ttl: 2000})
+  instance.get('/ttl', (req, res) => {
+    res.send({hello: 'world'})
+  })
+  instance.listen(0, async (err) => {
+    if (err) t.threw(err)
+    instance.server.unref()
+    const portNum = instance.server.address().port
+    const address = `http://127.0.0.1:${portNum}/ttl`
+    const [response1, response2] = await BPromise.all([
+      axios.get(address),
+      axios.get(address),
+    ])
+    await BPromise.delay(3000)
+    const response3 = await axios.get(address)
+    t.is(response1.status, 200)
+    t.is(response2.status, 200)
+    t.is(response3.status, 200)
+    t.is(response1.headers['x-response-cache'], 'miss')
+    t.is(response2.headers['x-response-cache'], 'hit')
+    t.is(response3.headers['x-response-cache'], 'miss')
+    t.deepEqual(response1.data, {hello: 'world'})
+    t.deepEqual(response2.data, {hello: 'world'})
+    t.deepEqual(response3.data, {hello: 'world'})
+  })
+})
+
+test('should apply additionalCondition config', (t) => {
+  t.plan(12)
+  const instance = fastify()
+  instance.register(plugin, {
+    additionalCondition: {
+      headers: ['x-should-applied'],
+    },
+  })
+  instance.get('/headers', (req, res) => {
+    res.send({hello: 'world'})
+  })
+  instance.listen(0, async (err) => {
+    if (err) t.threw(err)
+    instance.server.unref()
+    const portNum = instance.server.address().port
+    const address = `http://127.0.0.1:${portNum}/headers`
+    const [response1, response2, response3, response4] = await BPromise.all([
+      axios.get(address, {
+        headers: {'x-should-applied': 'yes'},
+      }),
+      axios.get(address, {
+        headers: {'x-should-applied': 'yes'},
+      }),
+      axios.get(address, {
+        headers: {'x-should-applied': 'no'},
+      }),
+      axios.get(address),
+    ])
+    t.is(response1.status, 200)
+    t.is(response2.status, 200)
+    t.is(response3.status, 200)
+    t.is(response4.status, 200)
+    t.is(response1.headers['x-response-cache'], 'miss')
+    t.is(response2.headers['x-response-cache'], 'hit')
+    t.is(response3.headers['x-response-cache'], 'miss')
+    t.is(response4.headers['x-response-cache'], 'miss')
+    t.deepEqual(response1.data, {hello: 'world'})
+    t.deepEqual(response2.data, {hello: 'world'})
+    t.deepEqual(response3.data, {hello: 'world'})
+    t.deepEqual(response4.data, {hello: 'world'})
+  })
+})
+
+test('should waiting for cache if multiple same request come in', (t) => {
+  t.plan(6)
+  const instance = fastify()
+  instance.register(plugin, {ttl: 5000})
+  instance.get('/waiting', async (req, res) => {
+    await BPromise.delay(3000)
+    res.send({hello: 'world'})
+  })
+  instance.listen(0, async (err) => {
+    if (err) t.threw(err)
+    instance.server.unref()
+    const portNum = instance.server.address().port
+    const address = `http://127.0.0.1:${portNum}/waiting`
+    const [response1, response2] = await BPromise.all([
+      axios.get(address),
+      axios.get(address),
+    ])
+    t.is(response1.status, 200)
+    t.is(response2.status, 200)
+    t.is(response1.headers['x-response-cache'], 'miss')
+    t.is(response2.headers['x-response-cache'], 'hit')
+    t.deepEqual(response1.data, {hello: 'world'})
+    t.deepEqual(response2.data, {hello: 'world'})
+  })
+})
+
+test('should not waiting for cache due to timeout', (t) => {
+  t.plan(6)
+  const instance = fastify()
+  instance.register(plugin)
+  instance.get('/abort', async (req, res) => {
+    await BPromise.delay(2000)
+    res.send({hello: 'world'})
+  })
+  instance.listen(0, async (err) => {
+    if (err) t.threw(err)
+    instance.server.unref()
+    const portNum = instance.server.address().port
+    const address = `http://127.0.0.1:${portNum}/abort`
+    const [response1, response2] = await BPromise.all([
+      axios.get(address),
+      axios.get(address),
+    ])
+    t.is(response1.status, 200)
+    t.is(response2.status, 200)
+    t.is(response1.headers['x-response-cache'], 'miss')
+    t.is(response2.headers['x-response-cache'], 'miss')
+    t.deepEqual(response1.data, {hello: 'world'})
+    t.deepEqual(response2.data, {hello: 'world'})
+  })
+})