mkdir rbac-aula
cd rbac-aula
npm init -y
npm install express jsonwebtoken dotenv --save

📋 Copiar

// server.js

// Importa o framework Express para criar e gerenciar nosso servidor web.
const express = require('express');
// Importa o módulo jsonwebtoken para lidar com a criação e verificação de JWTs.
const jwt = require('jsonwebtoken');
// Importa o módulo dotenv para carregar variáveis de ambiente do arquivo .env.
require('dotenv').config();
// Inicializa o aplicativo Express.
const app = express();
// Define a porta do servidor, usando a variável de ambiente PORT ou 3000 como padrão.
const PORT = process.env.PORT || 3000;
// Define uma chave secreta para assinar e verificar os JWTs, obtida do ambiente.
// É fundamental que esta chave seja secreta e robusta em produção.
const JWT_SECRET = process.env.JWT_SECRET || 'umaChaveSuperSecretaEforteParaAssinarTokens';
// Middleware do Express para parsear o corpo das requisições como JSON.
app.use(express.json());
// --- 1. Dados In-Memory para Simular Usuários, Papéis e Permissões ---
// Em uma aplicação real, estes dados seriam armazenados em um banco de dados.
// Representa os usuários do nosso sistema.
// Cada usuário tem um 'id', 'username', 'password' e um 'role' (papel).
const users = [
    { id: 1, username: 'admin', password: 'password123', role: 'admin' },
    { id: 2, username: 'editor', password: 'password123', role: 'editor' },
    { id: 3, username: 'viewer', password: 'password123', role: 'viewer' },
    { id: 4, username: 'guest', password: 'password123', role: 'guest' },
];
// Define as permissões associadas a cada papel (role).
// Este é o coração do nosso RBAC, mapeando papéis a um conjunto de ações permitidas.
const roles = {
    admin: [
        'manage_users', 'create_product', 'read_product', 'update_product', 'delete_product',
        'read_reports', 'manage_settings'
    ],
    editor: [
        'create_product', 'read_product', 'update_product',
        'read_reports'
    ],
    viewer: [
        'read_product',
        'read_reports'
    ],
    guest: [
        'read_product' // Um convidado pode apenas visualizar produtos.
    ]
};
// --- 2. Middleware de Autenticação (Simulado) ---
// Este middleware verifica se um JWT válido foi fornecido na requisição.
// Em uma aplicação real, a autenticação seria mais complexa (e.g., Passport.js).
function authenticateToken(req, res, next) {
    // Obtém o cabeçalho de autorização.
    const authHeader = req.headers['authorization'];
    // Extrai o token (geralmente no formato 'Bearer TOKEN').
    const token = authHeader && authHeader.split(' ')[1];
    // Se não houver token, retorna erro 401 (Não Autorizado).
    if (token == null) {
        console.log('Log: Requisição sem token de autenticação.');
        return res.status(401).json({ message: 'Acesso negado: Token não fornecido.' });
    }
    // Verifica o token usando a chave secreta.
    jwt.verify(token, JWT_SECRET, (err, user) => {
        // Se o token for inválido, retorna erro 403 (Proibido).
        if (err) {
            console.error('Log: Token inválido.', err.message);
            return res.status(403).json({ message: 'Acesso negado: Token inválido.' });
        }
        // Anexa as informações do usuário (incluindo o papel) ao objeto de requisição.
        // Isso será crucial para o middleware de autorização (RBAC).
        req.user = user;
        console.log(Log: Usuário autenticado: ${user.username} com papel: ${user.role}.);
        // Chama o próximo middleware na cadeia.
        next();
    });
}
// --- 3. Middleware de Autorização RBAC ---
// Este é o nosso middleware principal para controle de acesso.
// Ele aceita uma permissão ou um array de permissões como argumento.
function authorize(...requiredPermissions) {
    return (req, res, next) => {
        // Verifica se o usuário foi anexado pela autenticação.
        if (!req.user || !req.user.role) {
            console.error('Log: Usuário não autenticado ou sem papel definido para autorização.');
            // Isso geralmente não deveria acontecer se authenticateToken rodou primeiro,
            // mas é uma validação de segurança.
            return res.status(403).json({ message: 'Acesso negado: Informações do usuário ausentes.' });
        }
        // Obtém o papel do usuário autenticado.
        const userRole = req.user.role;
        // Obtém todas as permissões associadas a este papel.
        const userPermissions = roles[userRole];
        // Se o papel do usuário não tiver permissões definidas, nega o acesso.
        if (!userPermissions) {
            console.warn(Log: Papel '${userRole}' não possui permissões definidas.);
            return res.status(403).json({ message: 'Acesso negado: Papel não possui permissões.' });
        }
        // Verifica se o usuário possui TODAS as permissões necessárias.
        // O método 'every' retorna true se todos os elementos do array passarem no teste.
        const hasAllPermissions = requiredPermissions.every(perm => userPermissions.includes(perm));
        if (hasAllPermissions) {
            console.log(Log: Usuário ${req.user.username} autorizado para a ação: ${requiredPermissions.join(', ')}.);
            // Se tiver as permissões, chama o próximo middleware.
            next();
        } else {
            console.warn(Log: Usuário ${req.user.username} (papel: ${userRole}) não tem permissão para a ação: ${requiredPermissions.join(', ')}.);
            // Caso contrário, nega o acesso.
            res.status(403).json({ message: Acesso negado: Você não possui as permissões necessárias para esta ação. Papel atual: ${userRole}. Permissões necessárias: ${requiredPermissions.join(', ')}. });
        }
    };
}
// --- 4. Rotas da API ---
// Rota para login e obtenção de um token JWT.
app.post('/login', (req, res) => {
    const { username, password } = req.body;
    // Encontra o usuário em nossa lista in-memory.
    const user = users.find(u => u.username === username && u.password === password);
    if (!user) {
        console.warn(Log: Tentativa de login falha para o usuário: ${username}.);
        return res.status(400).json({ message: 'Nome de usuário ou senha inválidos.' });
    }
    // Cria um JWT contendo o ID, username e o papel do usuário.
    // O papel é crucial para nosso middleware de autorização.
    const token = jwt.sign({ id: user.id, username: user.username, role: user.role }, JWT_SECRET, { expiresIn: '1h' });
    console.log(Log: Usuário ${username} logado com sucesso. Token gerado.);
    res.json({ token: token, role: user.role });
});
// Rota pública para visualizar produtos (qualquer um pode ver, mesmo sem autenticação).
app.get('/products', (req, res) => {
    // Em um cenário real, aqui viriam os produtos de um DB.
    console.log('Log: Acessando rota pública /products.');
    res.json([{ id: 1, name: 'Produto X', price: 100 }, { id: 2, name: 'Produto Y', price: 150 }]);
});
// --- Rotas Protegidas com Autenticação e RBAC ---
// Rota para criar um novo produto. Requer autenticação e a permissão 'create_product'.
app.post('/products', authenticateToken, authorize('create_product'), (req, res) => {
    const { name, price } = req.body;
    // Lógica para criar produto...
    console.log(Log: Usuário ${req.user.username} criou o produto: ${name}.);
    res.status(201).json({ message: Produto '${name}' criado com sucesso por ${req.user.username}. });
});
// Rota para atualizar um produto existente. Requer autenticação e a permissão 'update_product'.
app.put('/products/:id', authenticateToken, authorize('update_product'), (req, res) => {
    const { id } = req.params;
    const { name, price } = req.body;
    // Lógica para atualizar produto...
    console.log(Log: Usuário ${req.user.username} atualizou o produto ID: ${id}.);
    res.json({ message: Produto ID ${id} atualizado com sucesso por ${req.user.username}. });
});
// Rota para deletar um produto. Requer autenticação e a permissão 'delete_product'.
app.delete('/products/:id', authenticateToken, authorize('delete_product'), (req, res) => {
    const { id } = req.params;
    // Lógica para deletar produto...
    console.log(Log: Usuário ${req.user.username} deletou o produto ID: ${id}.);
    res.json({ message: Produto ID ${id} deletado com sucesso por ${req.user.username}. });
});
// Rota para gerenciar usuários. Requer autenticação e a permissão 'manage_users'.
app.get('/users-management', authenticateToken, authorize('manage_users'), (req, res) => {
    console.log(Log: Usuário ${req.user.username} acessou o gerenciamento de usuários.);
    // Em uma aplicação real, aqui haveria uma listagem ou interface de gerenciamento de usuários.
    res.json({ message: Bem-vindo à área de gerenciamento de usuários, ${req.user.username}! });
});
// Rota para visualizar relatórios. Requer autenticação e a permissão 'read_reports'.
app.get('/reports', authenticateToken, authorize('read_reports'), (req, res) => {
    console.log(Log: Usuário ${req.user.username} acessou os relatórios.);
    res.json({ message: Aqui estão seus relatórios, ${req.user.username}. });
});
// --- 5. Tratamento de Erros Excepcional ---
// Middleware de tratamento de erros, sempre o último a ser registrado.
app.use((err, req, res, next) => {
    console.error('Log de Erro: ', err.stack); // Registra o stack trace do erro.
    res.status(500).json({ message: 'Ocorreu um erro interno no servidor. Por favor, tente novamente mais tarde.' });
});
// --- 6. Inicialização do Servidor ---
app.listen(PORT, () => {
    console.log(Servidor rodando na porta ${PORT});
    console.log(Para testar, use ferramentas como Postman ou curl.);
    console.log(Documentação do JWT: https://jwt.io/);
});

📋 Copiar

JWT_SECRET="umaChaveSuperSecretaEforteParaAssinarTokens"
PORT=3000

📋 Copiar

node server.js

📋 Copiar

curl -X POST -H "Content-Type: application/json" -d '{"username":"admin", "password":"password123"}' http://localhost:3000/login

Copie o token retornado para as próximas requisições. Ex: eyJhbGciOiJIUzI1Ni...



    
📚 Informações da Aula

    
Curso: API Completo - Node.js & Express

    
Tempo estimado: 25 minutos

    
Pré-requisitos: JavaScript básico

📋 Copiar

Substitua  pelo token obtido no login

curl -X POST -H "Content-Type: application/json" -H "Authorization: Bearer " -d '{"name":"Super Item Admin", "price":299}' http://localhost:3000/products

Deve retornar: "Produto 'Super Item Admin' criado com sucesso por admin." (status 201)

📋 Copiar

Primeiro, logue como editor para obter o token:

curl -X POST -H "Content-Type: application/json" -d '{"username":"editor", "password":"password123"}' http://localhost:3000/login

Copie o token do editor.

Em seguida, tente criar um produto:

curl -X POST -H "Content-Type: application/json" -H "Authorization: Bearer " -d '{"name":"Item Editor", "price":150}' http://localhost:3000/products

Deve retornar: "Produto 'Item Editor' criado com sucesso por editor." (status 201)

📋 Copiar

Primeiro, logue como viewer para obter o token:

curl -X POST -H "Content-Type: application/json" -d '{"username":"viewer", "password":"password123"}' http://localhost:3000/login

Copie o token do viewer.

Em seguida, tente criar um produto:

curl -X POST -H "Content-Type: application/json" -H "Authorization: Bearer " -d '{"name":"Item Viewer", "price":50}' http://localhost:3000/products

Deve retornar: "Acesso negado: Você não possui as permissões necessárias para esta ação..." (status 403)

📋 Copiar

Use o token do viewer novamente

curl -X GET -H "Authorization: Bearer " http://localhost:3000/reports

Deve retornar: "Aqui estão seus relatórios, viewer." (status 200)

📋 Copiar

Use o token do viewer

curl -X GET -H "Authorization: Bearer " http://localhost:3000/users-management

Deve retornar: "Acesso negado: Você não possui as permissões necessárias para esta ação..." (status 403)

📋 Copiar

const users = [
    // ... outros usuários
    { id: 5, username: 'supervisor', password: 'password123', role: 'supervisor' },
];

📋 Copiar

const roles = {
    // ... outros papéis
    supervisor: [
        'create_product', 'read_product', 'update_product',
        'read_reports',
        'visualizar_logs_auditoria' // Nova permissão específica do supervisor
    ],
    // ...
};

📋 Copiar

// Rota para visualizar logs de auditoria. Requer autenticação e a permissão 'visualizar_logs_auditoria'.
app.get('/audit-logs', authenticateToken, authorize('visualizar_logs_auditoria'), (req, res) => {
    console.log(Log: Usuário ${req.user.username} acessou os logs de auditoria.);
    res.json({ message: Acesso aos logs de auditoria concedido para ${req.user.username}. });
});

📋 Copiar

curl -X POST -H "Content-Type: application/json" -d '{"username":"supervisor", "password":"password123"}' http://localhost:3000/login

Copie o 

📋 Copiar

curl -X GET -H "Authorization: Bearer " http://localhost:3000/audit-logs

Deve retornar: "Acesso aos logs de auditoria concedido para supervisor." (status 200)

📋 Copiar

Logue como editor novamente e use o token do editor.

curl -X GET -H "Authorization: Bearer " http://localhost:3000/audit-logs

Deve retornar: "Acesso negado: Você não possui as permissões necessárias..." (status 403)

📋 Copiar

🚀 Pronto para a próxima aula?

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

📚 Ver todas as aulas