ক্যাশিং বেসিকস

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);