Cilat janë modulet në NestJS?

Question

Accepted Answer

Një **modul** është një klasë e dekoruar me `@Module()` që **grupon komponentë të ndërlidhura** — kontrollerë, furnizues/shërbime — në një njësi koherente. Modulet janë si NestJS organizon një aplikacion në veçori, dhe çdo aplikacion Nest ka të paktën një `AppModule` rrënjor.

## Përcaktimi i një moduli

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

## Katër vetitë kyçe

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

Modulet formojnë një **DI scope**: një furnizues është i disponueshëm brenda modulit të tij, dhe në module të tjera vetëm nëse është **eksportuar** (dhe moduli tjetër **e importon**).

## Moduli rrënjor

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

Çdo aplikacion ka një `AppModule` rrënjor që importon modulet e veçorive, duke përbërë aplikacionin e tërë.

## Organizimi i bazuar në veçori

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

Konvencioni është **një modul për çdo veçori/fushë** (përdorues, autentifikim, produkte), duke mbajtur kodin e ndërlidhur bashkë dhe varësitë eksplicite.

## Ndarje e furnizuesve përmes moduleve

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

Për të përdorur një furnizues nga një modul tjetër, moduli furnizues duhet ta **eksportojë** atë dhe moduli konsumator duhet ta **importojë** modulin furnizues — duke e bërë varësinë eksplicite.

## Pse ka rëndësi

Modulet janë kurora e organizimit të secilit aplikacion NestJS — ata grupojnë kontrollerë dhe furnizues të ndërlidhur në njësi veçoresh koherente dhe përcaktojnë kufijtë e dependency-injection.

Përvijimi i katër vetive (`controllers`, `providers`, `imports`, `exports`) dhe veçanërisht mekanizmi i **importimit/eksportimit** për ndarjen e furnizuesve përmes moduleve është thelbësor: kështu NestJS arrin arkitekturën modular dhe lirshëm të çiftuar ku çdo veçori është e pavarur dhe varësitë janë eksplicite.

Struktura e modulit të bazuar në veçori (një modul për çdo fushë) është mënyra standarde për të organizuar aplikacionet Nest për skalabilitet dhe mirëmbajtje.

Modulet, bashkë me kontrollerët dhe furnizuesit, formojnë arkitekturën bazë të NestJS, duke i bërë ato njohuri themelore — zotërimi i mënyrës se si të strukturoni një aplikacion në module dhe si të lidhni furnizuesit ndërmjet tyre përmes importimeve/eksportimeve është i nevojshëm për ndërtimin e ndonjë aplikacioni NestJS jo-trivial dhe është një pikë shpesh konfuzioni që vlen të kuptohet mirë në fillim.