APIs com NodeJS

npm init -y

npm install express

console.log('Olá Mundo!');

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

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

app.use(express.json());

//Rotas Endpoints

app.get('/', (req, res) => {
    res.status(200).json({ message: 'Seja bem vindos a API da Micilini, consulte a documentação para acessar mais detalhes 🥳' });
});

app.post('/newUser', (req, res) => {
    const { name, email, password } = req.body;
    console.log(name, email, password);
    res.status(201).json({ message: `Usuário ${name} criado com sucesso!` });
});

app.put('/updateUser/:idUser', (req,
    res) => {

    //Exemplo de status de erro caso idUser não seja informado
    if (!req.params.idUser) {
        res.status(422).json({ message: 'Informe o id do usuário que deseja atualizar' });
        return;
    }

    const { idUser } = req.params;
    const { name, email, password } = req.body;
    console.log(idUser, name, email, password);
    res.status(200).json({ message: `Usuário ${name} atualizado com sucesso!` });
});

app.delete('/removeUser/:idUser', (req, res) => {
    const { idUser } = req.params;
    console.log(idUser);
    res.status(201).json({ message: `Usuário ${idUser} removido com sucesso!` });
});

app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

npm init -y

npm install bcrypt cookie-parser cors express jsonwebtoken mysql2 sequelize multer dotenv

DB_NAME=nodejs
DB_USER=root
DB_PASS=SUASENHA
DB_HOST=localhost
DB_DIALECT=mysql
ACCESS_SECRET=MICILINIACCESSSECRET
REFRESH_SECRET=MICILINIREFRESHSECRET

const { Sequelize, DataTypes } = require('sequelize');
const sequelize = require('../db/connection');

const Usuario = sequelize.define('Usuario', {
    id_usuario: {
        type: DataTypes.INTEGER,
        autoIncrement: true,
        primaryKey: true
    },
    nome_usuario: {
        type: DataTypes.STRING,
        allowNull: false
    },
    email_usuario: {
        type: DataTypes.STRING,
        allowNull: false
    },
    senha_usuario: {
        type: DataTypes.STRING,
        allowNull: false
    },
    imagem_usuario: {
        type: DataTypes.STRING,
        allowNull: true
    },
    whatsapp_usuario: {
        type: DataTypes.STRING,
        allowNull: false
    }
}, {
    timestamps: true
});

module.exports = Usuario;

const { Sequelize, DataTypes } = require('sequelize');
const sequelize = require('../db/connection');
const Usuario = require('./Usuario'); // Relacionamento com o model Usuario

const Dragao = sequelize.define('Dragao', {
    id_dragao: {
        type: DataTypes.INTEGER,
        autoIncrement: true,
        primaryKey: true
    },
    nome_dragao: {
        type: DataTypes.STRING,
        allowNull: false
    },
    peso_dragao: {
        type: DataTypes.FLOAT, // Alterado de NUMBER para FLOAT
        allowNull: false
    },
    idade_dragao: {
        type: DataTypes.INTEGER,
        allowNull: false
    },
    cor_dragao: {
        type: DataTypes.STRING,
        allowNull: false
    },
    imagens_dragao: {
        type: DataTypes.TEXT, // Armazenar array como JSON
        allowNull: false,
        get() {
            const value = this.getDataValue('imagens_dragao');
            return value ? JSON.parse(value) : [];
        },
        set(value) {
            this.setDataValue('imagens_dragao', JSON.stringify(value));
        }
    },
    existe_dragao: {
        type: DataTypes.BOOLEAN,
        defaultValue: true
    }
}, {
    timestamps: true
});

// Relacionamento: Dragão pertence a um Usuário
Dragao.belongsTo(Usuario, { foreignKey: 'id_usuario' });

module.exports = Dragao;

require('dotenv').config(); // Carrega as variáveis do .env

const { Sequelize } = require('sequelize');// Carrega a biblioteca do Sequelize

