📘 Redis with TypeScript: Caching Layer

🎯 Introduction

Welcome to this exciting tutorial on Redis with TypeScript! 🎉 In this guide, we’ll explore how to build lightning-fast caching layers that’ll make your applications zoom like rockets! 🚀

You’ll discover how Redis can transform your TypeScript applications by dramatically improving performance and user experience. Whether you’re building APIs 🌐, web applications 💻, or real-time systems ⚡, understanding Redis caching is essential for creating scalable, high-performance applications.

By the end of this tutorial, you’ll feel confident implementing Redis caching in your own projects! Let’s dive in! 🏊‍♂️

📚 Understanding Redis

🤔 What is Redis?

Redis is like a super-fast memory box 📦 that stores your data in RAM instead of on disk. Think of it as your computer’s short-term memory - it’s incredibly quick to access but needs power to keep working. It’s perfect for caching frequently accessed data!

In TypeScript terms, Redis acts as an in-memory key-value store that helps you:

✨ Cache expensive database queries
🚀 Store session data for lightning-fast access
🛡️ Implement rate limiting and security features
📊 Handle real-time data like leaderboards

💡 Why Use Redis for Caching?

Here’s why developers love Redis:

Blazing Fast ⚡: Sub-millisecond response times
Type-Safe Integration 🔒: Perfect TypeScript support with proper typing
Rich Data Structures 📦: Strings, hashes, lists, sets, and more
Persistence Options 💾: Keep your cache data safe
Scaling Power 🚀: Handle millions of operations per second

Real-world example: Imagine an e-commerce store 🛒. Instead of hitting your database every time someone views product details, Redis caches that data in memory for instant access!

🔧 Basic Syntax and Usage

📝 Setting Up Redis with TypeScript

Let’s start with a friendly setup:

// 👋 Hello, Redis + TypeScript!
import { createClient, RedisClientType } from 'redis';

// 🎨 Creating our Redis client with types
interface CacheClient {
  client: RedisClientType;
  connect: () => Promise<void>;
  disconnect: () => Promise<void>;
}

class RedisCache implements CacheClient {
  public client: RedisClientType;
  
  constructor(url?: string) {
    // 🚀 Create Redis client with connection string
    this.client = createClient({
      url: url || 'redis://localhost:6379'
    });
    
    // 🛡️ Error handling
    this.client.on('error', (err) => {
      console.log('❌ Redis Client Error:', err);
    });
  }
  
  // 🔌 Connect to Redis
  async connect(): Promise<void> {
    await this.client.connect();
    console.log('✅ Connected to Redis! 🎉');
  }
  
  // 🔌 Disconnect from Redis
  async disconnect(): Promise<void> {
    await this.client.disconnect();
    console.log('👋 Disconnected from Redis!');
  }
}

💡 Explanation: Notice how we define proper TypeScript interfaces for our Redis client! This gives us autocomplete and type safety.

🎯 Basic Caching Operations

Here are the essential caching patterns:

// 🏗️ Generic cache operations
interface CacheValue {
  data: any;
  timestamp: number;
  ttl?: number; // ⏰ Time to live in seconds
}

class TypeSafeCache extends RedisCache {
  
  // 💾 Set cache with TTL
  async set<T>(key: string, value: T, ttlSeconds: number = 3600): Promise<void> {
    const cacheValue: CacheValue = {
      data: value,
      timestamp: Date.now(),
      ttl: ttlSeconds
    };
    
    await this.client.setEx(key, ttlSeconds, JSON.stringify(cacheValue));
    console.log(`✅ Cached: ${key} (TTL: ${ttlSeconds}s) 📦`);
  }
  
  // 📖 Get from cache with type safety
  async get<T>(key: string): Promise<T | null> {
    const cached = await this.client.get(key);
    
    if (!cached) {
      console.log(`❌ Cache miss: ${key} 💨`);
      return null;
    }
    
    const cacheValue: CacheValue = JSON.parse(cached);
    console.log(`✅ Cache hit: ${key} ⚡`);
    return cacheValue.data as T;
  }
  
