¿Qué son los módulos en NestJS?

Question

Accepted Answer

Un **módulo** es una clase decorada con `@Module()` que **agrupa componentes relacionados** — controladores, proveedores/servicios — en una unidad coherente. Los módulos son cómo NestJS organiza una aplicación en features, y toda app de Nest tiene al menos un `AppModule` raíz.

## Definir un módulo

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

## Las cuatro propiedades clave

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

Los módulos forman un **DI scope**: un proveedor está disponible dentro de su módulo y en otros módulos solo si se **exporta** (y el otro módulo lo **importa**).

## El módulo raíz

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

Cada app tiene un `AppModule` raíz que importa los módulos de features, componiendo la aplicación completa.

## Organización basada en features

```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 convención es **un módulo por feature/dominio** (usuarios, autenticación, productos), manteniendo el código relacionado junto y las dependencias explícitas.

## Compartir proveedores entre módulos

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

Para usar un proveedor de otro módulo, el módulo que lo provee debe **exportarlo** y el módulo que lo consume debe **importar** el módulo que lo provee — haciendo las dependencias explícitas.

## Por qué es importante

Los módulos son la columna vertebral organizativa de toda aplicación de NestJS — agrupan controladores y proveedores relacionados en unidades de features coherentes y definen los límites de inyección de dependencias.

Entender las cuatro propiedades (`controllers`, `providers`, `imports`, `exports`) y especialmente el **mecanismo de import/export** para compartir proveedores entre módulos es esencial: es cómo NestJS logra una arquitectura modular y débilmente acoplada donde cada feature es autónoma y las dependencias son explícitas.

La estructura de módulos basada en features (un módulo por dominio) es la forma estándar de organizar aplicaciones de Nest para escalabilidad y mantenibilidad.

Los módulos, junto con controladores y proveedores, forman la arquitectura central de NestJS, haciéndolos un conocimiento fundamental — dominar cómo estructurar una aplicación en módulos y conectar proveedores entre ellos mediante imports/exports es necesario para construir cualquier aplicación de NestJS no trivial y es un punto frecuente de confusión que vale la pena entender bien desde el principio.