O Express.js é um framework minimalista e flexível para Node.js que facilita a criação de aplicações web e APIs. Um dos recursos mais poderosos do Express.js é o middleware, que permite modularizar e gerenciar o fluxo de solicitações HTTP de maneira eficiente. Neste artigo, vamos explorar como integrar middleware em suas aplicações Express.js, abordando desde os conceitos básicos até exemplos práticos de uso.

Pré-requisitos

Para seguir este guia, você precisará de:

1. Conhecimento básico de JavaScript e Node.js
2. Noções básicas sobre o Express.js
3. Node.js e npm instalados em seu ambiente de desenvolvimento

O que é Middleware?

Middleware são funções que têm acesso ao objeto de solicitação (req), ao objeto de resposta (res) e à próxima função middleware no ciclo de solicitação-resposta. Elas podem executar as seguintes tarefas:

• Executar qualquer código
• Fazer mudanças nos objetos de solicitação e resposta
• Encerrar o ciclo de solicitação-resposta
• Chamar o próximo middleware na pilha

Se o middleware atual não encerrar o ciclo de solicitação-resposta, ele deve chamar next() para passar o controle para a próxima função middleware.

Tipos de Middleware

1. Middleware de Aplicação: Vinculado à instância do objeto app.
2. Middleware de Roteador: Vinculado a uma instância do objeto router.
3. Middleware de Manipulador de Erros: Manipula erros na aplicação.
4. Middleware Incorporado: Middleware fornecido pelo próprio Express.js.
5. Middleware de Terceiros: Middleware desenvolvido por terceiros.

Integração de Middleware em Express.js

1. Configurando o Ambiente

Antes de começarmos a integrar middleware, vamos configurar um ambiente básico com Express.js.

mkdir express-middleware-example
cd express-middleware-example
npm init -y
npm install express

Crie um arquivo app.js e configure um servidor básico Express.js:

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

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

app.listen(port, () => {
    console.log(`Server is running on http://localhost:${port}`);
});

2. Middleware de Aplicação

Vamos criar e integrar um middleware de aplicação simples que registra o tempo de solicitação.

// Logger Middleware
const requestTime = (req, res, next) => {
    req.requestTime = Date.now();
    console.log(`Request received at: ${req.requestTime}`);
    next();
};

app.use(requestTime);

app.get('/', (req, res) => {
    res.send(`Hello, world! Request received at: ${req.requestTime}`);
});

Neste exemplo, o middleware requestTime adiciona uma propriedade requestTime ao objeto req e a registra no console.

3. Middleware Incorporado

O Express.js fornece alguns middleware incorporados, como express.json() e express.urlencoded() para lidar com dados JSON e dados de formulário.

app.use(express.json());
app.use(express.urlencoded({ extended: true }));

app.post('/data', (req, res) => {
    res.send(req.body);
});

4. Middleware de Terceiros

Há uma variedade de middleware de terceiros disponíveis para Express.js, como morgan para registro de log e body-parser para análise de corpo de solicitação.

npm install morgan body-parser

const morgan = require('morgan');
const bodyParser = require('body-parser');

app.use(morgan('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));

app.post('/data', (req, res) => {
    res.send(req.body);
});

5. Middleware de Manipulador de Erros

Um middleware de manipulador de erros captura erros e envia uma resposta apropriada ao cliente.

const errorHandler = (err, req, res, next) => {
    console.error(err.stack);
    res.status(500).send('Something broke!');
};

app.use(errorHandler);

app.get('/error', (req, res) => {
    throw new Error('This is a forced error.');
});

Exemplos de Middleware

Middleware de Autenticação

Um exemplo comum de middleware é a autenticação, onde você verifica se um usuário está autenticado antes de acessar uma rota.

const authMiddleware = (req, res, next) => {
    const token = req.headers['authorization'];

    if (!token) {
        return res.status(403).send('No token provided.');
    }

    // Verifique o token aqui (ex: JWT)
    // Se válido, prossiga; caso contrário, responda com um erro
    try {
        // const decoded = jwt.verify(token, 'secret_key');
        // req.user = decoded;
        next();
    } catch (err) {
        res.status(401).send('Invalid token.');
    }
};

app.use('/protected', authMiddleware);

app.get('/protected', (req, res) => {
    res.send('This is a protected route.');
});

Conclusão

Integrar middleware em suas aplicações Express.js é essencial para modularizar e gerenciar o fluxo de solicitações HTTP. Com middleware, você pode adicionar funcionalidades como autenticação, registro de log, tratamento de erros e muito mais. Experimente os exemplos fornecidos e explore outras bibliotecas de middleware para aprimorar ainda mais suas aplicações Express.js.

Com essas práticas e exemplos, você está preparado para criar e integrar middleware de forma eficaz em suas aplicações Express.js, melhorando a organização e funcionalidade de seu código.

---