Entendendo e Implementando Middlewares no Express.js

O Express.js é um dos frameworks mais populares para construir aplicações web com Node.js. Ele facilita a criação de APIs RESTful e permite estruturar aplicações de forma modular. Um dos principais conceitos no Express.js é o uso de middlewares. Neste artigo, vamos entender o que são middlewares, como funcionam e como você pode criar os seus próprios.

O que são Middlewares?

Middlewares são funções que têm acesso ao objeto de requisição (req), ao objeto de resposta (res) e à função next(). Eles podem modificar o objeto de requisição e/ou resposta e controlar o ciclo de requisição-resposta. Um middleware pode fazer várias coisas, como:

• Executar qualquer código.
• Modificar a requisição e a resposta.
• Encerrar o ciclo de requisição-resposta.
• Chamar o próximo middleware na cadeia.

A assinatura básica de um middleware em Express.js é:

function middleware(req, res, next) {
    // Lógica do middleware
    next(); // Chama o próximo middleware
}

Tipos de Middlewares

No Express, podemos encontrar vários tipos de middlewares:

1. Middlewares de Aplicação: São middlewares que afetam a aplicação inteira ou um conjunto de rotas.
2. Middlewares de Rota: Específicos para uma ou mais rotas.
3. Middlewares Integrados: Como o express.json() e express.static(), fornecidos diretamente pelo Express.
4. Middlewares de Terceiros: Como o morgan ou cors, que você pode instalar para estender a funcionalidade do Express.

Como os Middlewares Funcionam?

Quando uma requisição é recebida, ela passa por uma "cadeia de middlewares". Cada middleware pode processar a requisição e, ao final de sua execução, decidir se chama o próximo middleware (usando a função next()) ou finaliza a resposta.

const express = require('express');
const app = express();

// Middleware global
app.use((req, res, next) => {
    console.log('Request Type:', req.method);
    next();
});

// Middleware específico para a rota /user
app.use('/user', (req, res, next) => {
    console.log('Middleware para /user');
    next();
});

app.get('/user', (req, res) => {
    res.send('Página do Usuário');
});

app.listen(3000, () => {
    console.log('Servidor rodando na porta 3000');
});

Criando Middlewares Personalizados

Além dos middlewares fornecidos pelo Express ou de terceiros, você pode criar seus próprios middlewares para lidar com funcionalidades específicas, como autenticação, logging, ou manipulação de dados.

Exemplo de um middleware simples de autenticação:

function autenticar(req, res, next) {
    const token = req.header('Authorization');
    if (!token) {
        return res.status(401).send('Acesso negado. Token não fornecido.');
    }
    try {
        // Lógica para validar o token
        next(); // Continua para o próximo middleware
    } catch (err) {
        res.status(400).send('Token inválido.');
    }
}

app.use(autenticar); // Aplica o middleware para todas as rotas

Middlewares de Terceiros

O Express também permite a utilização de middlewares de terceiros, que podem ser instalados via npm. Alguns dos mais populares são:

• morgan: Para logs HTTP.
• helmet: Para segurança, configurando cabeçalhos HTTP de proteção.
• cors: Para habilitar CORS (Cross-Origin Resource Sharing).

Instalando e utilizando o morgan:

npm install morgan

const morgan = require('morgan');

// Middleware de log
app.use(morgan('tiny'));

app.get('/', (req, res) => {
    res.send('Hello World');
});

Ordem dos Middlewares

A ordem em que você define os middlewares é importante, pois eles são executados na sequência em que são registrados. Por exemplo, se você definir um middleware de autenticação depois de uma rota que requer autenticação, ele não será executado para aquela rota.

app.use(express.json()); // Middleware para parsear JSON

app.post('/secure-data', autenticar, (req, res) => {
    res.send('Acesso a dados seguros');
});

Finalizando Middlewares

Se um middleware não chamar a função next(), ele interromperá o ciclo de requisição-resposta. Isso pode ser útil em casos onde você quer finalizar a requisição dentro do próprio middleware, como em uma verificação de autenticação:

function autenticar(req, res, next) {
    if (!req.header('Authorization')) {
        return res.status(403).send('Não autorizado');
    }
    next();
}

Conclusão

Middlewares são uma parte essencial da construção de aplicações com Express.js, permitindo uma grande flexibilidade e modularidade. Ao dominar o uso de middlewares, você será capaz de estruturar suas APIs de forma eficiente, reutilizando código e adicionando funcionalidades como autenticação, segurança e manipulação de dados de forma simples e escalável.

Se você ainda não está utilizando middlewares personalizados em seus projetos, comece com algo simples, como um middleware de logging ou autenticação, e experimente a modularidade e flexibilidade que o Express.js oferece!

Gostou do artigo? Não esqueça de compartilhar com seus colegas desenvolvedores!