Kas yra moduliai NestJS?

Question

Accepted Answer

**Modulis** yra klasė dekoruota su `@Module()`, kuri **sugrupuoja susijusius komponentus** — kontrolerius, tiekėjus/servisus — į vieningą vienetą. Moduliai yra tai, kaip NestJS organizuoja programą į funkcijas, ir kiekviena Nest programa turi bent vieną šaknies `AppModule`.

## Modulio apibrėžimas

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

## Keturios pagrindinės savybės

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

Moduliai sudaro **DI sritį**: tiekėjas yra prieinamas savo modulyje ir kitiems moduliams tik jei yra **eksportuojamas** (ir kitas modulis jį **importuoja**).

## Šaknies modulis

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

Kiekviena programa turi šaknies `AppModule`, kuris importuoja funkcijų modulius, sudarydamas visą programą.

## Pagrindu pagrįsta organizacija

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

Konvencija yra **vienas modulis vienai funkcijaidom/sričiai** (naudotojai, autentifikacija, produktai), laikant susijusį kodą kartu ir padaryti priklausomybes aiškiomis.

## Tiekėjų bendrinimas tarp modulių

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

Norėdami naudoti tiekėją iš kito modulio, teikiantis modulis turi jį **eksportuoti**, o naudojantis modulis turi **importuoti** teikiantį modulį — todėl priklausomybės yra aiškios.

## Kodėl tai svarbu

Moduliai yra organizacinė kiekvienos NestJS programos griaučiai — jie sugrupuoja susijusius kontrolerius ir tiekėjus į vieningus funkcijų vienetus ir apibrėžia priklausomybės injekavimo ribas.

Supratimas keturių savybių (`controllers`, `providers`, `imports`, `exports`) ir ypač **importavimo/eksportavimo mechanizmo** tiekėjams dalintis tarp modulių yra esmingas: tai yra tai, kaip NestJS pasiekia modulinę, laisvai susietą architektūrą, kur kiekviena funkcija yra savarankiška ir priklausomybės yra aiškios.

Pagrindu pagrįsta modulio struktūra (vienas modulis vienai sričiai) yra standartinis būdas organizuoti Nest programas, siekiant mastelability ir išlaikymo.

Moduliai, kartu su kontroleriais ir tiekėjais, sudaro NestJS pagrindinę architektūrą, todėl jie yra pagrindinės žinios — įvaldyti, kaip struktūruoti programą į modulius ir sujungti tiekėjus tarp jų per importavimą/eksportavimą, yra būtina bet kuriai netryvialiai NestJS programai sukurti ir tai yra dažnas painiojimo šaltinis, kurį verta gerai suprasti iš pradžių.