Caching Basics

import Redis from "ioredis";
import pg from "pg";

// --- Redis connection ---
const redis = new Redis({
  host: process.env.REDIS_HOST || "localhost",
  port: parseInt(process.env.REDIS_PORT || "6379"),
  maxRetriesPerRequest: 3,
  retryStrategy(times: number) {
    const delay = Math.min(times * 200, 5000);
    return delay;
  },
});

redis.on("error", (err) => console.error("Redis error:", err));

const db = new pg.Pool({
  connectionString: process.env.DATABASE_URL || "postgres://localhost:5432/blog",
  max: 20,
});

// --- Types ---
interface Post {
  id: string;
  slug: string;
  title: string;
  body: string;
  authorId: string;
  published: boolean;
}

interface CacheStats {
  hits: number;
  misses: number;
  ratio: number;
}

// --- Cache service ---
class CacheService {
  private hits = 0;
  private misses = 0;

  private key(prefix: string, id: string): string {
    return `blog:${prefix}:${id}`;
  }

  async getPost(slug: string): Promise<Post | null> {
    const cacheKey = this.key("post", slug);

    // 1. Check cache
    const cached = await redis.get(cacheKey);
    if (cached) {
      this.hits++;
      return JSON.parse(cached);
    }

    // 2. Cache miss — query database
    this.misses++;
    const result = await db.query<Post>(
      `SELECT id, slug, title, body, author_id AS "authorId", published
       FROM posts WHERE slug = $1`,
      [slug]
    );

    if (result.rows.length === 0) {
      // Cache negative result to prevent repeated DB lookups
      await redis.set(cacheKey, JSON.stringify(null), "EX", 60);
      return null;
    }

    const post = result.rows[0];

    // 3. Store in cache with TTL
    await redis.set(cacheKey, JSON.stringify(post), "EX", 300); // 5 min TTL
    return post;
  }

  async getPostList(page: number, limit: number): Promise<Post[]> {
    const cacheKey = `blog:posts:page:${page}:${limit}`;

    const cached = await redis.get(cacheKey);
    if (cached) {
      this.hits++;
      return JSON.parse(cached);
    }

    this.misses++;
    const offset = (page - 1) * limit;
    const result = await db.query<Post>(
      `SELECT id, slug, title, LEFT(body, 200) AS body,
              author_id AS "authorId", published
       FROM posts
       WHERE published = TRUE
       ORDER BY created_at DESC
       LIMIT $1 OFFSET $2`,
      [limit, offset]
    );

    // Shorter TTL for list views since they change more frequently
    await redis.set(cacheKey, JSON.stringify(result.rows), "EX", 60);
    return result.rows;
  }

  // --- Cache Invalidation ---

  // Invalidate single post cache
  async invalidatePost(slug: string): Promise<void> {
    await redis.del(this.key("post", slug));
    // Also invalidate list caches since they may contain this post
    await this.invalidatePostLists();
  }

  // Invalidate all post list caches using pattern scan
  async invalidatePostLists(): Promise<void> {
    const stream = redis.scanStream({
      match: "blog:posts:page:*",
      count: 100,
    });

    const pipeline = redis.pipeline();
    let count = 0;

    for await (const keys of stream) {
      for (const key of keys as string[]) {
        pipeline.del(key);
        count++;
      }
    }

    if (count > 0) {
      await pipeline.exec();
    }
  }

  // Update post: write-through (update DB + cache simultaneously)
  async updatePost(slug: string, data: Partial<Post>): Promise<Post | null> {
    const fields: string[] = [];
    const values: unknown[] = [];
    let idx = 1;

    if (data.title) { fields.push(`title = $${idx++}`); values.push(data.title); }
    if (data.body) { fields.push(`body = $${idx++}`); values.push(data.body); }
    if (data.published !== undefined) { fields.push(`published = $${idx++}`); values.push(data.published); }

    if (fields.length === 0) return null;

    fields.push(`updated_at = NOW()`);
    values.push(slug);

    const result = await db.query<Post>(
      `UPDATE posts SET ${fields.join(", ")}
       WHERE slug = $${idx}
       RETURNING id, slug, title, body, author_id AS "authorId", published`,
      values
    );

    if (result.rows.length === 0) return null;

    const post = result.rows[0];

    // Write-through: update cache with fresh data
    const cacheKey = this.key("post", slug);
    await redis.set(cacheKey, JSON.stringify(post), "EX", 300);

    // Invalidate list caches
    await this.invalidatePostLists();

    return post;
  }

  // Delete post: invalidate cache
  async deletePost(slug: string): Promise<boolean> {
    const result = await db.query("DELETE FROM posts WHERE slug = $1", [slug]);
    await this.invalidatePost(slug);
    return (result.rowCount ?? 0) > 0;
  }

  // --- Stats ---
  getStats(): CacheStats {
    const total = this.hits + this.misses;
    return {
      hits: this.hits,
      misses: this.misses,
      ratio: total > 0 ? this.hits / total : 0,
    };
  }
}

// --- Usage ---
async function main() {
  const cache = new CacheService();

  // First call: cache miss, hits DB
  const post1 = await cache.getPost("hello-world");
  console.log("First fetch:", post1?.title, cache.getStats());

  // Second call: cache hit, skips DB
  const post2 = await cache.getPost("hello-world");
  console.log("Second fetch:", post2?.title, cache.getStats());

  // Update: write-through
  await cache.updatePost("hello-world", { title: "Updated Title" });

  // Cleanup
  await redis.quit();
  await db.end();
}

main().catch(console.error);