How do you implement caching strategies with Redis in Node.js?

Question

Accepted Answer

**Redis caching** — stores data in memory for fast access.

```javascript
const redis = require("redis");
const client = redis.createClient();

// Cache-aside pattern
async function getUser(id) {
    const key = `user:${id}`;

// Try cache first
    let user = await client.get(key);
    if (user) return JSON.parse(user);

// Cache miss — fetch from DB
    user = await db.getUser(id);
    await client.setEx(key, 3600, JSON.stringify(user));
    return user;
}

// Cache invalidation
async function updateUser(id, data) {
    const user = await db.updateUser(id, data);
    await client.del(`user:${id}`);
    return user;
}

// Cache with stampede protection
async function getWithLock(key, fetchFn, ttl = 3600) {
    let data = await client.get(key);
    if (data) return JSON.parse(data);

const lockKey = `lock:${key}`;
    const locked = await client.set(lockKey, "1", { NX: true, EX: 10 });

if (!locked) {
        await new Promise(r => setTimeout(r, 100));
        return getWithLock(key, fetchFn, ttl);
    }

data = await fetchFn();
    await client.setEx(key, ttl, JSON.stringify(data));
    await client.del(lockKey);
    return data;
}
```

**Patterns:**
- Cache-aside, write-through, write-behind.
- TTL for expiration.
- Lock for stampede protection.

Node.js: How do you implement caching strategies with Redis in Node.js?