Was sind Module in NestJS?

Question

Accepted Answer

Ein **Modul** ist eine Klasse, die mit `@Module()` dekoriert wird und **verwandte Komponenten zusammenfasst** — Controller, Provider/Services — in einer kohärenten Einheit. Module sind die Art und Weise, wie NestJS eine Anwendung in Features organisiert, und jede Nest-App hat mindestens ein Root-`AppModule`.

## Definition eines Moduls

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

## Die vier wichtigsten Eigenschaften

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

Module bilden einen **DI Scope**: Ein Provider ist innerhalb seines Moduls verfügbar und für andere Module nur dann, wenn er **exportiert** wird (und das andere Modul ihn **importiert**).

## Das Root-Modul

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

Jede App hat ein Root-`AppModule`, das die Feature-Module importiert und die gesamte Anwendung zusammensetzt.

## Feature-basierte Organisation

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

Die Konvention ist **ein Modul pro Feature/Domain** (Benutzer, Authentifizierung, Produkte), was zusammenhängenden Code zusammenhält und Abhängigkeiten explizit macht.

## Teilen von Providern über Module hinweg

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

Um einen Provider aus einem anderen Modul zu verwenden, muss das bereitstellende Modul ihn **exportieren** und das verbrauchende Modul muss das bereitstellende Modul **importieren** — was Abhängigkeiten explizit macht.

## Warum es wichtig ist

Module sind das organisatorische Rückgrat jeder NestJS-Anwendung — sie fassen verwandte Controller und Provider in kohärenten Feature-Einheiten zusammen und definieren die Dependency-Injection-Grenzen.

Das Verständnis der vier Eigenschaften (`controllers`, `providers`, `imports`, `exports`) und insbesondere des **Import/Export-Mechanismus** zum Teilen von Providern über Module hinweg ist essentiell: So erreicht NestJS eine modulare, lose gekoppelte Architektur, in der jede Feature in sich geschlossen ist und Abhängigkeiten explizit sind.

Die Feature-basierte Modul-Struktur (ein Modul pro Domain) ist die Standardmethode zur Organisation von Nest-Apps für Skalierbarkeit und Wartbarkeit.

Module bilden zusammen mit Controllern und Providern die Kernarchitektur von NestJS, weshalb sie fundamentales Wissen darstellen — die Fähigkeit, eine App in Module zu strukturieren und Provider über Imports/Exports zu verbinden, ist notwendig zum Aufbau jeder nicht-trivialen NestJS-Anwendung und ist ein häufiger Verwirrungspunkt, den es sich lohnt, früh gut zu verstehen.