Caching Strategies in Web Applications

Practical Caching Applications

API Response Caching

Implementing a middleware for caching API responses can significantly improve API performance and reduce database load.

// Express middleware for API response caching
function apiCache(redisClient, options = {}) {
  const {
    ttl = 60, // Default TTL in seconds
    keyPrefix = 'api:cache:',
    keyGenerator = null,
    shouldCache = null
  } = options;
  
  return async function cacheMiddleware(req, res, next) {
    // Skip caching for non-GET requests
    if (req.method !== 'GET') {
      return next();
    }
    
    // Generate cache key
    const key = keyGenerator
      ? keyGenerator(req)
      : `${keyPrefix}${req.originalUrl || req.url}`;
    
    // Check if we should cache this request
    if (shouldCache && !shouldCache(req)) {
      req.skipCache = true;
      return next();
    }
    
    try {
      // Try to get from cache
      const cachedResponse = await redisClient.get(key);
      
      if (cachedResponse) {
        const { statusCode, body, headers } = JSON.parse(cachedResponse);
        
        // Set headers from cached response
        if (headers) {
          for (const [name, value] of Object.entries(headers)) {
            res.setHeader(name, value);
          }
        }
        
        // Add cache header for transparency
        res.setHeader('X-Cache', 'HIT');
        
        // Send cached response
        return res.status(statusCode).send(body);
      }
      
      // Cache miss, capture the response
      const originalSend = res.send;
      
      res.send = function(body) {
        // Only cache successful responses
        if (res.statusCode >= 200 && res.statusCode < 300 && !req.skipCache) {
          const headers = {};
          
          // Get content-type and other important headers
          const headersToCache = ['content-type', 'content-language', 'content-encoding'];
          
          for (const header of headersToCache) {
            const value = res.getHeader(header);
            if (value) {
              headers[header] = value;
            }
          }
          
          // Store response in cache
          const cacheEntry = JSON.stringify({
            statusCode: res.statusCode,
            body,
            headers
          });
          
          redisClient.set(key, cacheEntry, { EX: ttl }).catch(err => {
            console.error('Error caching response:', err);
          });
        }
        
        // Add cache header for transparency
        res.setHeader('X-Cache', 'MISS');
        
        // Call original send
        return originalSend.call(this, body);
      };
      
      next();
    } catch (error) {
      console.error('Cache middleware error:', error);
      next();
    }
  };
}

// Usage in Express app
const express = require('express');
const redis = require('redis');

const app = express();
const redisClient = redis.createClient();

await redisClient.connect();

// Apply cache middleware to specific routes
app.get('/api/products', 
  apiCache(redisClient, { ttl: 300 }), // 5 minutes cache
  async (req, res) => {
    try {
      const products = await db.products.find().limit(20).toArray();
      res.json(products);
    } catch (error) {
      console.error('Error fetching products:', error);
      res.status(500).json({ error: 'Failed to fetch products' });
    }
  }
);

// Route with custom cache key
app.get('/api/products/category/:categoryId',
  apiCache(redisClient, {
    ttl: 600, // 10 minutes
    keyGenerator: (req) => `api:products:category:${req.params.categoryId}`
  }),
  async (req, res) => {
    try {
      const products = await db.products.find({
        categoryId: req.params.categoryId
      }).toArray();
      
      res.json(products);
    } catch (error) {
      console.error('Error fetching products by category:', error);
      res.status(500).json({ error: 'Failed to fetch products' });
    }
  }
);

// Route with conditional caching
app.get('/api/user/:userId/profile',
  apiCache(redisClient, {
    ttl: 1800, // 30 minutes
    // Don't cache if user is viewing their own profile (likely to change)
    shouldCache: (req) => req.params.userId !== req.user?.id
  }),
  async (req, res) => {
    // Profile retrieval logic...
  }
);
            

Session Storage

Using Redis for session storage provides better performance and easier scaling than traditional server-side sessions.

// Redis session storage for Express
const express = require('express');
const session = require('express-session');
const RedisStore = require('connect-redis').default;
const redis = require('redis');

const app = express();

// Create Redis client
const redisClient = redis.createClient({
  url: process.env.REDIS_URL || 'redis://localhost:6379'
});

redisClient.connect().catch(console.error);

// Configure session middleware
app.use(
  session({
    store: new RedisStore({ client: redisClient }),
    secret: process.env.SESSION_SECRET || 'your-secret-key',
    resave: false,
    saveUninitialized: false,
    cookie: {
      secure: process.env.NODE_ENV === 'production',
      httpOnly: true,
      maxAge: 1000 * 60 * 60 * 24 * 7 // 1 week
    }
  })
);

// Session usage example
app.post('/login', async (req, res) => {
  const { username, password } = req.body;
  
  // Authenticate user (simplified)
  const user = await authenticateUser(username, password);
  
  if (user) {
    // Store user info in session
    req.session.user = {
      id: user._id,
      username: user.username,
      role: user.role,
      lastLogin: new Date()
    };
    
    res.json({ success: true, message: 'Login successful' });
  } else {
    res.status(401).json({ success: false, message: 'Invalid credentials' });
  }
});

