mkdir db-fundamentals-api
cd db-fundamentals-api
npm init -y
npm install express dotenv mysql2 mongoose winston

📋 Copiar

mkdir config models routes utils
touch app.js .env config/db.js utils/logger.js models/user.model.js models/product.model.js routes/data.routes.js

📋 Copiar

DB_HOST_SQL=localhost
DB_USER_SQL=root
DB_PASSWORD_SQL=sua_senha_mysql
DB_NAME_SQL=meu_banco_sql
DB_PORT_SQL=3306

MONGODB_URI_NOSQL=mongodb://localhost:27017/meu_banco_nosql # Ou um URI do MongoDB Atlas

📋 Copiar

// utils/logger.js
const winston = require('winston');

const logger = winston.createLogger({
    level: 'info',
    format: winston.format.combine(
        winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
        winston.format.errors({ stack: true }),
        winston.format.splat(),
        winston.format.json()
    ),
    transports: [
        new winston.transports.Console({
            format: winston.format.combine(
                winston.format.colorize(),
                winston.format.simple()
            )
        }),
        // Em produção, você adicionaria transportes para arquivos ou serviços de log
        // new winston.transports.File({ filename: 'error.log', level: 'error' }),
        // new winston.transports.File({ filename: 'combined.log' })
    ],
    exitOnError: false, // Não sair em exceções não tratadas
});
// Se não estiver em ambiente de produção, logar também no console para info/debug
if (process.env.NODE_ENV !== 'production') {
    logger.add(new winston.transports.Console({
        format: winston.format.simple()
    }));
}
module.exports = logger;

📋 Copiar

// config/db.js
const mysql = require('mysql2/promise'); // Driver SQL para MySQL
const mongoose = require('mongoose');    // ODM NoSQL para MongoDB
const logger = require('../utils/logger');
require('dotenv').config();

// Configuração MySQL (SQL)
const sqlConfig = {
    host: process.env.DB_HOST_SQL,
    user: process.env.DB_USER_SQL,
    password: process.env.DB_PASSWORD_SQL,
    database: process.env.DB_NAME_SQL,
    port: process.env.DB_PORT_SQL,
    waitForConnections: true,
    connectionLimit: 10,
    queueLimit: 0
};
let sqlPool;
const connectSQL = async () => {
    try {
        sqlPool = mysql.createPool(sqlConfig);
        await sqlPool.getConnection(); // Testa a conexão
        logger.info('Conexão SQL (MySQL) estabelecida com sucesso!');
    } catch (error) {
        logger.error('Falha ao conectar ao banco de dados SQL (MySQL):', error.message);
        process.exit(1); // Encerra a aplicação se a conexão falhar
    }
};
const getSQLConnection = () => {
    if (!sqlPool) {
        logger.error('Pool de conexão SQL não inicializado.');
        throw new Error('Pool de conexão SQL não inicializado.');
    }
    return sqlPool;
};
// Configuração MongoDB (NoSQL)
const connectNoSQL = async () => {
    try {
        await mongoose.connect(process.env.MONGODB_URI_NOSQL, {
            useNewUrlParser: true,
            useUnifiedTopology: true,
            // useCreateIndex: true, // Deprecado no Mongoose 6+
            // useFindAndModify: false // Deprecado no Mongoose 6+
        });
        logger.info('Conexão NoSQL (MongoDB) estabelecida com sucesso!');
    } catch (error) {
        logger.error('Falha ao conectar ao banco de dados NoSQL (MongoDB):', error.message);
        process.exit(1); // Encerra a aplicação se a conexão falhar
    }
};
module.exports = {
    connectSQL,
    getSQLConnection,
    connectNoSQL
};

📋 Copiar

// models/user.model.js
const { getSQLConnection } = require('../config/db');
const logger = require('../utils/logger');

