NestJS-இல் dependency injection எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

**Dependency Injection (DI)** என்பது ஒரு முக்கிய NestJS pattern ஆகும், அங்கு framework ஒரு class-க்கு தேவையான dependencies-ஐ **தானாகவே உருவாக்கி வழங்குகிறது**, class அவற்றை தானே உருவாக்குவதற்கு பதிலாக. உங்களுக்கு தேவையானதை நீங்கள் constructor-இல் அறிவிக்கிறீர்கள், மற்றும் NestJS அதை வழங்குகிறது — இது loosely-coupled, testable code-க்கு வழிவகுக்கிறது.

## இது எவ்வாறு செயல்படுகிறது: 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 constructor-இன் parameter types-ஐ படித்து, தொடர்புடைய பதிவு செய்யப்பட்ட providers-ஐ தேடி, அவற்றை உருவாக்கி (இன்னும் இல்லையென்றால்), அவற்றை அனுப்புகிறது — முழு dependency graph-ஐயும் தானாகவே resolve செய்கிறது.

## DI flow

```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();
```

class தனது dependencies-ஐ உருவாக்காததால், testing-க்காக mocks-ஐ swap செய்யலாம் — DI NestJS apps-ஐ மிகவும் testable ஆக்குகிறது.

## class அல்லாத values-ஐ inject செய்தல்

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

## இது ஏன் முக்கியம்

Dependency injection என்பது NestJS-இன் முழு architecture-ஐயும் ஆதரிக்கும் அடிப்படை pattern — இதுதான் controllers services-ஐ பெறும் விதம், services repositories மற்றும் மற்ற services-ஐ பெறும் விதம், மற்றும் முழு applicationம் ஒன்றாக இணைக்கப்படும் விதம்.

இதை புரிந்துகொள்வது அத்தியாவசியம், ஏனெனில் கிட்டத்தட்ட ஒவ்வொரு NestJS class-ம் DI-இல் பங்கேற்கிறது: நீங்கள் dependencies-ஐ constructor-இல் அறிவிக்கிறீர்கள் மற்றும் framework-இன் IoC container அவற்றை தானாகவே resolve செய்து வழங்குகிறது, manual instantiation மற்றும் tight coupling-ஐ நீக்குகிறது.

நன்மைகள் குறிப்பிடத்தக்கவை மற்றும் NestJS ஏன் மதிக்கப்படுகிறது என்பதற்கு மையமானவை: **loose coupling** (abstractions-ஐ சார்ந்திருத்தல்), **testability** (real dependencies-க்கு பதிலாக mocks-ஐ inject செய்தல் — முழுமையான unit testing-ஐ எளிதாக்குதல்), reusability (shared singletons), மற்றும் maintainability.

DI என்பது Angular மற்றும் Spring போன்ற frameworks-இலிருந்து கடன் வாங்கப்பட்டது, மற்றும் அதை தேர்ச்சி பெறுவது — dependencies-ஐ எவ்வாறு அறிவிப்பது, பதிவு செய்வது, inject செய்வது, மற்றும் mock செய்வது — நன்கு கட்டமைக்கப்பட்ட, testable NestJS applications-ஐ உருவாக்க அவசியம் மற்றும் framework-இல் ஆழமாக புரிந்துகொள்ள வேண்டிய மிக முக்கியமான கருத்துக்களில் ஒன்று.