  // 🗑️ Delete from cache
  async delete(key: string): Promise<boolean> {
    const result = await this.client.del(key);
    console.log(result ? `✅ Deleted: ${key} 🗑️` : `❌ Not found: ${key}`);
    return result > 0;
  }
  
  // ⏰ Check if key exists
  async exists(key: string): Promise<boolean> {
    const exists = await this.client.exists(key);
    return exists === 1;
  }
}

💡 Practical Examples

🛒 Example 1: E-commerce Product Cache

Let’s build a real caching system for an online store:

// 🛍️ Product interface
interface Product {
  id: string;
  name: string;
  price: number;
  description: string;
  category: string;
  inStock: boolean;
  emoji: string; // Every product needs personality! 
}

// 🏪 Product service with caching
class ProductService {
  private cache: TypeSafeCache;
  private readonly CACHE_TTL = 1800; // 🕐 30 minutes
  
  constructor(cache: TypeSafeCache) {
    this.cache = cache;
  }
  
  // 📦 Get product with caching
  async getProduct(productId: string): Promise<Product | null> {
    const cacheKey = `product:${productId}`;
    
    // 🔍 Try cache first
    let product = await this.cache.get<Product>(cacheKey);
    
    if (product) {
      console.log(`🚀 Served from cache: ${product.emoji} ${product.name}`);
      return product;
    }
    
    // 💾 Cache miss - fetch from database
    product = await this.fetchProductFromDatabase(productId);
    
    if (product) {
      // 📦 Cache for next time
      await this.cache.set(cacheKey, product, this.CACHE_TTL);
      console.log(`💾 Cached product: ${product.emoji} ${product.name}`);
    }
    
    return product;
  }
  
  // 🏷️ Get products by category (with bulk caching)
  async getProductsByCategory(category: string): Promise<Product[]> {
    const cacheKey = `category:${category}`;
    
    // 🔍 Check cache
    let products = await this.cache.get<Product[]>(cacheKey);
    
    if (products) {
      console.log(`🚀 Category cache hit: ${category} (${products.length} products)`);
      return products;
    }
    
    // 💾 Fetch from database
    products = await this.fetchProductsByCategoryFromDatabase(category);
    
    // 📦 Cache the results
    await this.cache.set(cacheKey, products, this.CACHE_TTL);
    console.log(`💾 Cached category: ${category} with ${products.length} products`);
    
    return products;
  }
  
  // 🔄 Update product (invalidate cache)
  async updateProduct(productId: string, updates: Partial<Product>): Promise<Product | null> {
    // 🗑️ Remove from cache first
    await this.cache.delete(`product:${productId}`);
    
    // 💾 Update in database
    const updatedProduct = await this.updateProductInDatabase(productId, updates);
    
    if (updatedProduct) {
      // 📦 Cache the updated product
      await this.cache.set(`product:${productId}`, updatedProduct, this.CACHE_TTL);
      console.log(`🔄 Updated and cached: ${updatedProduct.emoji} ${updatedProduct.name}`);
    }
    
    return updatedProduct;
  }
  
  // 🎭 Mock database methods (replace with real DB calls)
  private async fetchProductFromDatabase(id: string): Promise<Product | null> {
    // 🎮 Simulate database delay
    await new Promise(resolve => setTimeout(resolve, 100));
    
    return {
      id,
      name: "TypeScript Masterclass",
      price: 99.99,
      description: "Learn TypeScript like a pro!",
      category: "education",
      inStock: true,
      emoji: "📘"
    };
  }
  
