Vad är moduler i NestJS?

Question

Accepted Answer

En **modul** är en klass dekorerad med `@Module()` som **grupperar relaterade komponenter** — controllers, providers/services — till en sammanhängande enhet. Moduler är hur NestJS organiserar en applikation i features, och varje Nest-app har minst en root `AppModule`.

## Definiera 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 fyra nyckelegenskaperna

```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 bildar ett **DI-scope**: en provider är tillgänglig inom sin modul, och för andra moduler endast om den **exporteras** (och den andra modulen **importerar** den).

## Root-modulen

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

Varje app har en root `AppModule` som importerar feature-modulerna och komponerar hela applikationen.

## Feature-baserad 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)
```

Konventionen är **en modul per feature/domän** (users, auth, products), vilket håller relaterad kod tillsammans och gör beroenden explicita.

## Dela providers över 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 {}
```

För att använda en provider från en annan modul måste den tillhandahållande modulen **exportera** den och den konsumerande modulen måste **importera** den tillhandahållande modulen — vilket gör beroenden explicita.

## Varför det är viktigt

Moduler är det organisatoriska ryggrandet i varje NestJS-applikation — de grupperar relaterade controllers och providers till sammanhängande feature-enheter och definierar dependency-injection-gränserna.

Att förstå de fyra egenskaperna (`controllers`, `providers`, `imports`, `exports`) och särskilt **import/export-mekanismen** för att dela providers över moduler är väsentligt: det är hur NestJS uppnår en modulär, löst kopplad arkitektur där varje feature är självständig och beroenden är explicita.

Den feature-baserade modulstrukturen (en modul per domän) är standardsättet att organisera Nest-appar för skalbarhet och underhållbarhet.

Moduler tillsammans med controllers och providers bildar NestJS:s kärnarkitektur, vilket gör dem till grundläggande kunskap — att behärska hur man strukturerar en app i moduler och kopplar providers mellan dem via imports/exports är nödvändigt för att bygga någon icke-trivial NestJS-applikation och är en frekvent förvirringspoint som är värd att förstå väl tidigt.