Clean Architecture em NestJS: Um Guia para Iniciantes

A arquitetura de software é fundamental para o desenvolvimento de aplicações escaláveis e de fácil manutenção. Entre as diversas abordagens, a Clean Architecture (Arquitetura Limpa) se destaca por sua capacidade de separar as responsabilidades e promover a independência de frameworks, bancos de dados e outros elementos de infraestrutura.

Neste artigo, vamos explorar como implementar a Clean Architecture em uma aplicação NestJS, uma estrutura poderosa para construir aplicações backend em Node.js.

O que é Clean Architecture?

Clean Architecture é um conceito criado por Robert C. Martin, também conhecido como Uncle Bob. A ideia central é organizar o código de forma que as regras de negócio sejam independentes de detalhes de implementação, como frameworks e bancos de dados. Isso facilita a manutenção e a evolução do software, permitindo que você troque partes do sistema sem impactar outras.

Princípios da Clean Architecture

1. Independência de Frameworks: O código deve ser escrito de maneira que não dependa de bibliotecas ou frameworks específicos.
2. Testabilidade: A arquitetura deve permitir testes unitários e de integração de forma fácil.
3. Independência de Banco de Dados: O modelo de domínio deve ser independente do sistema de persistência.
4. Separação de Responsabilidades: Cada parte do sistema deve ter uma única responsabilidade.

Estrutura da Clean Architecture

A Clean Architecture é frequentemente representada em camadas. As principais camadas são:

1. Entidades: Contém as regras de negócio e lógica central.
2. Casos de Uso: Representa as operações que o sistema pode executar.
3. Interface do Usuário: Responsável pela interação com o usuário.
4. Frameworks e Drivers: Inclui detalhes de implementação, como bibliotecas e serviços externos.

Implementando Clean Architecture em NestJS

Para exemplificar a implementação da Clean Architecture em NestJS, vamos criar um projeto simples de gerenciamento de tarefas. Este projeto terá as seguintes camadas:

1. Domínio (Entidades)
2. Casos de Uso
3. Controladores (Interface do Usuário)
4. Infraestrutura (Frameworks e Drivers)

1. Configurando o Projeto

Para começar, vamos criar um novo projeto NestJS. Se você não tem o Nest CLI instalado, execute:

npm install -g @nestjs/cli

Em seguida, crie um novo projeto:

nest new task-manager

Navegue até o diretório do projeto:

cd task-manager

2. Criando as Entidades

No diretório src, crie uma nova pasta chamada domain e, dentro dela, crie um arquivo chamado task.entity.ts. Este arquivo conterá a entidade de tarefa:

// src/domain/task.entity.ts
export class Task {
  constructor(
    public id: string,
    public title: string,
    public completed: boolean = false,
  ) {}

  // Métodos relacionados às tarefas podem ser adicionados aqui
}

3. Criando Casos de Uso

Agora, vamos criar os casos de uso. Crie uma pasta chamada use-cases dentro do diretório src e, dentro dela, crie um arquivo chamado create-task.use-case.ts.

// src/use-cases/create-task.use-case.ts
import { Task } from '../domain/task.entity';

export class CreateTaskUseCase {
  private tasks: Task[] = [];

  execute(title: string): Task {
    const newTask = new Task(this.generateId(), title);
    this.tasks.push(newTask);
    return newTask;
  }

  private generateId(): string {
    return (Math.random() * 1000).toString();
  }
}

4. Criando o Controlador

Agora, vamos criar um controlador para lidar com as requisições. Crie uma nova pasta chamada controllers e, dentro dela, crie um arquivo chamado task.controller.ts.

// src/controllers/task.controller.ts
import { Controller, Post, Body } from '@nestjs/common';
import { CreateTaskUseCase } from '../use-cases/create-task.use-case';
import { Task } from '../domain/task.entity';

@Controller('tasks')
export class TaskController {
  private createTaskUseCase = new CreateTaskUseCase();

  @Post()
  create(@Body('title') title: string): Task {
    return this.createTaskUseCase.execute(title);
  }
}

5. Registrando o Controlador

Agora, precisamos registrar o controlador no módulo principal da aplicação. Abra o arquivo app.module.ts e faça as seguintes modificações:

// src/app.module.ts
import { Module } from '@nestjs/common';
import { TaskController } from './controllers/task.controller';

@Module({
  imports: [],
  controllers: [TaskController],
  providers: [],
})
export class AppModule {}

6. Testando a Aplicação

Para testar a aplicação, inicie o servidor:

npm run start

Agora, você pode usar uma ferramenta como o Postman ou o Insomnia para enviar uma requisição POST para http://localhost:3000/tasks com um corpo JSON, por exemplo:

{
  "title": "Estudar Clean Architecture"
}

Se tudo estiver correto, você deve receber uma resposta com a tarefa criada.

Conclusão

Neste artigo, exploramos a Clean Architecture e como implementá-la em um projeto NestJS. Essa abordagem não apenas melhora a organização do seu código, mas também facilita a manutenção e os testes, promovendo uma base sólida para o crescimento da sua aplicação.

Se você está começando no desenvolvimento de software, a Clean Architecture pode parecer um conceito desafiador, mas com a prática, você verá como ela pode simplificar o processo de desenvolvimento.

Gostou do artigo? Tem alguma dúvida ou sugestão? Deixe seu comentário abaixo e compartilhe suas experiências com Clean Architecture em NestJS! Seu feedback é muito importante para nós.

---

Esse artigo foi escrito com um foco em iniciantes, apresentando conceitos fundamentais e exemplos práticos. Se precisar de mais informações ou ajustes, sinta-se à vontade para pedir!