Guia de Práticas para Projeto Backend com Node.js e TypeScript

Este guia fornece diretrizes e boas práticas para o desenvolvimento de um projeto backend com Node.js e TypeScript, seguindo uma arquitetura composta por três camadas: Service, Repository e Controller. Essas práticas ajudarão a manter seu código organizado, escalável e de fácil manutenção.

Índice

1. Requisitos Prévios
2. Estrutura de Diretórios
3. Camada de Controller
4. Camada de Service
5. Camada de Repository
6. Boas Práticas
7. Testes Unitários
8. Documentação
9. Gerenciamento de Dependências
10. Conclusão

Requisitos Prévios

• Node.js instalado
• TypeScript configurado no projeto
• Gerenciador de pacotes (como o npm ou yarn)
• Conhecimento básico de TypeScript

Estrutura de Diretórios

Uma organização clara da estrutura do projeto é essencial para a manutenção e escalabilidade. Aqui está uma sugestão de estrutura de diretórios:

/
  src/
    controllers/
    services/
    repositories/
    models/
    routes/
  app.ts
  server.ts

• controllers: Contém os controladores da aplicação.
• services: Armazena as lógicas de negócios da aplicação.
• repositories: Lida com a persistência de dados e interação com o banco de dados.
• models: Definição dos modelos de dados.
• routes: Configuração das rotas da aplicação.
• app.ts: Arquivo de configuração principal da aplicação.
• server.ts: Inicialização do servidor.

Camada de Controller

Os controladores lidam com as requisições HTTP e a interação com a camada de serviço. Siga estas práticas:

• Mantenha os controladores finos e focados apenas em rotear as requisições para a camada de serviço.
• Não coloque lógica de negócios nos controladores.
• Valide os dados de entrada das requisições e trate erros de forma adequada.

// Exemplo de controller

import { Request, Response } from 'express';
import UserService from '../services/userService';

class UserController {
  private userService: UserService;

  constructor() {
    this.userService = new UserService();
  }

  async getUser(req: Request, res: Response) {
    const userId = req.params.id;
    const user = await this.userService.getUserById(userId);
    res.json(user);
  }
}

export default UserController;

Camada de Service

A camada de serviço contém a lógica de negócios da aplicação. Siga estas práticas:

• Mantenha a camada de serviço independente de qualquer framework ou tecnologia.
• Encapsule a lógica de negócios em métodos reutilizáveis.
• Injete dependências, como os repositórios, para facilitar os testes unitários.

// Exemplo de service

import UserRepository from '../repositories/userRepository';
import User from '../models/user';

class UserService {
  private userRepository: UserRepository;

  constructor() {
    this.userRepository = new UserRepository();
  }

  async getUserById(id: string): Promise<User | null> {
    return this.userRepository.findById(id);
  }
}

export default UserService;

Camada de Repository

A camada de repositório lida com a persistência de dados e interação com o banco de dados. Siga estas práticas:

• Separe a lógica de banco de dados em métodos de fácil leitura.
• Use uma biblioteca de acesso ao banco de dados, como o TypeORM ou Sequelize.
• Evite a complexidade de consultas diretamente na camada de serviço.

// Exemplo de repository

import User from '../models/user';

class UserRepository {
  async findById(id: string): Promise<User | null> {
    // Implemente a lógica de consulta ao banco de dados aqui
  }
}

export default UserRepository;

Boas Práticas

• Use tipagem forte com TypeScript para evitar erros em tempo de execução.
• Utilize variáveis de ambiente para configurações sensíveis (como credenciais de banco de dados).
• Utilize os recursos assíncronos do Node.js para evitar bloqueio de thread.
• Trate erros de forma apropriada e forneça mensagens de erro informativas.
• Adote padrões de codificação consistentes e siga as convenções de estilo de código.

Testes Unitários

Testes unitários são essenciais para garantir a qualidade do código. Use ferramentas como Jest, Mocha ou Chai para escrever testes para cada parte do seu código, incluindo controladores, serviços e repositórios.

Documentação

Mantenha sua documentação atualizada. Use ferramentas como o Swagger para gerar documentação de API automaticamente. Documente também os modelos de dados, os endpoints da API e as instruções de configuração.

Gerenciamento de Dependências

Use um gerenciador de dependências como npm ou yarn para manter suas bibliotecas e pacotes atualizados. Mantenha um arquivo package.json ou yarn.lock bem organizado e versionado.

Conclusão

Este guia de práticas visa ajudar no desenvolvimento de um projeto backend com Node.js e TypeScript seguindo uma arquitetura de três camadas. Lembre-se de que boas práticas de codificação, testes e documentação são cruciais para criar uma aplicação robusta e de fácil manutenção. Aprenda continuamente e ajuste suas práticas conforme necessário para atender às necessidades específicas do seu projeto.