Caching in Nuxt · NuxtHub

API Routes Caching

To cache Nuxt API and server routes, use the cachedEventHandler function. This function will cache the response of the server route into the cache storage.

server/api/cached-route.ts

import type { H3Event } from 'h3'

export default cachedEventHandler((event) => {
  return {
    success: true,
    date: new Date().toISOString()
  }
}, {
  maxAge: 60 * 60, // 1 hour
  getKey: (event: H3Event) => event.path
})

The above example will cache the response of the /api/cached-route route for 1 hour. The getKey function is used to generate the key for the cache entry.

Server Functions Caching

Using the cachedFunction function, You can cache the response of a server function based on the arguments passed to the function.

This is useful to cache the result of a function used in multiple API routes or within authenticated routes.

server/utils/cached-function.ts

import type { H3Event } from 'h3'

export const getRepoStarCached = defineCachedFunction(async (event: H3Event, repo: string) => {
  const data: any = await $fetch(`https://api.github.com/repos/${repo}`)

  return data.stargazers_count
}, {
  maxAge: 60 * 60, // 1 hour
  name: 'ghStars',
  getKey: (event: H3Event, repo: string) => repo
})

The above example will cache the result of the getRepoStarCached function for 1 hour.

It is important to note that the event argument should always be the first argument of the cached function. Nitro leverages event.waitUntil to keep the instance alive while the cache is being updated while the response is sent to the client.
Read more about this in the Nitro docs.

Routes Caching

You can enable route caching in your nuxt.config.ts file.

nuxt.config.ts

export default defineNuxtConfig({
  routeRules: {
    '/blog/**': {
      cache: {
        maxAge: 60 * 60,
        // other options like name, group, swr...
      }
    }
  }
})

Cache Invalidation

When using the defineCachedFunction or defineCachedEventHandler functions, the cache key is generated using the following pattern:

`${options.group}:${options.name}:${options.getKey(...args)}.json`

The defaults are:

group: 'nitro'
name: 'handlers' for API routes, 'functions' for server functions, or 'routes' for route handlers

For example, the following function:

const getAccessToken = defineCachedFunction(() => {
  return String(Date.now())
}, {
  maxAge: 60,
  name: 'getAccessToken',
  getKey: () => 'default'
})

Will generate the following cache key:

nitro:functions:getAccessToken:default.json

You can invalidate the cached function entry from your storage using cache key.

await useStorage('cache').removeItem('nitro:functions:getAccessToken:default.json')

You can use the group and name options to invalidate multiple cache entries based on their prefixes.

// Gets all keys that start with nitro:handlers
await useStorage('cache').clear('nitro:handlers')

Normalizing Cache Keys

Cache keys are automatically normalized using an internal utility that removes non-alphanumeric characters such as / and -. This behavior helps ensure compatibility across various storage backends (e.g., file systems, key-value stores) that might have restrictions on characters in keys, and also prevents potential path traversal vulnerabilities.

For example:

getKey: () => '/api/products/sale-items'

Would generate a key like:

api/productssaleitems.json

This behavior may result in keys that look different from the original route or identifier.

To manually reproduce the same normalized key pattern used by Nitro (e.g., when invalidating cache entries), you can use the escapeKey utility function provided below:

function escapeKey(key: string | string[]) {
  return String(key).replace(/\W/g, "");
}

It's recommended to use escapeKey() when invalidating manually using route paths or identifiers to ensure consistency with Nitro's internal key generation.

For example, if your getKey function is:

getKey: (id: string) => `product/${id}/details`

And you want to invalidate product/123/details, you would do:

const normalizedKey = escapeKey('product/123/details')
await useStorage('cache').removeItem(`nitro:functions:getProductDetails:${normalizedKey}.json`)