API com Node.js
Parte 1: Criando o banco de dados
Se você já possui um banco de dados MySQL, ok, use ele e pule para a próxima parte.
Se você não possui um banco MySQL, você tem duas opções:
- baixar e instalar o MySQL (gratuito) na sua máquina;
- contratar um banco MySQL na nuvem (gratuito, vou te ensinar abaixo);
A primeira opção é um pouco mais trabalhosa, porém te dá mais liberdade. Baixe, instale e crie um novo banco de dados para uso nesse tutorial. Durante a instalação, você irá precisar definir uma senha para o usuário ‘root’, não esqueça dela.
A segunda opção é bem simples também, mais vai exigir que você tenha conexão com a Internet enquanto estiver programando pois seu banco vai estar na nuvem. Na Umbler, startup que já trabalhei há alguns anos, você pode criar bancos MySQL gratuitos de até 1GB, para testes e estudos.
Para isso, basta você criar um site que custa R$6/mês, mas não se preocupe com o valor, você ganha créditos de graça para usar livremente conforme vai cumprindo algumas etapas dentro do painel e mais tarde, se não quiser mais mantê-lo, basta excluir ele (ou parar o site para reduzir os custos).
Crie um site com um domínio qualquer (mesmo que não tenha registrado) e depois vá na parte de banco de dados para criar um do tipo MySQL e escolha a opção Grátis (1GB) e habilite o acesso externo, como na imagem abaixo. Durante a criação do seu banco, você vai definir o nome dele, o usuário e a senha, anote tudo, bem como o endereço do servidor que a Umbler vai te fornecer.
Parte 2: Criando e populando a tabela
Agora que você já tem o banco pronto, vamos criar uma tabela nele e colocar alguns dados de exemplo. Não pule esta etapa pois vamos fazer tudo isso usando Node.js!
Crie uma pasta para guardar os arquivos do seu projeto Node.js, você pode fazer isso pelo console se quiser, usaremos ele algumas vezes nesse tutorial. No exemplo abaixo, criei a pasta e depois entrei dentro dela.
> mkdir nodemysql
> cd nodemysqlAgora execute no console o comando “npm init” que o próprio NPM (gerenciador de pacotes do Node) vai te guiar para a construção do arquivo package.json, que é o arquivo de configuração do projeto. Se ficar em dúvida ou com preguiça, segue o meu package.json abaixo:
{
"name": "nodemysql",
"version": "1.0.0",
"description": "tutorial de node com mysql",
"main": "index.js",
"scripts": {
"test": "echo " Error: no test specified" && exit 1"
},
"author": "luiztools",
"license": "ISC"
}Com o arquivo de configurações criado, vá no console novamente, na pasta do projeto e digite o seguinte comando para instalar a extensão mysql, que permite usar Node com MySQL:
nodemysql> npm install mysqlAgora, crie um arquivo create-table.js dentro dessa pasta, que será o arquivo que vai criar e popular nossa tabela que usaremos neste exercícios. Também usaremos ele para entender o básico de comandos SQL, conexão com o banco, etc. Vamos começar nosso create-table.js definindo uma constante para a String de conexão com o banco e uma constante para o objeto que vai carregar a extensão mysql (e que mais tarde usaremos para conectar, executar SQL, etc). O código abaixo é auto explicativo:
const mysql = require('mysql');
const connection = mysql.createConnection({
host : 'XXX',
port : XXX,
user : 'XXX',
password : 'XXX',
database : 'XXX'
});Agora, usaremos esse objeto connection para fazer uma conexão e, em caso de sucesso, imprimir uma mensagem de sucesso. Caso contrário, se der erro, uma mensagem de falha:
connection.connect(function(err){
if(err) return console.log(err);
console.log('conectou!');
})Se esse código lhe parece muito bizarro, calma, é fácil de entender. O objeto connection permite que façamos coisas no banco de dados, uma delas é a conexão (connect). No entanto, o Node.js trabalha de maneira assíncrona, o que quer dizer que ele não espera pela conexão ser estabelecida. Quando ele terminar de estabelecer a conexão, ele vai executar a função de callback passada por parâmetro, contendo ou não um objeto de erro.
Para executar esse arquivo, abra o console (se estiver usando VS Code, apenas aperta F5 com este arquivo aberto no editor) e na pasta do projeto digite:
nodemysql> node create-table.jsAgora que sabemos como conectar no MySQL através de Node.js, é hora de executarmos o comando que vai criar a tabela e popular ela, ao invés de simplesmente imprimir “conectou”. Sendo assim, vamos criar uma função JS nesse arquivo pra fazer a criação da tabela:
function createTable(conn){
const sql = "CREATE TABLE IF NOT EXISTS Clientes (n"+
"ID int NOT NULL AUTO_INCREMENT,n"+
"Nome varchar(150) NOT NULL,n"+
"CPF char(11) NOT NULL,n"+
"PRIMARY KEY (ID)n"+
");";
conn.query(sql, function (error, results, fields){
if(error) return console.log(error);
console.log('criou a tabela!');
});
}Coloque a chamada desta função no callback após a conexão no banco, passando o objeto conn por parâmetro, como abaixo:
connection.connect(function(err){
if(err) return console.log(err);
console.log('conectou!');
createTable(connection);
})Mande rodar esse arquivo novamente e verá que ele criará a sua tabela com sucesso. Para adicionar algumas linhas de exemplo, vamos criar outra função que vai fazer um bulk insert no MySQL via Node.js (inserção de várias linhas de uma vez):
function addRows(conn) {
const sql = "INSERT INTO Clientes(Nome,CPF) VALUES ?";
const values = [['teste1', '12345678901'], ['teste1', '09876543210'], ['teste3', '12312312399']];
conn.query(sql, [values], function (error, results, fields) {
if (error) return console.log(error); console.log('adicionou registros!'); conn.end();//fecha a conexão
});
}Essa função deve ser chamada dentro do callback da query que criou a tabela, logo abaixo de onde diz “console.log(‘criou a tabela!’);”. Se não quiser fazer isso dessa maneira, você pode fazer pela sua ferramenta de gerenciamento do MySQL (como o MySQL Workbench) ou pelo Visual Studio, se estiver usando ele para programar Node.js.
Parte 3: Criando a API
Agora que já temos nosso banco de dados MySQL pronto, com dados de exemplo e aprendemos como fazer a conexão nele, vamos criar uma API básica usando Express para conseguir criar um CRUD com Node.js + MySQL no próximo passo. Se já sabe como montar uma API básica com Node + Express, pule esta parte.
Vamos começar adicionando a dependência do Express (framework web) e do Body-Parser (parser para os POSTs futuros) no projeto via linha de comando na pasta do mesmo:
nodesqlserver> npm install express body-parserNa sequência, vamos criar um arquivo index.js na pasta do projeto onde vamos criar o nosso servidor da API para tratar as requisições que chegarão em breve. Vamos começar bem simples, apenas definindo as constantes locais que serão usadas mais pra frente:
const express = require('express');
const app = express();
const bodyParser = require('body-parser');
const port = 3000; //porta padrão
const mysql = require('mysql');Agora, logo abaixo, vamos configurar nossa aplicação (app) Express para usar o body parser que carregamos da biblioteca body-parser, permitindo que recebamos mais tarde POSTs nos formatos URLEncoded e JSON:
//configurando o body parser para pegar POSTS mais tarde
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());Na sequência, vamos criar um roteador e dentro dele definir uma regra inicial que apenas exibe uma mensagem de sucesso quando o usuário requisitar um GET na raiz da API (/) para ver se está funcionando.
//definindo as rotas
const router = express.Router();
router.get('/', (req, res) => res.json({ message: 'Funcionando!' }));
app.use('/', router);Note que na última linha eu digo que requisições que chegarem na raiz devem ser mandadas para o router. Por fim, adicionamos as linhas abaixo no final do arquivo que dão o start no servidor da API:
//inicia o servidor
app.listen(port);
console.log('API funcionando!');Teste sua API executando via console o seu index.js com o comando ‘node index.js’. Você deve ver a mensagem de ‘API funcionando!’ no console, e se acessar no navegador localhost:3000 deve ver o JSON default que deixamos na rota raiz!
Parte 4: Criando a listagem de clientes
Agora que temos uma API funcionando, vamos adicionar uma rota /clientes que listará todos os clientes do banco de dados. Para fazer isso, primeiro vamos criar uma função que executará consultas SQL no banco usando uma conexão que será criada a cada uso (existem técnicas mais avançadas para maior performance, mas por ora, isso resolve satisfatoriamente), como abaixo:
function execSQLQuery(sqlQry, res){
const connection = mysql.createConnection({
host : 'XXX',
port : XXX,
user : 'XXX',
password : 'XXX',
database : 'XXX'
});
connection.query(sqlQry, function(error, results, fields){
if(error)
res.json(error);
else
res.json(results);
connection.end();
console.log('executou!');
});
}Esta função pode ficar no final do seu arquivo index.js e nós a usaremos para fazer todas as operações de banco de dados da nossa API, começando com consultar todos os clientes. Para isso, começaremos criando a rota /clientes logo abaixo da rota / (raiz):
router.get('/clientes', (req, res) =>{
execSQLQuery('SELECT * FROM Clientes', res);
})Agora, ao executarmos novamente nosso projeto e ao acessarmos a URL localhost:3000/clientes, veremos todos os clientes cadastrados no banco de dados (no passo 2, lembra?):
E com isso finalizamos a listagem de todos clientes na nossa API!
Parte 5: Criando a pesquisa de um cliente
Agora, se o usuário quiser ver apenas um cliente, ele deverá passar o ID do mesmo na URL, logo após o /clientes. Para fazer isso, vamos modificar nossa rota criada no passo anterior, /clientes, para aceitar um parâmetro opcional ID. Além disso, dentro do processamento da rota, se vier o ID, devemos fazer uma consulta diferente da anterior, como mostra o código abaixo, com os ajustes na mesma rota do passo anterior:
router.get('/clientes/:id?', (req, res) =>{
let filter = '';
if(req.params.id) filter = ' WHERE ID=' + parseInt(req.params.id);
execSQLQuery('SELECT * FROM Clientes' + filter, res);
})O parseInt que coloquei é apenas uma proteção contra SQL Injection uma vez que neste caso o ID deve ser um inteiro válido. Não é a melhor forma de resolver isso, mas vai nos atender por enquanto sem ter de entrar em conceitos mais avançados. Manda rodar e teste no navegador, verá que está funcionando perfeitamente!
E com isso terminamos a pesquisa por cliente.
Parte 6: Excluindo um cliente
Para excluir um cliente vamos fazer um processo parecido com o de pesquisar um cliente, no entanto, mudaremos o verbo HTTP de GET para DELETE, como manda o protocolo. Adicione a nova rota logo após as demais:
router.delete('/clientes/:id', (req, res) =>{
execSQLQuery('DELETE FROM Clientes WHERE ID=' + parseInt(req.params.id), res);
})Note que desta vez o parâmetro id na URL não é opcional (não usei ? após :id). E dentro do processamento da requisição delete do router eu mando um SQL de DELETE passando o ID numérico.
Para testar essa rota você tem duas alternativas, ou usa o POSTMAN para forjar um DELETE, como abaixo:
Ou fazer via console usando cURL (se tiver ele instalado na sua máquina):
> curl -X DELETE http://localhost:3000/clientes/1Em ambos os casos você deve obter uma resposta 200 OK (caso não tenha dado erro) e se mandar listar todos clientes novamente, verá que o número 1 sumiu.
Parte 7: Adicionando um cliente
Agora vamos adicionar um novo cliente com um POST na rota /clientes. Adicione esta nova rota logo abaixo das anteriores.
router.post('/clientes', (req, res) =>{
const nome = req.body.nome.substring(0,150);
const cpf = req.body.cpf.substring(0,11);
execSQLQuery(`INSERT INTO Clientes(Nome, CPF) VALUES('${nome}','${cpf}')`, res);
});Nela, eu pego as variáveis que devem vir junto ao POST, faço algumas validações de tamanho e tipo de dado e depois junto elas a um comando de INSERT que vai ser executado no banco de dados.
Para testar esse POST, você usar o POSTMAN, como mostrado anteriormente:
Se quiser fazer via cURL:
> curl -X POST -d "nome=luiz&cpf=12345678901" http://localhost:3000/clientesTambém podemos permitir outras maneiras de passar os dados com a requisição POST, como através de JSON ou através da URL, mas isso foge do escopo deste artigo que deve focar mais no CRUD com MySQL + Node.
Se testar agora vai ver que é possível inserir novos registros no banco de dados através de requisições POST.
Parte 8: Atualizando um cliente
E para finalizar o CRUD, vamos ver como podemos atualizar um cliente no banco de dados SQL Server através da nossa API Node.js. Para fazer updates podemos usar os verbos PUT ou PATCH. O protocolo diz que devemos usar PUT se pretendemos passar todos os parâmetros da entidade que está sendo atualizada, mas não vamos alterar jamais o ID, então usaremos PATCH nesta API.
Crie uma rota PATCH em /clientes esperando o ID do cliente a ser alterado.
router.patch('/clientes/:id', (req, res) =>{
const id = parseInt(req.params.id);
const nome = req.body.nome.substring(0,150);
const cpf = req.body.cpf.substring(0,11);
execSQLQuery(`UPDATE Clientes SET Nome='${nome}', CPF='${cpf}' WHERE ID=${id}`, res);
})No código acima, pegamos o ID que veio na URL e as demais informações que vieram no corpo da requisição, fazendo as mesmas validações que já havia feito antes (podemos melhorar a segurança aqui). Depois monto o UPDATE com as variáveis locais e mando para nossa função de executar SQL.
Para testar uma requisição PATCH, você pode usar o POSTMAN:
Ou o cURL:
> cURL -X PATCH -d "nome=fernando&cpf=12345678901" http://localhost:3000/clientes/4O resultado é o mesmo: o cliente cujo ID=4 vai ter o seu nome alterado para ‘fernando’. Note que se ele não existir, ocasionará um erro que será apresentado no corpo da resposta.
E com isso finalizamos o CRUD da nossa API Node.js que usa MySQL como persistência de dados.
Bônus 1: ORM
Se você não curte muito a ideia de ficar usando SQL no meio dos seus códigos JS, experimente usar alguma biblioteca ORM (Object-Relational Mapping) como o Sequelize.
Bônus 2: Boas práticas
Não quis deixar o tutorial muito extenso e por isso deixei de passar algumas boas práticas.
SQL Injection
O código que forneci nos exemplos concatenando strings para formar uma query SQL deixa uma brecha potencialmente nociva no código da sua API chamada SQL Injection. Para evitar isso, você pode usar ‘?’ no lugar das variáveis que devem ser substituídas e passar um array de variáveis para substituição como segundo parâmetro da função query.
Para um dado comando SQL como:
const consulta = "SELECT * FROM tabela WHERE id = ?";note que coloquei o ‘?’ no lugar do valor do id, e poderia fazer isso para quantos filtros minha consulta tiver. Agora, quando chamar a função query do módulo mysql, farei da seguinte forma, passando um array de variáveis/valores para preencher esses ‘?’, na mesma ordem que foram descritos na consulta:
conn.query(consulta, [id], callback);Dessa forma, meu código não fica mais suscetível à SQL Injection!
Conexões auto-gerenciadas
No código que forneci, nós temos total controle sobre a abertura e fechamento de conexões. Como boa prática, você pode deixar para a própria função query se encarregar de abrir e fechar essas conexões, se livrando desse “microgerenciamento”.
Em meus testes pessoais notei que isso pode ser melhor ou pior que o exemplo que mostrei no tutorial, considerando peculiaridades da sua infraestrutura de MySQL. Na dúvida, o meu código não tem a melhor performance, mas a garantia de funcionamento mesmo em hospedagens compartilhadas, onde não temos tanto controle das configurações do MySQL.
SELECT *
A menos que você sempre vá usar todas as informações da sua tabela, jamais use SELECT *, mas sim a versão extensão da consulta SQL em que você passa todas as colunas da tabela que deseja retornar. Pense em um SELECT como sendo um download do seu banco de dados, quanto menos colunas você incluir no SELECT, mais rápido será esse download pois menos bytes serão retornados.
Bônus 3: Segurança
Segurança é um fator muito importante em Web APIs corporativas e aqui não é exceção.