Hva er moduler i NestJS?

Question

Accepted Answer

En **modul** er en klasse dekorert med `@Module()` som **grupperer relaterte komponenter** — kontrollere, providere/tjenester — inn i en sammenhengende enhet. Moduler er hvordan NestJS organiserer en applikasjon i funksjoner, og hver Nest-app har minst en rot `AppModule`.

## Definere en 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 nøkkel-egenskapene

```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-omfang**: en provider er tilgjengelig innen sin modul, og til andre moduler bare hvis den **eksporteres** (og den andre modulen **importerer** den).

## Rotmodulen

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

Hver app har en rot `AppModule` som importerer funksjonsmodulene og komponerer hele applikasjonen.

## Funksjon-basert 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)
```

Konvensjonen er **én modul per funksjon/domene** (brukere, autentisering, produkter), som holder relatert kode sammen og avhengigheter eksplisitte.

## Dele providere på tvers av 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 å bruke en provider fra en annen modul, må den leverende modulen **eksportere** den og den forbrukende modulen må **importere** den leverende modulen — noe som gjør avhengigheter eksplisitte.

## Hvorfor det betyr noe

Moduler er det organisatoriske ryggraden i hver NestJS-applikasjon — de grupperer relaterte kontrollere og providere inn i sammenhengende funksjonsenheter og definerer avhengighetsinsjeksjonsgrensene.

Å forstå de fire egenskapene (`controllers`, `providers`, `imports`, `exports`) og spesielt **import/eksport-mekanismen** for å dele providere på tvers av moduler er essensielt: det er hvordan NestJS oppnår modulær, løst koblet arkitektur der hver funksjon er selvstedig og avhengigheter er eksplisitte.

Den funksjon-baserte modulstrukturen (én modul per domene) er standardmåten å organisere Nest-apper på for skalerbarhet og vedlikeholdbarhet.

Moduler, sammen med kontrollere og providere, danner NestJS sin kjernearkitektur, noe som gjør dem til fundamental kunnskap — å mestre hvordan man strukturerer en app i moduler og kobler providere sammen via import/eksport er nødvendig for å bygge en hvilken som helst ikke-triviell NestJS-applikasjon og er et hyppig forvirringspunkt som er verdt å forstå godt tidlig.