How do you implement a cache invalidation strategy in Node.js?

Question

Accepted Answer

**Cache invalidation** — removing stale data from cache.

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

// Strategy 1: TTL-based
async function cacheWithTTL(key, fetchFn, ttl = 300) {
    let data = await redis.get(key);
    if (data) return JSON.parse(data);

data = await fetchFn();
    await redis.setEx(key, ttl, JSON.stringify(data));
    return data;
}

// Strategy 2: Write-through
async function updateUser(id, updates) {
    const user = await db.updateUser(id, updates);
    await redis.setEx(`user:${id}`, 3600, JSON.stringify(user));
    return user;
}

// Strategy 3: Tag-based invalidation
async function invalidateByTag(tag) {
    const keys = await redis.smembers(`tag:${tag}`);
    if (keys.length) {
        await redis.del(...keys);
        await redis.del(`tag:${tag}`);
    }
}

async function cacheWithTag(key, fetchFn, tags, ttl = 300) {
    const data = await cacheWithTTL(key, fetchFn, ttl);
    for (const tag of tags) {
        await redis.sadd(`tag:${tag}`, key);
    }
    return data;
}

// Invalidate all product caches
await invalidateByTag("products");
```

**Strategies:**
- TTL: simple, eventual consistency.
- Write-through: update on write.
- Tag-based: invalidate groups.

Node.js: How do you implement a cache invalidation strategy in Node.js?