ਤੁਸੀਂ 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 ਦਾ ਬਿਲਟ-ਇਨ ਕੈਸ਼ਿੰਗ ਮਾਡਿਊਲ ਇਸਨੂੰ ਸਾਫ ਅਤੇ ਬਾਰੀਕ ਬਣਾਉਂਦਾ ਹੈ।
ett ਹੋਣਾ ਮਹੱਤਵਪੂਰਣ ਹੈ ਕਿਉਂਕਿ ਪੜ੍ਹਨ ਵਾਲੀਆਂ ਭਾਰੀ API ਮਹਿੰਗੇ ਕਾਰਜਾਂ (ਡਾਟਾਬੇਸ ਕਿਊਰੀਜ਼, ਬਾਹਰੀ API ਕਾਲਸ, ਕਮਪਿਊਟੇਸ਼ਨਸ) ਨੂੰ ਕੈਸ਼ ਕਰਨ ਤੋਂ ਬਹੁਤ ਲਾਭ ਪ੍ਰਾਪਤ ਕਰਦੀਆਂ ਹਨ — ਵਿਲੰਬ ਅਤੇ ਭਾਰ ਨੂੰ ਨਾਟਖਟ ਰੂਪ ਵਿੱਚ ਘਟਾਉਂਦੀਆਂ ਹਨ।

NestJS ਸਧਾਰਨ ਆਟੋ-ਕੈਸ਼ਿੰਗ (GET ਐਂਡਪੁਆਇੰਟਸ ਲਈ `CacheInterceptor`) ਅਤੇ ਫਾਈਨ-ਗ੍ਰੇਨਡ ਮੈਨੁਅਲ ਨਿਯੰਤਰਣ (ਖਾਸ ਕਾਰਜਾਂ ਲਈ `CACHE_MANAGER` ਗੈੱਟ-ਆਰ-ਫੈਚ ਪੈਟਰਨ) ਦੋਹਾਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ।

ਮਹੱਤਵਪੂਰਣ ਗੱਲ ਇਹ ਹੈ ਕਿ ਯੂਨੀਫਾਈਡ API ਵੱਖ-ਵੱਖ ਸਟੋਰਾਂ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇੱਕੋ ਕੋਡ **ਇਨ-ਮੈਮੋਰੀ ਕੈਸ਼ਿੰਗ** (ਤੇਜ਼, ਸਿੰਗਲ-ਇਨਸਟੈਂਸ) ਜਾਂ **Redis** (ਮਲਟੀਪਲ ਇਨਸਟੈਂਸਾਂ ਵਿੱਚ ਇੱਕ ਸਾਂਝਾ ਕੈਸ਼) ਵਰਤ ਸਕਦਾ ਹੈ — ਅਤੇ ਇਹ ਜਾਣਨਾ ਕਿ ਇਨ-ਮੈਮੋਰੀ ਕੈਸ਼ *ਸਾਂਝਾ ਨਹੀਂ ਹੁੰਦਾ* ਹਰਿਜ਼ਾਨਤਲ ਸਕੇਲਿੰਗ ਸਮੇਂ (ਡਿਸਟ੍ਰੀਬਿਊਟਿਡ ਕੈਸ਼ਿੰਗ ਲਈ Redis ਦੀ ਲੋੜ) ਇੱਕ ਮਹੱਤਵਪੂਰਣ ਆਰਕੀਟੈਕਚਰਲ ਨੁਕਤਾ ਹੈ।

ਬਰਾਬਰ ਮਹੱਤਵਪੂਰਣ ਕੈਸ਼ਿੰਗ ਦੀ ਕੇਂਦਰੀ ਮੁਸ਼ਕਿਲ — **ਅਮਾਨਤਕਾਰੀ** (ਕੈਸ਼ ਨੂੰ ਸਾਫ ਕਰਨਾ ਜਾਂ ਅੱਪਡੇਟ ਕਰਨਾ ਜਦੋਂ ਡਾਟਾ ਬਦਲੇ, TTL ਜਾਂ ਸਪਸ਼ਟ ਡਿਲੀਸ਼ਨ ਦੁਆਰਾ, ਪੁਰਾਣਾ ਡਾਟਾ ਸਰਵ ਕਰਨ ਤੋਂ ਰੋਕਣ ਲਈ) — ਇਸ ਗੱਲ ਨੂੰ ਸਮਝਣਾ ਹੈ ਕਿ ਇਸ ਵਿੱਚ ਗਲਤੀ ਕਰਨਾ ਕੈਸ਼ਿੰਗ ਦੀ ਖਾਸ ਅਸਫਲਤਾ ਹੈ।

ਇਹ ਜਾਣਨਾ ਕਿ ਕੈਸ਼ਿੰਗ ਨੂੰ ਕਿਵੇਂ ਅਤੇ ਕਦੋਂ ਲਾਗੂ ਕਰਨਾ ਹੈ, ਡਿਪਲਾਇਮੈਂਟ ਲਈ ਸਹੀ ਸਟੋਰ ਚੁਣਨਾ ਹੈ, ਅਤੇ ਅਮਾਨਤਕਾਰੀ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਹੈਂਡਲ ਕਰਨਾ ਤੇਜ਼, ਸਕੇਲੇਬਲ NestJS ਸੇਵਾਵਾਂ ਬਣਾਉਣ ਲਈ ਮੁੱਲਵਾਨ ਸੀਨੀਅਰ-ਲੈਵਲ ਗਿਆਨ ਹੈ।