ORM com NodeJS: API com Sequelize e MySQL | Alura Cursos Online
Primeiras aulas do curso ORM com NodeJS: API com Sequelize e MySQL
Estruturando o projeto - Introdução
Olá! Boas-vindas ao curso de Sequelize e ORM com NodeJS e MySQL. Nesse curso, vamos escrever uma API para um sistema de controle de alunos e turmas de uma escola de inglês. Vamos partir de um diagrama de banco, onde as tabelas já estão dadas, e, a partir desses dados, escreveremos nossa API do zero.
A diferença é que, dessa vez, usaremos um ORM, um mapeador de objeto relacional. Sequelize é o nome do ORM que usaremos. O Sequelize abstrai os comandos de operações de SQL, e faz com que possamos usar linguagem de programação que já estamos usando no backend para nos conectarmos e operarmos o banco. Ou seja, no nosso projeto, não iremos inserir queries de SQL dentro da aplicação que está escrita em JavaScript.
Utilizaremos apenas JavaScript para nos conectarmos, passarmos instruções para o banco, fazermos as operações de CRUD, etc. Então, o JavaScript, através do Sequelize, vai se encarregar de traduzir as instruções para o SQL, para o banco, e fazer as operações necessárias.
Usando o Sequelize, nossa aplicação fica mais legível, elegante, é mais fácil fazer a manutenção, mais padronizada. Então, vamos ver alguns tópicos que iremos abordar no nosso curso. Vamos conhecer o Sequelize, criar uma API do zero com algumas ferramentas que ele tem para isso. Essas ferramentas são uma mão na roda. Iremos ver como utilizar um ORM para conectar aplicação ao banco SQL, para gerenciar essas conexões, etc. utilizando apenas JavaScript.
Iremos organizar a nossa aplicação no padrão MVC. Não é apenas organizar a aplicação, organizar os arquivos, mas também como aplicamos o conceito MVC no fluxo da aplicação. Vamos ver como utilizar as ferramentas do Sequelize e para fazer o CRUD junto ao banco e devolver dados no formato JSON.
Você vai aproveitar melhor esse curso se já tiver feito os cursos básicos de criação de API com Node e SQL que temos na nossa formação aqui na Alura. Não entraremos em detalhes durante o curso a respeito do JavaScript, do ambiente do Node e como fazer a conexão inicial com banco e o CRUD.
Muitas aplicações em Node utilizam Sequelize. Então, depois que você entender como o Sequelize funciona, conhecer alguns dos seus métodos, você já consegue desbravar projetos que utilizam esse ORM, descobrir mais ferramentas conforme a complexidade do projeto que você está trabalhando e também criar suas próprias APIs. Eu sou Juliana Amoasei, vou acompanhar você nesse curso. Então, vamos lá!
Estruturando o projeto - Instalação e pré-requisitos
Antes de efetivamente começarmos a trabalhar no projeto, o subiremos do zero, tem algumas ferramentas que precisam ser instaladas, se você já não as tiver instaladas no seu computador. Então, do que iremos precisar? De um SQL que seja suportado pelo Sequelize. No caso, aqui no curso, iremos usar o MySQL, mas existem alguns outros bancos que se pode usar com o Sequelize. Vou deixar uma lista deles na próxima sessão.
Se você quiser usar algum outro, tudo bem. Aqui no curso, vamos usar o MySQL. O ORM, o Sequelize, serve justamente para isso, para podermos abstrair comandos de SQL. A única coisa que faremos direto no banco será criar a database, nos conectarmos com ela, fazer algumas consultas, para acompanhar o que está acontecendo.
Nesse curso, precisaremos também saber sobre como criar e relacionar as tabelas do SQL. Se você preferir, pode dar uma conferida nesse curso de introdução ao SQL da Alura e podemos continuar a partir dele.
Também criaremos algumas rotas e usar alguns métodos, alguns verbos de HTTP, como get, post, etc. o famoso CRUD. Se você precisa lembrar um pouco como isso funciona, também temos um curso aqui de HTTP que fala de todos esses métodos. Você pode dar uma relembrada se precisar.
Faremos as consultas ao banco direto no terminal mesmo. Eu prefiro fazer dessa forma, mas se você quiser, pode usar o MySQL Workbench, que pode ser instalado com as ferramentas do SQL. Senão, você pode fazer no terminal mesmo, que é como eu vou fazer durante o curso. Já que iremos codar essa aplicação em JavaScript, precisaremos do ambiente do Node.
Então, no curso estamos usando o Node versão 10.20 e o NPM versão 6.14. Por último, para testarmos as rotas e os métodos HTTP que usaremos para conseguir enviar requisições, receber respostas e testar tudo direito, usaremos o Postman, que está iniciando. Se você não tem o Postman instalado na sua máquina, você pode instalar, eu vou deixar o link. Ele é essa ferramenta que serve justamente para conseguirmos enviar e receber requisições HTTP para testar APIs.
Se você já tem instalado, é só usar normalmente. Os links para instalação você encontra na próxima sessão. A instalação é de preparação de ambiente. Então, agora é a hora de colocar o nosso projeto em pé, criar os arquivos base dele e fazer algumas instalações.
Eu já estou aqui na pasta juliana:~/Documents/alura/orm-sequelize$ onde vou criar o meu projeto. Então você pode fazer a mesma coisa do seu lado, que é navegar pelo terminal até a pasta do projeto e dar o comando npm init -y, que já vai criar um arquivo package.json com esqueleto base, do arquivo base de configurações do nosso projeto.
Então já podemos deixar aberto inclusive o editor de código. Mas antes de começarmos a codar, existem algumas dependências que precisamos instalar de cara para começar a fazer qualquer coisa. Uma delas é o express, uma das bibliotecas que mais usamos no Node. No nosso caso, a usaremos para subir o servidor local e também para gerenciar as rotas que criaremos e usaremos na aplicação. A outra biblioteca que usaremos, por enquanto, é a Body Parser.
Parser é converter, então a Body Parser converterá os dados que chegarão no corpo, no body das requisições, por exemplo, em uma requisição do tipo post. Então, em requisições do tipo post, receberemos alguns dados e essa biblioteca será responsável por converter para um tipo de dado que iremos trabalhar em nossa aplicação.
No caso, estaremos trabalhando com dados do tipo Json. Eu falo json (pronúncia acentuada no "j"), tem gente que fala json (pronúncia acentuada no "son"), mas o importante é saber que sem a biblioteca, não conseguimos converter os dados para um tipo que consigamos usar; no caso, tipo Json.
O próximo passo é criar um arquivo que seja o ponto de entrada da nossa aplicação. Vou criar uma pasta chamada API para separar os arquivos que trabalharemos. Os arquivos de configuração, da pasta de módulos, etc. Dentro da pasta API, criarei a pasta index.js. Podemos, inclusive, no pack de Json, mudar o caminho do nosso main de "main": "index.js", para "main": "./api/index.js",.
Começaremos a subir nosso servidor local com express, começando por importar a biblioteca e também já importar o Body Parser.
Para começarmos a usar o express, vou criar a const app const app =express ()e nela iniciaremos oexpress, deixando através daconst app` os métodos da biblioteca disponíveis para o resto do código.
O primeiro que usaremos é o método use. Passaremos como parâmetro para ele o próprio Body Parser, e o método do Body Parser chamado Json, pelo comando app.use(bodyParser.json()). O método use serve para avisarmos o express que vai ter alguma biblioteca ou algum texto de código que vai, digamos assim, fazer um meio de campo entre as requisições e o próprio express.
No caso desse comando, é o Body Parser que pegará todos os dados que chegarão via requisições do tipo post, já convertendo para Json e passando em diante para ser usado pelo restante da aplicação.
Nosso servidor local precisará de uma porta. Estou passando na constante porta a porta 3.000, por meio do comando const port = 3000. É um número que normalmente usamos como padrão nas aplicações que subimos localmente com o express.
Agora, podemos criar uma rota de teste para fazermos um primeiro teste com nosso servidor. O método .get() do express se refere ao mesmo get do método de HTTP, tem o mesmo nome, e passaremos para ele dois parâmetros. O primeiro parâmetro é uma string com a rota que testaremos. Vamos dar para ela o nome de teste mesmo. E o segundo parâmetro é uma função callback que receberá requisição e resposta como parâmetros. O comando é app.get('/teste', (req, res) => ).
Então o express vai receber uma requisição e vai passar para frente uma resposta com algumas informações. Uma dessas informações será o status da requisição. Passaremos o status 200, que é o ok.
Em seguida, vamos também enviar uma informação de volta. Essa informação no método .send, de envio, pode ser uma array, pode ser um objeto. Vamos passar um objeto então que carregue .send( {mensagem: 'boas-vindas à API' }), por exemplo, só para testarmos e ver se está tudo ok.
Vamos pedir também para o express para ele ficar ouvindo, listening, ouvindo o nosso servidor para nos dizer se está tudo ok, se tem algum erro, se o servidor está de pé, etc. O método listening ele vai receber dois parâmetros. O primeiro é o número da porta onde ele tem que ficar ouvindo, e o segundo parâmetro é mais um callback e nele, passaremos só um console.log, que ficará no terminal nos dizendo se está tudo ok ou não.
Vamos passar app.listen (port, () => console. Log(servidor está rodando na porta ${port}). Estou usando os recursos do template string para conseguir colocar essa variável dentro da string usando crases, e não aspas simples.
Antes de testarmos, vamos exportar module. exports = app para ficar disponível para o restante da aplicação.
E agora podemos vir no nosso terminal chamar o Node. E para rodar com o Node, a API/index, e vamos ver o que acontece.
Servidor está rodando na porta 3.000. Isso significa que a parte app.listen(port, () => console.log(servidor está rodando na porta ${port})) está ok, está ouvindo e está tudo bem. E agora vamos no Postman para testarmos a rota. Essa rota do tipo get. Então, uma rota que está rodando localmente na porta 3000. Eu já tinha testado antes aqui no Postman, então vamos fazer um novo teste. Então http://localhost:3000/teste que é a rota que estamos testando. mensagem: "boas-vindas à API". Está tudo funcionando, por enquanto, perfeitamente. Tem várias alterações que podemos fazer.
Vamos dar uma melhorada para deixar nosso servidor um pouco mais prático. Então, vamos ver em seguida com o restante das instalações.
Estruturando o projeto - Finalizando o ambiente
O servidor está rodando, mas ainda temos um pequeno problema. Qualquer alteração que eu faço no código; por exemplo, mudar o número da porta de 3.000 para 3.500 e salvar. O servidor não enxergará essas alterações. Eu terei de derrubá-lo toda vez e subir de novo para ele ver que teve alterações no arquivo.
Então vamos derrubar o servidor uma última vez para instalar uma biblioteca que é super útil, "uma mão na roda", que se chama Nodemon. Instalarei essa biblioteca como dependência de desenvolvimento, porque ela não é usada na produção, só é usada na hora de desenvolvermos.
E o Nodemon serve para ficar escutando automaticamente todas as alterações que fazemos nos arquivos na aplicação, e toda vez que salvarmos qualquer alteração, ele vai automaticamente derrubar e subir o servidor de novo, salvando esse trabalho, senão teremos uma dor de cabeça.
Vamos aproveitar já para fazer nosso Nodemon funcionar, adicionando no nosso pack de Json um script. Normalmente chamamos esse script de start.
Quando rodamos o script start, ele passa para o terminal o comando Nodemon, que chamará a biblioteca e dá para ele aqui o entrypoint de aplicação para ele achar o servidor e rodar automaticamente. Vamos ver se está funcionando. npm run, rodar o comando start.
Certo. Iniciou o Nodemon, que achou o API/index e colocou para rodar. Agora eu posso voltar em index.js, mudar, de repente, de novo, para 3.000, salvar o arquivo. E ele viu automaticamente, já fez alterações, essa parte está tranquila.
Eu Já criei também um arquivo chamado .gitignore. Você com certeza, ou bem provavelmente, vai querer subir o seu projeto para o GitHub. É bom não esquecer de incluir esse arquivo e já colocar dentro dele o arquivo .gitignore, o node_modules para não correr o risco. Da pasta de instalação node_modules, que é uma pasta local mesmo, não correr o risco dela subir para o GitHub. Servidor no ar, vamos fazer as últimas instalações. Por enquanto deixarei a janela do terminal rodando com nosso servidor.
Vamos abrir uma outra janela e continuar com as últimas instalações principais. Faltou instalar uma coisa muito importante, que é o banco que trabalharemos. Faltou justamente ele. Trabalharemos com o MySQL nesse projeto, então eu vou instalar: npm install mysql2.
Conversamos um pouco anteriormente que existem outros bancos do tipo banco SQL que você pode utilizar nesse projeto caso você não queira usar o MySQL, e eles são o Postgres, o mysql2, o mariadb, o sqlite3 e o Microsoft SQL Server. Se você quiser instalar qualquer um deles, ao invés de $ npm instal -- save mysql2", o save não é mais necessário nas novas versões do npm. Você pode instalar pg-hstore, mariadb, sqlite3 ou o tedious, que é a ferramenta de gerenciamento do Microsoft SQL Server.
Mas, se você preferir trabalhar aqui conosco com o SQL2, é só dar o mesmo comando que dei aqui: npm install mysql2.
Para finalizar as instalações faltou o próprio Sequelize, que é a ferramenta que usaremos, o ORM que usaremos aqui a principal para desenvolver a nossa API. npm instal sequelize, e pedirei para o npm instalar mais duas dependências: sequelize-cli e path. npm instal sequelize sequelize-cli path.
Vejam que sequelize e sequelize-cli são dependências diferentes. O sequelize é usado para instalar e usar os métodos da ferramenta mesmo, e o sequelize-cli serve para usarmos alguns recursos de linha de comando que o sequelize tem. Tudo foi instalado nas dependências de desenvolvimento do Nodemon. E aqui as dependências normais, path, sequelize e sequelize-cli.
Esses recursos de linha de comando que o sequelize tem são para se conectar com o banco, para criação de modelos, criação de arquivos, etc. Então, se ele nada mais é do que o command line interface, que na prática é o nosso terminal, agora já podemos subir o Boiler Plate, um template padrão de início do projeto que o sequelize faz como projeto inicial, para termos um pontapé inicial no nosso projeto. Vamos fazer isso em seguida.
Durante o projeto, trabalharemos bastante com a ferramenta ORM. A documentação do sequelize aparece abaixo.
Vamos olhar agora algumas coisas que o sequelize pode nos fazer. Além de toda a comunicação com bancos, o sequelize também pode criar os arquivos de base. Conseguimos criar com ele um projeto vazio que serve como pontapé inicial para continuarmos nosso projeto. Vamos ver como isso funciona. Usaremos o npx sequelize-cli init. O npx é para rodar as dependências que estão instaladas localmente, uma vez que o sequelize e os outros programas instalados no projeto não foram instalados de forma global.
Vamos ver o que ele nos passou de mensagem. Ele passou que criou algumas coisas: config/config.json, um diretório models, um diretório migrações, diretórios de modo seeders.
Vamos, então, no nosso editor de código ver o que aconteceu. Criou essas quatro pastas. A pasta models e a pasta config já têm alguns arquivos dentro. Olharemos o que tem em seguida. Antes disso, vamos fazer o seguinte: criamos uma pasta API para colocar os arquivos, a nossa aplicação dentro. Só que como estamos rodando os comandos direto na raiz do nosso projeto, precisaremos passar os arquivos que o Sequelize criou na raiz para dentro da nossa pasta, para ficar tudo certo. Então as pastas criadas são essas, config, migrações, modelos e seeders.
Vamos passar as pastas config, migrações, modelos e seeders para dentro da pasta API, selecionando-as e arrastando-as para dentro da pasta API. E agora, como mudamos algumas coisas de lugar para ficar mais organizado, precisaremos avisar o Sequelize para ele não ficar perdido com relação a isso, porque qualquer outro comando que passemos para ele agora na raiz do projeto, ele não conseguirá encontrar os diretórios que jogamos dentro da pasta API. Criaremos um arquivo chamado .sequelizerc.
Esse arquivo, inclusive, está previsto na documentação do Sequelize. Tirando o babel que não precisaremos usar por enquanto, podemos criar esse arquivo .sequelizerc quando quisermos estruturar nossa aplicação, em, de repente, uma hierarquia de pastas um pouco diferente da padrão do Sequelize. E aí dentro, acho que podemos inclusive copiar esse trecho de código.
'config': path.resolve('./api/config', 'config.json'),
'models-path': path.resolve('./api/models'),
'seeders-path': path.resolve('./api/seeders'),
'migrations-path': path.resolve('./api/migrations')
Usaremos aquela biblioteca que instalamos lá atrás, o path, e exportarmos um módulo que resolverá, literalmente, para o Sequelize, os novos caminhos. Para ele conseguir encontrar config, conseguir encontrar models, seeders e tudo que ele criou.
Aqui dentro das linhas de código, temos que passar o caminho novo. Aqui dentro que vamos passar que, ao invés de estar em raiz models, com o comando 'models-path' : path.resolve('models'), ele está em /api/models, com o comando 'models-path' : path.resolve('./api/models'), . Isso será feito em todas as linhas de comando: config, seeders e migrações.
Estamos usando config.json. Se você, de repente, quiser utilizar config.js, ele também aceita, mas deixaremos como json aqui no nosso projeto. Agora já temos um projeto arrumado, um pontapé inicial, digamos assim, pronto para ser preenchido. Vamos nos conectar com o banco para poder começar a realmente testar de verdade a nossa API.
Sobre o curso ORM com NodeJS: API com Sequelize e MySQL
O curso ORM com NodeJS: API com Sequelize e MySQL possui 183 minutos de vídeos, em um total de 54 atividades. Gostou? Conheça nossos outros cursos de Node.JS em Programação, ou leia nossos artigos de Programação.