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

Asegúrese de que sus módulos estén bien organizados con inyección limpia y reutilizable.

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 <project-name>

Puede reemplazar “” con cualquier nombre que elija. 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 module module-a

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

nest generate module module-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 los directorios src/module-a y src/module-b:

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 módulo-a (módulo-a.module.ts). De forma predeterminada, la CLI de Nest.js no proporciona una matriz exports en el decorador @Module, por lo que el archivo del módulo generado tendrá este aspecto:

// 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],
})
export class ModuleAModule {}

Para hacer que service-a (module-a.service.ts) sea accesible para los módulos que importan module-a, cree una matriz exports en @Module. decorador y agréguele ModuleAService.

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],
})
export class ModuleAModule {}

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

import { Injectable } from '@nestjs/common';
@Injectable()
export class ModuleAService {
  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 la matriz imports del módulo receptor. En este caso, debe agregar el módulo-a a la matriz imports del decorador @Module del módulo-b.

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

Primero, importe el módulo principal (module-a.module.ts) al módulo receptor (module-b.module.ts), cree las importaciones< matriz y agregue ModuleAModule 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],
})
export class ModuleBModule {}

A continuación, abra su archivo module-b.service.ts e importe el decorador Inject y el ModuleAService desde @nests/common. y ../module-a/module-a.service, respectivamente:

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

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

A continuación, en su clase ModuleBService, agregue el siguiente bloque de código:

@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 método getHello de ModuleAService.

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

A continuación, abra su archivo module-b.controller.ts 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')
export class ModuleBController {
  constructor(private readonly moduleBService: ModuleBService) {}
  @Get('/hello')
  getHello(): string {
    return this.moduleBService.getHello();
  }
}

El bloque de código anterior configura un controlador de ruta GET para la función getHello.

Finalmente, realice una solicitud GET con curl a localhost:3000/module-b/hello. 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 crea API con Nest.js que tienen varios 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.