Nest
Tutorial Nest: Crear y utilizar módulos
Nest módulos: creación y uso. Aprende a crear y usar módulos en Nest con ejemplos prácticos y detallados.
Aprende Nest GRATIS y certifícateUna 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.
Ejercicios de esta lección Crear y utilizar módulos
Evalúa tus conocimientos de esta lección Crear y utilizar módulos con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.
Métodos GET en controladores
Método find en un servicio con repositorio
Desarrollo e inyección de servicios
Creación de entidades y tablas
Método DELETE en un controlador
Filtrados en consultas de repositorios
Método GET en un controlador
Estrategia de autenticación JwtStrategy
CRUD con repositorios
Método delete en un servicio con repositorio
API REST CRUD de entidad Restaurante con TypeORM
Creación de una entidad TypeORM
Crear y utilizar módulos
Métodos PUT en controladores
Iniciar sesión método de login
Configuración de TypeORM con MySQL
Gestión de errores en controladores
Decoradores en entidades
Instalación NestJS
Recibir y servir imágenes
Estrategia de autenticación JWT
Método PUT en un controlador
Comandos NestJS CLI
Método POST en un controlador
Login y registro
API REST CRUD de entidades Product y Manufacturer
Método save en un servicio con repositorio
Registro de usuarios
Métodos POST en controladores
Todas las lecciones de Nest
Accede a todas las lecciones de Nest y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.
Instalación Nestjs
Introducción Y Entorno
Comandos Nestjs Cli
Introducción Y Entorno
Métodos Get En Controladores
Controladores
Métodos Post En Controladores
Controladores
Métodos Put En Controladores
Controladores
Métodos Delete En Controladores
Controladores
Gestión De Errores En Controladores
Controladores
Recibir Y Servir Imágenes
Controladores
Desarrollo E Inyección De Servicios
Servicios E Inyección De Dependencias
Crear Y Utilizar Módulos
Módulos
Configuración De Typeorm Con Mysql
Typeorm
Creación De Entidades Y Tablas
Typeorm
Decoradores En Entidades
Typeorm
Crud Con Repositorios
Typeorm
Filtrados En Consultas De Repositorios
Typeorm
Registro De Usuarios
Autenticación
Iniciar Sesión Método De Login
Autenticación
Estrategia De Autenticación Jwtstrategy
Autenticación
Login Y Registro
Autenticación
Estrategia De Autenticación Jwt
Autenticación
Certificados de superación de Nest
Supera todos los ejercicios de programación del curso de Nest y obtén certificados de superación para mejorar tu currículum y tu empleabilidad.
En esta lección
Objetivos de aprendizaje de esta lección
- Comprender la estructura modular en NestJS.
- Aprender a importar y exportar módulos.
- Conocer las características de los módulos.
- Comprender la relación entre módulos.