»

Começando uma API REST com Node.JS Parte 2

Última atualização:
março 27, 2020

Vamos dar continuidade a nossa API. Se você não viu o começo, da uma conferida ae! 😀

Agora, vamos continuar

Para dar prosseguimento ao desenvolvimento, vamos escolher uma base de dados, para salvar as informações.

Optei pelo mongodb por ser bem fácil de usar, muito versátil e dá conta do recado.

No mongo um document é como um banco no SQL, e as collections são equivalentes as tabelas.

Por questões de agilidade no desenvolvimento, optei por utilizar uma versão do mongo em cloud https://www.mongodb.com/. Com isso não teremos problemas de instalação de client por dificuldades de diferentes sistemas operacionais e assim focamos no desenvolvimento da nossa API.

Basta clicar em “sign in” fazer login com uma conta do Google, selecionar o plano FREE, e na parte de criar um cluster, eu optei pelo Google, e escolhi o servidor do Brasil.

Em seguida alterei o nome do cluster:

E por fim, “Create Cluster” e “Continue without upgrading”

Após isso, um popup com o passo a passo vai aparecer, basta seguir os passos para criar o banco…

Primeiro ele pede um usuário:

Basta preencher o campo “username” e “password” e clicar em “add user”.

Em seguida vamos definir um lista de IP’s que poderão acessar nossos documentos, eu escolhi que qualquer IP terá acesso.

Apenas clique em “Allow access from anywhere” e “Confirm”.

Agora podemos pular para o último passo daquele popup “Connect to you cluster”.

Aqui em “connect”, podemos pegar nossa string de conexão, que vamos utilizar em nosso projeto.

“Connect your application” e copie a connection string.

Voltando a API, precisamos instalar o mongoose para fazermos a conexão, e o mapeamento das nossas collections.

Para instalar o mongoose, abra o terminal no diretório da API e:

 npm install --save mongoose

No arquivo server.js, criaremos nossa conexão:

Importaremos o mongoose, e usaremos nossa string connection, não se esqueça de alterar o password, e onde está “test” altere para o nome do banco!

const mongoose = require('mongoose');
mongoose.connect(
 'SUA STRING DE CONEXÃO', 
 {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

Também precisamos mudar a ordem de algumas coisas nesse arquivo.
Colocaremos a linha:

require('./src/Routes/index')(app);

antes de:

app.listen(3333);

E agora vamos aos models.

O model é nosso “espelho” do banco dentro da aplicação, é através dele que acessaremos nossos dados.

no diretório src criamos uma pasta Models e dentro dela um arquivo Usuario.js

const { Schema, model } = require('mongoose');
 
const UsuarioSchema = new Schema({
 nome: {
   type: String,
   required: true,
 },
 idade: {
   type: Number,
   required: true,
 },
 bio: String,
 foto: {
   type: String,
   required: true,
 }
}, {
 timestamps: true,
});
 
module.exports = model('Usuarios', UsuarioSchema);

Com isso estamos dizendo que criaremos uma collection chamada “Usuários”, com os campos: nome, idade, bio e foto, o parâmetro “timestamps” faz com que o mongo crie os campos “createdAt” e “updatedAt”.

No arquivo UsuarioController.js já podemos usar nossa model para adicionar, remover e consultar os dados.

Primeiro importamos a model:

const UsuarioModel = require('../Models/Usuario');

Na rota de POST, que é onde vai ser criado o usuário, adicionamos a palavra “async” para dizer que agora esse método é assíncrono, com isso também podemos usar “await” dentro dele, para esperar que uma promisse seja resolvida.

Nosso método ficou assim:

exports.post = async (req, res, next) => {
   const usuario = await UsuarioModel.create(req.body);
   res.status(200).send(usuario);
};

(async e await são coisas importantes dentro do javascript, se você não sabe como funciona, recomendo fortemente que de uma pausa nesse artigo para entender sobre. https://tableless.com.br/entendendo-o-async-e-o-await-em-javascript/)

Agora vamos até o postman para testar essa rota.

BOOYAH!

Veja que deu certo, ele retornou nosso usuário com o campo “_id”, que é padrão do mongo, e com a data de criação e alteração.

Se formos até o cluster (que criamos no começo desse artigo), e irmos em “collections” conseguimos ver nosso registro lá:

Agora iremos alterar nossa outras rotas.

Get:

exports.get = async (req, res, next) => {
   const usuarios = await UsuarioModel.find();
   res.status(200).send(usuarios)
};

GetById:

exports.getById = async (req, res, next) => {
   const id = req.params.id;
   const usuario = await UsuarioModel.findOne({ _id: id });
  res.status(200).send(usuario);
};

Edição (PUT):

exports.put = async (req, res, next) => {
   const id = req.params.id;
   const novo = req.body;
   await UsuarioModel.updateOne({ _id: id }, novo);
   const usuario = await UsuarioModel.findOne({ _id: id });
   res.status(200).send(usuario);
};

Perceba que alterou o campo “updateAt” também.

E por fim, DELETE:

exports.delete = async (req, res, next) => {
   let id = req.params.id;
   await UsuarioModel.deleteOne({ _id: id });
   res.status(200).send({ deleted: true });
};