คุณเพิ่ม caching ใน NestJS อย่างไร?

Question

Accepted Answer

NestJS มี **caching module** มาในตัว (`@nestjs/cache-manager`) พร้อม API แบบรวมศูนย์ที่ทำงานได้ข้าม store ต่างๆ โดย default เป็น in-memory หรือ **Redis** สำหรับการ cache แบบกระจายข้ามหลาย instance การ cache ช่วยเพิ่มประสิทธิภาพอย่างมากโดยหลีกเลี่ยงการทำงานที่มีค่าใช้จ่ายสูงซ้ำๆ

## การตั้งค่า cache module

```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 {}
```

## การ cache endpoint อัตโนมัติด้วย interceptor

```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` จะ cache response ของ endpoint `GET` โดยอัตโนมัติ (keyed ด้วย URL) และส่งผลลัพธ์ที่ cache ไว้เมื่อมี request ซ้ำ ซึ่งเป็นวิธีที่ง่ายที่สุดในการ cache endpoint ที่อ่านหนัก

## การ cache แบบ manual ด้วย 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;
  }
}
```

การ inject `CACHE_MANAGER` ให้การควบคุมเต็มที่ ด้วยแพทเทิร์น get-or-fetch (เช็ก cache, ย้อนกลับไปดึงจากแหล่งข้อมูล, เก็บผลลัพธ์) สำหรับการ cache operation ที่มีค่าใช้จ่ายสูงเฉพาะเจาะจง

## การ cache แบบกระจายด้วย Redis (หลาย instance)

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

API เดียวกัน แต่ใช้ **Redis** เป็นฐานหลัง ให้ cache ที่ **ใช้ร่วมกัน** ข้ามทุก instance ของแอป ซึ่งจำเป็นเมื่อรันหลาย instance (cache แบบ in-memory ไม่ได้ใช้ร่วมกันระหว่างกัน)

## ส่วนที่ยาก: การ invalidate cache

```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.
```

## ทำไมจึงสำคัญ

การ cache เป็นหนึ่งในการ optimize ประสิทธิภาพที่ส่งผลกระทบสูงสุดสำหรับแอปพลิเคชัน back-end และ caching module ที่มีมาในตัวของ NestJS ทำให้มันสะอาดและสอดคล้องกัน

การเข้าใจมันสำคัญเพราะ API ที่อ่านหนักได้ประโยชน์มหาศาลจากการ cache operation ที่มีค่าใช้จ่ายสูง (database query, การเรียก external API, การคำนวณ) ซึ่งลด latency และ load ลงอย่างมาก

NestJS มีทั้งการ cache อัตโนมัติแบบง่าย (`CacheInterceptor` สำหรับ GET endpoint) และการควบคุมแบบ manual ที่ละเอียด (แพทเทิร์น get-or-fetch ของ `CACHE_MANAGER` สำหรับ operation เฉพาะ)

ที่สำคัญคือ API แบบรวมศูนย์ทำงานได้กับ store ต่างๆ ทำให้โค้ดเดียวกันใช้ **in-memory caching** (เร็ว, instance เดียว) หรือ **Redis** (cache ที่ใช้ร่วมกันข้ามหลาย instance) ได้ และการรู้ว่า in-memory cache *ไม่ได้ใช้ร่วมกัน* เมื่อ scale แนวนอน (ต้องใช้ Redis สำหรับ cache แบบกระจาย) เป็นจุดทางสถาปัตยกรรมที่สำคัญ

สำคัญพอกันคือการเข้าใจความยากหลักของการ cache คือ **การ invalidate** (การล้างหรืออัปเดต cache เมื่อข้อมูลเปลี่ยน ผ่าน TTL หรือการลบอย่างชัดเจน เพื่อหลีกเลี่ยงการส่งข้อมูลเก่า) เพราะการทำผิดในเรื่องนี้คือความล้มเหลวคลาสสิกของการ cache

การรู้ว่าจะ apply การ cache อย่างไรและเมื่อใด, การเลือก store ที่ถูกต้องสำหรับ deployment และการจัดการ invalidation อย่างถูกต้อง เป็นความรู้ระดับ senior ที่มีค่าสำหรับการสร้าง NestJS service ที่รวดเร็วและ scale ได้