Tutorial Nest: Crear y utilizar módulos

Una de las principales características de NestJS es su estructura modular.

En NestJS, los módulos son un componente fundamental para organizar el código de manera efectiva y estructurada.

Módulos

Un módulo es una clase decorada con el decorador @Module(). Agrupa componentes relacionados, como proveedores, controladores, servicios, etc., permitiendo una mejor organización y separación de responsabilidades en la aplicación.

Los módulos también ayudan a promover el principio de responsabilidad única y facilitan la reutilización y el testing de los componentes.

Cada aplicación tiene al menos un módulo, el módulo raíz, pero por lo general hay múltiples módulos, especialmente en aplicaciones más grandes.

Estructura básica de un módulo

Aquí hay una estructura básica de cómo se ve un módulo en NestJS:

import { Module } from '@nestjs/common';
import { MiServicio } from './mi-servicio.service';
import { MiControlador } from './mi-controlador.controller';

@Module({
  imports: [],
  controllers: [MiControlador],
  providers: [MiServicio],
})
export class MiModulo {}

En este ejemplo:

• Se importa el decorador @Module desde '@nestjs/common'.
• Se definen controladores en el array controllers.
• Se definen proveedores (servicios) en el array providers.

Características de los módulos

Imports: Es un array que permite importar otros módulos. De esta manera, los proveedores de los módulos importados pueden ser utilizados en el módulo actual.

Controllers: Es un array que contiene los controladores a instanciar para el módulo. NestJS crea instancias de estos controladores y puede utilizar las rutas definidas en ellos.

Providers: Es un array de proveedores a instanciar para el módulo. Los proveedores pueden ser servicios, repositorios, etc.

Exports: Es un array de proveedores que deberían ser exportados y disponibles para otros módulos que importan este módulo.

Ejemplo de un módulo con imports y exports

import { Module } from '@nestjs/common';
import { OtroServicio } from './otro-servicio.service';
import { OtroModulo } from './otro-modulo.module';

@Module({
  imports: [OtroModulo],
  providers: [OtroServicio],
  exports: [OtroServicio],
})
export class MiModulo {}

En este ejemplo, MiModulo importa OtroModulo. Además, OtroServicio es tanto un proveedor como un servicio exportado, lo que significa que otros módulos que importen MiModulo tendrán acceso a OtroServicio.

Módulo raíz

En cada aplicación NestJS, el módulo raíz es responsable de organizar y coordinar todos los demás módulos en la aplicación.

Por defecto, este módulo se llama AppModule.

Cuando se crea una aplicación NestJS utilizando el CLI, un AppModule básico se genera automáticamente.

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
imports: [],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}
----

A medida que la aplicación crezca, se pueden importar y organizar diferentes módulos en el módulo raíz para mantener una estructura limpia y modular.

Beneficios de la modularidad

Desacoplamiento: La modularidad permite que los diferentes aspectos de una aplicación estén separados en módulos independientes. Esto significa que los cambios en un módulo tienen menos probabilidades de afectar a otros módulos, lo que facilita la mantenibilidad.

Reusabilidad: Los módulos pueden ser diseñados para ser reutilizados en diferentes partes de la aplicación o incluso en diferentes aplicaciones, promoviendo el principio DRY (Don't Repeat Yourself).

Testeabilidad: Dado que los módulos están desacoplados, se facilita la escritura de pruebas unitarias para cada módulo individualmente.

Organización: Los módulos ayudan a estructurar el código de la aplicación de manera lógica, lo que facilita la navegación y comprensión del código.

Relación entre módulos

Dentro de una aplicación NestJS, es común tener múltiples módulos que trabajan juntos para formar la funcionalidad completa de la aplicación.

Esta relación entre módulos puede ser visualizada como un gráfico, donde los nodos son módulos y las aristas representan las relaciones de dependencia entre ellos.

En otras palabras, cada módulo puede depender de uno o más módulos para acceder a sus recursos y funcionalidades.

Creación de módulos relacionados

Veamos un ejemplo práctico de cómo se relacionan los módulos en una aplicación.

Supongamos que se está creando una aplicación de gestión de tareas.

Podría haber un módulo para gestionar usuarios, otro para tareas y tal vez uno más para autenticación.

Módulo de usuarios

import { Module } from '@nestjs/common';
import { UsuariosController } from './usuarios.controller';
import { UsuariosService } from './usuarios.service';

@Module({
  controllers: [UsuariosController],
  providers: [UsuariosService],
  exports: [UsuariosService],
})
export class UsuariosModule {}

Módulo de tareas

Para gestionar las tareas, podría ser necesario interactuar con el módulo de usuarios. En este caso, el módulo de tareas podría importar el módulo de usuarios.

import { Module } from '@nestjs/common';
import { TareasController } from './tareas.controller';
import { TareasService } from './tareas.service';
import { UsuariosModule } from '../usuarios/usuarios.module';

@Module({
  imports: [UsuariosModule],
  controllers: [TareasController],
  providers: [TareasService],
})
export class TareasModule {}

Módulo de autenticación

Similarmente, el módulo de autenticación podría necesitar acceso al módulo de usuarios para verificar credenciales.

import { Module } from '@nestjs/common';
import { AuthService } from './auth.service';
import { UsuariosModule } from '../usuarios/usuarios.module';

@Module({
  imports: [UsuariosModule],
  providers: [AuthService],
})
export class AuthModule {}

Recomendaciones

Evitar dependencias circulares: Es importante garantizar que no haya dependencias circulares entre módulos, ya que esto puede causar problemas al iniciar la aplicación.

Minimizar las dependencias: Cuantas menos dependencias tenga un módulo, más fácil será reutilizarlo y testearlo. Se recomienda minimizar las relaciones entre módulos cuando sea posible.

Responsabilidad única: Cada módulo debe tener una responsabilidad única y claramente definida. Esto facilita la comprensión y mantenimiento del código.

Conclusión

Los módulos en NestJS proporcionan una forma de organizar y encapsular componentes relacionados en una aplicación. Ayudan a estructurar la aplicación en bloques lógicos y reutilizables, promoviendo buenas prácticas y facilitando la gestión y escalabilidad del código. Utilizar módulos adecuadamente en NestJS permite construir aplicaciones más limpias, más fáciles de mantener y de testear.