Co jsou moduly v NestJS?

Question

Accepted Answer

**Modul** je třída украšena `@Module()` která **seskupuje související komponenty** — kontroléry, poskytovatele/služby — do souvislé jednotky. Moduly jsou způsob, jak NestJS organizuje aplikaci do funkcí, a každá Nest aplikace má alespoň jeden kořenový `AppModule`.

## Definování modulu

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

## Čtyři klíčové vlastnosti

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

Moduly tvoří **DI scope**: poskytovatel je dostupný v rámci svého modulu a ostatním modulům pouze pokud je **exportován** (a druhý modul ho **importuje**).

## Kořenový modul

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

Každá aplikace má kořenový `AppModule` který importuje funkční moduly a skládá tak celou aplikaci.

## Organizace podle funkcí

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

Konvencí je **jeden modul na funkci/doménu** (uživatelé, autentizace, produkty), díky čemuž zůstává související kód pohromadě a závislosti explicitní.

## Sdílení poskytovatelů mezi moduly

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

Aby jste mohli použít poskytovatele z jiného modulu, poskytující modul ho musí **exportovat** a konzumující modul musí importovat poskytující modul — čímž jsou závislosti explicitní.

## Proč je to důležité

Moduly jsou organizační páteří každé NestJS aplikace — seskupují související kontroléry a poskytovatele do souvislých jednotek funkcí a definují hranice dependency-injection.

Rozmění čtyřech vlastností (`controllers`, `providers`, `imports`, `exports`) a zejména **mechanismu import/export** pro sdílení poskytovatelů mezi moduly je zásadní: to je způsob, jakým NestJS dosahuje modulární, volně vázané architektury, kde je každá funkce samostatná a závislosti jsou explicitní.

Struktura modulů podle funkcí (jeden modul na doménu) je standardní způsob organizace Nest aplikací pro škálovatelnost a udržovatelnost.

Moduly spolu s kontroléry a poskytovateli tvoří jádro NestJS architektury, což je z nich zásadní znalost — zvládnutí struktury aplikace na moduly a propojení poskytovatelů mezi nimi prostřednictvím import/export je nezbytné pro vytváření jakýchkoli netriviálních NestJS aplikací a je to časté zdroj zmatení, které stojí za to pochopit dobře od začátku.