Ce sunt modulele în NestJS?

Question

Accepted Answer

Un **modul** este o clasă decorată cu `@Module()` care **grupează componente conexe** — controllere, provideri/servicii — într-o unitate coezivă. Modulele sunt modul în care NestJS organizează o aplicație în funcționalități, și fiecare aplicație Nest are cel puțin un `AppModule` rădăcină.

## Definirea unui modul

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

@Module({
  controllers: [UsersController],    // controllers belonging to this module
  providers: [UsersService],          // providers (services) this module creates
  imports: [DatabaseModule],          // OTHER modules whose exports this module needs
  exports: [UsersService],            // what this module makes available to importers
})
export class UsersModule {}
```

## Cele patru proprietăți cheie

```text
controllers → the controllers (request handlers) in this module
providers   → the providers/services defined and instantiated here (for DI)
imports     → other modules whose EXPORTED providers this module can use
exports     → the subset of THIS module's providers shared with importing modules
```

Modulele formează un **DI scope**: un provider este disponibil în cadrul modulului său, și în alte module doar dacă este **exportat** (și celelalte module îl **importă**).

## Modulul rădăcină

```ts
@Module({
  imports: [UsersModule, AuthModule, DatabaseModule],   // compose feature modules
})
export class AppModule {}   // the root — bootstrapped to start the app
```

Fiecare aplicație are un `AppModule` rădăcină care importă modulele de funcționalitate, compunând întreaga aplicație.

## Organizare bazată pe funcționalități

```text
src/
  app.module.ts            (root — imports feature modules)
  users/
    users.module.ts        (groups users controller + service)
    users.controller.ts
    users.service.ts
  auth/
    auth.module.ts
  database/
    database.module.ts     (shared infrastructure)
```

Convenția este **un modul per funcționalitate/domeniu** (utilizatori, autentificare, produse), păstrând codul conexe împreună și dependențele explicite.

## Partajarea providerilor între module

```ts
// UsersModule exports UsersService...
@Module({ providers: [UsersService], exports: [UsersService] })
export class UsersModule {}

// ...so AuthModule can use it by importing UsersModule
@Module({ imports: [UsersModule] })   // now AuthModule can inject UsersService
export class AuthModule {}
```

Pentru a utiliza un provider din alt modul, modulul furnizor trebuie să îl **exporte** și modulul consumator trebuie să **importe** modulul furnizor — făcând dependențele explicite.

## De ce contează

Modulele sunt coloana vertebrală organizațională a fiecărei aplicații NestJS — ele grupează controllerele și providerii conexe în unități de funcționalitate coezive și definesc limitele injecției de dependențe.

Înțelegerea celor patru proprietăți (`controllers`, `providers`, `imports`, `exports`) și în special mecanismul **import/export** pentru partajarea providerilor între module este esențială: acesta este modul în care NestJS realizează o arhitectură modulară, slab cuplată, unde fiecare funcționalitate este auto-conținută și dependențele sunt explicite.

Structura modulului bazată pe funcționalități (un modul per domeniu) este modalitatea standard de a organiza aplicațiile Nest pentru scalabilitate și mentenabilitate.

Modulele, împreună cu controllerele și providerii, formează arhitectura de bază a NestJS, făcândule cunoștințe fundamentale — stăpânirea modului de a structura o aplicație în module și de a conecta providerii între ele prin importe/exporte este necesară pentru construirea oricărei aplicații NestJS netriviale și este un punct frecvent de confuzie care merită înțeles bine de la început.