redis

Redis

Overview

Redis is an in-memory data structure store used as a cache, message broker, and database. This skill covers caching patterns, data structures, and common use cases.

Common Use Cases

Caching

// Cache-aside pattern (most common)
async function getUser(id: string): Promise<User> {
  const cacheKey = `user:${id}`;

  // 1. Check cache
  const cached = await redis.get(cacheKey);
  if (cached) return JSON.parse(cached);

  // 2. Cache miss → fetch from DB
  const user = await db.users.findById(id);
  if (!user) throw new NotFoundError();

  // 3. Populate cache with TTL
  await redis.set(cacheKey, JSON.stringify(user), 'EX', 3600); // 1 hour

  return user;
}

// Invalidate on mutation
async function updateUser(id: string, data: UpdateUserDto): Promise<User> {
  const user = await db.users.update(id, data);
  await redis.del(`user:${id}`); // Invalidate cache
  return user;
}

Sessions

// Store session data with TTL
await redis.set(`session:${sessionId}`, JSON.stringify({
  userId: user.id,
  role: user.role,
  loginAt: Date.now(),
}), 'EX', 86400); // 24 hours

// Retrieve
const session = JSON.parse(await redis.get(`session:${sessionId}`) || 'null');

Rate Limiting

// Sliding window rate limiter
async function checkRateLimit(ip: string, limit: number, windowSec: number): Promise<boolean> {
  const key = `ratelimit:${ip}`;
  const current = await redis.incr(key);

  if (current === 1) {
    await redis.expire(key, windowSec);
  }

  return current <= limit;
}

Pub/Sub

// Publisher
await redis.publish('notifications', JSON.stringify({
  userId: '123',
  type: 'new_message',
  payload: { from: 'Jane', text: 'Hello' },
}));

// Subscriber
const sub = redis.duplicate();
await sub.subscribe('notifications');
sub.on('message', (channel, message) => {
  const notification = JSON.parse(message);
  sendToWebSocket(notification.userId, notification);
});

Data Structures