NestJS ਵਿੱਚ dependency injection ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?

Question

Accepted Answer

**Dependency Injection (DI)** ਇੱਕ ਮੁੱਖ NestJS ਪੈਟਰਨ ਹੈ ਜਿੱਥੇ framework **ਆਪਣੇ ਆਪ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਫ਼ਰਾਹਮ ਕਰਦਾ ਹੈ** ਉਹ dependencies ਜੋ ਇੱਕ ਕਲਾਸ ਨੂੰ ਚਾਹੀਦੀ ਹੈ, ਬਜਾਏ ਇਸ ਦੇ ਕਿ ਕਲਾਸ ਆਪ ਉਨ੍ਹਾਂ ਨੂੰ ਬਣਾਏ। ਤੁਸੀਂ 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 ਦੀਆਂ ਕਿਸਮਾਂ ਪੜ੍ਹਦਾ ਹੈ, ਪੰਜੀਕ੍ਰਿਤ providers ਨੂੰ ਲੱਭਦਾ ਹੈ, ਉਨ੍ਹਾਂ ਨੂੰ ਬਣਾਉਂਦਾ ਹੈ (ਜੇ ਪਹਿਲਾਂ ਨਹੀਂ ਹੈ), ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ pass ਕਰਦਾ ਹੈ — ਆਪਣੇ ਆਪ ਪੂਰੇ dependency graph ਨੂੰ ਹੱਲ ਕਰਦੇ ਹੋਏ।

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

## Registration ਅਤੇ 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();
```

ਕਿਉਂਕਿ ਕਲਾਸ ਆਪਣੀ dependencies ਨੂੰ ਨਹੀਂ ਬਣਾਉਂਦੀ, ਤੁਸੀਂ testing ਲਈ mocks ਵਿੱਚ swap ਕਰ ਸਕਦੇ ਹੋ — DI NestJS apps ਨੂੰ ਬਹੁਤ testable ਬਣਾਉਂਦਾ ਹੈ।

## Non-class ਮੁੱਲਾਂ ਨੂੰ inject ਕਰਨਾ

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

## ਇਹ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

Dependency injection NestJS ਦੇ ਪੂਰੇ architecture ਦਾ ਬੁਨਿਆਦੀ ਪੈਟਰਨ ਹੈ — ਇਹ ਹੈ ਕਿ ਕਿਵੇਂ controllers ਨੂੰ services ਮਿਲਦੀਆਂ ਹਨ, services ਨੂੰ repositories ਅਤੇ ਹੋਰ services ਮਿਲਦੀਆਂ ਹਨ, ਅਤੇ ਪੂਰੀ application ਨੂੰ ਇਕੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
oards ਕਰਨਾ ਜਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਲਗਭਗ ਹਰ NestJS ਕਲਾਸ DI ਵਿੱਚ ਹਿੱਸਾ ਲੈਂਦੀ ਹੈ: ਤੁਸੀਂ constructor ਵਿੱਚ dependencies ਦਾ ਐਲਾਨ ਕਰਦੇ ਹੋ ਅਤੇ framework ਦਾ IoC container ਉਨ੍ਹਾਂ ਨੂੰ ਆਪਣੇ ਆਪ ਹੱਲ ਕਰਦਾ ਹੈ ਅਤੇ ਫ਼ਰਾਹਮ ਕਰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਦਸਤੀ instantiation ਅਤੇ tight coupling ਨੂੰ ਖਤਮ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਫ਼ਾਇਦੇ ਮਹੱਤਵਪੂਰਨ ਅਤੇ NestJS ਦੇ ਮੁੱਲ ਦੇ ਕੇਂਦਰ ਵਿੱਚ ਹਨ: **loose coupling** (abstractions ਉੱਪਰ ਨਿਰਭਰ ਕਰਨਾ), **testability** (real dependencies ਦੀ ਥਾਂ mocks inject ਕਰਨਾ — ਜਿਸ ਨਾਲ thorough unit testing ਆਸਾਨ ਹੁੰਦਾ ਹੈ), reusability (shared singletons), ਅਤੇ maintainability।

DI frameworks ਜਿਵੇਂ ਕਿ Angular ਅਤੇ Spring ਤੋਂ ਲਏ ਗਏ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ master ਕਰਨਾ — ਕਿਵੇਂ dependencies ਨੂੰ declare, register, inject, ਅਤੇ mock ਕਰਨਾ ਹੈ — well-structured, testable NestJS applications ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਅਤੇ ਫ਼ਰੇਮਵਰਕ ਵਿੱਚ ਸਮਝਣ ਲਈ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ concepts ਵਿੱਚੋਂ ਇੱਕ ਹੈ।