//Realiza as configurações do Sequelize com as variáveis de ambiente (.env)
const sequelize = new Sequelize(process.env.DB_NAME, process.env.DB_USER, process.env.DB_PASS, {
    host: process.env.DB_HOST,
    dialect: process.env.DB_DIALECT
});

module.exports = sequelize;

const express = require('express');
const cors = require('cors');
const sequelize = require('./db/connection'); // Importa a conexão do Sequelize
const cookieParser = require('cookie-parser'); // Importa o cookie-parser

//Inicializa o express
const app = express();

//Configurações da resposta em JSON
app.use(express.json());

//Configurações do Parser de Coookies
app.use(cookieParser());

//Configuração do CORS
app.use(cors({ credentials: true, origin: 'http://localhost:3000' }));//Soluciona os erros de CORS na tentativa de acessarem a API estando no mesmo domínio

//Configuração e importação dos arquivos de rotas
app.use('/', require('./routes/GeralRotas'));
app.use('/usuarios', require('./routes/UsuarioRotas'));
app.use('/dragao', require('./routes/DragaoRotas'));

// Sincroniza o Sequelize com o banco de dados (cria as tabelas caso não existam)
sequelize.sync()
  .then(() => {
    console.log('Banco de dados sincronizado');
    
    // Configuração da porta do servidor
    app.listen(3333, () => {
        console.log('Servidor rodando em http://localhost:3333');
    });
  })
  .catch((error) => {
    console.error('Erro ao sincronizar o banco de dados:', error);
  });

const router = require('express').Router();

router.get('/', (req, res) => {
    res.send('Seja bem vindo a API de Dragões 🐉. Consulte a documentação para aprender a utilizar a API ️‍🔥');
});

module.exports = router;

const router = require('express').Router();

//Importa o Helper capaz de tratar imagens
const { imageUpload } = require('../helpers/uploadImage');

//Importa os controladores que serão usados
const UsuarioController = require('../controllers/UsuarioController');

router.post('/registrar', imageUpload.single("imagem"), UsuarioController.registrar);
router.post('/login', UsuarioController.login);
router.get('/authUser', UsuarioController.authUser);
router.post('/refreshToken', UsuarioController.refreshToken);
router.post('/logout', UsuarioController.logout);

module.exports = router;

const router = require('express').Router();

//Importa o Helper capaz de tratar imagens
const { imageUpload } = require('../helpers/uploadImage');

//Importa os middlewares que serão usados
const authMiddleware = require('../middleware/authMiddleware');

//Importa os controladores que serão usados
const DragaoController = require('../controllers/DragaoController');

// Aplica o middleware para todas as rotas dentro de /dragao
router.use(authMiddleware);

//Restante das rotas de /dragao
router.post('/criar', imageUpload.array('imagens'), DragaoController.criar);
router.get('/retornaTodos', DragaoController.retornaTodos);
router.get('/retornaPorId/:id', DragaoController.retornaPorId);
router.put('/atualizar/:id', imageUpload.array('imagens'), DragaoController.atualizar);
router.delete('/deletar/:id', DragaoController.deletar);

module.exports = router;

const Usuario = require('../models/Usuario');
const bcrypt = require('bcrypt');

//Importa as funções necessárias para gerar os tokens JWT
const { generateAccessToken, generateRefreshToken, verifyAccessToken, verifyRefreshToken } = require('../helpers/manageTokens');

