Inyectar un servicio Nest.js desde un módulo diferente

Inyectar un servicio desde un módulo Nest.js diferente implica algunos pasos para garantizar la inyección de dependencias y la organización del módulo adecuadas. Usando dos módulos de muestra, aprenda cómo funciona el proceso de exportación e importación de servicios.

Generando un proyecto Nest.js

Para generar un proyecto Nest.js, debe tener la CLI instalada en su dispositivo. Si no lo hace, ejecute este comando para instalarlo:

npm install -g @nestjs/cli

Con la CLI de Nest.js instalada, ejecute este comando para generar un nuevo proyecto de Nest.js:

nest new

Puedes reemplazar "”con el nombre que elijas. Al ejecutar el comando anterior se generará un nuevo proyecto Nest.js con el nombre especificado.

La estructura de su proyecto actual debería verse como la imagen a continuación:

Para practicar la inyección de un servicio de un módulo a otro módulo diferente, generará dos módulos, módulo-a y módulo-b. También generará sus correspondientes archivos de servicio y controlador.

Ejecute este comando para generar el módulo-a:

nest generate modulemodule-a

Y ejecute el comando equivalente para el módulo-b:

nest generate modulemodule-b

Luego ejecute este comando para generar los archivos de servicio y controlador para el módulo-a:

nest generate service module-a && nest generate controller module-a

Y ejecute el comando equivalente para el módulo-b:

nest generate service module-b && nest generate controller module-b

El directorio de su proyecto actual debería verse así, con src/módulo-a y src/módulo-b directorios:

Exportar un servicio desde el módulo A

Para exportar el servicio módulo-a desde el módulo módulo-a, debe incluirlo como una exportación en el archivo del módulo del módulo-a (módulo-a.module.ts). De forma predeterminada, la CLI de Nest.js no proporciona una exportaciones matriz en el @Módulo decorador, por lo que el archivo del módulo generado se verá así:

// module-a.module.ts
import { Module } from'@nestjs/common';
import { ModuleAService } from'./module-a.service';
import { ModuleAController } from'./module-a.controller';
@Module({
providers: [ModuleAService],
controllers: [ModuleAController],
})
exportclassModuleAModule{}

Para realizar el servicio-a (módulo-a.servicio.ts) accesible para módulos que importan módulo-a, crean un exportaciones matriz en el @Módulo decorador y agregar MóduloAServicio lo.

Al igual que:

import { Module } from'@nestjs/common';
import { ModuleAService } from'./module-a.service';
import { ModuleAController } from'./module-a.controller';
@Module({
providers: [ModuleAService],
controllers: [ModuleAController],
exports: [ModuleAService],
})
exportclassModuleAModule{}

A continuación, para fines de prueba, agregue una función simple a su módulo: un archivo de servicio (módulo-a.servicio.ts):

import { Injectable } from'@nestjs/common';
@Injectable()
exportclassModuleAService{
 getHello(): string {
return'Hello from Module A!';
 }
}

Esta función devuelve una cadena de muestra. Para confirmar que puede importar este servicio correctamente, llamará a esa función desde el módulo b después de inyectar el servicio a.

Importar un servicio al módulo B

Para importar un módulo a otro, debe incluirlo como una importación en el importaciones matriz del módulo receptor. En este caso, debe agregar el módulo-a al importaciones conjunto de módulos-b @Módulo decorador.

Como antes, la CLI de Nest.js no genera automáticamente un importaciones matriz, por lo que debes agregarla manualmente.

Primero, importe el módulo principal (módulo-a.module.ts) en el módulo receptor (módulo-b.módulo.ts), crear el importaciones matriz y agregar MóduloAMódulo a la matriz:

// module-b.module.ts
import { Module } from'@nestjs/common';
import { ModuleBController } from'./module-b.controller';
import { ModuleBService } from'./module-b.service';
import { ModuleAModule } from'../module-a/module-a.module';
@Module({
imports: [ModuleAModule],
controllers: [ModuleBController],
providers: [ModuleBService],
})
exportclassModuleBModule{}

A continuación, abre tu módulo-b.service.ts archivar e importar el Inyectar decorador y MóduloAServicio de @nidos/común y ../módulo-a/módulo-a.servicio, respectivamente:

import { Injectable, Inject } from'@nestjs/common';
import { ModuleAService } from'../module-a/module-a.service';

El Inyectar El decorador marca su parámetro como objetivo para la inyección de dependencia.

A continuación, en tu MóduloBServicio clase, agregue el bloque de código a continuación:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

El bloque de código anterior le da a su ModuleBService acceso a los métodos disponibles en su ModuleAService.

Puede probar el servicio llamando al servicio ModuleAService obtenerHola método.

// module-b.service.ts
import { Injectable, Inject } from'@nestjs/common';
import { ModuleAService } from'src/module-a/module-a.service';
@Injectable()
exportclassModuleBService{
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;
 getHello(): string {
returnthis.moduleAService.getHello();
 }
}

A continuación, abre tu módulo-b.controller.ts archivo y reemplace el código generado con el siguiente bloque de código:

// module-b.controller.ts
import { Controller, Get } from'@nestjs/common';
import { ModuleBService } from'./module-b.service';
@Controller('module-b')
exportclassModuleBController{
constructor(private readonly moduleBService: ModuleBService) {}
@Get('/hello')
 getHello(): string {
returnthis.moduleBService.getHello();
 }
}

El bloque de código anterior configura un CONSEGUIR controlador de ruta para el obtenerHola función.

Finalmente, hacer una solicitud GET con curl al host local: 3000/módulo-b/hola. El comando debería imprimir “¡Hola desde el Módulo A!” a tu consola.

Ha inyectado con éxito un servicio en otro módulo. Esto puede resultar útil cuando estás crear API con Nest.js que tienen múltiples módulos que necesitan llamar a los métodos de cada uno.

Beneficios de la inyección de módulos cruzados

Si bien llamar directamente a un servicio desde otro módulo puede parecer más simple al principio, a largo plazo puede generar un sistema más complejo, menos mantenible y menos escalable.

Sin embargo, la inyección entre módulos promueve la modularidad y la reutilización del código, lo que facilita su mantenimiento. Además, centraliza las dependencias, mejora la capacidad de prueba y admite una arquitectura escalable y desacoplada.