Co jsou moduly v NestJS?

Question

IT Interview Practice · 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.

Definování modulu

Čtyři klíčové vlastnosti

Kořenový modul

Organizace podle funkcí

Sdílení poskytovatelů mezi moduly

Proč je to důležité

Související otázky