class User {
    static async createTable() {
        // Exemplo de criação de tabela - em produção, migrations seriam usadas
        const pool = getSQLConnection();
        const query = 
            CREATE TABLE IF NOT EXISTS users (
                id INT AUTO_INCREMENT PRIMARY KEY,
                name VARCHAR(255) NOT NULL,
                email VARCHAR(255) UNIQUE NOT NULL,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            ) ENGINE=InnoDB;
        ;
        try {
            await pool.execute(query);
            logger.info('Tabela users verificada/criada com sucesso (SQL).');
        } catch (error) {
            logger.error('Erro ao criar tabela users (SQL):', error.message);
            throw error;
        }
    }
    static async createUser(name, email) {
        const pool = getSQLConnection();
        const query = 'INSERT INTO users (name, email) VALUES (?, ?)';
        try {
            const [result] = await pool.execute(query, [name, email]);
            logger.info('Novo usuário SQL criado com ID:', result.insertId);
            return { id: result.insertId, name, email };
        } catch (error) {
            logger.error('Erro ao criar usuário SQL:', error.message);
            throw error;
        }
    }
    static async getAllUsers() {
        const pool = getSQLConnection();
        const query = 'SELECT id, name, email FROM users';
        try {
            const [rows] = await pool.execute(query);
            logger.info('Usuários SQL recuperados:', rows.length);
            return rows;
        } catch (error) {
            logger.error('Erro ao recuperar usuários SQL:', error.message);
            throw error;
        }
    }
    static async getUserById(id) {
        const pool = getSQLConnection();
        const query = 'SELECT id, name, email FROM users WHERE id = ?';
        try {
            const [rows] = await pool.execute(query, [id]);
            logger.info('Usuário SQL recuperado por ID:', id);
            return rows[0]; // Retorna o primeiro usuário encontrado
        } catch (error) {
            logger.error('Erro ao recuperar usuário SQL por ID:', error.message);
            throw error;
        }
    }
}
module.exports = User;

📋 Copiar

// models/product.model.js
const mongoose = require('mongoose');
const logger = require('../utils/logger');

// Definição do Schema para um Produto
const productSchema = new mongoose.Schema({
    name: {
        type: String,
        required: true,
        trim: true
    },
    description: {
        type: String,
        required: false,
        trim: true
    },
    price: {
        type: Number,
        required: true,
        min: 0
    },
    category: {
        type: String,
        required: true,
        trim: true
    },
    stock: {
        type: Number,
        default: 0,
        min: 0
    },
    createdAt: {
        type: Date,
        default: Date.now
    }
});
// Métodos estáticos (ou de instância) para interações comuns
productSchema.statics.findProductsByCategory = async function (category) {
    try {
        const products = await this.find({ category: category });
        logger.info('Produtos NoSQL recuperados por categoria:', category);
        return products;
    } catch (error) {
        logger.error('Erro ao recuperar produtos NoSQL por categoria:', error.message);
        throw error;
    }
};
// Cria o Modelo a partir do Schema
const Product = mongoose.model('Product', productSchema);
module.exports = Product;

📋 Copiar

// routes/data.routes.js
const express = require('express');
const router = express.Router();
const User = require('../models/user.model');
const Product = require('../models/product.model');
const logger = require('../utils/logger');

