Hvad er moduler i NestJS?

Question

Accepted Answer

Et **modul** er en klasse dekoreret med `@Module()` som **grupperer relaterede komponenter** — controllers, providers/services — i en sammenhængende enhed. Moduler er hvordan NestJS organiserer en applikation i features, og hver Nest app har mindst en root `AppModule`.

## Definition af et 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 {}
```

## De fire vigtige egenskaber

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

Moduler danner et **DI scope**: en provider er tilgængelig inden for sit modul og til andre moduler kun hvis det **eksporteres** (og det andet modul **importerer** det).

## Root modulet

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

Enhver app har et root `AppModule` som importerer feature modulerne og sammensætter hele applikationen.

## Feature-baseret organisering

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

Konventionen er **et modul per feature/domæne** (brugere, auth, produkter), hvilket holder relateret kode sammen og gør afhængigheder eksplicitte.

## Deling af providers på tværs af moduler

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

For at bruge en provider fra et andet modul skal det udgivende modul **eksportere** det og det forbrugende modul skal **importere** det udgivende modul — hvilket gør afhængigheder eksplicitte.

## Hvorfor det er vigtigt

Moduler er det organisatoriske rygrad i enhver NestJS applikation — de grupperer relaterede controllers og providers i sammenhængende feature enheder og definerer dependency-injection grænserne.

At forstå de fire egenskaber (`controllers`, `providers`, `imports`, `exports`) og især **import/export mekanismen** for at dele providers på tværs af moduler er essentiell: det er hvordan NestJS opnår modulær, løst koblet arkitektur hvor hver feature er selvstændig og afhængigheder er eksplicitte.

Den feature-baserede modul struktur (et modul per domæne) er standardmåden at organisere Nest apps på for skalerbarhed og vedligeholdelse.

Moduler udgør sammen med controllers og providers NestJS kernearchitektur, hvilket gør dem til fundamental viden — at mestre hvordan man strukturerer en app i moduler og forbinder providers mellem dem via imports/exports er nødvendigt for at bygge enhver ikke-triviel NestJS applikation og er et hyppigt punkt af forvirring som er værd at forstå godt tidligt.