SQLite Backend para Iniciantes

Primeiros Passos no Desenvolvimento Backend

📁 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:

1

Criar pasta do projeto

Crie uma pasta chamada meu-projeto-backend na sua Área de Trabalho

2

Abrir no VS Code

Clique com botão direito na pasta → "Abrir com Code" ou arraste a pasta para o VS Code

3

Abrir terminal integrado

No VS Code: Ctrl + ` (acento grave) ou Menu → Terminal → New Terminal

4

Inicializar projeto Node.js

npm init -y

Isso cria o arquivo package.json automaticamente

5

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)!

✅ Vantagens para iniciantes:
Se você já sabe JavaScript, já está 50% do caminho andado!
🚀

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!

✅ Por que é perfeito para iniciantes:
Com 3 linhas de código você já tem um servidor funcionando!
🗄️

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)!

✅ Ideal para aprender:
Zero configuração! Funciona na hora, sem complicação.

🎯 Resumo: Por que essa combinação é perfeita?

Node.js + Express + SQLite é como ter um kit completo para iniciantes:

Node.js
Roda seu código JavaScript
Express
Organiza suas rotas e APIs
SQLite
Guarda seus dados com segurança

🌐 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:

GET 📖 VER/BUSCAR

Como perguntar: "Me mostra o cardápio?"

Exemplo: Ver lista de produtos, buscar um usuário

GET /produtos → "Me mostra todos os produtos"
POST ➕ CRIAR/ADICIONAR

Como pedir: "Quero fazer um pedido novo"

Exemplo: Criar conta, adicionar produto

POST /usuarios → "Criar um usuário novo"
PUT ✏️ ATUALIZAR

Como pedir: "Quero mudar meu pedido"

Exemplo: Atualizar perfil, editar produto

PUT /usuarios/1 → "Atualizar usuário 1"
DELETE 🗑️ DELETAR

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)

200 "Tudo OK!" 👍
201 "Criado com sucesso!" ✨

Como quando o garçom diz: "Seu pedido está pronto!"

⚠️ Você Errou (400s)

400 "Não entendi seu pedido" 🤔
404 "Não encontrei isso" 🔍

Como quando você pede algo que não existe no cardápio

💥 Servidor com Problema (500s)

500 "Algo quebrou aqui" 🔧
503 "Estamos fechados" 🚫

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:

👤 Você chega
🛡️ Segurança
🎫 Pegar senha
💰 Caixa
✅ Sair

💡 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?

  1. Alguém faz um pedido para sua API
  2. O middleware "anota" no console
  3. O next() deixa o pedido continuar
  4. 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:

1 Imports (require) - Importar bibliotecas
2 Criar app (const app = express())
3 Middlewares (app.use()) ← AQUI!
4 Rotas (app.get(), app.post(), etc.)
5 Iniciar servidor (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

PASSO 1
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

PASSO 2
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

PASSO 3
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"}

PASSO 4
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"}

PASSO 5
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)

PASSO 6
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:

// 1. Imports (no topo do arquivo)
const express = require('express');
const db = require('./database');
// 2. Criar app
const app = express();
// 3. Middlewares
app.use(express.json());
// 👇 AQUI você adiciona suas rotas CRUD (uma por vez)
// ✅ Suas operações CREATE, READ, UPDATE, DELETE
// 4. Iniciar servidor (sempre por último)
app.listen(3000, () => console.log('Servidor rodando...'));
CREATE 1. Adicionar rota POST

📝 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

READ 2. Adicionar rota GET

📝 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

UPDATE 3. Adicionar rota PUT

📝 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

DELETE 4. Adicionar rota DELETE

📝 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.js novamente 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)
1

Instalar: Ctrl+Shift+X → pesquise "Thunder Client" → Instalar

2

Usar: Clique no ícone ⚡ na barra lateral esquerda do VS Code

3

Criar requisição: Clique em "New Request" na aba Thunder Client

🗄️ SQLite (por alexcvzz - para visualizar tabelas)
1

Instalar: Ctrl+Shift+X → pesquise "SQLite" → escolha a extensão do "alexcvzz"

2

Usar: Clique com botão direito no arquivo .db → "Open Database"

3

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:

POST Criar novo usuário

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

PUT Atualizar usuário

URL: http://localhost:3000/usuarios/1

No Thunder Client: Selecione "PUT", cole a URL com o ID do usuário

DELETE Deletar 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:
  1. Abra Thunder Client (ícone ⚡ na barra lateral)
  2. Clique em "New Request"
  3. Escolha o método (GET, POST, PUT, DELETE)
  4. Digite a URL da sua API
  5. Se for POST/PUT, vá na aba "Body" → "JSON" e adicione os dados
  6. Clique em "Send" para enviar a requisição
  7. 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:

📂 meu-projeto-backend/
📄 package.json
📄 app.js ← vamos editar
📄 database.js ← vamos editar
📄 meuapp.db ← banco de dados

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.

Fazer Requisição

Resposta da API

Faça uma requisição para ver a resposta aqui...

Dados Atuais (Simulados)

Usuários cadastrados:
1. João Silva - joao@email.com
2. Maria Santos - maria@email.com
3. Pedro Costa - pedro@email.com