class UsuarioController {
    //Função para registrar novos usuários
    static async registrar(req, res) {
        try {
            const { nome, email, senha, imagem, whatsapp } = req.body;

            //Valida se todos os campos acima (que são obrigatórios) vieram na requisição, caso não, retorna um erro
            if (!nome || !email || !senha || !whatsapp) {
                return res.status(422).json({ mensagem: 'Os campos nome, email, senha e whatsapp são obrigatórios!' });
            }

            //Validação de imagens
            let image = null;

            if (req.file) {
                image = req.file.filename;//O middleware que configura o upload da imagem (declarado no arquivo de rotas) salva a imagem no req.file.filename
            }

            // Verifica se o email já existe no banco de dados
            const emailExiste = await UsuarioController.#verificarEmailExistente(email);
            if (emailExiste) {
                return res.status(409).json({ mensagem: 'Este email já está registrado!' });
            }

            //Fortifica a senha usando SALT + BCRYPT
            const salt = await bcrypt.genSalt(12);
            const passwordHash = await bcrypt.hash(senha, salt);

            //Salva o usuário no banco de dados

            const usuario = await Usuario.create({
                nome_usuario: nome,
                email_usuario: email,
                senha_usuario: passwordHash,
                imagem_usuario: image,
                whatsapp_usuario: whatsapp
            });

            return res.status(201).json(usuario);
        } catch (error) {
            return res.status(500).json({ error: error.message });
        }
    }
    // Função privada para verificar se o email já existe (a # indica ao JS que é privada)
    static async #verificarEmailExistente(email) {
        const usuario = await Usuario.findOne({ where: { email_usuario: email } });
        return usuario !== null; // Retorna true se o email já estiver registrado
    }
    //Função de login
    static async login(req, res) {
        try {
            const { email, senha } = req.body;

            //Valida se todos os campos acima (que são obrigatórios) vieram na requisição, caso não, retorna um erro
            if (!email || !senha) {
                return res.status(422).json({ mensagem: 'Os campos email e senha são obrigatórios!' });
            }

            //Verifica se o email existe no banco de dados
            const usuario = await Usuario.findOne({ where: { email_usuario: email } });
            if (!usuario) {
                return res.status(401).json({ mensagem: 'Email ou senha incorretos!' });
            }

            //Verifica se a senha está correta
            const senhaCorreta = await bcrypt.compare(senha, usuario.senha_usuario);
            if (!senhaCorreta) {
                return res.status(401).json({ mensagem: 'Email ou senha incorretos!' });
            }

            //Gera os tokens JWT
            const accessToken = generateAccessToken(usuario.id_usuario, 60 * 15); // 15 minutos
            const refreshToken = generateRefreshToken(usuario.id_usuario);

            //Salva o RefreshToken em um cookie
            res.cookie('refreshToken', refreshToken, {
                expires: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000), // expira em 30 dias
                path: '/',
                secure: true, // apenas HTTPS
                httpOnly: true, // acessível apenas via HTTP
                sameSite: 'None' // ajuste conforme necessário
            });

            //Retorna somente o AccessToken
            return res.status(200).json({ accessToken });
        } catch (error) {
            return res.status(500).json({ error: error.message });
        }
    }
    //Função de autenticação do usuário
    static async authUser(req, res) {
        try {
            //Pega o token de autorização da requisição
            const authHeader = req.headers['authorization'];//Não se esqueça de enviar no Header da Requisição o Authorization com o valor 'Bearer + AccessToken'
            const accessToken = authHeader && authHeader.split(' ')[1];

            //Verifica se o token é válido
            const user = verifyAccessToken(accessToken);
            if (!user) {
                return res.status(401).json({ mensagem: 'Token inválido!' });
            }

            //Retorna os dados do usuário
            const usuario = await Usuario.findByPk(user.user_id, { attributes: { exclude: ['senha_usuario'] } });
            return res.status(200).json(usuario);
        } catch (error) {
            return res.status(500).json({ error: error.message });
        }
    }
    //Função para atualizar o AccessToken por meio do refreshToken
    static async refreshToken(req, res) {
        try {
            //Pega o RefreshToken do cookie
            const refreshToken = req.cookies.refreshToken;
            console.log(refreshToken);

            //Verifica se o RefreshToken é válido
            const user = verifyRefreshToken(refreshToken);
            console.log(user);
            if (!user) {
                return res.status(401).json({ mensagem: 'Token inválido!' });
            }

            //Gera um novo AccessToken
            const accessToken = generateAccessToken(user.user_id, 60 * 15); // 15 minutos

            //Retorna os dados do usuário
            const usuario = await Usuario.findByPk(user.user_id, { attributes: { exclude: ['senha_usuario'] } });
            return res.status(200).json({ accessToken, usuario });
        } catch (error) {
            console.log(error);
            return res.status(500).json({ error: error.message });
        }
    }
    //Função para fazer logout
    static async logout(req, res) {
        try {
            //Limpa o cookie do refreshToken
            res.clearCookie('refreshToken');

            return res.status(200).json({ mensagem: 'Logout realizado com sucesso!' });
        } catch (error) {
            return res.status(500).json({ error: error.message });
        }
    }
}

