DEV Community: Luiz Pires

Inversão de Dependência com NestJS: Um Guia Detalhado

Luiz Pires — Sat, 06 Jul 2024 14:49:28 +0000

A inversão de dependência (Dependency Inversion Principle - DIP) é um dos cinco princípios SOLID, essenciais para a programação orientada a objetos. O DIP propõe que:

Módulos de alto nível não devem depender de módulos de baixo nível. Ambos devem depender de abstrações.
Abstrações não devem depender de detalhes. Detalhes devem depender de abstrações.
NestJS, um framework progressivo para Node.js, facilita a aplicação do DIP por meio de seu robusto sistema de injeção de dependência (Dependency Injection - DI). Vamos detalhar como implementar e aproveitar a inversão de dependência com NestJS.

Estrutura de um Projeto NestJS
Antes de entrarmos na inversão de dependência, é importante entender a estrutura básica de um projeto NestJS:

Módulos (Modules): Agrupam componentes relacionados, como controladores e serviços.
Controladores (Controllers): Gerenciam as rotas HTTP e são responsáveis por receber requisições e retornar respostas.
Serviços (Services): Contêm a lógica de negócio e são injetados nos controladores.
Passos para Implementar a Inversão de Dependência

1- Criação da Interface (Abstração)
Começamos criando uma interface que define os métodos que nosso serviço deve implementar. Isso assegura que nossas classes de implementação seguirão um contrato específico, promovendo o desacoplamento.

// src/cats/interfaces/cat-service.interface.ts
export interface CatService {
  findAll(): string[];
}

2- Implementação da Interface
Agora, implementamos a interface em uma classe concreta. Usamos o decorador @Injectable() para permitir que esta classe seja gerenciada pelo container de injeção de dependência do NestJS.

// src/cats/services/cat.service.ts
import { Injectable } from '@nestjs/common';
import { CatService } from '../interfaces/cat-service.interface';

@Injectable()
export class CatServiceImpl implements CatService {
  private readonly cats: string[] = ['Tom', 'Garfield'];

  findAll(): string[] {
    return this.cats;
  }
}

3- Registro do Serviço no Módulo
Registramos o serviço no módulo correspondente. Isso permite que o container de injeção de dependência saiba como resolver a dependência quando necessário.

// src/cats/cats.module.ts
import { Module } from '@nestjs/common';
import { CatServiceImpl } from './services/cat.service';

@Module({
  providers: [
    {
      provide: 'CatService',
      useClass: CatServiceImpl,
    },
  ],
  exports: ['CatService'],
})
export class CatsModule {}

4- Injeção da Dependência no Controlador
Injetamos o serviço no controlador, usando a interface como token de injeção. Isso permite que o controlador dependa da abstração em vez de uma implementação específica.

// src/cats/controllers/cat.controller.ts
import { Controller, Get, Inject } from '@nestjs/common';
import { CatService } from '../interfaces/cat-service.interface';

@Controller('cats')
export class CatController {
  constructor(@Inject('CatService') private readonly catService: CatService) {}

  @Get()
  findAll(): string[] {
    return this.catService.findAll();
  }
}

Exemplos Avançados de Inversão de Dependência
Utilizando Fábricas de Provedores

Às vezes, é necessário fornecer instâncias de serviços dinamicamente. Podemos usar fábricas de provedores (provider factories) para isso.

// src/cats/providers/cat-service.factory.ts
import { CatService } from '../interfaces/cat-service.interface';
import { CatServiceImpl } from '../services/cat.service';

export const catServiceFactory = {
  provide: 'CatService',
  useFactory: (): CatService => {
    return new CatServiceImpl();
  },
};

Serviços Assíncronos com Dependências Externas

Para serviços que dependem de recursos assíncronos (como conexões de banco de dados), podemos configurar provedores assíncronos.

// src/cats/providers/cat-service.async.ts
import { CatService } from '../interfaces/cat-service.interface';
import { CatServiceImpl } from '../services/cat.service';

export const asyncCatServiceProvider = {
  provide: 'CatService',
  useFactory: async (): Promise<CatService> => {
    const connection = await createDatabaseConnection();
    return new CatServiceImpl(connection);
  },
};

Testando Componentes com Inversão de Dependência

A inversão de dependência facilita a criação de testes unitários, pois permite o uso de mocks para as dependências.

// src/cats/controllers/cat.controller.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { CatController } from './cat.controller';
import { CatService } from '../interfaces/cat-service.interface';

describe('CatController', () => {
  let catController: CatController;
  let catService: CatService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [CatController],
      providers: [
        {
          provide: 'CatService',
          useValue: {
            findAll: jest.fn().mockResolvedValue(['MockCat']),
          },
        },
      ],
    }).compile();

    catController = module.get<CatController>(CatController);
    catService = module.get<CatService>('CatService');
  });

  it('should return an array of cats', async () => {
    expect(await catController.findAll()).toEqual(['MockCat']);
  });
});

Benefícios da Inversão de Dependência

1- Flexibilidade e Testabilidade:

Facilita a substituição de implementações concretas por mocks, especialmente útil em testes unitários.

2- Desacoplamento:

Reduz o acoplamento entre módulos, permitindo que sejam desenvolvidos, testados e mantidos de forma independente.

3- Reutilização de Código:

Facilita a reutilização de componentes, já que diferentes implementações podem ser facilmente intercambiáveis.

Conclusão