app.get('/profile', (req, res) => {
  // Check if user is logged in
  if (!req.session.user) {
    return res.status(401).json({ error: 'Not authenticated' });
  }
  
  // Use session data
  res.json({
    user: req.session.user,
    sessionID: req.sessionID
  });
});

app.post('/logout', (req, res) => {
  req.session.destroy((err) => {
    if (err) {
      return res.status(500).json({ error: 'Logout failed' });
    }
    
    res.clearCookie('connect.sid');
    res.json({ success: true, message: 'Logged out successfully' });
  });
});
            

Rate Limiting

Redis is perfect for implementing rate limiting to protect your API from abuse and ensure fair usage.

// Redis-based rate limiting middleware
function rateLimiter(redisClient, options = {}) {
  const {
    points = 10, // Number of requests allowed
    duration = 60, // Time window in seconds
    keyPrefix = 'ratelimit:',
    keyGenerator = null,
    errorMessage = 'Too many requests, please try again later',
    statusCode = 429 // Too Many Requests
  } = options;
  
  return async function rateLimitMiddleware(req, res, next) {
    try {
      // Generate key based on IP or user ID
      const identifier = req.user?.id || req.ip;
      const key = keyGenerator
        ? keyGenerator(req)
        : `${keyPrefix}${identifier}`;
      
      // Get current count and TTL
      const [current, ttl] = await Promise.all([
        redisClient.get(key),
        redisClient.ttl(key)
      ]);
      
      // Calculate points consumed and time left
      const count = current ? parseInt(current) : 0;
      const timeLeft = ttl > 0 ? ttl : duration;
      
      // Set headers for rate limit info
      res.setHeader('X-RateLimit-Limit', points);
      res.setHeader('X-RateLimit-Remaining', Math.max(0, points - count - 1));
      res.setHeader('X-RateLimit-Reset', Date.now() + timeLeft * 1000);
      
      // Check if rate limit exceeded
      if (count >= points) {
        return res.status(statusCode).json({
          error: errorMessage,
          retryAfter: timeLeft
        });
      }
      
      // Increment counter
      if (count === 0) {
        // First request in window, set with expiration
        await redisClient.set(key, 1, { EX: duration });
      } else {
        // Increment existing counter
        await redisClient.incr(key);
      }
      
      next();
    } catch (error) {
      console.error('Rate limit middleware error:', error);
      // Fail open - let request through if rate limiting fails
      next();
    }
  };
}

// Usage in Express app
app.use('/api/sensitive-endpoint',
  rateLimiter(redisClient, {
    points: 5,
    duration: 60, // 5 requests per minute
    keyPrefix: 'ratelimit:sensitive:'
  }),
  async (req, res) => {
    // Endpoint logic...
  }
);

// Different limits for logged-in vs anonymous users
app.use('/api/public',
  (req, res, next) => {
    // Apply different rate limits based on user status
    const limiterOptions = req.user
      ? { points: 100, duration: 60 } // 100 requests per minute for logged-in users
      : { points: 20, duration: 60 };  // 20 requests per minute for anonymous users
    
    rateLimiter(redisClient, limiterOptions)(req, res, next);
  },
  async (req, res) => {
    // Endpoint logic...
  }
);
            

Distributed Locks

Redis can be used to implement distributed locks, which are crucial for coordinating operations across multiple servers in a distributed system.

// Redis-based distributed lock
class RedisLock {
  constructor(redisClient, options = {}) {
    this.redisClient = redisClient;
    this.options = {
      lockPrefix: 'lock:',
      retryCount: 5,
      retryDelay: 200,
      lockTimeout: 10000, // 10 seconds
      ...options
    };
  }
  
  /**
   * Acquire a distributed lock
   * @param {string} resource - Resource identifier to lock
   * @param {object} options - Lock options
   * @returns {Promise} - Lock token if successful, null if failed
   */
  async acquire(resource, options = {}) {
    const {
      retryCount = this.options.retryCount,
      retryDelay = this.options.retryDelay,
      lockTimeout = this.options.lockTimeout
    } = options;
    
    const lockKey = `${this.options.lockPrefix}${resource}`;
    const token = this.generateToken();
    
    for (let attempt = 0; attempt <= retryCount; attempt++) {
      // Try to set the lock with NX option (only if it doesn't exist)
      const result = await this.redisClient.set(lockKey, token, {
        NX: true,
        PX: lockTimeout
      });
      
      if (result === 'OK') {
        return token; // Lock acquired successfully
      }
      
      // If we've reached max retries, give up
      if (attempt === retryCount) {
        return null; // Failed to acquire lock
      }
      
      // Wait before retrying
      await new Promise(resolve => setTimeout(resolve, retryDelay));
    }
    
    return null; // Should not reach here, but just in case
  }
  
