Provider และ service คืออะไร?

Question

Accepted Answer

ใน NestJS **provider** คือคลาสใด ๆ ที่สามารถถูก **inject** เข้ามาเป็น dependency ได้ ส่วน **service** คือชนิดที่พบบ่อยที่สุด — คลาสที่เก็บ **business logic** การทำเครื่องหมายคลาสด้วย `@Injectable()` ทำให้มันกลายเป็น provider ที่ระบบ DI ของ NestJS สามารถสร้างและ inject ได้

## การกำหนด service (provider ที่พบบ่อยที่สุด)

```ts
import { Injectable } from "@nestjs/common";

@Injectable()              // marks the class as a provider (injectable)
export class UsersService {
  private users = [];

findAll() { return this.users; }                  // business logic
  findOne(id: string) { return this.users.find(u => u.id === id); }
  create(data) { this.users.push(data); return data; }
}
```

Decorator `@Injectable()` บอก NestJS ว่าคลาสนี้เข้าร่วมใน dependency injection — สามารถ inject เข้าไปใน controller หรือ provider อื่นได้

## การ inject service ผ่าน constructor

```ts
@Controller("users")
export class UsersController {
  // NestJS sees this parameter and INJECTS a UsersService instance automatically
  constructor(private usersService: UsersService) {}

@Get()
  findAll() {
    return this.usersService.findAll();   // use the injected service
  }
}
```

คุณประกาศ dependency เป็นพารามิเตอร์ของ constructor แล้ว NestJS จะสร้างและจัดหา instance ให้ — คุณไม่ต้องเขียน `new UsersService()` เลย

## การลงทะเบียน provider ใน module

```ts
@Module({
  controllers: [UsersController],
  providers: [UsersService],        // register the provider so DI can resolve it
  exports: [UsersService],          // make it available to OTHER modules that import this one
})
export class UsersModule {}
```

Provider ต้องลงทะเบียนใน array `providers` ของ module เพื่อให้ DI รู้จัก ส่วน `exports` ทำให้มันใช้ได้กับ module อื่น

## โดยปริยาย provider เป็น singleton

```text
By default, NestJS creates ONE shared instance of each provider (singleton scope)
for the whole application → efficient, shared state.
(Other scopes exist: REQUEST-scoped, TRANSIENT — but singleton is the default.)
```

## ทำไมต้องแยก service ออกจาก controller?

```text
Controller → handles HTTP (routing, request/response)
Service    → handles business logic (rules, data access, computations)
→ Separation makes logic REUSABLE (multiple controllers can use one service),
  TESTABLE (test the service in isolation), and ORGANIZED.
```

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

Provider และ service เป็นแกนกลางของสถาปัตยกรรม NestJS และการออกแบบที่ขับเคลื่อนด้วย dependency injection

Service เก็บ **business logic** ของแอปพลิเคชัน โดยแยกออกจาก controller (ซึ่งจัดการเฉพาะเรื่อง HTTP) — การแยกหน้าที่นี้ทำให้ logic นำกลับมาใช้ซ้ำได้ข้าม controller, ทดสอบแบบ isolated ได้ง่าย และเป็นระเบียบ

การเข้าใจว่า `@Injectable()` ทำเครื่องหมายคลาสให้เป็น provider ที่ inject ได้, ว่า provider ถูกลงทะเบียนใน module และ inject ผ่าน constructor (โดย DI สร้าง instance ให้คุณ) และว่าโดยปริยายมันเป็น singleton เป็นความรู้ NestJS พื้นฐานที่ใช้ทุกวัน

รูปแบบ provider/service ร่วมกับ controller และ module เป็นกระดูกสันหลังของทุกแอปพลิเคชัน NestJS — การเชี่ยวชาญมันจำเป็นต่อการสร้าง back-end ที่มีโครงสร้างดีและดูแลรักษาง่าย และเป็นหนึ่งในแนวคิดแรก ๆ ที่ควรเรียนรู้ในเฟรมเวิร์ก