pn-caching

Caching

When to use

• Reducing database query load or external API call volume
• Adding in-memory or Redis caching to a backend service
• Configuring HTTP cache headers and CDN behaviour
• Using Next.js server-side caching (fetch options, unstable_cache, route segment config)
• Adding SWR or React Query for client-side data fetching with stale-while-revalidate

Cache hierarchy

Browser Cache (memory / disk)
    ↓ miss
CDN / Edge Cache (Vercel Edge, Cloudflare)
    ↓ miss
Application Cache (Redis / in-memory)
    ↓ miss
Database / External API

Redis patterns

Read-through (most common)

import { Redis } from "ioredis";

const redis = new Redis(process.env.REDIS_URL!);

async function getProduct(id: string): Promise<Product> {
  const cached = await redis.get(`product:${id}`);
  if (cached) return JSON.parse(cached) as Product;

  const product = await db.product.findUniqueOrThrow({ where: { id } });
  await redis.setex(`product:${id}`, 300, JSON.stringify(product)); // TTL: 5 min
  return product;
}

Write-through (keep cache consistent on writes)

async function updateProduct(id: string, data: Partial<Product>): Promise<Product> {
  const product = await db.product.update({ where: { id }, data });
  await redis.setex(`product:${id}`, 300, JSON.stringify(product));
  return product;
}

Cache invalidation on write

async function deleteProduct(id: string): Promise<void> {
  await db.product.delete({ where: { id } });
  await redis.del(`product:${id}`);
  await redis.del("products:list"); // invalidate list caches too
}

Stampede protection (dogpile prevention)

async function getWithLock<T>(key: string, ttl: number, fetcher: () => Promise<T>): Promise<T> {
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached) as T;

  const lockKey = `lock:${key}`;
  const acquired = await redis.set(lockKey, "1", "NX", "EX", 5); // 5s lock
  if (!acquired) {
    await new Promise((r) => setTimeout(r, 100));
    return getWithLock(key, ttl, fetcher); // retry after brief wait
  }
  try {
    const value = await fetcher();
    await redis.setex(key, ttl, JSON.stringify(value));
    return value;
  } finally {
    await redis.del(lockKey);
  }
}