NestJS માં કેશિંગ કેવી રીતે ઉમેરવું?

Question

Accepted Answer

NestJS એક બિલ્ટ-ઇન **કેશિંગ મોડ્યુલ** (`@nestjs/cache-manager`) પ્રદાન કરે છે જે અનેક સ્ટોર્સ પર કામ કરતું એક સમર્થિત API છે — ડિફોલ્ટ તરીકે ઇન-મેમરી, અથવા ઘણાં ઇન્સ્ટન્સ્ સમક્ષ વિતરિત કેશિંગ માટે **Redis**। કેશિંગ પુનરાવર્તિત ખર્ચાળ કામ ટાળીને પ્રદર્શનમાં નાટકીય રીતે સુધાર કરે છે.

## કેશ મોડ્યુલ સેટ અપ કરવું

```ts
@Module({
  imports: [
    CacheModule.register({
      ttl: 60000,        // default time-to-live (ms) — entries expire after 60s
      max: 100,          // max items in memory (in-memory store)
      isGlobal: true,    // available app-wide
    }),
  ],
})
export class AppModule {}
```

## ઇન્ટરસેપ્ટર સાથે એન્ડપોઇન્ટ્સને સ્વચાલિત કેશ કરવું

```ts
@Controller("products")
@UseInterceptors(CacheInterceptor)   // automatically caches GET responses
export class ProductsController {
  @Get()
  @CacheTTL(30000)                    // override TTL for this route
  findAll() {
    return this.productsService.findAll();   // result cached; subsequent GETs are instant
  }
}
```

`CacheInterceptor` આપોઆપ `GET` એન્ડપોઇન્ટ પ્રતિક્રિયાઓને કેશ કરે છે (URL દ્વારા કીયુક્ત) અને પુનરાવર્તન અનુરોધો પર કેશ્ડ પરિણામો આપે છે — વાંચન-ભારી એન્ડપોઇન્ટ્સને કેશ કરવાનો સરળ તરીકો.

## CacheManager સાથે શુદ્ધ કેશિંગ (વધુ નિયંત્રણ)

```ts
@Injectable()
export class ProductsService {
  constructor(@Inject(CACHE_MANAGER) private cache: Cache) {}

async getProduct(id: string) {
    const cached = await this.cache.get(`product:${id}`);   // check cache first
    if (cached) return cached;                               // cache HIT

const product = await this.db.findProduct(id);           // cache MISS — fetch
    await this.cache.set(`product:${id}`, product, 3600000); // store (1h TTL)
    return product;
  }
}
```

`CACHE_MANAGER` ઇજેક્ટ કરવાથી સંપૂર્ણ નિયંત્રણ મળે છે — ગેટ-અથવા-ફેચ પેટર્ન (કેશ તપાસો, સ્ત્રોતમાં ફરી લાવો, પરિણામ સંગ્રહો) ચોક્કસ ખર્ચાળ ક્રિયાકલાપોને કેશ કરવા માટે.

## Redis સાથે વિતરિત કેશિંગ (બહુવિધ ઇન્સ્ટન્સ્)

```ts
CacheModule.registerAsync({
  useFactory: async () => ({
    store: await redisStore({ url: process.env.REDIS_URL }),   // use Redis as the store
    ttl: 60000,
  }),
});
```

તે જ API, **Redis** દ્વારા સમર્થિત, બધા એપ ઇન્સ્ટન્સ્ સમક્ષ **શેર્ડ** કેશ આપે છે — બહુવિધ ઇન્સ્ટન્સ્ ચલાવતી વખતે આવશ્યક (ઇન-મેમરી કેશ તેમની વચ્ચે શેર્ડ નથી).

## મુશ્કેલ ભાગ: કેશ અમાન્યતા

```ts
async updateProduct(id: string, data) {
  await this.db.update(id, data);
  await this.cache.del(`product:${id}`);   // INVALIDATE on change → avoid stale data
}
```

```text
The biggest caching challenge: INVALIDATION. When data changes, the cache must be
cleared/updated, or users see stale data. Strategies: TTL (accept brief staleness),
explicit deletion on writes (cache.del), or cache tags.
```

## શા માટે તે મહત્વપૂર્ણ છે

કેશિંગ બેક-એન્ડ એપ્લીકેશનો માટે સર્વોચ્ચ-અસર પ્રદર્શન ઑપ્ટિમાઇઝેશનમાંથી એક છે, અને NestJS નું બિલ્ટ-ઇન કેશિંગ મોડ્યુલ તે સ્વચ્છ અને સુસંગત બનાવે છે.

તે સમજવું મહત્વપૂર્ણ છે કારણ કે વાંચન-ભારી APIs ખર્ચાળ ક્રિયાકલાપોને કેશ કરવાથી અપાર લાભ મેળવે છે (ડેટાબેસ પ્રશ્નો, બાહ્ય API કૉલ્સ, ગણતરીઓ) — અસ્પષ્ટતા અને લોડમાં નાટકીય રીતે ઘટાડો કરે છે.

NestJS સરળ આપોઆપ કેશિંગ બંને (GET એન્ડપોઇન્ટ્સ માટે `CacheInterceptor`) અને સુંદર-દાણા શુદ્ધ નિયંત્રણ (ચોક્કસ ક્રિયાકલાપો માટે `CACHE_MANAGER` ગેટ-અથવા-ફેચ પેટર્ન) બંને આપે છે.

non-essential રીતે, એક જીવંત API વિવિધ સ્ટોર્સ સાથે કામ કરે છે, તેથી તે જ કોડ **ઇન-મેમરી કેશિંગ** (ઝડપી, એક-ઇન્સ્ટન્સ) અથવા **Redis** (બહુવિધ ઇન્સ્ટન્સ્ સમક્ષ શેર્ડ કેશ) નો ઉપયોગ કરી શકે છે — અને તે જાણવું કે ઇન-મેમરી કેશ *શેર્ડ નથી* જ્યારે આડંબરણીય રીતે સ્કેલ કરો (વિતરિત કેશિંગ માટે Redis આવશ્યક) એક મહત્વપૂર્ણ આર્કિટેક્ચરલ બિંદુ છે.

તેટલું જ મહત્વપૂર્ણ કેશિંગનો કેન્દ્રીય મુશ્કેલી સમજવું છે — **અમાન્યતા** (કેશ સાફ કરવું અથવા અપડેટ કરવું જ્યારે ડેટા બદલાય, TTL અથવા સ્પષ્ટ કાઢી નાખવા દ્વારા, જૂના ડેટા પરોવતા ટાળવા માટે) — કારણ કે આ ખોટો કરવો ક્લાસિક કેશિંગ નિષ્ફળતા છે.

કેશિંગ કેવું અને ક્યારે લાગુ કરવું, તથ્યાધાર માટે યોગ્ય સ્ટોર પસંદ કરવું, અને અમાન્યતાને યોગ્યરીતે હેન્ડલ કરવું ઝડપી, સ્કેલેબલ NestJS સેવાઓ બાંધવા માટે મૂલ્યવાન સીનિયર-લેવલ જ્ઞાન છે.