Injetar um serviço de um módulo Nest.js diferente envolve algumas etapas para garantir a injeção de dependência adequada e a organização do módulo. Usando dois módulos de amostra, aprenda como funciona o processo de exportação e importação de serviços.
últimas postagens
Gerando um projeto Nest.js
Para gerar um projeto Nest.js, você precisa ter a CLI instalada em seu dispositivo. Caso contrário, execute este comando para instalá-lo:
npm install -g @nestjs/cli
Com a CLI Nest.js instalada, execute este comando para gerar um novo projeto Nest.js:
nest new <project-name>
Você pode substituir “
A estrutura atual do seu projeto deve ser semelhante à imagem abaixo:
Para praticar a injeção de um serviço de um módulo em um módulo diferente, você gerará dois módulos, módulo-a e módulo-b. Você também gerará seus arquivos de serviço e controlador correspondentes.
Execute este comando para gerar o módulo-a:
nest generate module module-a
E execute o comando equivalente para o módulo-b:
nest generate module module-b
Em seguida, execute este comando para gerar os arquivos de serviço e controlador para o módulo-a:
nest generate service module-a && nest generate controller module-a
E execute o comando equivalente para o módulo-b:
nest generate service module-b && nest generate controller module-b
O diretório do seu projeto atual deve ficar assim, com os diretórios src/module-a e src/module-b:
Exportando um serviço do módulo A
Para exportar o serviço module-a do módulo module-a, você deve listá-lo como uma exportação no arquivo do módulo module-a (module-a.module.ts). Por padrão, a CLI Nest.js não fornece uma matriz de exportações no decorador @Module, portanto, o arquivo do módulo gerado terá a seguinte aparência:
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 tornar o serviço-a (module-a.service.ts) acessível aos módulos que importam o módulo-a, crie uma matriz de exportações no decorador @Module e adicione ModuleAService a ele.
Igual a:
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 {}
Em seguida, para fins de teste, adicione uma função simples ao arquivo de serviço do módulo (module-a.service.ts):
import { Injectable } from '@nestjs/common';@Injectable()
export class ModuleAService {
getHello(): string {
return 'Hello from Module A!';
}
}
Esta função retorna uma string de amostra. Para confirmar que você pode importar este serviço corretamente, você chamará essa função do módulo-b após injetar o serviço-a.
Importando um serviço para o módulo B
Para importar um módulo para outro, você deve listá-lo como uma importação no array imports do módulo receptor. Nesse caso, você deve adicionar module-a ao array imports do decorador @Module do module-b.
Como antes, a CLI Nest.js não gera automaticamente uma matriz de importações, portanto, você deve adicioná-la manualmente.
Primeiro, importe o módulo pai (module-a.module.ts) para o módulo receptor (module-b.module.ts), crie o array imports e adicione ModuleAModule ao array:
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 {}
Em seguida, abra seu arquivo module-b.service.ts e importe o decorador Inject e ModuleAServerice de @nests/common e ../module-a/module-a.service, respectivamente:
import { Injectable, Inject } from '@nestjs/common';
import { ModuleAService } from '../module-a/module-a.service';
O decorador Inject marca seu parâmetro como alvo para injeção de dependência.
A seguir, em sua classe ModuleBService, adicione o bloco de código abaixo:
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;
O bloco de código acima dá ao seu ModuleBService acesso aos métodos disponíveis no seu ModuleAService.
Você pode testar o serviço chamando o método getHello do ModuleAService.
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 seguir, abra seu arquivo module-b.controller.ts e substitua o código gerado pelo bloco de código abaixo:
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();
}
}
O bloco de código acima configura um manipulador de rota GET para a função getHello.
Por fim, faça uma solicitação GET com curl para localhost:3000/module-b/hello. O comando deve imprimir “Olá do Módulo A!” para o seu console.
Você injetou com sucesso um serviço em outro módulo. Isso pode ser útil quando você cria APIs com Nest.js que possuem vários módulos que precisam chamar os métodos uns dos outros.
Benefícios da injeção entre módulos
Embora chamar diretamente um serviço de outro módulo possa parecer mais simples no início, isso pode levar a um sistema mais complexo, menos sustentável e menos escalável no longo prazo.
No entanto, a injeção entre módulos promove a modularidade e a reutilização do código, facilitando sua manutenção. Além disso, centraliza dependências, melhora a testabilidade e oferece suporte a uma arquitetura escalonável e desacoplada.