Cad iad na modúil i NestJS?

Question

Accepted Answer

Is é **modúil** ná rang a bhfuil an deaitheoir `@Module()` air atá **grúpaí a dhéanamh de chomhpháirteanna gaolmhara** — rialaitheorí, soláthraithe/seirbhísí — i bhfad comhcheangailte. Is é an bealach a dhéanann NestJS d'fheidhmchlár a eagrú ina ngnéithe ná modúil, agus tá `AppModule` fréamhaigh ann ar a laghad i ngach aip Nest.

## Modúil a shainiú

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

## Na ceithre airí príomhúla

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

Cruthaíonn modúil **raon DI**: tá soláthraitheoir ar fáil laistigh dá mhodúil, agus do mhodúil eile ar bhealach amháin má tá sé **onnmhairithe** (agus an modúil eile á **iompórtáil**) air.

## An modúil fréamhaigh

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

Tá `AppModule` fréamhaigh ann i ngach feidhmchlár a iompórtaíonn na modúil gné, agus é ag iomasamhlú an fheidhmchláir ar fad.

## Eagraitheacht bunaithe ar ghné

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

Is é an ghnáth-nós **modúil amháin in aghaidh gné/fearann** (úsáideoirí, fíordheimhniú, táirgí), ag coimeád cód gaolmhar le chéile agus ag déanamh a raibh ag brath ar a bheith soiléir.

## Soláthraithe a roinnt trasna modúl

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

Chun soláthraitheoir a úsáid ó mhodúil eile, caithfidh an modúil soláthraithe a **onnmhairiú** air agus caithfidh an modúil tomhaltach an modúil soláthraithe a **iompórtáil** — ag déanamh go raibh ag brath ar a bheith soiléir.

## Cad a thabhachtaíonn sé

Is iad modúil an dromchla eagrúcháin de gach feidhmchlár NestJS — déanann siad rialaitheorí agus soláthraithe gaolmhara a ghrúpáil i bhfad gné chomhcheangailte agus sainíonn siad na teorainneacha ionchuir-eisceachta.

Bheith ar thuiscint an ceithre airí (`controllers`, `providers`, `imports`, `exports`) agus go háirithe an **taidhchiallóireachta iompórtáil/onnmhairithe** chun soláthraithe a roinnt trasna modúl ríthábhachtach: is é an bealach a bhaint amach ag NestJS ailtireacht modúlach, lagdhiangachtach áit a bhfuil gach gné féin-fhéadraithe agus a raibh ag brath ar a bheith soiléir.

Is é an struchtúr modúil bunaithe ar ghnéithe (modúil amháin in aghaidh fearainn) an bealach caighdeánach chun aipeanna Nest a eagrú le haghaidh inscoilteachta agus inchothromála.

Cruthaíonn modúil, in éineacht le rialaitheorí agus soláthraithe, ailtireacht bhunúsach NestJS, ina ndéanann siad eolas bunúsach – is gá a thuiscint conas feidhmchlár a chur i struchtúr i modúil agus soláthraithe a dhraein idir iad trí iompórtálacha/onnmhairithe chun aon fheidhmchlár neamh-bhréagtha NestJS a thógáil agus is poncanna bréis mearbhaill é atá tuigbheartúil go maith go luath.