Criando microsserviços com Node.js e Docker

Com o crescimento de aplicações modernas que consomem dados via HTTP, construir APIs RESTful robustas e escaláveis se tornou uma habilidade essencial. E quando falamos de desenvolvimento backend em JavaScript, o Express.js continua sendo uma das bibliotecas mais populares e versáteis.

Neste artigo, vamos apresentar melhores práticas para construir APIs RESTful com Express.js, abordando organização de código, segurança, validação de dados e muito mais.

1. Organize seu projeto em camadas

Evite colocar toda a lógica no mesmo arquivo. Separe a aplicação em camadas como:

• Rotas (routes/)
• Controladores (controllers/)
• Serviços ou lógica de negócio (services/)
• Modelos de dados (models/)
• Middlewares (middlewares/)

Exemplo de estrutura:

project/
├── routes/
│   └── userRoutes.js
├── controllers/
│   └── userController.js
├── services/
│   └── userService.js
├── models/
│   └── userModel.js
├── middlewares/
│   └── authMiddleware.js
└── app.js

2. Use middlewares de forma inteligente

Middlewares são o coração do Express. Use-os para tratar:

• Autenticação e autorização
• Logs de requisições
• Validação de dados
• Manipulação de erros

Exemplo:

javascript;
app.use(express.json());
app.use(cors());
app.use(authMiddleware);

3. Valide os dados da requisição

Jamais confie nos dados que chegam via req.body, req.params ou req.query.

Utilize bibliotecas como Joi, Zod ou express-validator para garantir que os dados estão corretos antes de prosseguir.

Exemplo com express-validator:

javascript;
const { body } = require("express-validator");

router.post(
  "/users",
  [body("email").isEmail(), body("password").isLength({ min: 6 })],
  userController.createUser
);

4. Padronize os códigos de status HTTP

Use códigos de status corretamente para que o cliente saiba o que está acontecendo:

• 200 OK – requisição bem-sucedida
• 201 Created – recurso criado com sucesso
• 400 Bad Request – dados inválidos
• 401 Unauthorized – sem autenticação
• 403 Forbidden – sem permissão
• 404 Not Found – recurso não encontrado
• 500 Internal Server Error – erro inesperado

5. Trate erros de forma centralizada

Crie um middleware de erro que capture exceções e envie respostas consistentes.

Exemplo:

javascript;
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(err.status || 500).json({
    message: err.message || "Erro interno do servidor",
  });
});

6. Implemente autenticação com JWT

Para proteger rotas, use tokens JWT (JSON Web Tokens) em conjunto com um middleware de autenticação.

Exemplo simples de middleware:

javascript;
const jwt = require("jsonwebtoken");

function authMiddleware(req, res, next) {
  const token = req.headers.authorization?.split(" ")[1];
  if (!token) return res.status(401).json({ message: "Token ausente" });

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch {
    res.status(403).json({ message: "Token inválido" });
  }
}

7. Utilize variáveis de ambiente

Nunca exponha credenciais no código. Use bibliotecas como dotenv para gerenciar variáveis de ambiente:

javascript;
require("dotenv").config();
const port = process.env.PORT || 3000;

8. Documente sua API

Uma API bem documentada facilita a vida de quem consome seus endpoints. Use Swagger (OpenAPI) para gerar documentação interativa.

• Ferramenta recomendada: swagger-ui-express

Conclusão

Construir APIs RESTful com Express.js pode ser simples, mas garantir que elas sejam escaláveis, seguras e manuteníveis exige boas práticas. Ao seguir uma arquitetura bem definida, validar dados, proteger suas rotas e tratar erros corretamente, você cria um backend robusto e profissional.

Se você quer levar suas APIs a um próximo nível, considere também implementar testes automatizados, versionamento de rotas e cache de respostas.