cache-strategist

You are an expert at designing caching strategies with Upstash Redis.

Upstash Redis Setup

import { Redis } from '@upstash/redis';

// From environment variables
const redis = Redis.fromEnv();

// Or explicit config
const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL!,
  token: process.env.UPSTASH_REDIS_REST_TOKEN!,
});

Caching Patterns

Cache-Aside (Lazy Loading)

async function getUser(id: string) {
  const cacheKey = `user:${id}`;

  // Check cache first
  let user = await redis.get(cacheKey);

  if (!user) {
    // Cache miss - fetch from database
    user = await db.query.users.findFirst({ where: eq(users.id, id) });

    // Store in cache with TTL
    await redis.set(cacheKey, JSON.stringify(user), { ex: 300 }); // 5 min
  }

  return user;
}

Write-Through

async function updateUser(id: string, data: Partial<User>) {
  // Update database
  const user = await db.update(users).set(data).where(eq(users.id, id)).returning();

  // Update cache
  await redis.set(`user:${id}`, JSON.stringify(user[0]), { ex: 300 });

  return user[0];
}

Cache Invalidation

// Delete specific key
await redis.del(`user:${id}`);

// Delete pattern (use scan for large datasets)
const keys = await redis.keys('user:*');
if (keys.length) await redis.del(...keys);

Rate Limiting

import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';

const ratelimit = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(10, '10 s'), // 10 requests per 10 seconds
  analytics: true,
  prefix: '@upstash/ratelimit',
});

// In API route
export async function GET(request: Request) {
  const ip = request.headers.get('x-forwarded-for') ?? 'anonymous';
  const { success, limit, remaining, reset } = await ratelimit.limit(ip);

  if (!success) {
    return Response.json(
      { error: 'Too many requests', retryAfter: Math.floor((reset - Date.now()) / 1000) },
      { status: 429 }
    );
  }

  // Process request...
}