Continuaremos do ponto onde paramos no curso anterior de Sequelize. Porém, caso queira recomeçar com um repositório igual ao que eu vou utilizar no curso (comecei um repositório novo para este curso), deixaremos o link para você realizar o download.
Caso queira continuar com o repositório do curso anterior, também pode. Porém, do curso anterior para esse, adicionamos algumas pessoas, alguns cursos nas tabelas do nosso banco database.sqlite. Se quiser substituir o banco que possui do curso anterior por este, para nós termos uma paridade de registros que vão retornar ao nosso JSON, você pode fazer isso também.
Refatorando a estrutura de pastas
Antes de continuarmos, faremos uma pequena refatoração para dar uma organizada na nossa estrutura de pastas, porque o nosso diretório src, ele está com muita coisa dentro, está meio bagunçado.
Dentro de src, criamos uma nova pasta chamada de database. Para isso, clicamos no segundo ícone abaixo de "Explorer" na parte superior.
O que vamos colocar dentro dessa pasta database? Lembrando do que conversamos no curso anterior sobre camadas da API. Temos a camada de modelos, temos a camada de controladores, e temos a camada do banco de dados, da nossa database.
Dentro de src, o que temos que faz referência à database? Nós temos a pasta config, nós temos a pasta migrations, models, o mais importante, e seeders. Selecionamos, clicando com o "control" esses quatro diretórios. Iremos arrastá-los para dentro de database. O VSC vai pedir para confirmar, selecionamos "Ok" e confirmamos.
- database
- config
- migrations
- models
- seeders
Além disso, dentro de database, criamos mais uma pasta manualmente chamada de storage. Arrastamos arquivo database.sqlite para dentro de storage, porque ele tinha ficado meio perdido na raiz do projeto. E ele, o nosso banco de dados, também faz parte da camada de database, da camada de dados.
- database
- config
- migrations
- models
- seeders
- storage
Agora, se observarmos as pastas que estão dentro de src, elas estão refletindo melhor, a nossa organização de pastas reflete melhor as camadas do nosso projeto, as camadas da nossa API.
- src
- controllers
- database
- routes
- services
Então, controllers, camada de dados, a database, routes e services.
Na parte externa, temos os pontos de entrada, tanto do servidor quanto do nosso app.js, que é o que inicia o Express. Só que agora, como modificamos locais, modificamos caminhos, precisamos** organizar novamente para a API não se perder**.
Organizando os caminhos
Onde temos caminhos para arrumar dentro da API? Dentro de "database > config" temos o arquivo config.json, que é onde passamos o caminho da database em si, o caminho do nosso arquivo.
config.json
{
"development": {
"dialect": "sqlite",
"storage": "./database.sqlite"
},
"test": {
"username": "root",
"password": null,
"database": "database_test",
"host": "127.0.0.1",
"dialect": "mysql"
},
"production": {
"username": "root",
"password": null,
"database": "database_production",
"host": "127.0.0.1",
"dialect": "mysql"
}
}
Como que agora passamos dentro da propriedade storage? Estávamos passando /database.sqlite porque ele estava na raiz. Agora, o que podemos fazer é ir dentro de storage, clicar com o botão direito em database.sqlite e selecionar a opção "Copy Relative Path" (Copiar o Caminho Relativo) ou podemos usar o atalho "Alt + Ctrl + Shift + C".
Copiamos o caminho e dentro do arquivo config.json colamos, ele vai exibir exatamente src/database/storage/database.sqlite, que é agora o caminho do nosso arquivo de banco de dados com relação ao ponto de entrada da API.
Na propriedade storage, substituímos ./database.sqlite por ./src/database/storage/database.sqlite.
config.json
{
"development": {
"dialect": "sqlite",
"storage": "./src/database/storage/database.sqlite"
},
"test": {
"username": "root",
"password": null,
"database": "database_test",
"host": "127.0.0.1",
"dialect": "mysql"
},
"production": {
"username": "root",
"password": null,
"database": "database_production",
"host": "127.0.0.1",
"dialect": "mysql"
}
}
É muito importante verificar se o caminho para o arquivo SQLite está correto, porque o comportamento padrão do SQLite é criar um novo arquivo se ele não encontrar o existente, e isso pode causar muita confusão.
Outro ponto muito importante é onde temos o caminho que precisamos arrumar? É no arquivo .sequelizerc, que está na raiz do projeto.
.sequelizerc
const path = require('path');
module.exports = {
'config': path.resolve('./src/config', 'config.json'),
'models-path': path.resolve('./src/models'),
'seeders-path': path.resolve('./src/seeders'),
'migrations-path': path.resolve('./src/migrations'),
}
Este arquivo literalmente resolve os caminhos quando usamos a ferramenta de CLI do Sequelize, o Sequelize-CLI, para que ele consiga encontrar onde estão os arquivos que ele precisa trabalhar.
Agora, onde está src/config, src/models, src/seeders, etc., temos que adicionar a pasta database, para onde mandamos essas coisas.
Selecionamos "src/", na primeira ocorrência dele, usamos o "Ctrl + D" para selecionar todas as ocorrências iguais e incluir "database/" no final.
.sequelizerc
const path = require('path');
module.exports = {
'config': path.resolve('./src/database/config', 'config.json'),
'models-path': path.resolve('./src/database/models'),
'seeders-path': path.resolve('./src/database/seeders'),
'migrations-path': path.resolve('./src/database/migrations'),
}
Agora, tudo está consertado: src/database/config, src/database/models, etc. Vamos salvar o arquivo. O último local onde precisamos arrumar os caminhos é justamente qual é o ponto de contato da nossa API com a parte do banco.
Está na pasta services. Lembra que no curso passado nós organizamos a nossa API e desacoplamos os controllers dos models, ou seja, todo o contato com o banco de dados está sendo feito a partir da camada de services. A camada de services é o único ponto onde temos que refazer esses caminhos.
Dentro de services, no arquivo services.js, lá no topo do arquivo, na primeira linha, onde importamos os nossos modelos, ao invés de require('../models'), agora é require('../database/models').
services.js
const dataSource = require('../database/models');
// código omitido
Como os nossos serviços específicos não estão importando diretamente dos models, eles importam apenas de services.js mesmo, não temos mais nenhum outro local, nenhum outro ponto de contato da database com o resto da aplicação.
Isso é bom para quando temos que fazer esse tipo de refatoração, fica mais fácil organizar onde temos que mexer.
Aproveitando que estamos falando de refatoração, lá dentro de controllers, em controller.js, no curso anterior faltou trabalharmos com uma parte de tratamento de erros. Todos os nossos catches, eles estão por enquanto com um comentário // erro.
Vamos alterar isso para podermos ter um controle literalmente melhor do que acontece quando dá erro na nossa aplicação?
Em todos os lugares, da mesma forma que fizemos anteriormente, vamos selecionar o "// erro" e teclamos "Ctrl + D" para localizar todos os pontos onde tem esse comentário.
Substituímos esse comentário por return res.status(500).json({ erro: erro.message }). Aqui, erro está em português porque é um objeto que será recebido dentro do catch se houver algum problema. O erro.message tem que estar em inglês mesmo porque é uma propriedade do objeto Error no JavaScript.
Todos os objetos de error possuem a propriedade message, sendo uma mensagem por extenso, e é justamente isso que desejamos inserir no JSON para resolver os problemas que ocorrerão no desenvolvimento.
controller.js
} catch (erro) {
return res.status(500).json({ erro: erro.message });
}
}
// código omitido
No arquivo controller.js o VSC está acusando um erro, e esse erro está no método exclui, porque fiz um erro de digitação e no catch, ao invés de catch (erro) em português, ficou error em inglês com r no final. Assim, ficamos com catch(erro). Vou corrigir isso.
Podemos também verificar se existe alguma mensagem de erro que precisa ser corrigida dando um "Ctrl + Shift + F" e procurando por // erro. Aí tem só mais um lugar dentro de PessoaController onde precisamos fazer essa substituição. Copiamos a linha que acabamos de criar, do return res.status(500).json({ erro: erro.message }), e em PessoaController e substituímos pelo único lugar onde faltou.
PessoaController
} catch (erro) {
return res.status (500).json({ erro: erro.message });
// código omitido
Agora, se temos erros durante o nosso desenvolvimento e eles são pegos no controller, então, basicamente, erros de resposta da requisição, conseguimos capturá-los, ele vai jogar para nós o JSON e o capturamos, por exemplo, no Postman ou no serviço que estivermos utilizando.
Agora, podemos iniciar o servidor. No terminal, na pasta do projeto do curso, onde já instalamos o projeto com npm install, basta executar npm run dev para verificar se tudo está correto.
Obtemos:
servidor escutando!
Subiu, o Nodemon informou que o servidor escutando.
No Postman, vamos só testar as rotas que deixamos criadas anteriormente. Faremos um GET em localhost:3000/categorias, clicando no botão "Send" do lado direito. Observem na parte inferior que continua chegando, temos o id 1 com o título "Node.js", o campo informando a criação e a atualização.
Em /pessoas, vamos testar também, continua vindo. Tem até os registros a mais que criei. E /cursos também está vindo. Lembrando que matrícula é um pouco diferente, vamos conversar mais sobre matrícula durante este curso, mas, por enquanto, está tudo funcionando.
Conclusão e Próximos Passos
Já organizamos as camadas da nossa API, agora elas refletem um pouco melhor a nossa organização de pastas. Já arrumamos um pouco, fizemos um tratamento de erro bem incipiente, mas que já vai nos ajudar se tivermos problemas no desenvolvimento.
Agora, podemos continuar desenvolvendo a nossa API, acrescentando funcionalidades nela.
Até a próxima aula!