module.exports = UsuarioController;

const Dragao = require('../models/Dragoes');

class DragaoController {
    //Função para retornar todos os dragoes
    static async retornaTodos(req, res) {
        try {
            const dragoes = await Dragao.findAll();
            return res.status(200).json(dragoes);
        } catch (error) {
            return res.status(500).json({ error: error.message });
        }
    }
    //Função para criar um dragao
    static async criar(req, res) {
        try {
            const { nome, peso, idade, cor, existe, imagens } = req.body;

            //Validar para ver se todos os campos vieram
            if (!nome || !peso || !idade || !cor || !existe) {
                return res.status(400).json({ error: 'Os campos nome, peso, idade, cor e existe são obrigatórios!' });
            }

            //Faz a validação de imagens
            let images = [];

            if (req.files) {
                images = req.files.map(file => file.filename);
            }

            //Criar um dragao
            const dragao = await Dragao.create({
                nome_dragao: nome,
                peso_dragao: peso,
                idade_dragao: idade,
                cor_dragao: cor,
                imagens_dragao: images,
                existe_dragao: existe,
            });
            return res.status(201).json(dragao);
        } catch (error) {
            return res.status(500).json({ error: error.message });
        }
    }
    //Função para retornar um dragao por :id
    static async retornaPorId(req, res) {
        try {
            const { id } = req.params;
            const dragao = await Dragao.findByPk(id);
            if (!dragao) {
                return res.status(404).json({ error: 'Dragão não encontrado!' });
            }
            return res.status(200).json(dragao);
        } catch (error) {
            return res.status(500).json({ error: error.message });
        }
    }
    //Função para atualizar um dragao por :id
    static async atualizar(req, res) {
        try {
            const { id } = req.params;
            const { nome, peso, idade, cor, existe, imagens } = req.body;

            //Validar para ver se todos os campos vieram
            if (!nome || !peso || !idade || !cor || !existe) {
                return res.status(400).json({ error: 'Os campos nome, peso, idade, cor e existe são obrigatórios!' });
            }

            //Faz a validação de imagens
            let images = [];

            if (req.files) {
                images = req.files.map(file => file.filename);
            }

            //Atualizar um dragao
            const dragao = await Dragao.findByPk(id);
            if (!dragao) {
                return res.status(404).json({ error: 'Dragão não encontrado!' });
            }
            await dragao.update({
                nome_dragao: nome,
                peso_dragao: peso,
                idade_dragao: idade,
                cor_dragao: cor,
                imagens_dragao: images,
                existe_dragao: existe,
            });
            return res.status(200).json(dragao);
        } catch (error) {
            return res.status(500).json({ error: error.message });
        }
    }
    //Função para deletar um dragao por :id
    static async deletar(req, res) {
        try {
            const { id } = req.params;
            const dragao = await Dragao.findByPk(id);
            if (!dragao) {
                return res.status(404).json({ error: 'Dragão não encontrado!' });
            }
            await dragao.destroy();
            return res.status(204).end();
        } catch (error) {
            return res.status(500).json({ error: error.message });
        }
    }
}

