Cosa sono i moduli in NestJS?

Question

Accepted Answer

Un **modulo** è una classe decorata con `@Module()` che **raggruppa componenti correlati** — controller, provider/servizi — in un'unità coesa. I moduli sono il modo in cui NestJS organizza un'applicazione in feature, e ogni app Nest ha almeno un `AppModule` radice.

## Definire un modulo

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

## Le quattro proprietà chiave

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

I moduli formano un **scope DI**: un provider è disponibile all'interno del suo modulo, e agli altri moduli solo se **esportato** (e l'altro modulo lo **importa**).

## Il modulo radice

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

Ogni app ha un `AppModule` radice che importa i moduli feature, componendo l'intera applicazione.

## Organizzazione basata su 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)
```

La convenzione è **un modulo per feature/dominio** (utenti, autenticazione, prodotti), mantenendo il codice correlato insieme e le dipendenze esplicite.

## Condividere provider tra 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 {}
```

Per usare un provider da un altro modulo, il modulo che lo fornisce deve **esportarlo** e il modulo che lo consuma deve **importare** il modulo che lo fornisce — rendendo le dipendenze esplicite.

## Perché è importante

I moduli sono la spina dorsale organizzativa di ogni applicazione NestJS — raggruppano controller e provider correlati in unità feature coese e definiscono i confini dell'iniezione delle dipendenze.

Comprendere le quattro proprietà (`controllers`, `providers`, `imports`, `exports`) e in particolare il meccanismo **import/export** per condividere provider tra moduli è essenziale: è il modo in cui NestJS realizza un'architettura modulare e debolmente accoppiata dove ogni feature è autocontenuta e le dipendenze sono esplicite.

La struttura modulare basata su feature (un modulo per dominio) è il modo standard per organizzare le app Nest per scalabilità e manutenibilità.

I moduli, insieme a controller e provider, formano l'architettura core di NestJS, rendendoli una conoscenza fondamentale — padroneggiare come strutturare un'app in moduli e collegare provider tra loro tramite import/export è necessario per costruire qualsiasi applicazione NestJS non banale ed è un punto di confusione frequente che vale la pena di capire bene all'inizio.