  private async fetchProductsByCategoryFromDatabase(category: string): Promise<Product[]> {
    await new Promise(resolve => setTimeout(resolve, 150));
    
    return [
      {
        id: "1",
        name: "Redis Guide",
        price: 49.99,
        description: "Master Redis caching",
        category,
        inStock: true,
        emoji: "📦"
      },
      {
        id: "2", 
        name: "TypeScript Handbook",
        price: 79.99,
        description: "Complete TypeScript reference",
        category,
        inStock: true,
        emoji: "📖"
      }
    ];
  }
  
  private async updateProductInDatabase(id: string, updates: Partial<Product>): Promise<Product | null> {
    await new Promise(resolve => setTimeout(resolve, 80));
    
    return {
      id,
      name: "Updated Product",
      price: 59.99,
      description: "Freshly updated!",
      category: "books",
      inStock: true,
      emoji: "✨",
      ...updates
    };
  }
}

🎯 Try it yourself: Add a “hot products” cache that stores the most viewed items!

🎮 Example 2: User Session Management

Let’s implement a session cache system:

// 👤 User session interface
interface UserSession {
  userId: string;
  username: string;
  email: string;
  roles: string[];
  loginTime: Date;
  lastActivity: Date;
  preferences: {
    theme: 'light' | 'dark';
    language: string;
    notifications: boolean;
  };
}

// 🔐 Session manager with Redis
class SessionManager {
  private cache: TypeSafeCache;
  private readonly SESSION_TTL = 86400; // 🕐 24 hours
  
  constructor(cache: TypeSafeCache) {
    this.cache = cache;
  }
  
  // 🎫 Create new session
  async createSession(userId: string, userInfo: Omit<UserSession, 'userId' | 'loginTime' | 'lastActivity'>): Promise<string> {
    const sessionId = this.generateSessionId();
    const session: UserSession = {
      userId,
      ...userInfo,
      loginTime: new Date(),
      lastActivity: new Date()
    };
    
    const sessionKey = `session:${sessionId}`;
    const userSessionKey = `user_sessions:${userId}`;
    
    // 💾 Store session data
    await this.cache.set(sessionKey, session, this.SESSION_TTL);
    
    // 📝 Track user's active sessions
    const activeSessions = await this.cache.get<string[]>(userSessionKey) || [];
    activeSessions.push(sessionId);
    await this.cache.set(userSessionKey, activeSessions, this.SESSION_TTL);
    
    console.log(`✅ Created session for ${userInfo.username}: ${sessionId} 🎫`);
    return sessionId;
  }
  
  // 🔍 Get session
  async getSession(sessionId: string): Promise<UserSession | null> {
    const sessionKey = `session:${sessionId}`;
    const session = await this.cache.get<UserSession>(sessionKey);
    
    if (session) {
      // 🔄 Update last activity
      session.lastActivity = new Date();
      await this.cache.set(sessionKey, session, this.SESSION_TTL);
      console.log(`⚡ Session accessed: ${session.username}`);
    }
    
    return session;
  }
  
  // 🗑️ Destroy session
  async destroySession(sessionId: string): Promise<boolean> {
    const session = await this.getSession(sessionId);
    
    if (session) {
      // 🗑️ Remove session
      await this.cache.delete(`session:${sessionId}`);
      
      // 📝 Update user's session list
      const userSessionKey = `user_sessions:${session.userId}`;
      const activeSessions = await this.cache.get<string[]>(userSessionKey) || [];
      const updatedSessions = activeSessions.filter(id => id !== sessionId);
      
      if (updatedSessions.length > 0) {
        await this.cache.set(userSessionKey, updatedSessions, this.SESSION_TTL);
      } else {
        await this.cache.delete(userSessionKey);
      }
      
      console.log(`🗑️ Destroyed session: ${session.username}`);
      return true;
    }
    
    return false;
  }
  