// Rota para criar um novo usuário (SQL)
router.post('/sql/users', async (req, res) => {
    const { name, email } = req.body;
    if (!name || !email) {
        logger.warn('Validação de entrada falhou para /sql/users: name ou email ausente.');
        return res.status(400).json({ message: 'Nome e email são obrigatórios.' });
    }
    try {
        const newUser = await User.createUser(name, email);
        res.status(201).json({ message: 'Usuário SQL criado com sucesso!', user: newUser });
    } catch (error) {
        logger.error('Erro na rota POST /sql/users:', error.message);
        res.status(500).json({ message: 'Erro ao criar usuário SQL.', error: error.message });
    }
});
// Rota para listar todos os usuários (SQL)
router.get('/sql/users', async (req, res) => {
    try {
        const users = await User.getAllUsers();
        res.status(200).json({ message: 'Usuários SQL recuperados com sucesso!', users });
    } catch (error) {
        logger.error('Erro na rota GET /sql/users:', error.message);
        res.status(500).json({ message: 'Erro ao recuperar usuários SQL.', error: error.message });
    }
});
// Rota para obter um usuário por ID (SQL)
router.get('/sql/users/:id', async (req, res) => {
    const { id } = req.params;
    if (isNaN(id)) {
        logger.warn('Validação de entrada falhou para /sql/users/:id: ID inválido.');
        return res.status(400).json({ message: 'ID de usuário deve ser um número válido.' });
    }
    try {
        const user = await User.getUserById(id);
        if (user) {
            res.status(200).json({ message: 'Usuário SQL encontrado.', user });
        } else {
            res.status(404).json({ message: 'Usuário SQL não encontrado.' });
        }
    } catch (error) {
        logger.error('Erro na rota GET /sql/users/:id:', error.message);
        res.status(500).json({ message: 'Erro ao recuperar usuário SQL.', error: error.message });
    }
});
// Rota para criar um novo produto (NoSQL)
router.post('/nosql/products', async (req, res) => {
    const { name, description, price, category, stock } = req.body;
    if (!name || !price || !category) {
        logger.warn('Validação de entrada falhou para /nosql/products: name, price ou category ausente.');
        return res.status(400).json({ message: 'Nome, preço e categoria são obrigatórios.' });
    }
    try {
        const newProduct = new Product({ name, description, price, category, stock });
        await newProduct.save(); // Salva no MongoDB
        res.status(201).json({ message: 'Produto NoSQL criado com sucesso!', product: newProduct });
    } catch (error) {
        logger.error('Erro na rota POST /nosql/products:', error.message);
        res.status(500).json({ message: 'Erro ao criar produto NoSQL.', error: error.message });
    }
});
// Rota para listar todos os produtos (NoSQL)
router.get('/nosql/products', async (req, res) => {
    try {
        const products = await Product.find({}); // Busca todos os produtos
        res.status(200).json({ message: 'Produtos NoSQL recuperados com sucesso!', products });
    } catch (error) {
        logger.error('Erro na rota GET /nosql/products:', error.message);
        res.status(500).json({ message: 'Erro ao recuperar produtos NoSQL.', error: error.message });
    }
});
// Rota para listar produtos por categoria (NoSQL - usando método estático)
router.get('/nosql/products/category/:category', async (req, res) => {
    const { category } = req.params;
    try {
        const products = await Product.findProductsByCategory(category);
        res.status(200).json({ message: Produtos NoSQL da categoria '${category}' recuperados., products });
    } catch (error) {
        logger.error('Erro na rota GET /nosql/products/category/:category:', error.message);
        res.status(500).json({ message: 'Erro ao recuperar produtos NoSQL por categoria.', error: error.message });
    }
});
module.exports = router;

📋 Copiar

