Que sont les modules dans NestJS?

Question

Accepted Answer

Un **module** est une classe décorée avec `@Module()` qui **regroupe les composants associés** — contrôleurs, fournisseurs/services — en une unité cohésive. Les modules sont la façon dont NestJS organise une application en fonctionnalités, et chaque application Nest a au moins un `AppModule` racine.

## Définir un module

```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 {}
```

## Les quatre propriétés clés

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

Les modules forment une **portée d'injection de dépendances** : un fournisseur est disponible dans son module, et aux autres modules uniquement s'il est **exporté** (et l'autre module l'**importe**).

## Le module racine

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

Chaque application a un `AppModule` racine qui importe les modules de fonctionnalité, composant l'application entière.

## Organisation basée sur les fonctionnalités

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

La convention est **un module par fonctionnalité/domaine** (utilisateurs, authentification, produits), en gardant le code associé ensemble et les dépendances explicites.

## Partager des fournisseurs entre les modules

```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 {}
```

Pour utiliser un fournisseur d'un autre module, le module fournisseur doit l'**exporter** et le module consommateur doit **importer** le module fournisseur — rendant les dépendances explicites.

## Pourquoi c'est important

Les modules sont l'épine dorsale organisationnelle de chaque application NestJS — ils regroupent les contrôleurs et fournisseurs associés en unités de fonctionnalité cohésives et définissent les limites d'injection de dépendances.

Comprendre les quatre propriétés (`controllers`, `providers`, `imports`, `exports`) et notamment le mécanisme **import/export** pour partager les fournisseurs entre les modules est essentiel : c'est ainsi que NestJS réalise une architecture modulaire et faiblement couplée où chaque fonctionnalité est auto-contenue et les dépendances sont explicites.

La structure des modules basée sur les fonctionnalités (un module par domaine) est la façon standard d'organiser les applications Nest pour la scalabilité et la maintenabilité.

Les modules, ainsi que les contrôleurs et les fournisseurs, forment l'architecture centrale de NestJS, ce qui en fait une connaissance fondamentale — maîtriser comment structurer une application en modules et câbler les fournisseurs entre eux via imports/exports est nécessaire pour construire n'importe quelle application NestJS non-triviale et c'est un point de confusion fréquent qui mérite d'être bien compris dès le départ.