module.exports = DragaoController;

//Importa as funções necessárias para gerar os tokens JWT
const { verifyRefreshToken } = require('../helpers/manageTokens');

//Middleware para verificar se o token de atualização é válido
async function authMiddleware(req, res, next) {
    // Pega o refreshToken dos cookies
    const refreshToken = req.cookies.refreshToken;
    console.log('RefreshToken:', refreshToken);

    if (!refreshToken) {
        return res.status(401).json({ mensagem: 'RefreshToken não fornecido!' });
    }

    try {
        // Verifica se o refreshToken é válido
        const decoded = verifyRefreshToken(refreshToken);

        if(!decoded){
            return res.status(403).json({ mensagem: 'RefreshToken inválido ou expirado!' });
        }

        // Chama o próximo middleware ou controlador
        next();
    } catch (error) {
        return res.status(403).json({ mensagem: 'RefreshToken inválido ou expirado!' });
    }

}

module.exports = authMiddleware;

const jwt = require('jsonwebtoken');

// Definir segredos para assinar os tokens JWT
const ACCESS_SECRET = process.env.ACCESS_SECRET;
const REFRESH_SECRET = process.env.REFRESH_SECRET;

// Função para gerar AccessToken
function generateAccessToken(userID, expiresIn) {
    const accessTokenPayload = {
        user_id: userID,
        exp: Math.floor(Date.now() / 1000) + expiresIn // Expiração em segundos
    };

    // Gera e retorna o AccessToken
    return jwt.sign(accessTokenPayload, ACCESS_SECRET, { algorithm: 'HS256' });
}

// Função para gerar RefreshToken
function generateRefreshToken(userID) {
    const expirationTime = Math.floor(Date.now() / 1000) + (30 * 24 * 60 * 60); // 30 dias

    const refreshTokenPayload = {
        user_id: userID,
        exp: expirationTime
    };

    // Gera e retorna o RefreshToken
    return jwt.sign(refreshTokenPayload, REFRESH_SECRET, { algorithm: 'HS256' });
}

//Função para verificar se o AccessToken é válido
function verifyAccessToken(accessToken) {
    try {
        return jwt.verify(accessToken, ACCESS_SECRET, { algorithm: 'HS256' });
    } catch (error) {
        return null;
    }
}

//Função para verificar se o RefreshToken é válido
function verifyRefreshToken(refreshToken) {
    try {
        return jwt.verify(refreshToken, REFRESH_SECRET, { algorithm: 'HS256' });
    } catch (error) {
        console.log('Token verification error:', error.message); // Adicione este log
        return null;
    }
}

module.exports = {
    generateAccessToken,
    generateRefreshToken,
    verifyAccessToken,
    verifyRefreshToken
};

const multer = require('multer');
const path = require('path');

//Destino para onde as imagens serão salvas
const storage = multer.diskStorage({
    destination: function (req, file, cb) {
        let folder = "files";//Pasta onde as imagens serão salvas
        cb(null, path.resolve(__dirname, '..', folder));//Caminho para a pasta, exemplo: /home/usuario/Documentos/Projeto/files
    },
    filename: function (req, file, cb) {
        cb(null, Date.now() + path.extname(file.originalname));//Nome do arquivo, exemplo: 123456789.jpg
    }
});

const imageUpload = multer({
    storage: storage,
    limits: { fileSize: 1000000 },//Tamanho máximo do arquivo em bytes
    fileFilter: function (req, file, cb) {
        if(!file.originalname.match(/\.(jpg|jpeg|png)$/)){//Extensões permitidas
            return cb(new Error('Por favor, envie apenas imagens!'));
        }
    cb(undefined, true);
    }
});//Nome do campo que será enviado no formulário

module.exports = { imageUpload };

node ./index.js

Seja bem vindo a API de Dragões 🐉. Consulte a documentação para aprender a utilizar a API ️‍🔥