Redis 8 Caching Strategies: From Basics to Production Patterns

import Redis from 'ioredis';
const redis = new Redis(process.env.REDIS_URL);

// Cache-Aside Pattern (most common)
async function getUserWithCache(userId: string) {
  const cacheKey = `user:${userId}`;
  
  // 1. Check cache
  const cached = await redis.get(cacheKey);
  if (cached) {
    console.log('Cache HIT');
    return JSON.parse(cached);
  }
  
  // 2. Cache MISS — read from database
  console.log('Cache MISS — fetching from DB');
  const user = await db.user.findUnique({ where: { id: userId } });
  
  if (!user) return null;
  
  // 3. Write to cache with TTL (1 hour)
  await redis.setex(cacheKey, 3600, JSON.stringify(user));
  
  return user;
}

// Cache Invalidation (on update)
async function updateUser(userId: string, data: UpdateUserInput) {
  // 1. Update database
  const user = await db.user.update({ where: { id: userId }, data });
  
  // 2. Invalidate cache (next read will refresh)
  await redis.del(`user:${userId}`);
  
  // Also invalidate any list caches
  await redis.del('users:list:page:*');
  
  return user;
}

// Write-Through Pattern
async function createPost(data: CreatePostInput) {
  // 1. Write to database
  const post = await db.post.create({ data });
  
  // 2. Immediately write to cache (always fresh)
  await redis.setex(`post:${post.id}`, 3600, JSON.stringify(post));
  
  // 3. Invalidate list cache
  await redis.del('posts:latest');
  
  return post;
}

// Publisher: Notify all servers of cache invalidation
async function publishCacheInvalidation(key: string) {
  await redis.publish('cache:invalidate', JSON.stringify({
    key,
    timestamp: Date.now(),
    source: process.env.SERVER_ID,
  }));
}

// Subscriber: Listen for invalidation events
const subscriber = new Redis(process.env.REDIS_URL);
subscriber.subscribe('cache:invalidate', (err) => {
  if (err) console.error('Subscribe failed:', err);
});

subscriber.on('message', async (channel, message) => {
  const { key, source } = JSON.parse(message);
  
  // Don't process our own messages
  if (source === process.env.SERVER_ID) return;
  
  // Invalidate local cache
  await localCache.delete(key);
  console.log(`Cache invalidated: ${key}`);
});

// Real-time notifications
await redis.publish('notifications:user:123', JSON.stringify({
  type: 'new_comment',
  postTitle: 'React Server Components Guide',
  commenter: 'Priya',
}));

// Sliding Window Rate Limiter
async function checkRateLimit(
  key: string,
  limit: number,
  windowSeconds: number
): Promise<{ allowed: boolean; remaining: number; resetAt: number }> {
  const now = Date.now();
  const windowStart = now - (windowSeconds * 1000);
  
  // Use sorted set with timestamp as score
  const multi = redis.multi();
  multi.zremrangebyscore(key, 0, windowStart); // Remove expired entries
  multi.zadd(key, now, `${now}:${Math.random()}`); // Add current request
  multi.zcard(key); // Count requests in window
  multi.expire(key, windowSeconds); // Auto-cleanup
  
  const results = await multi.exec();
  const requestCount = results![2][1] as number;
  
  return {
    allowed: requestCount <= limit,
    remaining: Math.max(0, limit - requestCount),
    resetAt: Math.ceil((windowStart + windowSeconds * 1000) / 1000),
  };
}

// Usage in middleware
app.addHook('onRequest', async (request, reply) => {
  const result = await checkRateLimit(
    `ratelimit:${request.ip}`,
    100,  // 100 requests
    60    // per 60 seconds
  );
  
  reply.header('X-RateLimit-Limit', '100');
  reply.header('X-RateLimit-Remaining', result.remaining.toString());
  reply.header('X-RateLimit-Reset', result.resetAt.toString());
  
  if (!result.allowed) {
    return reply.status(429).send({ error: 'Too many requests' });
  }
});