کون سی caching strategies ایک Node API کی performance بہتر بناتی ہیں؟

Question

Accepted Answer

**Caching** مہنگے operations (DB queries، computations، external API calls) کے نتائج کو store کرتی ہے تاکہ بار بار آنے والی requests کو کام دوبارہ کیے بغیر تیزی سے serve کیا جا سکے۔ یہ ایک API کے لیے سب سے زیادہ اثر انداز performance optimizations میں سے ایک ہے۔

## In-memory caching (سب سے تیز، single-instance)

```js
const cache = new Map();

async function getUser(id) {
  if (cache.has(id)) return cache.get(id); // cache HIT — instant
  const user = await db.findUser(id);       // cache MISS — do the work
  cache.set(id, user);
  return user;
}
```

سادہ اور انتہائی تیز، مگر cache **per-process** ہے (instances کے درمیان شیئر نہیں ہوتی) اور restart پر ضائع ہو جاتی ہے۔ چھوٹے، hot data کے لیے اچھی — مگر memory کو bound کرنے کے لیے eviction درکار ہے (`lru-cache` جیسی LRU cache استعمال کریں)۔

## Redis کے ساتھ distributed caching (شیئرڈ، scalable)

```js
import { createClient } from "redis";
const redis = createClient();

async function getUser(id) {
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);          // hit

const user = await db.findUser(id);
  await redis.setEx(`user:${id}`, 3600, JSON.stringify(user)); // cache for 1h (TTL)
  return user;
}
```

**Redis** متعدد server instances کے درمیان caching کے لیے معیار ہے — ایک شیئرڈ، تیز store جو restarts سے بچ جاتی ہے اور آپ کی app کے ساتھ scale ہوتی ہے۔ **TTL** (time-to-live) entries کو خودکار طور پر expire کرتی ہے تاکہ data ہمیشہ کے لیے stale نہ ہو۔

## HTTP caching (clients/CDNs کو cache کرنے دیں)

```js
res.set("Cache-Control", "public, max-age=3600"); // browsers/CDN cache for 1h
res.set("ETag", hash);                            // conditional requests (304 Not Modified)
```

HTTP cache headers caching کو مکمل طور پر browsers اور CDNs پر منتقل کر دیتے ہیں — سب سے تیز cache وہ request ہے جو آپ کے server تک کبھی نہیں پہنچتی۔

## مشکل حصہ: cache invalidation

```js
// when data changes, the cache must be updated or cleared, or users see stale data
async function updateUser(id, data) {
  await db.updateUser(id, data);
  await redis.del(`user:${id}`); // INVALIDATE — next read repopulates with fresh data
}
```

سب سے بڑا caching چیلنج **invalidation** ہے — اس بات کو یقینی بنانا کہ updates متاثرہ cache entries کو clear/refresh کریں تاکہ users کو stale data نظر نہ آئے۔ Strategies: TTL (مختصر staleness قبول کریں)، write-through (write پر cache update کریں)، یا mutation پر صریح deletion۔

## کیا cache کریں (اور کیا نہیں)

```text
✓ Read-heavy, infrequently-changing data (config, product catalogs, user profiles)
✓ Expensive computations, external API responses
✗ Highly dynamic/personalized or rapidly-changing data (or use very short TTLs)
✗ Sensitive data without care for who can read the cache
```

## یہ کیوں اہم ہے

Caching latency اور database/external load کو ڈرامائی طور پر کم کرتی ہے، اکثر یہ ایک سست API اور ایک تیز، scalable API کے درمیان فرق ہوتا ہے۔

layers جاننا — in-memory (سب سے تیز، per-instance، LRU کے ساتھ bounded)، Redis (instances کے درمیان شیئرڈ)، اور HTTP/CDN caching (مکمل طور پر offload) — آپ کو درست strategy منتخب کرنے دیتا ہے۔

اور caching کی مرکزی مشکل، **invalidation** (TTL یا writes پر صریح clearing کے ذریعے) کو سمجھنا، وہ چیز ہے جو users کو stale data serve کرنے کی کلاسیکی trade-off ناکامی کو روکتی ہے۔

مؤثر caching API performance اور scalability کے لیے سب سے زیادہ اثر انداز tools میں سے ایک ہے۔