Caching Strategy

import redis
import json

# Redis connection
r = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)

# ──────────────────────────────────────────────
# 1. STRING — Simple cache
# ──────────────────────────────────────────────
# Set with TTL (expires in 5 minutes)
r.set('user:123:name', 'Ripon Ahmed', ex=300)
name = r.get('user:123:name')   # 'Ripon Ahmed'

# ──────────────────────────────────────────────
# 2. HASH — Object store (User profile)
# ──────────────────────────────────────────────
r.hset('user:123', mapping={
    'name': 'Ripon Ahmed',
    'email': 'ripon@example.com',
    'age': '28'
})
user = r.hgetall('user:123')
# {'name': 'Ripon Ahmed', 'email': 'ripon@example.com', 'age': '28'}

# Single field পড়ো
email = r.hget('user:123', 'email')

# ──────────────────────────────────────────────
# 3. COUNTER — Atomic increment (race-condition safe)
# ──────────────────────────────────────────────
r.set('page:home:views', 0)
r.incr('page:home:views')   # 1
r.incr('page:home:views')   # 2
r.incrby('page:home:views', 10)  # 12

# ──────────────────────────────────────────────
# 4. SORTED SET — Leaderboard
# ──────────────────────────────────────────────
# Game leaderboard — player: score
r.zadd('leaderboard:game1', {
    'alice': 9500,
    'bob': 8700,
    'charlie': 9800,
    'diana': 7200
})

# Top 3 players (highest score first)
top3 = r.zrevrange('leaderboard:game1', 0, 2, withscores=True)
# [('charlie', 9800.0), ('alice', 9500.0), ('bob', 8700.0)]

# Alice এর rank (0-indexed)
rank = r.zrevrank('leaderboard:game1', 'alice')  # 1 (2nd place)

const redis = require('redis');

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

// ──────────────────────────────────────────────────────────────
// Cache-Aside Pattern — Production-ready implementation
// ──────────────────────────────────────────────────────────────
class CacheService {
  constructor(defaultTTL = 300) {  // Default 5 minutes TTL
    this.defaultTTL = defaultTTL;
  }

  // Generic cache-aside method
  async getOrSet(key, fetchFn, ttl = this.defaultTTL) {
    try {
      // 1. Cache check করুন
      const cached = await client.get(key);
      if (cached) {
        console.log(`Cache HIT: ${key}`);
        return JSON.parse(cached);
      }

      // 2. Cache miss — DB থেকে আনো
      console.log(`Cache MISS: ${key} — fetching from DB`);
      const data = await fetchFn();

      // 3. Cache এ রাখুন
      await client.setEx(key, ttl, JSON.stringify(data));

      return data;
    } catch (err) {
      // Cache fail হলেও app চলবে — DB থেকে directly serve করুন
      console.error('Cache error:', err);
      return fetchFn();
    }
  }

  // Cache invalidation
  async invalidate(key) {
    await client.del(key);
    console.log(`Cache invalidated: ${key}`);
  }

  // Pattern-based invalidation (e.g., all user:* keys)
  async invalidatePattern(pattern) {
    const keys = await client.keys(pattern);
    if (keys.length > 0) {
      await client.del(keys);
      console.log(`Invalidated ${keys.length} keys matching: ${pattern}`);
    }
  }
}

// ──────────────────────────────────────────────────────────────
// Express.js route তে ব্যবহার
// ──────────────────────────────────────────────────────────────
const cache = new CacheService();

app.get('/api/users/:id', async (req, res) => {
  const { id } = req.params;

  const user = await cache.getOrSet(
    `user:${id}`,
    () => db.query('SELECT * FROM users WHERE id = ?', [id]),
    600  // 10 minutes TTL
  );

  res.json(user);
});

// Write হলে cache invalidate করুন
app.put('/api/users/:id', async (req, res) => {
  const { id } = req.params;
  await db.query('UPDATE users SET ? WHERE id = ?', [req.body, id]);
  await cache.invalidate(`user:${id}`);  // Stale cache মুছে দিন
  res.json({ success: true });
});

// ──────────────────────────────────────────────────────────────
// Rate Limiting with Redis — Sliding Window Algorithm
// ──────────────────────────────────────────────────────────────
// Redis এর atomic INCR + EXPIRE ব্যবহার করে race-condition ছাড়াই
// rate limiting implement করা যায়

async function rateLimiter(userId, limit = 100, windowSeconds = 60) {
  const key = `ratelimit:${userId}:${Math.floor(Date.now() / 1000 / windowSeconds)}`;

  // Atomic increment + TTL set (Lua script দিয়ে atomic করা)
  const script = `
    local current = redis.call('INCR', KEYS[1])
    if current == 1 then
      redis.call('EXPIRE', KEYS[1], ARGV[1])
    end
    return current
  `;

  const count = await client.eval(script, {
    keys: [key],
    arguments: [windowSeconds.toString()]
  });

  const remaining = Math.max(0, limit - count);
  const allowed = count <= limit;

  return { allowed, count, remaining, limit };
}

// Express middleware হিসেবে ব্যবহার
const rateLimitMiddleware = (limit = 100, window = 60) => {
  return async (req, res, next) => {
    const userId = req.user?.id || req.ip;
    const { allowed, remaining } = await rateLimiter(userId, limit, window);

    // Standard rate limit headers set করুন
    res.setHeader('X-RateLimit-Limit', limit);
    res.setHeader('X-RateLimit-Remaining', remaining);

    if (!allowed) {
      return res.status(429).json({
        error: 'Too Many Requests',
        message: `Rate limit exceeded. Try again in ${window} seconds.`
      });
    }

    next();
  };
};

// Route এ apply করুন
app.use('/api/', rateLimitMiddleware(100, 60));  // 100 req/min
app.use('/api/auth/', rateLimitMiddleware(5, 60));  // Login: 5 req/min