mkdir custom-middleware-api
cd custom-middleware-api
npm init -y
npm install express dotenv

📋 Copiar

custom-middleware-api/
├── .env
├── server.js
└── middleware/
    ├── authMiddleware.js
    ├── loggerMiddleware.js
    └── validationMiddleware.js

📋 Copiar

// .env
// Este arquivo armazena variáveis de ambiente sensíveis.
// Nunca comite este arquivo em repositórios públicos.
PORT=3000
API_KEY_SECRET=sua-chave-secreta-api-aqui

📋 Copiar

// middleware/loggerMiddleware.js
// Este middleware será responsável por registrar informações de cada requisição.

/* Middleware de logging para registrar detalhes da requisição.
  @param {object} req - Objeto de requisição do Express.
  @param {object} res - Objeto de resposta do Express.
  @param {function} next - Função para passar o controle para o próximo middleware.
 /
function logger(req, res, next) {
    const timestamp = new Date().toISOString(); // Gera um timestamp no formato ISO.
    const method = req.method;                 // Captura o método HTTP da requisição (GET, POST, etc.).
    const url = req.originalUrl;               // Captura a URL original da requisição.
    const ip = req.ip || req.connection.remoteAddress; // Captura o endereço IP do cliente.
    // Loga as informações no console, que é uma forma simples de logging para exemplos.
    // Em produção, usaríamos bibliotecas como Winston ou Morgan para logging mais robusto.
    console.log([${timestamp}] ${method} ${url} - IP: ${ip});
    next(); // Chama a próxima função middleware na pilha. É crucial chamar next() para que a requisição continue.
}
module.exports = logger; // Exporta o middleware para ser utilizado em outras partes da aplicação.

📋 Copiar

// middleware/authMiddleware.js
// Este middleware verifica a presença e validade de uma chave API no cabeçalho da requisição.

/* Middleware de autenticação de API Key.
  Verifica se um 'x-api-key' válido está presente no cabeçalho da requisição.
  @param {object} req - Objeto de requisição do Express.
  @param {object} res - Objeto de resposta do Express.
  @param {function} next - Função para passar o controle para o próximo middleware ou para um manipulador de erro.
 /
function authenticateApiKey(req, res, next) {
    const apiKey = req.header('x-api-key'); // Tenta obter a chave API do cabeçalho 'x-api-key'.
    const secretApiKey = process.env.API_KEY_SECRET; // Obtém a chave API secreta do ambiente.

    // A validação de entrada robusta começa aqui.
    if (!apiKey) {
        // Se a chave API não for fornecida, retorna um erro 401 (Unauthorized).
        return res.status(401).json({ message: 'Acesso não autorizado: Chave API ausente.' });
    }
    if (apiKey !== secretApiKey) {
        // Se a chave API fornecida não corresponder à chave secreta, retorna um erro 403 (Forbidden).
        return res.status(403).json({ message: 'Acesso negado: Chave API inválida.' });
    }
    // Se a chave API for válida, o controle é passado para o próximo middleware/rota.
    next();
}
module.exports = authenticateApiKey; // Exporta o middleware.

// middleware/validationMiddleware.js
// Este middleware será usado para validar dados específicos em requisições POST/PUT.

/ Middleware para validar a presença de campos essenciais no corpo da requisição.
  @param {string[]} fields - Um array de strings com os nomes dos campos obrigatórios.
  @returns {function} - Retorna a função middleware real.
 /
function validateRequiredFields(fields) {
    // Retorna uma função middleware, o que permite que este middleware seja configurado
    // com campos diferentes para rotas diferentes (currying).
    return (req, res, next) => {
        const missingFields = []; // Array para armazenar os campos que estão faltando.

        for (const field of fields) {
            // Verifica se o campo obrigatório não existe no corpo da requisição.
            // Poderíamos adicionar validações mais complexas aqui (tipo, formato, etc.).
            if (!req.body || !req.body[field]) {
                missingFields.push(field); // Adiciona o campo ausente à lista.
            }
        }
        if (missingFields.length > 0) {
            // Se houver campos ausentes, retorna um erro 400 (Bad Request).
            return res.status(400).json({ 
                message: Campos obrigatórios ausentes: ${missingFields.join(', ')}.,
                missingFields: missingFields 
            });
        }
        // Se todos os campos obrigatórios estiverem presentes, passa o controle.
        next();
    };
}
module.exports = validateRequiredFields; // Exporta a função que gera o middleware.

// server.js
// Arquivo principal da aplicação Express.

require('dotenv').config(); // Carrega as variáveis de ambiente do arquivo .env.
const express = require('express'); // Importa o módulo Express.
const loggerMiddleware = require('./middleware/loggerMiddleware'); // Importa o middleware de logging.
const authMiddleware = require('./middleware/authMiddleware'); // Importa o middleware de autenticação.
const validateRequiredFields = require('./middleware/validationMiddleware'); // Importa a função que gera o middleware de validação.
const app = express(); // Cria uma instância da aplicação Express.
const PORT = process.env.PORT || 3000; // Define a porta, usando a variável de ambiente ou 3000 como padrão.
// Para HostGator Plano M, certifique-se de que a porta configurada esteja disponível ou use o valor que o ambiente espera.
// Geralmente, para Node.js no HostGator, você usaria o valor de process.env.PORT fornecido pelo ambiente.
// Middlewares Globais: Aplicam-se a todas as requisições.
// Note que a ordem dos middlewares importa!
app.use(express.json()); // Middleware embutido do Express para parsear o corpo das requisições JSON.
app.use(loggerMiddleware); // Nosso middleware de logging customizado. Será executado para CADA requisição.
// Rota pública (não requer autenticação)
app.get('/', (req, res) => {
    res.status(200).json({ message: 'Bem-vindo à API Custom Middleware!' });
});
// Exemplo de rota protegida por autenticação
// O middleware 'authMiddleware' é aplicado APENAS a esta rota.
app.get('/api/dados-protegidos', authMiddleware, (req, res) => {
    // Se você chegou aqui, a chave API foi validada pelo authMiddleware.
    res.status(200).json({ message: 'Estes são dados sensíveis que exigem autenticação.', data: { id: 1, info: 'segredo' } });
});
// Exemplo de rota que requer autenticação E validação de dados
// Múltiplos middlewares podem ser encadeados. Eles serão executados na ordem definida.
app.post(
    '/api/criar-recurso', 
    authMiddleware, // Primeiro, autentica a API Key.
    validateRequiredFields(['nome', 'descricao']), // Depois, valida se 'nome' e 'descricao' estão no body.
    (req, res) => {
        // Se você chegou aqui, a chave API é válida e os campos 'nome' e 'descricao' existem.
        const { nome, descricao } = req.body;
        // Simula a criação de um recurso (em um ambiente real, salvaria em um DB).
        const novoRecurso = { id: Math.floor(Math.random()  1000), nome, descricao, createdAt: new Date() };
        console.log('Recurso criado:', novoRecurso); // Log profissional (simulado).
        res.status(201).json({ message: 'Recurso criado com sucesso!', data: novoRecurso });
    }
);
// Middleware de tratamento de erros (excepcional error handling)
// Este middleware é o último na cadeia e só é chamado se 'next(error)' for invocado.
// É uma prática enterprise ter um manipulador de erros centralizado.
app.use((err, req, res, next) => {
    console.error('Erro detectado pelo middleware de erro:', err.stack); // Registra o stack trace do erro.
    res.status(err.status || 500).json({
        message: err.message || 'Ocorreu um erro interno no servidor.',
        error: process.env.NODE_ENV === 'production' ? {} : err.message // Em produção, evite expor detalhes do erro.
    });
});
// Inicia o servidor.
app.listen(PORT, () => {
    console.log(Servidor rodando na porta ${PORT});
    console.log(Para testar, use 'curl' ou um cliente HTTP.);
});

📋 Copiar

node server.js

📋 Copiar

    curl http://localhost:3000/

📋 Copiar

    curl http://localhost:3000/api/dados-protegidos

📋 Copiar

    curl -H "x-api-key: chave-errada" http://localhost:3000/api/dados-protegidos

📋 Copiar

    curl -H "x-api-key: sua-chave-secreta-api-aqui" http://localhost:3000/api/dados-protegidos

📋 Copiar

    curl -X POST -H "Content-Type: application/json" -d '{"nome":"Teste","descricao":"Um teste"}' http://localhost:3000/api/criar-recurso

📋 Copiar

    curl -X POST -H "x-api-key: sua-chave-secreta-api-aqui" -H "Content-Type: application/json" -d '{"nome":"Produto X"}' http://localhost:3000/api/criar-recurso

📋 Copiar

    curl -X POST -H "x-api-key: sua-chave-secreta-api-aqui" -H "Content-Type: application/json" -d '{"nome":"Produto X","descricao":"Descrição do Produto X"}' http://localhost:3000/api/criar-recurso

📋 Copiar

// middleware/checkUserRole.js

/* Middleware para verificar o perfil (role) do usuário.
  Retorna uma função middleware configurada com o perfil necessário.
  @param {string} requiredRole - O perfil de usuário necessário para acessar a rota.
  @returns {function} - A função middleware real.
 /
function checkUserRole(requiredRole) {
    return (req, res, next) => {
        // Verifica se o objeto de usuário foi anexado à requisição por um middleware anterior.
        // Simulamos que req.user seria populado após um middleware de autenticação real.
        if (!req.user) {
            return res.status(401).json({ message: 'Acesso não autorizado: Usuário não logado.' });
        }
        // Verifica se o perfil do usuário corresponde ao perfil requerido.
        if (req.user.role !== requiredRole) {
            return res.status(403).json({ message: 'Acesso negado: Perfil insuficiente.', userRole: req.user.role, requiredRole: requiredRole });
        }
        // Se o usuário estiver logado e tiver o perfil correto, passa para o próximo.
        next();
    };
}
module.exports = checkUserRole;
    

📋 Copiar

// server.js (trechos modificados e novos)

require('dotenv').config();
const express = require('express');
const loggerMiddleware = require('./middleware/loggerMiddleware');
const authMiddleware = require('./middleware/authMiddleware');
const validateRequiredFields = require('./middleware/validationMiddleware');
const checkUserRole = require('./middleware/checkUserRole'); // Importe o novo middleware
const app = express();
const PORT = process.env.PORT || 3000;
app.use(express.json());
app.use(loggerMiddleware);
// Novo middleware para simular um usuário logado.
// Em uma aplicação real, isso viria de um token JWT, sessão, etc.
// Ele deve vir ANTES dos middlewares que dependem de req.user.
app.use((req, res, next) => {
    // Para fins de teste, podemos simular diferentes usuários.
    // Comente/descomente para testar diferentes cenários.
    // req.user = { id: 1, name: 'João', role: 'editor' }; // Usuário editor
    req.user = { id: 2, name: 'Maria', role: 'admin' }; // Usuário admin
    // req.user = { id: 3, name: 'Carlos', role: 'viewer' }; // Usuário com outro perfil
    // req.user = null; // Simula usuário não logado
    next();
});
// ... (rotas existentes)
// Nova rota para o painel de administração (requer perfil 'admin')
app.get('/api/admin-panel', 
    authMiddleware, // Apenas para demonstrar encadeamento com autenticação de API Key
    checkUserRole('admin'), // Verifica se o usuário simulado é 'admin'
    (req, res) => {
        res.status(200).json({ 
            message: 'Bem-vindo ao painel de administração!', 
            user: req.user,
            accessLevel: 'admin' 
        });
    }
);
// Nova rota para área de editor (requer perfil 'editor' ou 'admin')
// Podemos usar um array de middlewares para permitir múltiplos roles,
// ou criar um middleware mais complexo que aceite múltiplos roles.
// Para este exemplo, faremos um encadeamento simples para 'editor'.
// Uma forma mais elegante seria um checkUserRoles(['admin', 'editor']).
app.get('/api/editor-area', 
    authMiddleware,
    // Este é um exemplo simplificado. Para múltiplos roles,
    // o middleware checkUserRole precisaria ser mais genérico
    // ou você encadearia múltiplas chamadas (não o ideal).
    // Para simplificar, vamos assumir que apenas 'editor' ou 'admin' passará se o req.user.role for 'admin' ou 'editor'
    // Se o user for admin, o checkUserRole('editor') falharia.
    // Variação: para esta rota, se você estiver com o req.user.role = 'editor', funcionará.
    // Para 'admin' também passar, o middleware checkUserRole precisaria ser ajustado para aceitar uma lista de roles
    // ou você precisaria de um middleware mais genérico.
    // Por simplicidade, vamos manter a rota para 'editor'. Se quiser que 'admin' também passe, use checkUserRole('admin') ou crie uma rota separada.
    checkUserRole('editor'), // Usuário simulado precisa ser 'editor' para esta rota.
    (req, res) => {
        res.status(200).json({ 
            message: 'Bem-vindo à área de edição!', 
            user: req.user,
            accessLevel: 'editor' 
        });
    }
);
// ... (middleware de tratamento de erros e app.listen)
    

📋 Copiar

        curl -H "x-api-key: sua-chave-secreta-api-aqui" http://localhost:3000/api/admin-panel

📋 Copiar

        curl -H "x-api-key: sua-chave-secreta-api-aqui" http://localhost:3000/api/editor-area

📋 Copiar

🚀 Pronto para a próxima aula?

Continue sua jornada no desenvolvimento de APIs e domine Node.js & Express!

📚 Ver todas as aulas