  // 📊 Get user's active sessions
  async getUserSessions(userId: string): Promise<UserSession[]> {
    const userSessionKey = `user_sessions:${userId}`;
    const sessionIds = await this.cache.get<string[]>(userSessionKey) || [];
    
    const sessions: UserSession[] = [];
    
    for (const sessionId of sessionIds) {
      const session = await this.cache.get<UserSession>(`session:${sessionId}`);
      if (session) {
        sessions.push(session);
      }
    }
    
    console.log(`📊 Found ${sessions.length} active sessions for user ${userId}`);
    return sessions;
  }
  
  // 🎲 Generate unique session ID
  private generateSessionId(): string {
    return `sess_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
}

🚀 Advanced Concepts

🧙‍♂️ Advanced Topic 1: Cache Patterns & Strategies

When you’re ready to level up, try these advanced caching patterns:

// 🎯 Cache-aside pattern with automatic refresh
class AdvancedCacheManager<T> {
  private cache: TypeSafeCache;
  private refreshCallbacks: Map<string, () => Promise<T>> = new Map();
  
  constructor(cache: TypeSafeCache) {
    this.cache = cache;
  }
  
  // 🔄 Cache-aside with background refresh
  async getWithRefresh<T>(
    key: string, 
    fetchFunction: () => Promise<T>,
    ttl: number = 3600,
    refreshThreshold: number = 0.8 // 📊 Refresh when 80% of TTL passed
  ): Promise<T> {
    
    // 🔍 Try cache first
    const cached = await this.cache.get<{data: T, cachedAt: number}>(key);
    
    if (cached) {
      const age = Date.now() - cached.cachedAt;
      const refreshTime = ttl * 1000 * refreshThreshold;
      
      // 🔄 Background refresh if approaching expiry
      if (age > refreshTime && !this.refreshCallbacks.has(key)) {
        this.refreshInBackground(key, fetchFunction, ttl);
      }
      
      return cached.data;
    }
    
    // 💾 Cache miss - fetch and cache
    const freshData = await fetchFunction();
    await this.cacheWithTimestamp(key, freshData, ttl);
    
    return freshData;
  }
  
  // 🌙 Background refresh (non-blocking)
  private async refreshInBackground<T>(
    key: string, 
    fetchFunction: () => Promise<T>,
    ttl: number
  ): Promise<void> {
    this.refreshCallbacks.set(key, fetchFunction);
    
    try {
      console.log(`🔄 Background refresh started: ${key}`);
      const freshData = await fetchFunction();
      await this.cacheWithTimestamp(key, freshData, ttl);
      console.log(`✅ Background refresh completed: ${key} 🌟`);
    } catch (error) {
      console.log(`❌ Background refresh failed: ${key}`, error);
    } finally {
      this.refreshCallbacks.delete(key);
    }
  }
  
  // 📦 Cache with timestamp
  private async cacheWithTimestamp<T>(key: string, data: T, ttl: number): Promise<void> {
    const cacheData = {
      data,
      cachedAt: Date.now()
    };
    
    await this.cache.set(key, cacheData, ttl);
  }
}

🏗️ Advanced Topic 2: Distributed Cache Patterns

For enterprise applications, try distributed caching:

// 🌐 Distributed cache with Redis Cluster
interface CacheNode {
  host: string;
  port: number;
  role: 'master' | 'replica';
}

class DistributedCache {
  private nodes: Map<string, RedisClientType> = new Map();
  
  constructor(nodes: CacheNode[]) {
    this.initializeNodes(nodes);
  }
  
  // 🎯 Consistent hashing for key distribution
  private getNodeForKey(key: string): RedisClientType {
    const hash = this.hashKey(key);
    const nodeKeys = Array.from(this.nodes.keys());
    const nodeIndex = hash % nodeKeys.length;
    
    const selectedNode = this.nodes.get(nodeKeys[nodeIndex]);
    if (!selectedNode) {
      throw new Error('❌ No available cache nodes!');
    }
    
    return selectedNode;
  }
  
  // 🔧 Initialize connection to all nodes
  private async initializeNodes(nodes: CacheNode[]): Promise<void> {
    for (const node of nodes) {
      const client = createClient({
        socket: {
          host: node.host,
          port: node.port
        }
      });
      
      await client.connect();
      this.nodes.set(`${node.host}:${node.port}`, client);
      console.log(`✅ Connected to cache node: ${node.host}:${node.port} 🌐`);
    }
  }
  
  // 🔢 Simple hash function
  private hashKey(key: string): number {
    let hash = 0;
    for (let i = 0; i < key.length; i++) {
      const char = key.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash; // Convert to 32-bit integer
    }
    return Math.abs(hash);
  }
  
  // 📦 Distributed set
  async set(key: string, value: any, ttl: number): Promise<void> {
    const node = this.getNodeForKey(key);
    await node.setEx(key, ttl, JSON.stringify(value));
    console.log(`📦 Distributed cache set: ${key} ⚡`);
  }
  
  // 🔍 Distributed get
  async get<T>(key: string): Promise<T | null> {
    const node = this.getNodeForKey(key);
    const result = await node.get(key);
    
    if (result) {
      console.log(`🎯 Distributed cache hit: ${key} 🚀`);
      return JSON.parse(result) as T;
    }
    
    console.log(`💨 Distributed cache miss: ${key}`);
    return null;
  }
}

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Cache Stampede

// ❌ Wrong way - multiple requests fetch the same data!
class BadCache {
  async getData(key: string): Promise<any> {
    let data = await this.cache.get(key);
    if (!data) {
      // 💥 All requests will hit the database simultaneously!
      data = await this.expensiveDatabaseQuery();
      await this.cache.set(key, data, 3600);
    }
    return data;
  }
}

// ✅ Correct way - use locks to prevent stampede!
class GoodCache {
  private lockMap: Map<string, Promise<any>> = new Map();
  
  async getData(key: string): Promise<any> {
    let data = await this.cache.get(key);
    if (data) return data;
    
    // 🔒 Check if someone else is already fetching
    if (this.lockMap.has(key)) {
      console.log(`⏳ Waiting for lock: ${key}`);
      return await this.lockMap.get(key);
    }
    
    // 🔐 Acquire lock and fetch data
    const fetchPromise = this.fetchWithLock(key);
    this.lockMap.set(key, fetchPromise);
    
    try {
      data = await fetchPromise;
      return data;
    } finally {
      this.lockMap.delete(key); // 🔓 Release lock
    }
  }
  
  private async fetchWithLock(key: string): Promise<any> {
    console.log(`🔐 Acquired lock for: ${key}`);
    const data = await this.expensiveDatabaseQuery();
    await this.cache.set(key, data, 3600);
    console.log(`✅ Cached with lock: ${key} 🎉`);
    return data;
  }
}

🤯 Pitfall 2: Memory Leaks with Large Objects

// ❌ Dangerous - caching huge objects without limits!
class DangerousCache {
  async cacheUserData(userId: string, userData: any): Promise<void> {
    // 💥 Could cache massive objects eating all memory!
    await this.cache.set(`user:${userId}`, userData, 3600);
  }
}

// ✅ Safe - implement size limits and compression!
class SafeCache {
  private readonly MAX_CACHE_SIZE = 1024 * 1024; // 📏 1MB limit
  
  async cacheUserData(userId: string, userData: any): Promise<void> {
    const serialized = JSON.stringify(userData);
    
    // 📏 Check size before caching
    if (serialized.length > this.MAX_CACHE_SIZE) {
      console.log(`⚠️ Object too large to cache: ${userId} (${serialized.length} bytes)`);
      return;
    }
    
    // 🗜️ Optional: compress large objects
    const compressed = serialized.length > 1024 ? 
      await this.compress(serialized) : serialized;
    
    await this.cache.set(`user:${userId}`, compressed, 3600);
    console.log(`✅ Safely cached: ${userId} (${compressed.length} bytes) 💾`);
  }
  
  private async compress(data: string): Promise<string> {
    // 🗜️ Use zlib or similar compression
    console.log(`🗜️ Compressing data...`);
    return data; // Simplified - implement real compression
  }
}

🛠️ Best Practices

🎯 Use Appropriate TTLs: Short for frequently changing data, longer for stable data
📝 Implement Cache Keys Carefully: Use consistent, hierarchical naming (user:123:profile)
🛡️ Handle Cache Failures Gracefully: Always have fallback to original data source
🎨 Type Everything: Use proper TypeScript interfaces for cached data
⚡ Monitor Cache Performance: Track hit rates, memory usage, and response times
🔄 Implement Cache Invalidation: Update or remove stale data promptly
📊 Use Cache Layers: L1 (in-memory), L2 (Redis), L3 (database)

🧪 Hands-On Exercise

🎯 Challenge: Build a Blog Post Cache System

Create a comprehensive caching system for a blog platform:

📋 Requirements:

✅ Cache blog posts with automatic expiration (30 minutes)
🏷️ Cache posts by category and tags
👤 Cache author information separately (4 hours TTL)
📊 Implement view count caching with atomic increments
🔍 Add search result caching (15 minutes)
⚡ Handle cache invalidation when posts are updated
🎨 Include TypeScript interfaces for all data structures

🚀 Bonus Points:

Add cache warming for popular posts
Implement cache size monitoring
Create a cache analytics dashboard
Add distributed caching support

💡 Solution

🔍 Click to see solution

// 🎯 Our type-safe blog cache system!
interface BlogPost {
  id: string;
  title: string;
  content: string;
  authorId: string;
  category: string;
  tags: string[];
  publishedAt: Date;
  updatedAt: Date;
  viewCount: number;
  featured: boolean;
  emoji: string;
}

interface Author {
  id: string;
  name: string;
  email: string;
  bio: string;
  avatar: string;
  postsCount: number;
}

interface SearchResult {
  query: string;
  posts: BlogPost[];
  totalCount: number;
  searchedAt: Date;
}

class BlogCacheManager {
  private cache: TypeSafeCache;
  
  // ⏰ Cache TTL constants
  private readonly POST_TTL = 1800;      // 30 minutes
  private readonly AUTHOR_TTL = 14400;   // 4 hours
  private readonly SEARCH_TTL = 900;     // 15 minutes
  private readonly VIEWS_TTL = 86400;    // 24 hours
  
  constructor(cache: TypeSafeCache) {
    this.cache = cache;
  }
  
  // 📝 Get blog post with caching
  async getPost(postId: string): Promise<BlogPost | null> {
    const cacheKey = `post:${postId}`;
    
    // 🔍 Try cache first
    let post = await this.cache.get<BlogPost>(cacheKey);
    
    if (post) {
      console.log(`🚀 Post cache hit: ${post.emoji} ${post.title}`);
      // 📊 Increment view count atomically
      await this.incrementViewCount(postId);
      return post;
    }
    
    // 💾 Cache miss - fetch from database
    post = await this.fetchPostFromDatabase(postId);
    
    if (post) {
      await this.cache.set(cacheKey, post, this.POST_TTL);
      await this.incrementViewCount(postId);
      console.log(`💾 Cached post: ${post.emoji} ${post.title}`);
    }
    
    return post;
  }
  
  // 👤 Get author with caching
  async getAuthor(authorId: string): Promise<Author | null> {
    const cacheKey = `author:${authorId}`;
    
    let author = await this.cache.get<Author>(cacheKey);
    
    if (author) {
      console.log(`👤 Author cache hit: ${author.name}`);
      return author;
    }
    
    author = await this.fetchAuthorFromDatabase(authorId);
    
    if (author) {
      await this.cache.set(cacheKey, author, this.AUTHOR_TTL);
      console.log(`💾 Cached author: ${author.name}`);
    }
    
    return author;
  }
  
  // 🏷️ Get posts by category
  async getPostsByCategory(category: string): Promise<BlogPost[]> {
    const cacheKey = `category:${category}`;
    
    let posts = await this.cache.get<BlogPost[]>(cacheKey);
    
    if (posts) {
      console.log(`🏷️ Category cache hit: ${category} (${posts.length} posts)`);
      return posts;
    }
    
    posts = await this.fetchPostsByCategoryFromDatabase(category);
    await this.cache.set(cacheKey, posts, this.POST_TTL);
    console.log(`💾 Cached category: ${category} with ${posts.length} posts`);
    
    return posts;
  }
  
  // 🔍 Search posts with caching
  async searchPosts(query: string): Promise<SearchResult> {
    const cacheKey = `search:${this.normalizeSearchQuery(query)}`;
    
    let result = await this.cache.get<SearchResult>(cacheKey);
    
    if (result) {
      console.log(`🔍 Search cache hit: "${query}" (${result.posts.length} results)`);
      return result;
    }
    
    const posts = await this.performSearchInDatabase(query);
    result = {
      query,
      posts,
      totalCount: posts.length,
      searchedAt: new Date()
    };
    
    await this.cache.set(cacheKey, result, this.SEARCH_TTL);
    console.log(`💾 Cached search: "${query}" with ${posts.length} results`);
    
    return result;
  }
  
  // 📊 Increment view count atomically
  async incrementViewCount(postId: string): Promise<number> {
    const viewsKey = `views:${postId}`;
    
    // 🔢 Use Redis INCR for atomic increment
    const newCount = await this.cache.client.incr(viewsKey);
    await this.cache.client.expire(viewsKey, this.VIEWS_TTL);
    
    return newCount;
  }
  
  // 🗑️ Invalidate post cache when updated
  async invalidatePost(postId: string): Promise<void> {
    const post = await this.cache.get<BlogPost>(`post:${postId}`);
    
    if (post) {
      // 🗑️ Remove post cache
      await this.cache.delete(`post:${postId}`);
      
      // 🗑️ Remove category cache
      await this.cache.delete(`category:${post.category}`);
      
      // 🗑️ Remove tag caches
      for (const tag of post.tags) {
        await this.cache.delete(`tag:${tag}`);
      }
      
      console.log(`🗑️ Invalidated caches for post: ${post.title}`);
    }
  }
  
  // 🔥 Cache warming for popular posts
  async warmCache(popularPostIds: string[]): Promise<void> {
    console.log(`🔥 Warming cache for ${popularPostIds.length} popular posts...`);
    
    const warmingPromises = popularPostIds.map(async (postId) => {
      const post = await this.fetchPostFromDatabase(postId);
      if (post) {
        await this.cache.set(`post:${postId}`, post, this.POST_TTL);
        console.log(`🔥 Warmed cache: ${post.emoji} ${post.title}`);
      }
    });
    
    await Promise.all(warmingPromises);
    console.log(`✅ Cache warming completed! 🎉`);
  }
  
  // 📊 Get cache statistics
  async getCacheStats(): Promise<{hits: number, misses: number, size: number}> {
    // 📊 Mock implementation - in real app, track these metrics
    return {
      hits: 1542,
      misses: 238,
      size: 1024 * 1024 * 15 // 15MB
    };
  }
  
  // 🔧 Helper methods
  private normalizeSearchQuery(query: string): string {
    return query.toLowerCase().trim().replace(/\s+/g, '-');
  }
  
  // 🎭 Mock database methods
  private async fetchPostFromDatabase(id: string): Promise<BlogPost | null> {
    await new Promise(resolve => setTimeout(resolve, 100));
    
    return {
      id,
      title: "Redis Caching Mastery",
      content: "Learn how to build lightning-fast applications...",
      authorId: "author-123",
      category: "tutorials",
      tags: ["redis", "typescript", "caching"],
      publishedAt: new Date('2024-01-15'),
      updatedAt: new Date('2024-01-16'),
      viewCount: 0,
      featured: true,
      emoji: "🚀"
    };
  }
  
  private async fetchAuthorFromDatabase(id: string): Promise<Author | null> {
    await new Promise(resolve => setTimeout(resolve, 80));
    
    return {
      id,
      name: "Sarah TypeScript",
      email: "[email protected]",
      bio: "Full-stack developer passionate about TypeScript",
      avatar: "https://example.com/sarah.jpg",
      postsCount: 42
    };
  }
  
  private async fetchPostsByCategoryFromDatabase(category: string): Promise<BlogPost[]> {
    await new Promise(resolve => setTimeout(resolve, 120));
    
    return [
      {
        id: "post-1",
        title: "TypeScript Advanced Types",
        content: "Master complex type manipulations...",
        authorId: "author-123",
        category,
        tags: ["typescript", "types"],
        publishedAt: new Date(),
        updatedAt: new Date(),
        viewCount: 156,
        featured: false,
        emoji: "📘"
      },
      {
        id: "post-2",
        title: "Redis Performance Tips",
        content: "Optimize your Redis usage...",
        authorId: "author-456",
        category,
        tags: ["redis", "performance"],
        publishedAt: new Date(),
        updatedAt: new Date(),
        viewCount: 89,
        featured: true,
        emoji: "⚡"
      }
    ];
  }
  
  private async performSearchInDatabase(query: string): Promise<BlogPost[]> {
    await new Promise(resolve => setTimeout(resolve, 200));
    
    return [
      {
        id: "search-result-1",
        title: `Search Result for: ${query}`,
        content: "This post matches your search query...",
        authorId: "author-789",
        category: "search-results",
        tags: [query.toLowerCase()],
        publishedAt: new Date(),
        updatedAt: new Date(),
        viewCount: 23,
        featured: false,
        emoji: "🔍"
      }
    ];
  }
}

// 🎮 Usage example
async function demonstrateBlogCache() {
  const cache = new TypeSafeCache();
  await cache.connect();
  
  const blogCache = new BlogCacheManager(cache);
  
  // 🔥 Warm the cache
  await blogCache.warmCache(['post-1', 'post-2', 'post-3']);
  
  // 📝 Get posts (will be served from cache)
  const post = await blogCache.getPost('post-1');
  const author = await blogCache.getAuthor('author-123');
  const categoryPosts = await blogCache.getPostsByCategory('tutorials');
  const searchResults = await blogCache.searchPosts('TypeScript Redis');
  
  // 📊 Check stats
  const stats = await blogCache.getCacheStats();
  console.log('📊 Cache Stats:', stats);
  
  await cache.disconnect();
}

🎓 Key Takeaways

You’ve learned so much! Here’s what you can now do:

✅ Implement Redis caching with complete type safety 💪
✅ Avoid cache stampedes and other common pitfalls 🛡️
✅ Build scalable caching systems for real applications 🎯
✅ Debug caching issues like a pro 🐛
✅ Create lightning-fast applications with Redis! 🚀

Remember: Redis caching is like having a superpower for your applications - use it wisely and your users will thank you for the blazing-fast performance! ⚡

🤝 Next Steps

Congratulations! 🎉 You’ve mastered Redis caching with TypeScript!

Here’s what to do next:

💻 Practice with the blog cache exercise above
🏗️ Build a caching layer for your own project
📚 Move on to our next tutorial: Database ORMs with TypeScript
🌟 Share your caching success stories with the community!

Remember: Every high-performance application uses caching effectively. You now have the skills to build systems that can handle millions of users! Keep coding, keep caching, and most importantly, have fun! 🚀

Happy caching! 🎉🚀✨

Prerequisites

What you'll learn