What are the different caching patterns in Node.js?

Question

Accepted Answer

**Caching patterns** — different strategies for different use cases.

**Cache-aside (Lazy Loading):**
```javascript
async function cacheAside(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;
}
```
- Pros: only loads what's needed, resilient to cache failure.
- Cons: cache miss penalty.

**Write-through:**
```javascript
async function writeThrough(key, data, ttl = 300) {
    await db.update(key, data);
    await redis.setEx(key, ttl, JSON.stringify(data));
}
```
- Pros: cache always fresh.
- Cons: write latency.

**Write-behind (Write-back):**
```javascript
const writeQueue = new Queue("db-writes");

async function writeBehind(key, data) {
    await redis.setEx(key, 300, JSON.stringify(data));
    await writeQueue.add("update", { key, data });
}
```
- Pros: fast writes.
- Cons: data loss risk.

**Read-through:**
```javascript
async function readThrough(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;
}
```

Node.js: What are the different caching patterns in Node.js?