Dependency injection ใน NestJS ทำงานอย่างไร?

Question

Accepted Answer

**Dependency Injection (DI)** เป็นรูปแบบหลักของ NestJS ที่เฟรมเวิร์ก **สร้างและจัดหา** dependency ที่คลาสต้องการ **โดยอัตโนมัติ** แทนที่คลาสจะสร้างเอง. คุณประกาศสิ่งที่ต้องการใน constructor แล้ว NestJS จัดหาให้ — นำไปสู่โค้ดที่ loosely-coupled และทดสอบได้

## หลักการทำงาน: ประกาศใน constructor

```ts
@Injectable()
export class UsersService {
  // declare dependencies as constructor parameters — Nest injects them
  constructor(
    private readonly db: DatabaseService,
    private readonly logger: LoggerService,
  ) {}
  // you NEVER write `new DatabaseService()` — Nest creates and provides it
}
```

Nest อ่านชนิด (type) ของพารามิเตอร์ใน constructor, ค้นหา provider ที่ลงทะเบียนไว้ที่ตรงกัน, สร้างมันขึ้นมา (ถ้ายังไม่มี) แล้วส่งเข้ามา — โดยแก้ปัญหา dependency graph ทั้งหมดอัตโนมัติ

## ขั้นตอนของ DI

```text
1. A class is marked @Injectable() → it's a provider
2. The provider is registered in a module's `providers` array
3. Another class declares it as a constructor parameter
4. NestJS's IoC container resolves and INJECTS the instance automatically
```

## การลงทะเบียนและการแก้ค่า (resolution)

```ts
@Module({
  providers: [UsersService, DatabaseService, LoggerService],  // register all providers
  controllers: [UsersController],
})
export class UsersModule {}
// Nest's container now knows how to construct each and inject them where needed
```

## ทำไม DI จึงมีคุณค่า

```text
✓ Loose coupling — classes depend on ABSTRACTIONS, not on constructing concrete deps
✓ Testability — inject MOCK dependencies in tests easily (no real DB needed)
✓ Reusability — one shared instance (singleton) used across the app
✓ Maintainability — change an implementation in one place (the module registration)
```

## Testability — ประโยชน์ที่เด่นที่สุด

```ts
// in a test, provide a fake DatabaseService — no real database required
const module = await Test.createTestingModule({
  providers: [
    UsersService,
    { provide: DatabaseService, useValue: mockDatabase },  // inject a mock
  ],
}).compile();
```

เพราะคลาสไม่ได้สร้าง dependency ของมันเอง คุณจึงสามารถสลับ mock เข้ามาเพื่อการทดสอบได้ — DI ทำให้แอป NestJS ทดสอบได้สูง

## การ inject ค่าที่ไม่ใช่คลาส

```ts
// use injection tokens for config/values, not just classes
constructor(@Inject("CONFIG") private config: AppConfig) {}
```

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

Dependency injection เป็นรูปแบบรากฐานที่รองรับสถาปัตยกรรมทั้งหมดของ NestJS — เป็นวิธีที่ controller ได้รับ service, service ได้รับ repository และ service อื่น ๆ และแอปพลิเคชันทั้งหมดถูกเชื่อมต่อเข้าด้วยกัน

การเข้าใจมันเป็นสิ่งจำเป็นเพราะคลาส NestJS แทบทุกตัวเข้าร่วมใน DI: คุณประกาศ dependency ใน constructor แล้ว IoC container ของเฟรมเวิร์กจะแก้ค่าและจัดหาให้โดยอัตโนมัติ ขจัดการสร้าง instance เองด้วยมือและ tight coupling

ประโยชน์นั้นสำคัญและเป็นแก่นของเหตุผลที่ NestJS ได้รับการยกย่อง: **loose coupling** (พึ่งพา abstraction), **testability** (inject mock แทน dependency จริง — ทำให้ unit testing อย่างถี่ถ้วนทำได้ง่าย), reusability (singleton ที่แชร์ร่วมกัน) และ maintainability

DI ยืมแนวคิดมาจากเฟรมเวิร์กอย่าง Angular และ Spring และการเชี่ยวชาญมัน — วิธีประกาศ, ลงทะเบียน, inject และ mock dependency — จำเป็นต่อการสร้างแอปพลิเคชัน NestJS ที่มีโครงสร้างดีและทดสอบได้ และเป็นหนึ่งในแนวคิดที่สำคัญที่สุดที่ต้องเข้าใจอย่างลึกซึ้งในเฟรมเวิร์ก