Implementar a inversão de dependência em NestJS não só melhora a qualidade e a manutenção do código, mas também promove práticas de desenvolvimento mais eficientes e escaláveis. Seguindo esses princípios, você pode criar sistemas mais robustos, testáveis e flexíveis, alinhados com as melhores práticas da engenharia de software.

Esses conceitos, quando aplicados corretamente, permitem que os desenvolvedores construam aplicações complexas de forma modular e sustentável, beneficiando-se de uma arquitetura sólida e bem definida.

relacionamento 1:n mongose

Luiz Pires — Tue, 29 Aug 2023 17:27:47 +0000

Para criar um relacionamento 1:n (um para muitos) utilizando o Mongoose e o NestJS, você pode seguir os seguintes passos:

Defina os Modelos: Comece definindo os modelos para as entidades envolvidas no relacionamento.

// post.model.ts
import { Schema, Prop, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

@Schema()
export class Post extends Document {
  @Prop()
  title: string;

  @Prop()
  content: string;
}

export const PostSchema = SchemaFactory.createForClass(Post);

// comment.model.ts
import { Schema, Prop, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

@Schema()
export class Comment extends Document {
  @Prop()
  text: string;
}

export const CommentSchema = SchemaFactory.createForClass(Comment);

Defina as Relações: No modelo Post, você pode criar um campo que armazene um array de IDs de comentários para representar a relação 1:n.

// post.model.ts
import { Schema, Prop, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';
import { Comment } from './comment.model';

@Schema()
export class Post extends Document {
  @Prop()
  title: string;

  @Prop()
  content: string;

  @Prop({ type: [{ type: Schema.Types.ObjectId, ref: 'Comment' }] })
  comments: Comment[];
}

export const PostSchema = SchemaFactory.createForClass(Post);

Crie os Serviços: Agora, você precisa criar os serviços para interagir com os modelos.

// post.service.ts
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Post } from './post.model';

@Injectable()
export class PostService {
  constructor(@InjectModel(Post.name) private postModel: Model<Post>) {}

  async findAll(): Promise<Post[]> {
    return this.postModel.find().populate('comments').exec();
  }

  // ... outros métodos
}

// comment.service.ts
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Comment } from './comment.model';

@Injectable()
export class CommentService {
  constructor(@InjectModel(Comment.name) private commentModel: Model<Comment>) {}

  // ... métodos para criar comentários, etc.
}

Configure os Módulos: Configure os módulos no NestJS para que eles possam ser injetados onde necessário.

// post.module.ts
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { PostService } from './post.service';
import { Post, PostSchema } from './post.model';

@Module({
  imports: [MongooseModule.forFeature([{ name: Post.name, schema: PostSchema }])],
  providers: [PostService],
  exports: [PostService],
})
export class PostModule {}

// comment.module.ts
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { CommentService } from './comment.service';
import { Comment, CommentSchema } from './comment.model';

@Module({
  imports: [MongooseModule.forFeature([{ name: Comment.name, schema: CommentSchema }])],
  providers: [CommentService],
  exports: [CommentService],
})
export class CommentModule {}

Utilize os Serviços: Agora você pode utilizar os serviços para criar, listar e manipular posts e comentários.

Lembrando que este é um exemplo básico de como criar um relacionamento 1:n entre posts e comentários usando Mongoose e NestJS. Dependendo das suas necessidades, você pode precisar adicionar mais funcionalidades e validações aos seus serviços e controladores.

Inversão de dependência com NestJS

Luiz Pires — Sun, 02 Apr 2023 16:14:43 +0000

A inversão de dependência é um princípio importante da programação orientada a objetos, que consiste em tornar as classes independentes de outras classes específicas, e sim depender de interfaces genéricas. Isso permite uma maior flexibilidade e modularidade do código, além de facilitar o teste unitário e a manutenção.

No NestJS, é possível implementar a inversão de dependência através do uso de injeção de dependência. A injeção de dependência é um padrão de projeto que permite que as dependências de uma classe sejam fornecidas por uma fonte externa, como um contêiner de dependência.

Para implementar a injeção de dependência no NestJS, primeiro é necessário definir uma interface para a classe que será injetada. Por exemplo, se quisermos injetar uma classe UserService em outra classe, podemos definir uma interface IUserService que descreve os métodos que a classe UserService deve implementar.

export interface IUserService {
  getUser(id: string): Promise<User>;
  saveUser(user: User): Promise<void>;
}

Em seguida, é preciso criar uma classe concreta que implemente essa interface. Nesse caso, a classe UserService.

@Injectable()
export class UserService implements IUserService {
  async getUser(id: string): Promise<User> {
    // Lógica para buscar usuário no banco de dados
  }

  async saveUser(user: User): Promise<void> {
    // Lógica para salvar usuário no banco de dados
  }
}

Agora, para injetar essa classe em outra classe, basta usar o decorador @Inject() e especificar a interface que a classe implementa.

@Injectable()
export class UserApiController {
  constructor(@Inject('IUserService') private readonly userService: IUserService) {}

  async getUser(id: string): Promise<User> {
    return this.userService.getUser(id);
  }

  async saveUser(user: User): Promise<void> {
    return this.userService.saveUser(user);
  }
}

Por fim, é preciso registrar a classe UserService no módulo do NestJS, utilizando o método forProvider() do módulo.

@Module({
  providers: [
    { provide: 'IUserService', useClass: UserService }
  ],
  controllers: [UserApiController],
})
export class UserModule {}

Dessa forma, a classe UserService será injetada automaticamente na classe UserApiController sempre que for necessário, sem que a classe dependa diretamente dela.