Wat zijn modules in NestJS?

Question

Accepted Answer

Een **module** is een klasse gedecoreerd met `@Module()` die **gerelateerde componenten** — controllers, providers/services — in een cohesieve eenheid groepeert. Modules zijn hoe NestJS een applicatie in features organiseert, en elke Nest-app heeft minstens een root `AppModule`.

## Een module definiëren

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

## De vier belangrijkste eigenschappen

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

Modules vormen een **DI scope**: een provider is beschikbaar binnen zijn module, en voor andere modules alleen als deze **geëxporteerd** is (en de andere module deze **importeert**).

## De root module

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

Elke app heeft een root `AppModule` die de feature modules importeert, waarmee de hele applicatie wordt samengesteld.

## Feature-gebaseerde organisatie

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

De conventie is **één module per feature/domain** (users, auth, products), waarbij gerelateerde code bij elkaar blijft en afhankelijkheden expliciet zijn.

## Providers delen tussen 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 {}
```

Om een provider van een andere module te gebruiken, moet de aanbiedende module deze **exporteren** en moet de consumerende module de aanbiedende module **importeren** — waardoor afhankelijkheden expliciet worden gemaakt.

## Waarom het belangrijk is

Modules zijn de organisatorische ruggengraat van elke NestJS-applicatie — zij groeperen gerelateerde controllers en providers in cohesieve feature-eenheden en definiëren de dependency-injection grenzen.

Het begrijpen van de vier eigenschappen (`controllers`, `providers`, `imports`, `exports`) en vooral het **import/export-mechanisme** voor het delen van providers tussen modules is essentieel: dit is hoe NestJS modulaire, losjes gekoppelde architectuur bereikt, waarbij elke feature zelfstandig is en afhankelijkheden expliciet zijn.

De feature-gebaseerde modulestructuur (één module per domain) is de standaardmanier om Nest-apps voor schaalbaarheid en onderhoudbaarheid te organiseren.

Modules vormen samen met controllers en providers de kernarchitectuur van NestJS, waardoor zij fundamentele kennis zijn — het beheersen van hoe je een app in modules structureert en hoe je providers tussen deze modules draad via imports/exports is noodzakelijk voor het bouwen van elke niet-triviale NestJS-applicatie en is een veelvoorkomend verwarringsmoment dat het waard is om vroegtijdig goed te begrijpen.