Modules ni nini katika NestJS?

Question

Accepted Answer

**Module** ni class iliyopambwa kwa `@Module()` ambayo **huweka pamoja vipengele vinavyohusiana** — controllers, providers/services — katika kitengo kimoja chenye mshikamano. Modules ndiyo jinsi NestJS inavyopanga programu kuwa features, na kila programu ya Nest ina angalau root `AppModule`.

## Kufafanua module

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

## Sifa nne muhimu

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

Modules huunda **DI scope**: provider hupatikana ndani ya module yake, na kwa modules nyingine pale tu inapokuwa **imeexportiwa** (na module nyingine **iki-import** hiyo).

## Root module

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

Kila programu ina root `AppModule` ambayo huimport feature modules, ikikusanya programu nzima.

## Upangaji kwa misingi ya feature

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

Kaida ni **module moja kwa kila feature/domain** (users, auth, products), ikiweka code inayohusiana pamoja na dependencies zikiwa wazi.

## Kushirikisha providers kati ya modules

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

Ili kutumia provider kutoka module nyingine, module inayotoa lazima i-**export** hiyo na module inayotumia lazima i-**import** module inayotoa — jambo linalofanya dependencies kuwa wazi.

## Kwa nini ni muhimu

Modules ni uti wa mgongo wa upangaji wa kila programu ya NestJS — huweka pamoja controllers na providers zinazohusiana katika vitengo vya feature vyenye mshikamano na hufafanua mipaka ya dependency injection.

Kuelewa sifa nne (`controllers`, `providers`, `imports`, `exports`) na hasa **utaratibu wa import/export** wa kushirikisha providers kati ya modules ni muhimu: ndiyo jinsi NestJS inavyofanikisha usanifu wa kimodyuli, usiounganishwa kwa nguvu (loosely-coupled) ambapo kila feature inajitegemea na dependencies ziko wazi.

Muundo wa module unaotegemea feature (module moja kwa kila domain) ndiyo njia ya kawaida ya kupanga programu za Nest kwa ajili ya uwezo wa kukua na udumishaji.

Modules, pamoja na controllers na providers, huunda usanifu wa msingi wa NestJS, jambo linalozifanya kuwa maarifa ya msingi — kuumudu jinsi ya kupanga programu kuwa modules na kuunganisha providers kati yao kupitia imports/exports ni lazima kwa kujenga programu yoyote ya NestJS isiyo ya kawaida, na ni eneo linalochanganya mara nyingi linalostahili kueleweka vizuri mapema.