  /**
   * Release a distributed lock
   * @param {string} resource - Resource identifier to unlock
   * @param {string} token - Lock token
   * @returns {Promise} - True if released, false if not owner
   */
  async release(resource, token) {
    const lockKey = `${this.options.lockPrefix}${resource}`;
    
    // Use Lua script to ensure atomic release
    const script = `
      if redis.call('get', KEYS[1]) == ARGV[1] then
        return redis.call('del', KEYS[1])
      else
        return 0
      end
    `;
    
    const result = await this.redisClient.eval(script, {
      keys: [lockKey],
      arguments: [token]
    });
    
    return result === 1;
  }
  
  /**
   * Extend the lock timeout
   * @param {string} resource - Resource identifier
   * @param {string} token - Lock token
   * @param {number} timeout - New timeout in milliseconds
   * @returns {Promise} - True if extended, false if not owner
   */
  async extend(resource, token, timeout = this.options.lockTimeout) {
    const lockKey = `${this.options.lockPrefix}${resource}`;
    
    // Use Lua script to ensure atomic extension
    const script = `
      if redis.call('get', KEYS[1]) == ARGV[1] then
        return redis.call('pexpire', KEYS[1], ARGV[2])
      else
        return 0
      end
    `;
    
    const result = await this.redisClient.eval(script, {
      keys: [lockKey],
      arguments: [token, timeout.toString()]
    });
    
    return result === 1;
  }
  
  /**
   * Generate a unique token for the lock
   * @returns {string} - Unique token
   */
  generateToken() {
    return `${Math.random().toString(36).substring(2)}:${Date.now()}`;
  }
}

// Usage example
async function processOrder(orderId) {
  const lock = new RedisLock(redisClient);
  const resource = `order:${orderId}`;
  
  // Try to acquire a lock
  const token = await lock.acquire(resource, { 
    lockTimeout: 30000 // 30 seconds
  });
  
  if (!token) {
    console.log(`Failed to acquire lock for order ${orderId}, already being processed`);
    return false;
  }
  
  try {
    console.log(`Processing order ${orderId}...`);
    
    // Simulate long-running process
    await processingLogic(orderId);
    
    // Operation completed successfully
    return true;
  } catch (error) {
    console.error(`Error processing order ${orderId}:`, error);
    throw error;
  } finally {
    // Always release the lock when done
    await lock.release(resource, token);
    console.log(`Released lock for order ${orderId}`);
  }
}

// Example with lock extension for long-running tasks
async function generateLargeReport(reportId) {
  const lock = new RedisLock(redisClient);
  const resource = `report:${reportId}`;
  
  // Try to acquire a lock
  const token = await lock.acquire(resource, { 
    lockTimeout: 60000 // 1 minute initial timeout
  });
  
  if (!token) {
    console.log(`Failed to acquire lock for report ${reportId}, already being generated`);
    return false;
  }
  
  // Set up automatic lock extension to prevent expiration during processing
  const extensionInterval = setInterval(async () => {
    const extended = await lock.extend(resource, token, 60000);
    if (extended) {
      console.log(`Extended lock for report ${reportId}`);
    } else {
      console.warn(`Failed to extend lock for report ${reportId}, it may have been lost`);
      clearInterval(extensionInterval);
    }
  }, 30000); // Extend every 30 seconds
  
  try {
    console.log(`Generating report ${reportId}...`);
    
    // Simulate long-running report generation
    await generateReportLogic(reportId);
    
    // Operation completed successfully
    return true;
  } catch (error) {
    console.error(`Error generating report ${reportId}:`, error);
    throw error;
  } finally {
    // Clear the extension interval
    clearInterval(extensionInterval);
    
    // Release the lock when done
    await lock.release(resource, token);
    console.log(`Released lock for report ${reportId}`);
  }
}
            

Database Query Caching

Caching database query results can significantly reduce database load and improve application performance.

// Database query caching system
class QueryCache {
  constructor(redisClient, options = {}) {
    this.redisClient = redisClient;
    this.options = {
      keyPrefix: 'query:',
      defaultTTL: 3600, // 1 hour
      ...options
    };
  }
  
  /**
   * Generate a cache key for a query
   * @param {string} collection - Collection or table name
   * @param {object} query - Query parameters
   * @param {object} options - Query options (projection, sort, limit, etc.)
   * @returns {string} - Cache key
   */
  generateKey(collection, query, options = {}) {
    // Create a deterministic string from the query and options
    const queryString = JSON.stringify(query, Object.keys(query).sort());
    const optionsString = JSON.stringify(options, Object.keys(options).sort());
    
    // Create a hash of the query+options for a shorter key
    const hash = require('crypto')
      .createHash('md5')
      .update(`${queryString}:${optionsString}`)
      .digest('hex');
    
    return `${this.options.keyPrefix}${collection}:${hash}`;
  }
  
  /**
   * Execute a query with caching
   * @param {string} collection - Collection or table name
   * @param {object} query - Query parameters
   * @param {object} options - Query options (projection, sort, limit, etc.)
   * @param {function} queryFn - Function to execute if cache miss
   * @param {object} cacheOptions - Caching options
   * @returns {Promise