// app.js
const express = require('express');
const { connectSQL, connectNoSQL } = require('./config/db');
const dataRoutes = require('./routes/data.routes');
const User = require('./models/user.model'); // Importar para criar a tabela
const logger = require('./utils/logger');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 3000;
// Middlewares
app.use(express.json()); // Habilita o parsing de JSON no corpo das requisições
// Conexão com os bancos de dados
const startServer = async () => {
    try {
        await connectSQL(); // Tenta conectar ao MySQL
        await User.createTable(); // Garante que a tabela 'users' existe no MySQL
        await connectNoSQL(); // Tenta conectar ao MongoDB
        // Rotas da API
        app.use('/api', dataRoutes);
        // Rota padrão para teste
        app.get('/', (req, res) => {
            res.send('API de Fundamentos de Banco de Dados está rodando!');
        });
        // Middleware de tratamento de erros global
        app.use((err, req, res, next) => {
            logger.error('Erro não tratado na API:', err.stack);
            res.status(500).send('Algo deu muito errado!');
        });
        app.listen(PORT, () => {
            logger.info(Servidor rodando na porta ${PORT});
            logger.info(Acesse: http://localhost:${PORT});
        });
    } catch (error) {
        logger.error('Falha ao iniciar o servidor:', error.message);
        process.exit(1); // Encerra a aplicação em caso de falha crítica
    }
};
startServer();

📋 Copiar

// models/user.model.js (adicionar dentro da classe User)
// ... código existente ...

    static async updateUser(id, name, email) {
        const pool = getSQLConnection();
        const query = 'UPDATE users SET name = ?, email = ? WHERE id = ?';
        try {
            const [result] = await pool.execute(query, [name, email, id]);
            if (result.affectedRows === 0) {
                logger.warn('Nenhum usuário SQL encontrado para atualização com ID:', id);
                return null; // Usuário não encontrado
            }
            logger.info('Usuário SQL atualizado com ID:', id);
            return { id, name, email };
        } catch (error) {
            logger.error('Erro ao atualizar usuário SQL:', error.message);
            throw error;
        }
    }
// ...

📋 Copiar

// routes/data.routes.js (adicionar após as rotas existentes)
// ... código existente ...

// Rota para atualizar um usuário (SQL)
router.put('/sql/users/:id', async (req, res) => {
    const { id } = req.params;
    const { name, email } = req.body;
    if (isNaN(id)) {
        logger.warn('Validação de entrada falhou para PUT /sql/users/:id: ID inválido.');
        return res.status(400).json({ message: 'ID de usuário deve ser um número válido.' });
    }
    if (!name && !email) { // Pelo menos um campo para atualizar
        logger.warn('Validação de entrada falhou para PUT /sql/users/:id: Nenhum campo para atualizar fornecido.');
        return res.status(400).json({ message: 'Forneça pelo menos nome ou email para atualização.' });
    }
    try {
        const updatedUser = await User.updateUser(id, name, email);
        if (updatedUser) {
            res.status(200).json({ message: 'Usuário SQL atualizado com sucesso!', user: updatedUser });
        } else {
            res.status(404).json({ message: 'Usuário SQL não encontrado para atualização.' });
        }
    } catch (error) {
        logger.error('Erro na rota PUT /sql/users/:id:', error.message);
        res.status(500).json({ message: 'Erro ao atualizar usuário SQL.', error: error.message });
    }
});
// Rota para atualizar um produto (NoSQL)
router.put('/nosql/products/:id', async (req, res) => {
    const { id } = req.params; // _id do MongoDB
    const updates = req.body; // Objeto com os campos a serem atualizados
    // Validação básica: verificar se há campos para atualizar
    if (Object.keys(updates).length === 0) {
        logger.warn('Validação de entrada falhou para PUT /nosql/products/:id: Nenhum campo para atualizar fornecido.');
        return res.status(400).json({ message: 'Forneça pelo menos um campo para atualização.' });
    }
    try {
        // Mongoose findByIdAndUpdate:
        // - id: o _id do documento
        // - updates: o objeto com os campos a serem atualizados
        // - { new: true }: retorna o documento atualizado
        // - { runValidators: true }: executa as validações do schema antes de atualizar
        const updatedProduct = await Product.findByIdAndUpdate(id, updates, { new: true, runValidators: true });
        if (updatedProduct) {
            res.status(200).json({ message: 'Produto NoSQL atualizado com sucesso!', product: updatedProduct });
        } else {
            res.status(404).json({ message: 'Produto NoSQL não encontrado para atualização.' });
        }
    } catch (error) {
        logger.error('Erro na rota PUT /nosql/products/:id:', error.message);
        // Em caso de erro de validação do Mongoose
        if (error.name === 'ValidationError') {
            return res.status(400).json({ message: 'Erro de validação ao atualizar produto.', details: error.message });
        }
        res.status(500).json({ message: 'Erro ao atualizar produto NoSQL.', error: error.message });
    }
});
module.exports = router;

📋 Copiar

🚀 Pronto para a próxima aula?

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

📚 Ver todas as aulas