📁 Estrutura do Projeto
Como Organizar seu Projeto Backend
Antes de começar a programar, vamos criar a estrutura correta do projeto. Isso é fundamental para manter seu código organizado!
📋 Passo a Passo Completo:
Criar pasta do projeto
Crie uma pasta chamada meu-projeto-backend na sua Área de Trabalho
Abrir no VS Code
Clique com botão direito na pasta → "Abrir com Code" ou arraste a pasta para o VS Code
Abrir terminal integrado
No VS Code: Ctrl + ` (acento grave) ou Menu → Terminal → New Terminal
Inicializar projeto Node.js
npm init -y
Isso cria o arquivo package.json automaticamente
Instalar dependências
npm install express sqlite3
Express para criar APIs e SQLite3 para banco de dados
📂 Estrutura Final do Projeto:
meu-projeto-backend/
├── package.json (criado automaticamente)
├── package-lock.json (criado automaticamente)
├── node_modules/ (criado automaticamente)
├── app.js (você vai criar)
├── database.js (você vai criar)
├── meuapp.db (criado automaticamente pelo SQLite)
└── README.md (opcional)
✅ Arquivos que VOCÊ vai criar:
- /meu-projeto-backend/app.js - Arquivo principal da aplicação
- /meu-projeto-backend/database.js - Configuração do banco de dados
💡 Os outros arquivos são criados automaticamente pelo Node.js e SQLite!
🚀 O que é Backend?
Entendendo o Backend
Imagine um restaurante: o frontend é o salão onde os clientes fazem pedidos, e o backend é a cozinha onde a comida é preparada!
🎨 Frontend (Parte Visível):
- O que o usuário vê e clica
- Botões, formulários, menus
- Cores, imagens, animações
- Roda no navegador do usuário
⚙️ Backend (Parte Invisível):
- Processa os dados enviados
- Salva informações no banco de dados
- Faz cálculos e validações
- Roda no servidor da empresa
Por que Aprender Backend?
Salários Altos
Desenvolvedores backend são muito valorizados no mercado
Resolver Problemas
Você cria a lógica que faz tudo funcionar
Impacto Real
Seus sistemas podem ser usados por milhões de pessoas
Tecnologias que Vamos Usar
Vamos conhecer melhor cada ferramenta que usaremos para criar nosso backend:
Node.js
O "motor" que roda JavaScript no servidor
O que é?
Normalmente, JavaScript só funciona no navegador. Node.js permite que você use JavaScript para criar servidores e aplicações backend!
Por que usar?
- Mesma linguagem no frontend e backend
- Muito rápido e eficiente
- Comunidade gigante
- Milhares de bibliotecas prontas (NPM)
Analogia:
Imagine que JavaScript é como saber dirigir. Antes, você só podia dirigir carros (navegador). Node.js é como ganhar habilitação para dirigir caminhões, ônibus e motos também (servidores)!
Express
Framework que facilita criar APIs e servidores
O que é?
Express é como um "kit de ferramentas" que torna muito mais fácil criar servidores web com Node.js. Sem ele, seria como construir uma casa sem martelo!
O que ele faz?
- Cria rotas (URLs) facilmente
- Gerencia requisições e respostas
- Adiciona middleware (funcionalidades extras)
- Organiza seu código de forma limpa
Analogia:
Se Node.js é o motor do carro, Express é como ter direção hidráulica, ar condicionado e GPS. Você consegue dirigir sem, mas fica muito mais fácil e confortável com!
SQLite
Banco de dados simples e poderoso
O que é?
SQLite é um banco de dados que funciona como um arquivo no seu computador. É como ter um armário super organizado onde você guarda todas as informações!
Vantagens:
- Não precisa instalar servidor separado
- Funciona em qualquer computador
- Rápido e confiável
- Usado por apps famosos (WhatsApp, Skype)
Analogia:
Imagine uma biblioteca pessoal super organizada. Você pode guardar livros (dados), encontrar rapidamente qualquer um, emprestar para amigos, e tudo fica no seu quarto (seu projeto)!
🎯 Resumo: Por que essa combinação é perfeita?
Node.js + Express + SQLite é como ter um kit completo para iniciantes:
🌐 O que são APIs?
Entendendo APIs de Forma Simples
Uma API é como um garçom em um restaurante: você faz um pedido (requisição), o garçom leva para a cozinha (servidor), e traz de volta sua comida (resposta)!
🍽️ Exemplo Prático:
Você: "Quero ver todos os produtos da loja"
API: "Vou buscar no banco de dados..."
API: "Aqui estão todos os produtos!"
Por que APIs são Importantes?
- Permitem que aplicativos conversem entre si
- Facilitam o compartilhamento de dados
- Tornam o desenvolvimento mais rápido
- Permitem criar aplicativos móveis e web
Vantagens:
- Simplicidade
- Escalabilidade
- Flexibilidade
- Padrão amplamente aceito
Os 4 Tipos de Pedidos Básicos
Assim como no restaurante, existem 4 tipos básicos de pedidos que podemos fazer para uma API:
Como perguntar: "Me mostra o cardápio?"
Exemplo: Ver lista de produtos, buscar um usuário
GET /produtos → "Me mostra todos os produtos"
Como pedir: "Quero fazer um pedido novo"
Exemplo: Criar conta, adicionar produto
POST /usuarios → "Criar um usuário novo"
Como pedir: "Quero mudar meu pedido"
Exemplo: Atualizar perfil, editar produto
PUT /usuarios/1 → "Atualizar usuário 1"
Como pedir: "Cancela meu pedido"
Exemplo: Deletar conta, remover produto
DELETE /usuarios/1 → "Deletar usuário 1"
💡 Dica Importante:
Esses 4 tipos cobrem praticamente tudo que você vai fazer no backend! É como ter 4 ferramentas básicas que resolvem qualquer problema.
Como a API Responde: Códigos de Status
Assim como o garçom te diz se seu pedido deu certo ou não, a API sempre responde com um código que indica o que aconteceu:
✅ Deu Certo! (200s)
Como quando o garçom diz: "Seu pedido está pronto!"
⚠️ Você Errou (400s)
Como quando você pede algo que não existe no cardápio
💥 Servidor com Problema (500s)
Como quando a cozinha do restaurante quebra
🎯 Resumo Simples:
- 200s: Tudo funcionou perfeitamente!
- 400s: Você enviou algo errado
- 500s: O servidor teve um problema
⚙️ Middleware: Os "Ajudantes" do Express
O que é Middleware?
Imagine que você está em uma fila do banco. Antes de chegar no caixa, você passa por várias etapas: segurança, pegar senha, aguardar. Cada etapa é como um middleware!
🏦 Exemplo do Banco:
💡 No Express é Igual:
Cada middleware é uma "etapa" que acontece antes da sua API responder. Por exemplo:
- Verificar se o usuário está logado
- Registrar quem fez o pedido
- Verificar se os dados estão corretos
- Finalmente processar o pedido
Seu Primeiro Middleware
🎯 Vamos Começar Simples!
Imagine que você quer registrar toda vez que alguém visita sua API. É como um "livro de visitas"!
📝 Exemplo Super Simples:
// Este código "anota" toda visita
app.use((req, res, next) => {
console.log('🔔 Alguém visitou a API!');
console.log('⏰ Horário:', new Date());
// IMPORTANTE: sempre chamar next() para continuar
next();
});
🤔 O que Acontece?
- Alguém faz um pedido para sua API
- O middleware "anota" no console
- O
next()deixa o pedido continuar - Sua API responde normalmente
💡 Dica: Se você esquecer o next(), sua API vai "travar"!
📍 Onde Colocar o Middleware no VS Code
🎯 Local Correto: Arquivo app.js
O código do middleware deve ser colocado no arquivo principal da sua aplicação:
📁 Caminho: /meu-projeto-backend/app.js
📋 Ordem CORRETA no app.js:
const app = express())
app.use()) ← AQUI!
app.get(), app.post(), etc.)
app.listen())
💻 Exemplo Prático no VS Code:
Abra o arquivo /meu-projeto-backend/app.js e organize assim:
// /meu-projeto-backend/app.js
const express = require('express');
const db = require('./database');
const app = express();
// ✅ AQUI é onde você coloca os middlewares!
app.use(express.json()); // Middleware essencial
// Seu primeiro middleware personalizado
app.use((req, res, next) => {
console.log('🔔 Alguém visitou a API!');
console.log('⏰ Horário:', new Date());
next(); // IMPORTANTE: sempre chamar next()
});
// Rota de teste
app.get('/', (req, res) => {
res.json({ mensagem: 'API funcionando! 🚀' });
});
// ✅ Aqui você vai adicionar as operações CRUD seguindo os passos abaixo
app.listen(3000, () => {
console.log('Servidor rodando na porta 3000');
});
⚠️ Ordem Importante!
✅ CERTO: Middlewares ANTES das rotas
❌ ERRADO: Middlewares DEPOIS das rotas
💡 Por quê? Os middlewares são executados na ordem que você escreve!
🚀 Como Testar:
1. Salve o arquivo Ctrl + S
2. No terminal: node app.js
3. Acesse: http://localhost:3000
4. Veja as mensagens no terminal do VS Code!
Um Middleware que Você VAI Usar
📦 express.json() - O Mais Importante!
Este middleware é ESSENCIAL! Ele permite que sua API entenda dados JSON que chegam do frontend.
🔧 Como Usar:
// SEMPRE coloque esta linha no seu app.js
app.use(express.json());
// Agora sua API pode receber dados assim:
// { "nome": "João", "idade": 25 }
⚠️ Sem Isso, Sua API Não Funciona!
Se você esquecer o express.json():
- Dados do frontend chegam como
undefined - Você não consegue criar/atualizar dados
- Sua API vai dar erro!
💡 Lembre-se: Sempre use app.use(express.json()) no início!
🗄️ SQLite Básico para Backend
Como Conectar Node.js com SQLite
🔌 Primeiro: Instalar o SQLite
No terminal, dentro da pasta do seu projeto:
npm install sqlite3
📁 Segundo: Criar o Arquivo de Conexão
No VS Code, crie um novo arquivo:
📝 Como criar o arquivo:
1. No VS Code, clique com botão direito na pasta do projeto
2. Selecione "New File" (Novo Arquivo)
3. Digite o nome: database.js
4. Pressione Enter para criar
Caminho completo: /meu-projeto-backend/database.js
// /meu-projeto-backend/database.js
const sqlite3 = require('sqlite3').verbose();
// Criar/conectar com o banco de dados
const db = new sqlite3.Database('meuapp.db', (err) => {
if (err) {
console.error('❌ Erro ao conectar:', err.message);
} else {
console.log('✅ Conectado ao SQLite!');
}
});
// Criar tabela de usuários se não existir
db.run(`CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nome TEXT NOT NULL,
email TEXT UNIQUE NOT NULL,
data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP
)`);
module.exports = db;
🎯 Terceiro: Construindo o app.js Passo a Passo
📝 Como criar o app.js:
1. No VS Code, clique com botão direito na pasta do projeto
2. Selecione "New File" (Novo Arquivo)
3. Digite o nome: app.js
4. Pressione Enter para criar
Caminho completo: /meu-projeto-backend/app.js
📋 Sequência de Construção do app.js
Siga esta ordem exata para construir seu arquivo app.js. Copie cada passo sequencialmente:
✅ PASSO 1: Configuração inicial (imports, middlewares e rota de teste)
✅ PASSO 2: Operação READ (GET /usuarios)
✅ PASSO 3: Operação CREATE (POST /usuarios)
✅ PASSO 4: Operação UPDATE (PUT /usuarios/:id)
✅ PASSO 5: Operação DELETE (DELETE /usuarios/:id)
✅ PASSO 6: Iniciar servidor
Configuração Inicial
📝 O que faz: Importa bibliotecas, cria o app Express, configura middlewares e rota de teste
📍 Onde colar: Substitua TODO o conteúdo do arquivo app.js por este código
// /meu-projeto-backend/app.js
const express = require('express');
const db = require('./database'); // Importar a conexão
const app = express();
const PORT = 3000;
// Middleware essencial para APIs
app.use(express.json());
// Middleware personalizado (opcional)
app.use((req, res, next) => {
console.log('🔔 Alguém visitou a API!');
console.log('⏰ Horário:', new Date());
next(); // IMPORTANTE: sempre chamar next()
});
// Rota de teste
app.get('/', (req, res) => {
res.json({ mensagem: 'API funcionando! 🚀' });
});
// ✅ AQUI você vai adicionar as operações CRUD nos próximos passos
// Iniciar servidor (sempre por último)
app.listen(PORT, () => {
console.log(`🚀 Servidor rodando em http://localhost:${PORT}`);
});
💡 Teste: Salve o arquivo (Ctrl+S), execute node app.js e acesse http://localhost:3000
Operação READ (Listar Usuários)
📝 O que faz: Busca e retorna todos os usuários do banco de dados
📍 Onde adicionar: Substitua a linha // ✅ AQUI você vai adicionar as operações CRUD nos próximos passos por este código:
// === OPERAÇÃO READ (Buscar usuários) ===
app.get('/usuarios', (req, res) => {
db.all('SELECT * FROM usuarios', (err, rows) => {
if (err) {
res.status(500).json({ erro: err.message });
} else {
res.json({ usuarios: rows, total: rows.length });
}
});
});
🧪 Teste: Salve (Ctrl+S), reinicie o servidor e acesse http://localhost:3000/usuarios
Operação CREATE (Criar Usuário)
📝 O que faz: Cria um novo usuário no banco de dados
📍 Onde adicionar: Logo após a rota GET /usuarios (adicione uma linha em branco e cole este código)
// === OPERAÇÃO CREATE (Criar usuário) ===
app.post('/usuarios', (req, res) => {
const { nome, email } = req.body;
// Validação básica
if (!nome || !email) {
return res.status(400).json({ erro: 'Nome e email são obrigatórios' });
}
db.run('INSERT INTO usuarios (nome, email) VALUES (?, ?)', [nome, email], function(err) {
if (err) {
res.status(500).json({ erro: 'Erro ao criar usuário' });
} else {
res.json({
id: this.lastID,
nome,
email,
mensagem: 'Usuário criado com sucesso!'
});
}
});
});
🧪 Teste: Thunder Client → POST → URL: http://localhost:3000/usuarios → Body JSON: {"nome": "João", "email": "joao@email.com"}
Operação UPDATE (Atualizar Usuário)
📝 O que faz: Atualiza os dados de um usuário existente
📍 Onde adicionar: Logo após a rota POST /usuarios (adicione uma linha em branco e cole este código)
// === OPERAÇÃO UPDATE (Atualizar usuário) ===
app.put('/usuarios/:id', (req, res) => {
const { id } = req.params;
const { nome, email } = req.body;
// Validação
if (!nome || !email) {
return res.status(400).json({ erro: 'Nome e email são obrigatórios' });
}
db.run('UPDATE usuarios SET nome = ?, email = ? WHERE id = ?', [nome, email, id], function(err) {
if (err) {
res.status(500).json({ erro: 'Erro ao atualizar usuário' });
} else if (this.changes === 0) {
res.status(404).json({ erro: 'Usuário não encontrado' });
} else {
res.json({
id: parseInt(id),
nome,
email,
mensagem: 'Usuário atualizado com sucesso!'
});
}
});
});
🧪 Teste: Thunder Client → PUT → URL: http://localhost:3000/usuarios/1 → Body JSON: {"nome": "João Silva", "email": "joao.silva@email.com"}
Operação DELETE (Remover Usuário)
📝 O que faz: Remove um usuário do banco de dados
📍 Onde adicionar: Logo após a rota PUT /usuarios/:id (adicione uma linha em branco e cole este código)
// === OPERAÇÃO DELETE (Remover usuário) ===
app.delete('/usuarios/:id', (req, res) => {
const { id } = req.params;
db.run('DELETE FROM usuarios WHERE id = ?', [id], function(err) {
if (err) {
res.status(500).json({ erro: 'Erro ao deletar usuário' });
} else if (this.changes === 0) {
res.status(404).json({ erro: 'Usuário não encontrado' });
} else {
res.json({
id: parseInt(id),
mensagem: 'Usuário deletado com sucesso!'
});
}
});
});
🧪 Teste: Thunder Client → DELETE → URL: http://localhost:3000/usuarios/1 (sem Body JSON)
Arquivo app.js Completo
📝 Resultado final: Seu arquivo app.js deve estar assim após seguir todos os passos
📍 Verificação: Compare seu arquivo com este código completo
// === CONFIGURAÇÃO INICIAL ===
const express = require('express');
const sqlite3 = require('sqlite3').verbose();
const app = express();
const PORT = 3000;
// Conectar ao banco de dados
const db = new sqlite3.Database('./database.db');
// Middleware essencial
app.use(express.json());
// Middleware personalizado (log de requisições)
app.use((req, res, next) => {
console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);
next();
});
// === ROTA DE TESTE ===
app.get('/', (req, res) => {
res.json({ mensagem: '🚀 API funcionando!', timestamp: new Date() });
});
// === OPERAÇÃO READ (Buscar usuários) ===
app.get('/usuarios', (req, res) => {
db.all('SELECT * FROM usuarios', (err, rows) => {
if (err) {
res.status(500).json({ erro: err.message });
} else {
res.json({ usuarios: rows, total: rows.length });
}
});
});
// === OPERAÇÃO CREATE (Criar usuário) ===
app.post('/usuarios', (req, res) => {
const { nome, email } = req.body;
// Validação básica
if (!nome || !email) {
return res.status(400).json({ erro: 'Nome e email são obrigatórios' });
}
db.run('INSERT INTO usuarios (nome, email) VALUES (?, ?)', [nome, email], function(err) {
if (err) {
res.status(500).json({ erro: 'Erro ao criar usuário' });
} else {
res.json({
id: this.lastID,
nome,
email,
mensagem: 'Usuário criado com sucesso!'
});
}
});
});
// === OPERAÇÃO UPDATE (Atualizar usuário) ===
app.put('/usuarios/:id', (req, res) => {
const { id } = req.params;
const { nome, email } = req.body;
// Validação
if (!nome || !email) {
return res.status(400).json({ erro: 'Nome e email são obrigatórios' });
}
db.run('UPDATE usuarios SET nome = ?, email = ? WHERE id = ?', [nome, email, id], function(err) {
if (err) {
res.status(500).json({ erro: 'Erro ao atualizar usuário' });
} else if (this.changes === 0) {
res.status(404).json({ erro: 'Usuário não encontrado' });
} else {
res.json({
id: parseInt(id),
nome,
email,
mensagem: 'Usuário atualizado com sucesso!'
});
}
});
});
// === OPERAÇÃO DELETE (Remover usuário) ===
app.delete('/usuarios/:id', (req, res) => {
const { id } = req.params;
db.run('DELETE FROM usuarios WHERE id = ?', [id], function(err) {
if (err) {
res.status(500).json({ erro: 'Erro ao deletar usuário' });
} else if (this.changes === 0) {
res.status(404).json({ erro: 'Usuário não encontrado' });
} else {
res.json({
id: parseInt(id),
mensagem: 'Usuário deletado com sucesso!'
});
}
});
});
// === INICIAR SERVIDOR (sempre por último) ===
app.listen(PORT, () => {
console.log(`🚀 Servidor rodando em http://localhost:${PORT}`);
});
// === CONFIGURAÇÃO INICIAL ===
const express = require('express');
//const sqlite3 = require('sqlite3').verbose();
const app = express();
const PORT = 3000;
// Conectar ao banco de dados
//const db = new sqlite3.Database('./database.db');
const db = require('./database.js');
// Middleware essencial
app.use(express.json());
// Middleware personalizado (log de requisições)
app.use((req, res, next) => {
console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);
next();
});
// === ROTA DE TESTE ===
app.get('/', (req, res) => {
res.json({ mensagem: '🚀 API funcionando!', timestamp: new Date() });
});
// === OPERAÇÃO READ (Buscar usuários) ===
app.get('/usuarios', (req, res) => {
db.all('SELECT * FROM usuarios', (err, rows) => {
if (err) {
res.status(500).json({ erro: err.message });
} else {
res.json({ usuarios: rows, total: rows.length });
}
});
});
// === OPERAÇÃO CREATE (Criar usuário) ===
app.post('/usuarios', (req, res) => {
const { nome, email } = req.body;
// Validação básica
if (!nome || !email) {
return res.status(400).json({ erro: 'Nome e email são obrigatórios' });
}
db.run('INSERT INTO usuarios (nome, email) VALUES (?, ?)', [nome, email], function(err) {
if (err) {
res.status(500).json({ erro: 'Erro ao criar usuário' });
} else {
res.json({
id: this.lastID,
nome,
email,
mensagem: 'Usuário criado com sucesso!'
});
}
});
});
// === OPERAÇÃO UPDATE (Atualizar usuário) ===
app.put('/usuarios/:id', (req, res) => {
const { id } = req.params;
const { nome, email } = req.body;
// Validação
if (!nome || !email) {
return res.status(400).json({ erro: 'Nome e email são obrigatórios' });
}
db.run('UPDATE usuarios SET nome = ?, email = ? WHERE id = ?', [nome, email, id], function(err) {
if (err) {
res.status(500).json({ erro: 'Erro ao atualizar usuário' });
} else if (this.changes === 0) {
res.status(404).json({ erro: 'Usuário não encontrado' });
} else {
res.json({
id: parseInt(id),
nome,
email,
mensagem: 'Usuário atualizado com sucesso!'
});
}
});
});
// === OPERAÇÃO DELETE (Remover usuário) ===
app.delete('/usuarios/:id', (req, res) => {
const { id } = req.params;
db.run('DELETE FROM usuarios WHERE id = ?', [id], function(err) {
if (err) {
res.status(500).json({ erro: 'Erro ao deletar usuário' });
} else if (this.changes === 0) {
res.status(404).json({ erro: 'Usuário não encontrado' });
} else {
res.json({
id: parseInt(id),
mensagem: 'Usuário deletado com sucesso!'
});
}
});
});
// === INICIAR SERVIDOR (sempre por último) ===
app.listen(PORT, () => {
console.log(`🚀 Servidor rodando em http://localhost:${PORT}`);
});
✅ Pronto! Se você seguiu todos os passos, seu arquivo deve ter todas as operações CRUD funcionando. Execute: node app.js
✅ Arquivo app.js Completo
1. Salve o arquivo completo (Ctrl+S)
2. No terminal do VS Code (Ctrl + `), digite:
node app.js
3. Você deve ver: "🚀 Servidor rodando em http://localhost:3000"
4. Teste no navegador: http://localhost:3000
📊 Resumo das Operações CRUD
Agora que você construiu o app.js seguindo o passo a passo acima, aqui está um resumo das 4 operações básicas implementadas:
📖 READ (Listar)
Método: GET
URL: /usuarios
Função: Lista todos os usuários
Teste: Navegador ou Thunder Client
➕ CREATE (Criar)
Método: POST
URL: /usuarios
Função: Cria novo usuário
Teste: Thunder Client + Body JSON
✏️ UPDATE (Atualizar)
Método: PUT
URL: /usuarios/:id
Função: Atualiza usuário existente
Teste: Thunder Client + Body JSON
🗑️ DELETE (Deletar)
Método: DELETE
URL: /usuarios/:id
Função: Remove usuário
Teste: Thunder Client (sem Body)
💡 Dica: Essas 4 operações (CRUD) são a base de qualquer aplicação backend! Você já implementou todas seguindo o passo a passo acima.
📍 Onde Colocar Cada Operação no VS Code
Agora que você viu os códigos, vamos aprender onde exatamente colocar cada operação no seu projeto!
🗂️ Arquivo Principal: /meu-projeto-backend/app.js
Todas as operações CRUD devem ser adicionadas neste arquivo, seguindo esta ordem:
📝 Onde: No arquivo /meu-projeto-backend/app.js
📍 Posição: Após app.use(express.json()); e antes de app.listen()
💡 Dica VS Code: Posicione o cursor após a linha do middleware e pressione Enter para criar uma nova linha
📝 Onde: No arquivo /meu-projeto-backend/app.js
📍 Posição: Logo após a rota POST (CREATE) que você acabou de adicionar
💡 Dica VS Code: Use Ctrl+D para selecionar palavras iguais e editar rapidamente
📝 Onde: No arquivo /meu-projeto-backend/app.js
📍 Posição: Logo após a rota GET (READ) que você acabou de adicionar
💡 Dica VS Code: Use Ctrl+C e Ctrl+V para copiar e colar, depois edite
📝 Onde: No arquivo /meu-projeto-backend/app.js
📍 Posição: Logo após a rota PUT (UPDATE) que você acabou de adicionar
💡 Dica VS Code: Use Ctrl+S para salvar após cada rota adicionada
⚠️ Dicas Importantes para o VS Code:
- Ordem importa: Sempre adicione as rotas na ordem: POST → GET → PUT → DELETE
- Indentação: Use Tab ou 4 espaços para manter o código organizado
- Salvar sempre: Pressione Ctrl+S após adicionar cada rota
- Terminal: Use Ctrl+` para abrir o terminal e testar
- Reiniciar servidor: Pressione Ctrl+C no terminal e rode
node app.jsnovamente após mudanças
🧪 Como Testar Cada Operação:
✅ CREATE (POST)
Thunder Client → POST → Body JSON
👀 READ (GET)
Navegador ou Thunder Client → GET
✏️ UPDATE (PUT)
Thunder Client → PUT → Body JSON
🗑️ DELETE
Thunder Client → DELETE → Sem Body
🧪 Como Testar sua API no VS Code
Agora que criamos nossa API, precisamos testá-la! Vamos usar o Thunder Client (extensão do VS Code) que substitui o Postman.
🔧 Configurando Extensões Essenciais no VS Code
⚡ Thunder Client (para testar APIs)
Instalar: Ctrl+Shift+X → pesquise "Thunder Client" → Instalar
Usar: Clique no ícone ⚡ na barra lateral esquerda do VS Code
Criar requisição: Clique em "New Request" na aba Thunder Client
🗄️ SQLite (por alexcvzz - para visualizar tabelas)
Instalar: Ctrl+Shift+X → pesquise "SQLite" → escolha a extensão do "alexcvzz"
Usar: Clique com botão direito no arquivo .db → "Open Database"
Visualizar: Veja suas tabelas e dados na aba "SQLite Explorer"
💡 Dica: Com essa extensão você pode ver suas tabelas SQLite diretamente no VS Code, sem precisar de programas externos!
🌐 Testando no Navegador (GET)
Para testar rotas GET rapidamente, você pode usar o próprio navegador:
http://localhost:3000/usuarios
💡 Dica VS Code: Pressione Ctrl+` para abrir o terminal e iniciar seu servidor!
⚡ Testando com Thunder Client (POST, PUT, DELETE)
Para outros métodos, use o Thunder Client integrado no VS Code:
URL: http://localhost:3000/usuarios
Body (JSON):
"nome": "João Silva",
"email": "joao@email.com"
}
No Thunder Client: Selecione "POST", cole a URL, vá na aba "Body" → "JSON" e cole o JSON acima
URL: http://localhost:3000/usuarios/1
No Thunder Client: Selecione "PUT", cole a URL com o ID do usuário
URL: http://localhost:3000/usuarios/1
No Thunder Client: Selecione "DELETE", cole a URL com o ID do usuário
🎯 Passo a passo no Thunder Client:
- Abra Thunder Client (ícone ⚡ na barra lateral)
- Clique em "New Request"
- Escolha o método (GET, POST, PUT, DELETE)
- Digite a URL da sua API
- Se for POST/PUT, vá na aba "Body" → "JSON" e adicione os dados
- Clique em "Send" para enviar a requisição
- Veja a resposta na parte inferior da tela
📝 Exercícios Práticos para Iniciantes
Exercício 1: Criando sua Primeira API de Tarefas
Vamos criar uma API simples para gerenciar uma lista de tarefas (To-Do List).
🎯 Objetivo:
Criar uma API que permita adicionar, listar, atualizar e remover tarefas.
📁 Estrutura Atual do Projeto:
Passo 1: Atualizar o database.js
📝 Edite o arquivo: /meu-projeto-backend/database.js
Adicione esta tabela após a tabela de usuários:
// /meu-projeto-backend/database.js
// ... código existente ...
// Adicione esta nova tabela:
db.run(`CREATE TABLE IF NOT EXISTS tarefas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descricao TEXT,
concluida BOOLEAN DEFAULT 0,
data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP
)`);
module.exports = db;
Passo 2: Adicionar rotas no app.js
📝 Edite o arquivo: /meu-projeto-backend/app.js
Adicione estas rotas após as rotas de usuários:
// === ROTAS PARA TAREFAS ===
// Listar todas as tarefas
app.get('/tarefas', (req, res) => {
db.all('SELECT * FROM tarefas ORDER BY data_criacao DESC', (err, rows) => {
if (err) {
res.status(500).json({ erro: err.message });
} else {
res.json({ tarefas: rows, total: rows.length });
}
});
});
// Criar nova tarefa
app.post('/tarefas', (req, res) => {
const { titulo, descricao } = req.body;
// Validação básica
if (!titulo || titulo.trim() === '') {
return res.status(400).json({ erro: 'Título é obrigatório' });
}
db.run('INSERT INTO tarefas (titulo, descricao) VALUES (?, ?)', [titulo, descricao], function(err) {
if (err) {
res.status(500).json({ erro: err.message });
} else {
res.json({
id: this.lastID,
titulo,
descricao,
mensagem: 'Tarefa criada com sucesso!'
});
}
});
});
🧪 Como testar:
1. Reiniciar o servidor:
node app.js
2. Testar no navegador: http://localhost:3000/tarefas
3. Testar POST no Thunder Client:
URL: http://localhost:3000/tarefas
Método: POST
Body (JSON):
{"titulo": "Estudar Node.js", "descricao": "Aprender backend"}
✅ Resultado esperado: Você deve conseguir listar e criar tarefas usando sua API!
Exercício 2: Completando a API com PUT e DELETE
Agora vamos completar nossa API adicionando as rotas para atualizar e deletar tarefas.
🎯 Objetivo:
Adicionar rotas PUT (atualizar) e DELETE (remover) para completar o CRUD.
Passo 1: Adicionar rota PUT (atualizar tarefa)
📝 No arquivo: /meu-projeto-backend/app.js
Adicione após as rotas existentes de tarefas:
// Atualizar tarefa (marcar como concluída ou editar)
app.put('/tarefas/:id', (req, res) => {
const { id } = req.params;
const { titulo, descricao, concluida } = req.body;
// Validação
if (!titulo || titulo.trim() === '') {
return res.status(400).json({ erro: 'Título é obrigatório' });
}
db.run(
'UPDATE tarefas SET titulo = ?, descricao = ?, concluida = ? WHERE id = ?',
[titulo, descricao, concluida || 0, id],
function(err) {
if (err) {
res.status(500).json({ erro: err.message });
} else if (this.changes === 0) {
res.status(404).json({ erro: 'Tarefa não encontrada' });
} else {
res.json({
id: parseInt(id),
titulo,
descricao,
concluida: concluida || 0,
mensagem: 'Tarefa atualizada com sucesso!'
});
}
}
);
});
Passo 2: Adicionar rota DELETE (remover tarefa)
📝 No mesmo arquivo: /meu-projeto-backend/app.js
Adicione após a rota PUT:
// Deletar tarefa
app.delete('/tarefas/:id', (req, res) => {
const { id } = req.params;
db.run('DELETE FROM tarefas WHERE id = ?', [id], function(err) {
if (err) {
res.status(500).json({ erro: err.message });
} else if (this.changes === 0) {
res.status(404).json({ erro: 'Tarefa não encontrada' });
} else {
res.json({
id: parseInt(id),
mensagem: 'Tarefa removida com sucesso!'
});
}
});
});
🧪 Como testar no Thunder Client:
Testar PUT (atualizar):
URL: http://localhost:3000/tarefas/1
Método: PUT
Body (JSON):
{"titulo": "Estudar Node.js - CONCLUÍDO", "descricao": "Aprender backend", "concluida": 1}
Testar DELETE (remover):
URL: http://localhost:3000/tarefas/1
Método: DELETE
Body: Não precisa (deixe vazio)
✅ Parabéns! Agora você tem uma API completa com CRUD (Create, Read, Update, Delete)!
Exercício 3: Testando e Validando a API Completa
Agora vamos testar nossa API completa e adicionar validações importantes.
🎯 Objetivo:
Testar todas as rotas da API e adicionar validações de segurança.
Passo 1: Adicionar validações de segurança
📝 No arquivo: /meu-projeto-backend/app.js
Adicione estas validações após as importações:
// Middleware para validar ID numérico
function validarId(req, res, next) {
const { id } = req.params;
if (isNaN(id) || id <= 0) {
return res.status(400).json({ erro: 'ID deve ser um número válido' });
}
next();
}
// Middleware para validar dados da tarefa
function validarTarefa(req, res, next) {
const { titulo } = req.body;
if (!titulo || titulo.trim() === '') {
return res.status(400).json({ erro: 'Título é obrigatório' });
}
if (titulo.length > 100) {
return res.status(400).json({ erro: 'Título muito longo (máximo 100 caracteres)' });
}
next();
}
Passo 2: Aplicar validações nas rotas
Atualize suas rotas para usar as validações:
// Atualizar as rotas existentes:
app.post('/tarefas', validarTarefa, (req, res) => { /* código existente */ });
app.put('/tarefas/:id', validarId, validarTarefa, (req, res) => { /* código existente */ });
app.delete('/tarefas/:id', validarId, (req, res) => { /* código existente */ });
Passo 3: Testes completos no navegador
🌐 Testes no navegador:
1. Listar tarefas: http://localhost:3000/tarefas
2. Buscar tarefa específica: http://localhost:3000/tarefas/1
3. Testar rota inválida: http://localhost:3000/tarefas/abc (deve retornar erro)
Passo 4: Testes completos no Thunder Client
⚡ Sequência de testes no Thunder Client:
Teste 1 - Criar tarefa válida:
POST http://localhost:3000/tarefas
{"titulo": "Aprender Express", "descricao": "Estudar rotas e middleware"}
Teste 2 - Tentar criar tarefa inválida:
POST http://localhost:3000/tarefas
{"titulo": "", "descricao": "Sem título"}
Deve retornar erro 400
Teste 3 - Atualizar tarefa:
PUT http://localhost:3000/tarefas/1
{"titulo": "Aprender Express - CONCLUÍDO", "concluida": 1}
Teste 4 - Tentar atualizar com ID inválido:
PUT http://localhost:3000/tarefas/abc
Deve retornar erro 400
Teste 5 - Deletar tarefa:
DELETE http://localhost:3000/tarefas/1
Deve confirmar remoção
💡 Dica importante:
Sempre teste os casos de erro! Uma boa API deve tratar entradas inválidas e retornar mensagens claras.
🎉 Excelente! Sua API agora está completa, validada e testada. Você aprendeu os fundamentos do desenvolvimento backend!
🚀 Próximos Passos
O que você aprendeu hoje
✅ Conceitos Básicos
- O que é backend e sua importância
- Como funcionam as APIs
- Os 4 tipos de pedidos básicos (GET, POST, PUT, DELETE)
- Como APIs respondem com códigos de status
- O que são middleware e como usar
🛠️ Habilidades Práticas
- Conectar Node.js com SQLite
- Criar operações CRUD básicas
- Testar APIs no navegador e Postman
- Implementar validações simples
- Organizar código de forma básica
🎓 Na próxima aula você vai aprender:
- Como conectar diferentes tabelas no banco de dados
- Conceitos de segurança básica
- Como organizar melhor seu código
- Tratamento de erros mais avançado
- Como fazer deploy da sua API
🧪 Simulador de API REST
Teste suas APIs
Use este simulador para entender como as APIs REST funcionam na prática.