Redis Caching in PayloadCMS v3 Beta?

[thijssmudde]

I’ve been digging into PayloadCMS v3 Beta and noticed that the old Redis caching plugin doesn’t seem to work anymore. Since caching is essential for performance—especially for collections and globals—I’m trying to figure out how to set it up in v3.

Has anyone managed to get Redis caching working in the new beta?
I’m guessing the changes in v3 might require a different approach than the old plugin. Anyone know what’s changed or have some tips?

Thinking about using custom hooks or middleware for caching and invalidation, but I’m not sure if that’s the best route.
What I’ve tried:
Looked at the old plugin code to see if it could be adapted for v3—no luck so far.

If anyone’s been down this road already or has any ideas, I’d love to hear from you! Bonus points for examples or links to resources that might help.

Thanks in advance!

[willemmulder]

I've also been looking into this. The collection afterChange hook can be used to store documents in cache. However, afaik there is currently no way to intercept find requests and then return data from cache. There are the beforeOperate and beforeRead hooks, but I don't see a way to return data there directly and prevent the query from happening. Does anyone know?

[revnelson]

It's ugly, but you can create your own endpoint (for example at /src/app/api/getPageData/route.tsx) and do the redis fetching in there. Hopefully an official fix is made so the native Payload find logic doesn't need to be recreated by hand.

[mkazyrevich]

Do you have any progress with the redis caching for payload cms v3?

[maximseshuk]

@thijssmudde what if we try to handle the paths within the application ourselves? Here's some sample code (not functional):

// app/api/[...slug]/route.ts
import { createHandlers } from './cache-handler'

const handlers = createHandlers({
  includedCollections: ['posts', 'products'],
  includedGlobals: ['settings'],
  includedPaths: ['/api/custom'],
  apiBaseUrl: '/api',
  defaultUserCollection: 'users'
})

export const { GET, POST, PUT, PATCH, DELETE, OPTIONS } = handlers

and

// app/api/[...slug]/cache-handler.ts
import { Hono } from 'hono'
import type { MiddlewareHandler } from 'hono'
import { handleEndpoints } from 'payload'
import config from '@payload-config'

interface CacheAdapter {
  get(key: string): Promise<string | null>
  set(key: string, value: string, options?: unknown): Promise<void>
  del(key: string): Promise<void>
}

interface AuthAdapter {
  getUserIdentifier(req: Request): Promise<string>
  getAuthToken(req: Request): string | null
}

interface CacheKeyGenerator {
  generate(req: Request, userId: string, authToken: string | null): string
}

interface RequestMatcher {
  shouldCache(req: Request): boolean
}

interface HandlerConfig {
  cacheAdapter: CacheAdapter
  authAdapter: AuthAdapter
  keyGenerator: CacheKeyGenerator
  requestMatcher: RequestMatcher
  timeToLive?: number
}

export const createHandlers = ({
  cacheAdapter,
  authAdapter,
  keyGenerator,
  requestMatcher,
}: HandlerConfig) => {
  const app = new Hono()

  const cacheMiddleware: MiddlewareHandler = async (c, next) => {
    const req = c.req
    if (!requestMatcher.shouldCache(req)) return next()

    try {
      const userId = await authAdapter.getUserIdentifier(req)
      const authToken = authAdapter.getAuthToken(req)
      const cacheKey = keyGenerator.generate(req, userId, authToken)

      const cached = await cacheAdapter.get(cacheKey)
      if (cached) {
        return new Response(cached, {
          headers: { 'Content-Type': 'application/json', 'X-Cache': 'HIT' }
        })
      }

      const response = await next()
      const clone = response.clone()

      if (response.ok) {
        const body = await clone.text()
        await cacheAdapter.set(cacheKey, body)
      }

      return response
    } catch (error) {
      console.error('Cache middleware error:', error)
      return next()
    }
  }

  app.use('*', cacheMiddleware)

  const handler = async (req: Request) => {
    try {
      const honoResponse = await app.fetch(req)
      if (honoResponse.status !== 404) {
        return honoResponse
      }
      const awaitedConfig = await config
      return await handleEndpoints({
        basePath: process.env.NEXT_BASE_PATH,
        config: awaitedConfig,
        request: req,
      })
    } catch (error) {
      console.error('Request handler error:', error)
      return new Response('Internal Server Error', { status: 500 })
    }
  }

  return {
    GET: handler,
    POST: handler,
    PUT: handler,
    PATCH: handler,
    DELETE: handler,
    OPTIONS: handler,
  }
}

This will let you get information about the request and handle it before calling handleEndpoints, everything you need.