Creación y Gestión de Módulos en NestJS: Dependencias y Comunicación entre Módulos

Los módulos son el bloque de construcción central de NestJS, y nos ayudan a organizar el código y gestionar las dependencias. Este artículo explica cómo crear y gestionar módulos en NestJS, explorando las dependencias y la comunicación entre módulos, y proporciona ejemplos de código que muestran la organización y gestión de dependencias en proyectos complejos.

Creación y Organización de Módulos

Creación de Módulos

En NestJS, los módulos se definen mediante el decorador @Module(). El siguiente ejemplo muestra cómo crear un sencillo UsersModule:

1
import { Module } from "@nestjs/common";
2
import { UsersService } from "./users.service";
3
import { UsersController } from "./users.controller";
4

5
@Module({
6
  providers: [UsersService],
7
  controllers: [UsersController],
8
})
9
export class UsersModule {}

Organización de Módulos

Un típico proyecto NestJS puede contener múltiples módulos, cada uno responsable de diferentes funcionalidades. Por ejemplo, puedes tener un AuthModule para la autenticación, un ProductsModule para la gestión de productos, etc.

1
import { Module } from "@nestjs/common";
2
import { UsersModule } from "./users/users.module";
3
import { AuthModule } from "./auth/auth.module";
4
import { ProductsModule } from "./products/products.module";
5

6
@Module({
7
  imports: [UsersModule, AuthModule, ProductsModule],
8
})
9
export class AppModule {}

Dependencias entre Módulos

Exportación e Importación de Módulos

Los módulos pueden exportar los servicios que proporcionan mediante la propiedad exports, permitiendo que otros módulos los importen y utilicen. El siguiente ejemplo muestra cómo exportar UsersService e importar UsersModule en AuthModule:

1
import { Module } from "@nestjs/common";
2
import { UsersService } from "./users.service";
3
import { UsersController } from "./users.controller";
4

5
@Module({
6
  providers: [UsersService],
7
  controllers: [UsersController],
8
  exports: [UsersService], // Exportar UsersService
9
})
10
export class UsersModule {}
11

12
// auth/auth.module.ts
13
import { Module } from "@nestjs/common";
14
import { AuthService } from "./auth.service";
15
import { UsersModule } from "../users/users.module";
16

17
@Module({
18
  imports: [UsersModule], // Importar UsersModule
19
  providers: [AuthService],
20
})
21
export class AuthModule {}

Comunicación entre Módulos

La comunicación entre módulos generalmente se realiza a través de servicios. Por ejemplo, AuthService puede llamar a UsersService para validar usuarios:

1
import { Injectable } from "@nestjs/common";
2
import { UsersService } from "../users/users.service";
3

4
@Injectable()
5
export class AuthService {
6
  constructor(private readonly usersService: UsersService) {}
7

8
  async validateUser(username: string, pass: string): Promise<any> {
9
    const user = await this.usersService.findOne(username);
10
    if (user && user.password === pass) {
11
      return user;
12
    }
13
    return null;
14
  }
15
}

Organización y Gestión de Dependencias en Proyectos Complejos

En proyectos complejos, la organización y gestión de dependencias de los módulos se vuelve crucial. A continuación, se presentan algunas mejores prácticas:

Uso de Módulos de Características

Organiza el código relacionado con funcionalidades en módulos de características. Por ejemplo, coloca todo el código relacionado con usuarios en UsersModule y todo el código relacionado con productos en ProductsModule.

Uso de Módulos Compartidos

Coloca servicios, canalizaciones, guardianes, etc. que se usan con frecuencia en un módulo compartido y expórtalos según sea necesario. Por ejemplo, puedes crear un SharedModule que proporcione conexión a la base de datos, servicios de registro, etc.

1
import { Module } from "@nestjs/common";
2
import { DatabaseService } from "./database.service";
3
import { LoggerService } from "./logger.service";
4

5
@Module({
6
  providers: [DatabaseService, LoggerService],
7
  exports: [DatabaseService, LoggerService],
8
})
9
export class SharedModule {}
10

11
// app.module.ts
12
import { Module } from "@nestjs/common";
13
import { SharedModule } from "./shared/shared.module";
14
import { UsersModule } from "./users/users.module";
15
import { AuthModule } from "./auth/auth.module";
16

17
@Module({
18
  imports: [SharedModule, UsersModule, AuthModule],
19
})
20
export class AppModule {}

Uso de Inyección de Dependencias entre Módulos

Utiliza el mecanismo de inyección de dependencias para asegurar un acoplamiento suelto entre módulos. Por ejemplo, inyecta servicios a través del constructor en lugar de instanciarlos directamente dentro del módulo.

1
import { Injectable } from "@nestjs/common";
2
import { DatabaseService } from "../shared/database.service";
3

4
@Injectable()
5
export class ProductsService {
6
  constructor(private readonly databaseService: DatabaseService) {}
7

8
  async findAll(): Promise<any[]> {
9
    return this.databaseService.query("SELECT * FROM products");
10
  }
11
}

Conclusión

En este artículo, hemos aprendido cómo crear y gestionar módulos en NestJS, explorado las dependencias y la comunicación entre módulos, y proporcionado ejemplos de código que muestran la organización y gestión de dependencias en proyectos complejos.