How do you implement a graceful degradation strategy in Node.js?

Question

Accepted Answer

**Graceful degradation** — continue working with reduced functionality when dependencies fail.

```javascript
class DegradationStrategy {
    constructor() {
        this.fallbacks = new Map();
    }

register(service, fallbackFn) {
        this.fallbacks.set(service, fallbackFn);
    }

async call(service, primaryFn, ...args) {
        try {
            return await primaryFn(...args);
        } catch (err) {
            console.error(`${service} failed:`, err.message);
            const fallback = this.fallbacks.get(service);
            if (fallback) {
                return fallback(...args);
            }
            throw err;
        }
    }
}

// Setup
const degradation = new DegradationStrategy();

degradation.register("recommendations", (userId) => {
    return getPopularProducts(); // fallback to popular
});

degradation.register("reviews", (productId) => {
    return { average: 0, count: 0 }; // empty reviews
});

// Usage
app.get("/products/:id", async (req, res) => {
    const product = await degradation.call(
        "recommendations",
        (userId) => getPersonalizedRecommendations(userId),
        req.user.id
    );
    res.json({ product, recommendations: product });
});
```

Node.js: How do you implement a graceful degradation strategy in Node.js?