Injectando um serviço Nest.js a partir de um módulo diferente

A injeção de um serviço de um módulo Nest.js diferente envolve algumas etapas para garantir a injeção de dependência e a organização do módulo adequadas. Usando dois módulos de amostra, saiba como funciona o processo de exportação e importação de serviços.

Gerando um projeto Nest.js

Para criar um aplicativo Nest.js, verifique se a interface de linha de comando (CLI) está instalada no sistema. Caso não esteja, execute o seguinte comando para configurar a CLI:

 npm install -g @nestjs/cli

Para criar um novo projeto Nest.js usando a interface de linha de comando (CLI) do Nest.js, execute as seguintes etapas:1. Instale a CLI do Nest.js executando o comando “npm install -g @nestjs/cli” ou “@yarn global add nestjs-cli”. Isso permitirá que você gerencie e interaja com seus projetos Nest.js a partir da linha de comando.2. Execute o comando “nest new " para gerar um novo projeto Nest.js no diretório especificado. A configuração padrão para o projeto recém-criado já está definida e pronta para o desenvolvimento.

 nest new <project-name>

Após a execução do comando fornecido, pode-se substituir ’ ’ por uma denominação de sua própria escolha para estabelecer um novo ambiente de desenvolvimento Nest.js com o título designado.

A configuração atual do seu projeto deve estar em conformidade com a representação ilustrada na representação gráfica fornecida abaixo:

Para aperfeiçoar as suas capacidades de integração de serviços em módulos distintos, é necessário criar dois módulos separados, nomeadamente o módulo-a e o módulo-b, juntamente com os respectivos ficheiros de serviço e controlador para cada um.

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

Para criar os arquivos necessários para o módulo-a, execute o seguinte comando:

 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

A estrutura do seu atual diretório de projeto deve assemelhar-se a um arranjo hierárquico, compreendendo dois subdirectórios primários - nomeadamente “src/module-a” e “src/module-b”.

Exportando um Serviço do Módulo A

Para extrair o componente Service-A do Módulo-A e torná-lo acessível para uso em outro lugar dentro da aplicação, é preciso incluí-lo entre os itens listados em “exports” no arquivo de módulo do Módulo-A (ou seja, Module-A.module.ts).Normalmente, ao utilizar a interface de linha de comando (CLI) do Nest.js, não há uma matriz “exports” predefinida fornecida com o decorador “@Module”; portanto, o arquivo de módulo resultante exibiria uma estrutura semelhante à seguinte:

 // 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 permitir a acessibilidade de module-a.service.ts por outros módulos que importam module-a , uma matrizexports deve ser criada dentro do decorador @Module e ModuleAService deve ser adicionada a ela.

Assim:

 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 {}

Para realizar testes no serviço module-a , você pode criar um novo arquivo chamado module-a.service.ts no mesmo diretório que os outros arquivos deste projeto. Esse arquivo conterá uma função simples que utiliza a classe ModuleAService e demonstra sua funcionalidade.

 import { Injectable } from '@nestjs/common';

@Injectable()
export class ModuleAService {
  getHello(): string {
    return 'Hello from Module A!';
  }
}

O texto apresentado parece ter sido escrito numa linguagem coloquial e carece de refinamento. Eis uma tentativa de o reformular com mais elegância: Para garantir a funcionalidade correcta deste serviço, recomendamos que se chame a função acima referida no módulo especificado (módulo-b) após a injeção do serviço-a. Ao fazê-lo, é possível verificar a integração bem sucedida do referido serviço.

Importando um serviço para o módulo B

Para que um módulo seja importado para outro, ele deve estar listado entre as importações do decorador @Module do módulo recetor. Assim, no caso em que o módulo-a está a ser importado pelo módulo-b, tem de ser adicionado à matriz imports dentro do decorador @Module do módulo-b.

Para utilizar os módulos importados em um projeto Nest.js, é preciso criar manualmente uma matriz imports dentro do arquivo de módulo do aplicativo. A interface de linha de comando (CLI) do Nest.js não fornece essa funcionalidade por padrão, necessitando de intervenção manual para sua inclusão.

De facto, o processo envolve a importação do módulo principal do ficheiro “module-a.module.ts” para o módulo recetor localizado em “module-b.module.ts”. Depois disso, é criada uma instrução de importação no código do módulo recetor e adicionada a uma matriz específica, após o que o módulo pretendido, nomeadamente “ModuleAModule”, é anexado a essa mesma 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 {}

De facto, passemos ao passo seguinte, abrindo o ficheiro module-b.service.ts no nosso projeto.Precisaremos importar tanto o decorador @Inject quanto a classe ModuleAService de duas fontes diferentes dentro da base de código do nosso aplicativo. Especificamente, devemos obter esses itens do pacote @nestjs/common para o primeiro e de um local separado em outra parte da estrutura do nosso projeto para o segundo.

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

O decorador Inject designa seu parâmetro como um destinatário pretendido da injeção de dependência, significando que ele é um componente crucial na funcionalidade do sistema e deve ser fornecido com os recursos ou serviços necessários para funcionar de forma eficaz.

De facto, no contexto da classe ModuleBService , é necessário incorporar o excerto de código supramencionado num momento apropriado.

 @Inject(ModuleAService)
  private readonly moduleAService: ModuleAService;

A concessão de acesso aos métodos do ModuleAService é facilitada pelo bloco de código fornecido, permitindo assim a utilização no ModuleBService.

É possível validar a funcionalidade do serviço, o método “getHello” do ModuleAService, através de testes.

 // 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();
  }
}

De facto, vamos agora modificar o conteúdo do ficheiro module-b.controller.ts, substituindo o código existente pelo excerto de código fornecido.

 // 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();
  }
}

O trecho de código fornecido estabelece um mecanismo de tratamento de pedidos HTTP GET para a função “getHello”, que é responsável por recuperar e processar dados relacionados com pedidos ou entradas específicas do utilizador.

Por fim, execute um pedido GET utilizando cURL para http://localhost:3000/module-b/hello . O comando apresentará “Hello from Module A!” na consola.

A injeção bem sucedida de um serviço noutro módulo é particularmente benéfica quando se desenvolvem APIs no Nest.js, que envolvem frequentemente vários módulos interdependentes que requerem acesso às funcionalidades uns dos outros.

Benefícios da injeção entre módulos

A incorporação de um serviço por meio de invocação direta pode parecer uma opção conveniente inicialmente; no entanto, ela geralmente resulta em uma arquitetura mais complexa, difícil de manter e de escopo limitado ao longo do tempo.

De facto, a implementação da injeção de módulos cruzados promove um sistema mais coeso e adaptável, aumentando a modularidade e facilitando a reutilização de componentes. Além disso, esta abordagem consolida as dependências, aumenta a viabilidade dos testes e permite um design arquitetonicamente sólido, com acoplamento flexível, capaz de acomodar o crescimento.