Uau.... quanto tempo não é mesmo????!!! Mais uma vez, peço mil desculpas a todos os meus leitores e milhares de seguidores tanto do meu site, como também do meu canal do Youtube. Esses últimos meses, tem sido bastante "punk" para não dizer outra coisa, na busca de recolocação no mercado.... Mas, graças a Deus, consegui um trabalho em uma das maiores empresas de Telecomunicações e já integrada num projeto na área de Plataforma Digitais. E é justamente por isso, que estou tratando sobre o tema acima: Desenvolvimento de uma API RESTful com Node.Js & Express com MongoDb. Calma!!! Vocês estão no site certo.... :)  Sei que vocês sabem que eu sou uma Desenvolvedora especializada em .NET.

Porém, acima de qualquer linguagem de programação, sou Desenvolvedora. E a oportunidade que apareceu para mim foi de trabalhar na parte de Back-End dessa empresa justamente trabalhando com o Node.Js, Express.Js e MongoDb. Por isso que hoje, gostaria de compartilhar um pouco do que eu venho aprendendo. Mas antes... deixa eu contar quando eu tive o meu primeiro contato com o Node.Js  :)

Antes de mais nada.... meu.... que saudades de escrever por aqui!!!

  miss

Bom.... vamos lá... o meu primeiro contato com Node.Js foi em meados de Outubro/2015. Estava morando fora do país (Argentina, Buenos Aires) e trabalhando para uma empresa multinacional, chamada: GlobalLogicLá... cheguei como Júnior e saí como Pleno. Pude aprender muita coisa, com muita gente boa e com uma empresa com estilo "Google wannabe". Era muito bom! Mas, voltando... infelizmente o projeto que eu estava que era de .NET tinha caído... devido a crise aqui no Brasil (o cliente que eu estava alocada era de um projeto de uma empresa brasileira). Lembro como se fosse hoje... era uma terça-feira à tarde, quando a menina do RH chamou toda a equipe (+ 30 pessoas envolvidas nesse projeto) para dar a triste notícia. Porém, como é uma empresa que valoriza os funcionários, eles deram 2 opções para os desenvolvedores e nos falaram:

"Tão cedo vamos ter projetos em .NET. E sabemos que vocês são especializados em .NET com isso vamos dar 2 opções:

  1. Temos plano de assinatura no PluralSight e CodeSchool. Vocês podem pegar a senha, estudar e se atualizarem até aparecer um projeto em .NET.
  2. Segunda opção: temos um cliente de grande porte e americana que iremos iniciar o projeto na semana que vem. Porém, o projeto será em MEAN ( MEAN é acrônimo de: Mongo, Express, Angular e Node.Js). Caso vocês desejam, poderão se alocar a partir de semana que vem para o 5º piso já para começar esse projeto."

Eu... não pensei 2x antes.... eu fui uma das primeiras a aceitar esse desafio, por mais que nunca tinha programado sequer uma linha de código em Node.Js. Mas, aceitei o desafio. Por quê? Porque como disse no início do artigo acima, independente de qualquer linguagem que programamos, somos Desenvolvedores. Temos que estar dispostos a novos desafios e abertos a aprender novas linguagens e tecnologias. O mundo da tecnologia e programação muda tudo muito rápido e com isso, devemos sempre estar dispostos a mudanças!

Foi sofrível. Claro que foi! Mas, posso dizer que foi de grande experiência para mim! Fiquei nesse projeto (na parte de Back-End) por 3 meses. 3 meses que foram suficientes para amar e me apaixonar por Node.Js e Angular.Js! :) <3

Infelizmente houve mudanças políticas naquele país e tive que retornar ao Brasil em Dezembro/2015. E não pude ver a integração final da parte da equipe de Back-End com a equipe do Front-End. Soube através de amigos meus, que felizmente deu tudo certo e o projeto se finalizou em Fevereiro/2016!

E foi assim que eu conheci e tenho estudado e me aprimorado na stack MEAN, em especial, em Node.Js e Angular.Js <3

meme_1

Hoje, não iremos tratar sobre o stack MEAN. Vamos antes procurar entender como funciona a parte do Back-End dessa stack: Node.Js, Express.Js e MongoDb. E tentar compreender porque empresas como: Walmart, Groupon, Netflix, PayPal e até mesmo a NASA estão desistindo de frameworks tradicionais corporativos, como Spring MVC do Java e estão amando usar o Node.Js e os thick clients em JavaScript devido a melhora de produtividade e desempenho. ;)

Vamos falar primeiramente sobre o Node.Js!

Node.Js , Express.Js e MongoDb!!!!

meme_2

p.s.: só para salientar que eu não entrarei em detalhes sobre o Node.Js, Express.Js e MongoDb. Caso, desejam saber mais informações mais profundas sobre cada stack, peço que leiam a documentação:

Essa é uma das grandes vantagens do Node.Js: Callbacks. Uma das outras vantagens do Node.Js é por ser uma plataforma que permite rodar os códigos desenvolvidos em JavaScript no servidor fora do navegador. E devido ao seu modelo ser baseado em eventos de Entrada e Saída - I/O não blocante, tornando assim muito rápido e otimizando demais o uso de cada ciclo do Computador.

Já o Express.Js é um framework web usado juntamente com o Node.Js. Ele será responsável por expor as API's desenvolvidas, podendo ser elas do tipo REST ou RESTful. Ele processa as solicitações vindas do navegador usando os middlewares (mais a respeito sobre o assunto LEIAM, POR FAVOR!!!: Clique Aqui)

Das duas stacks citadas acima, acredito que o próximo que irei mencionar aqui é o mais conhecido, ou com certeza alguém aqui já ouviu falar nele: MongoDb.

MongoDb é um banco de dados não relacional (NoSQL) mais conhecido do mercado, de código aberto e com uma documentação muito bem explicada, permitindo assim que todos consigam ter uma fácil aprendizagem. Tem uma estrutura de documentos semelhante ao JSON. A query usada no MongoDb é poderosa e muito expressiva.

Bom.... agora que já demos uma pequena "geral" sobre as stacks a qual iremos desenvolver a nossa aplicação. Antes de prosseguir com o tutorial abaixo, são pré-requisitos saber:

  • Ter noções de Node.Js (procuram ler algo a respeito.... documentação);
  • Ter noção de Express.Js (mesmo que acima);
  • Ter noção de MongoDb;
  • Saber programar em JavaScript;

A IDE que estarei utilizando é o Visual Code. Caso desejam baixar cliquem AQUI. Porém, sintam-se à vontade em usar outras IDES como: Sublime, WebStorm, Atom, NotePad ++ ou até mesmo um bloco de notas! ;)

Antes de começar... precisamos preparar o nosso ambiente de desenvolvimento. Vamos precisar baixar:

  • Node.Js - Aqui (baixar a versão - LTS)
  • PostMan - Aqui (depois explico porquê!! :D)
  • MongoDb - Aqui 

p.s.: antes de baixarem o MongoDb... para os usuários Windows.... peço que sigam piamente esse tutorial do canal do youtube - The New Boston - Aqui (por favor... não deixam de seguir esse tutorial!!! Ali irão ensinar a como instalar o MongoDb de maneira correta, como definir a path no Windows e como saber se o MongoDb foi instalado de maneira correta na sua máquina do Windows!!!)

Depois que tiver instalado o Node.Js na sua máquina, abre agora o terminal e digite o seguinte comando:

> node -v

Se no seu terminal aparecer a versão instalada, é porque o Node.Js está devidamente instalado no seu computador! :D

Ex.:
screen-shot-09-11-16-at-10-34-pm

Bom... agora vamos saber se o MongoDb está devidamente instalado na sua máquina. Acredito que a essa altura desse artigo, você deve ter seguido a orientação de assistir ao vídeo tutorial de como instalar devidamente o MongoDb no Windows... Caso tenha seguido aquele tutorial, peço que abre um outro terminal na sua máquina e digite o seguinte comando:

> mongod

Se você instalou tudo certinho... a sua conexão com o MongoDb deverá ser iniciada pela porta: 27017. Como a imagem abaixo:

screen-shot-09-11-16-at-10-38-pm

Bom.... vocês devem estar se perguntando... e o Express.Js? Não precisa instalar ele também? Não necessariamente.... até porque.. uma vez que você instala o Node.Js.. já vem integrado o Express.Js. Mas..... na dúvida.... caso queiram instalar... basta seguir os passos como descritos na documentação do Express.Js - Aqui.

E o PostMan, será necessário para poder testar as nossas APIs criadas. O PostMan é um plugin do Google Chrome e vamos usá-lo todo o tempo. Peço que também incluem esse plugin no navegador Chrome de vocês!! :D

Ufa! Agora sim, podemos realmente começar a desenvolver a nossa aplicação. Vamos nessa?!!! :D

meme_3

Definição da Aplicação!!

Como já dito antes, vamos desenvolver uma aplicação API que:

  1. Faremos o nosso famoso CRUD!! (Create, Read, Update e Delete);
  2. Será uma API básica. Com a intenção de aprender os conceitos básicos de RESTful. Com isso a nossa URL principal será ( http://exemplo.com/api/usuarios e http://exemplo.com/api/usuarios/:usuario_id);
  3. Faremos uso dos verbos do HTTP para desenvolver uma aplicação RESTful (GET, POST, PUT e DELETE) - para quem não saiba, peço que leiam esse artigo: Aqui
  4. A nossa aplicação retornará dados em JSON;
  5. Todos os registros das requisições serão em console.

Seguindo todos esses 5 passos, no final desse tutorial, teremos uma aplicação padrão para APIs RESTful rodando em sua/nossa máquina!!

E... Vamo que Vamo!! :D

Bom.... agora que já entenderam o que iremos desenvolver aqui, vamos agora montar o esqueleto do nosso projeto. Antes, vamos precisar definir os nossos pacotes do Node para que assim possamos ser capazes de iniciar o nosso serviço da aplicação usando o Express. Precisaremos definir o nosso modelo, declarar as nossas rotas usando o Express e por último claro, testar a nossa API! Uau.. quanta coisa precisamos fazer!! Sim! Por isso, peço que vocês deem uma olhada nos BackLogs (tarefas) que iremos desenvolver. (é uma boa prática de desenvolvimento, um desenvolvedor definir tarefas daquilo do que ele irá desenvolver! Assim, ele não se esquecerá do que precisará fazer e como fazer!)

Sintam-se à vontade em acompanhar as tarefas que iremos desenvolver Aqui

screen-shot-09-11-16-at-11-26-pm

Vamos ao primeiro item! "Definir a estrutura (esqueleto) do projeto a ser desenvolvido"

Abra o seu IDE e vamos criar os seguintes arquivos abaixo:

- app/
    |---models/
         |----- usuario.js /* será o nosso modelo */
 
- node_modules/  /* pasta criada pelo npm. Onde obtem as nossas dependências e pacotes */
 
- package.json   /* arquivo responsável pelas dependências da nossa aplicação node */
 
- server.js      /* arquivo responsável por configurar a nossa aplicação e onde iremos criar as nossas rotas. */


No final, o esqueleto do nosso projeto na sua IDE deverá estar da seguinte maneira:

screen-shot-09-11-16-at-11-44-pm
Observem que a pasta "node_modules" ainda não está em nosso projeto. Já Já iremos criá-la através do npm! (Mais informações sobre NPM: Aqui)

Primeiro passo feito. Agora vamos para o segundo passo: "Definir os pacotes de dependência do Node no projeto através do arquivo package.json".

Definindo os nossos pacotes Node: Package.Json!

No projeto, abre o arquivo 'package.json'. É justamente aí que vamos precisar definir os pacotes que utilizaremos para desenvolver a nossa aplicação RESTful.! ;)

Digite o código abaixo no arquivo 'package.json':

{
  "author": "Glaucia Lemos",
  "license": "MIT",
  "version": "1.0.0",
  "description": "Tutorial - Desenvolvendo uma Aplicação RESTful API - Node.Js &amp;amp;amp; Express com MongoDb",
  "name": "node-api",
  "main": "server.js",
  "scripts": {
    "test": "./node_modules/.bin/mocha --reporter spec"
  },
  "dependencies": {
    "body-parser": "~1.0.1",
    "express": "~4.0.0",
    "mongoose": "*",
    "request": "^2.74.0"
  },
  "repository": {
    "type": "git",
  }
}

Como vocês podem notar, estou atualizando o código desenvolvido num repositório do GitHub. Estarei documentando exatamente tudo que estarei desenvolvendo aqui no repositório do projeto, okay? :D

Afinal.... o que seriam esses pacotes? O que eles fazem? Bom, o Express como já expliquei acima, é um framework do Node. O 'mongoose' é um ORM que iremos usar para poder se comunicar com a nossa base de dados através do MongoDb. Já o 'body-parser' irá nos deixar enviar os conteúdos POST através do nosso pedido de HTTP para que possamos realizar e testar o nosso CRUD.

Bom... agora está tudo explicado... vamos agora baixar as nossas dependências. Mas, como fazemos isso???!!! Simples! Abre o terminal do seu computador (cmd - para máquinas Windows) e vai até o diretório onde está sendo desenvolvido o seu projeto! E daí digita o comando: npm install

> C:\Users\Seu Nome\Tutorial - CRUD\ npm install


Depois de digitar tal comando, automaticamente o npm fará o seu trabalho e irá baixar todas as dependências necessárias, que pré-definimos no arquivo 'package.json', como segue a imagem abaixo:

screen-shot-09-12-16-at-12-06-am

 Observem que depois de realizarmos o comando npm install no diretório do nosso projeto, a pasta 'node_modules' aparecerá no escopo do projeto.

screen-shot-09-12-16-at-12-09-am
 
Agora vamos ao próximo passo: "Configurar o Express.Js para poder levantar o serviço do projeto que será desenvolvido."

Iniciando com o Express.Js: server.js

Agora com os nossos pacotes já baixados, precisamos agora definir onde o Node irá procurar para poder começar a nossa aplicação e verificar o que desenvolvemos e configurarmos a nossa API.

Agora, vamos começar a codificar. Por todo esse tutorial estarei comentado o que estou desenvolvendo com o objetivo para que seja de fácil compreensão para todos que estão seguindo esse tutorial.

Abre o arquivo 'server.js' e digite o código abaixo:

/**
 * Arquivo: server.js
 * Descrição: Arquivo responsável por levantar o serviço do Node.Js para poder
 * executar a aplicação e a API através do Express.Js.
 * Author: Glaucia Lemos
 * Data de Criação: 13/10/2016
 */
 
//Base do Setup da Aplicação:
 
/* Chamada das Packages que iremos precisar para a nossa aplicação */
var express     = require('express'); //chamando o pacote express
var app         = express(); //definção da nossa aplicação através do express
var bodyParser  = require('body-parser');  //chamando o pacote body-parser
 
/** Configuração da variável 'app' para usar o 'bodyParser()'.
 * Ao fazermos isso nos permitirá retornar os dados a partir de um POST
 */
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
 
/** Definição da porta onde será executada a nossa aplicação */
var port = process.env.PORT || 8000;
 
//Rotas da nossa API:
//==============================================================
 
/* Aqui o 'router' irá pegar as instâncias das Rotas do Express */
var router  = express.Router();
 
/* Rota de Teste para sabermos se tudo está realmente funcionando (acessar através: GET: http://localhost:8000/api) */
router.get('/', function(req, res) {
    res.json({ message: 'YEAH! Seja Bem-Vindo a nossa API' });
});
 
/* TODO - Definir futuras rotas aqui!!! */
 
/* Todas as nossas rotas serão prefixadas com '/api' */
app.use('/api', router);
 
//Iniciando o Servidor (Aplicação):
//==============================================================
app.listen(port);
console.log('Iniciando a aplicação na porta ' + port);


Você deve estar pensando agora..... WHAAATTT??!

  what


Calma... vou explicar o que está acontecendo aqui! Vamos passo a passo! ;)

A Configuração base da nossa Aplicação é justamente a nossa base. Aqui nós iremos pegar todos os pacotes definidos no package.json já baixados pelo npm. Assim, definimos 2 pacotes que serão muito úteis na nossa aplicação: express e o body-parser. Aqui também definimos qual será a porta da nossa aplicação!

Já nas Rotas da Nossa API aqui iremos nessa parte do código definir todas as nossa rotas. Com a estrutura do Router (provido pelo Express) instanciamos o router. Assim, poderemos definir as rotas e depois desenvolver essas rotas para uma URL principal (neste caso, API).

Com tudo isso.. Definimos o que irá Iniciar o nosso Servidor. A nossa aplicação irá até a porta que definimos anteriormente. E então, enfim, poderemos iniciar a nossa aplicação que estará pronta para ser testada! E é isso que iremos fazer agora!! :D :D :D :D

Ufa! Depois dessa breve explicação... acredito que até o nosso amiguinho está mais tranks! :D

phew

Que Inicie a Aplicação!

Vamos verificar agora se o que desenvolvemos até agora está tudo dentro dos conformes! Para isso, vamos iniciar a nossa aplicação do Node e enviar um request para uma rota que nós definimos para ter certeza de que está sendo recebido por um response!

Vamos iniciar a nossa aplicação! Abre novamente o terminal até o diretório do projeto e digite a seguinte linha:

> node server.js


Depois de digitar o comando: node server.js e no final aparecer a imagem abaixo..... é porque está tudo correndo bem!!! YAHOOO!!!! :D screen-shot-09-12-16-at-12-46-am Agora que sabemos que a nossa aplicação está iniciada e tudo dentro dos conformes, vamos testar! Mas... como? Simples... ele.... PostMan (não... não é um super-herói!!)

Hora de testar a API .... PostMan que venha!!!! :D

O PostMan irá ser o nosso melhor amigo durante esse tutorial... será através dele que saberemos que o que estamos desenvolvendo está dentro dos conformes. Ele nos auxiliará a testar as nossas APIs. Ele irá basicamente enviar os requests/solicitações para a HTTP para uma URL da nossa escolha. Podemos até mesmo passar paramêtros (a qual faremos isso no futuro próximo durante esse tuto) e autenticações (algo que não iremos abordar nesse tuto).

Já com o PostMan instalado (espero que sim... senão... retorne a leitura acima!!!) e vamos dar uma olhada e ver como usá-lo! ;)

Olha o nosso amiguinho aí gente!! :D

screen-shot-09-12-16-at-12-53-am

Tudo que você tem que fazer é:

  1. Insere a URL que definimos no arquivo 'server.js' (http://localhost:8000/api);
  2. Escolha um verbo HTTP (nesse caso....vamos escolher: GET);
  3. E depois clique em Enviar

E note o que irá acontecer.....

screen-shot-09-12-16-at-12-56-am

Lindo, não é mesmo!!! A nossa API está executando de maneira correta e da maneira que definimos!!! Que alegria! Tanta alegria que dá vontade de....

cry  

Bom... vamos a luta... sabemos agora que a nossa aplicação está executando tudinho dentro dos conformes! Agora vamos começar a desenvolver o CRUD!!

Definição da Base de Dados e a classe modelo do Usuário: usuario.js

Bom... está tudo funcionando!. Mas, a melhor parte vem agora: desenvolver as rotas das nossas APIs!! :D Tudo o que iremos precisar é criar uma base de dados com o MongoDb e fazer com que a nossa aplicação se conecte a ele. Também será necessário criar uma classe modelo "usuario" usando o "mongoose" (Mais informações sobre mongoose Aqui ) para que possamos interagir com a nossa base de dados. Vamos nessa! :D

Criando a Base de Dados e Conectando...

Bom.. para facilitar a todos nesse tutorial, estaremos usando um banco de dados fornecido pelo ModulusNão há problemas de criar sua própria base de dados localmente, ou até mesmo usar o MongoLab. O item mais importante que iremos precisar é o URI para que possamos conectar com a nossa aplicação. Entre no site do Modulus e crie uma conta. Com a sua conta já criada, clique em "Create Database". Ao clicar, aparecerá uma caixa, onde você irá preencher os campos solicitados e enfim clique em "Create", como segue a imagem abaixo:

screen-shot-10-13-16-at-09-09-pm Depois disso, clique em "Administration" e vamos pegar o que realmente precisamos:  a connection string [ Mongo URI ], como segue a imagem abaixo: screen-shot-10-13-16-at-09-13-pm Bom.... criada  a nossa base de dados na Nuvem e temos agora a URI para poder conectar com a nossa aplicação. Agora é o momento de usarmos essa URI em nossa aplicação. Voltando ao Visual Code, abre o arquivo 'server.js' e adicione essas duas linhas de códigos:

//Configuração Base da Aplicação:
//====================================================================================
...
 
var mongoose = require('mongoose');
 
mongoose.connect('mongodb://root:123456@jello.modulusmongo.net:27017/ity3Ryje');
 
...

Procure colocar uma senha que seja fácil de lembrar. Pois você precisará para definir na sua connection string.

Ao fazermos isso, o pacote do mongoose irá se conectar com banco de dados remoto que está hospedado pelo Modulus. Agora que estamos conectados com o nosso banco de dados, vamos criar um modelo de schema via mongoose.

Modelo Usuario: app/models/usuario.js

Vamos agora criar o modelo para que possa fornecer os campos: nome, login e senha. Crie um novo arquivo chamado: 'usuario.js' dentro da pasta 'models'. E depois digite as seguintes linhas de código abaixo:

/**
 * Arquivo: usuario.js
 * Author: Glaucia Lemos
 * Description: Arquivo onde trataremos o modelo do projeto.
 * Definição dos esquemas para serem utilizadas na Base de Dados (MongoDb)
 * Data: 13/10/2016
 */
 
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
 
var UsuarioSchema = new Schema({
    nome: String,
    login: String,
    senha: String
});
 
module.exports = mongoose.model('Usuario', UsuarioSchema);

Agora que já definimos e desenvolvemos o nosso modelo, vamos retornar ao arquivo 'server.js' e vamos colocá-lo no arquivo para que possamos usar dentro da nossa aplicação. Com isso, adicione mais uma linha no arquivo 'server.js':

//Configuração Base da Aplicação: //==================================================================================== .
..
 
var Usuario = require('./app/models/usuario');
 
....

Agora sim! Toda a nossa aplicação está preparada para que possamos enfim construir e depois claro, consumir as nossas rotas. Essas rotas irão definir a nossa API principal, que é a grande razão de estarmos criando esse tutorial lindu! <3 !

Vamos nessa!

Criação de Rotas via Express.Js

Nós iremos usar uma instância  "Router" do Express para lidar com todas as nossas rotas. E abaixo segue quais a rotas iremos desenvolver agora!

screen-shot-10-13-16-at-09-54-pm

Todas essas rotas são básicas e necessários para uma API. E sem contar que segue um modelo de padrão e boas práticas. Executaremos os 5 verbos do HTTP para realizar as ações na nossa API (GET, POST, PUT e DELETE).

Rota Middleware

Bom... nós já definimos acima a nossa primeira rota e deu tudo certo! Agora o Express Router nos dará uma grande flexibilidade na definição das nossas rotas.

Vamos dizer que queremos que algo aconteça todas as vezes que façamos uma determinada requisição para a nossa API. Para este exemplo, estaremos usando o console.log() para que possa retornar uma mensagem. Vamos adicionar o middleware agora no arquivo 'server.js':

...
 
//Rotas da nossa API:
//==============================================================
 
/* Aqui o 'router' irá pegar as instâncias das Rotas do Express */
var router = express.Router();
 
/* Middleware para usar em todos os requests enviados para a nossa API- Mensagem Padrão */
router.use(function(req, res, next) {
    console.log('Algo está acontecendo aqui........');
    next(); //aqui é para sinalizar de que prosseguiremos para a próxima rota. E que não irá parar por aqui!!!
});
 
/* Rota de Teste para sabermos se tudo está realmente funcionando (acessar através: GET: http://localhost:8000/api) */
router.get('/', function(req, res) {
    res.json({ message: 'YEAH! Seja Bem-Vindo a nossa API' });
});
 
/* TODO - Definir futuras rotas aqui!!! */
 
/* Todas as nossas rotas serão prefixadas com '/api' */
app.use('/api', router);
 
...

O que realmente fizemos aqui foi declarar que o middleware irá usar um: 'router.use (function ())'. A maneira como definimos as partes do nosso router é muito importante. Eles serão executados na ordem em que são listados e graças às mudanças na Express 4.0, não vamos ter problemas ao fazer isso como em Express 3.0. Tudo será executado na ordem correta.

Note que adicionamos next(). Isso permitirá que a aplicação deverá continuar com as demais rotas. E isso é muito importante porque a nossa aplicação iria parar neste bloco de código.

Os usos de Middleware nas aplicações RestFul são de grande importância! Pois, podemos fazer validações para nos certificar de que tudo está dentro dos conformes e que as requisições estão sendo feitas de maneira correta. Podemos até mesmo fazer alguns logs extras para realizar análises ou quaisquer estatísticas que gostaríamos de guardar. Há uma infinidade de coisas que podemos fazer ao fazer uso de middlewares. Assim que: use bastante!!!!

Testando a nossa Middleware! YEAH!

Agora na nossa aplicação, quando formos enviar qualquer requisição ou pedido usando o Postman, a mensagem que definimos no escopo do código aparecerá no console: screen-shot-10-13-16-at-10-24-pm
 
Legal! Não é mesmo?! Agora.... vamos enfim criar o nosso CRUD!! :D

Criando um Usuario: POST /api/usuarios

Vamos adicionar a nova rota que irá realizar o POST e então depois vamos testar usando o Postman. Acrescente o código abaixo no arquivo 'server.js':

...
 
// Rotas que irão terminar em '/usuarios' - (servem tanto para: GET All & POST)
router.route('/usuarios')
 
    /* 1) Método: Criar Usuario (acessar em: POST http://localhost:8080/api/usuarios */
    .post(function(req, res) {
        var usuario = new Usuario();
 
        //aqui setamos os campos do usuario (que virá do request)
        usuario.nome = req.body.nome;
        usuario.login = req.body.login;
        usuario.senha = req.body.senha;
 
        usuario.save(function(error) {
            if(error)
                res.send(error);
 
            res.json({ message: 'Usuário criado!' });
        });
    });
 
/* Todas as nossas rotas serão prefixadas com '/api' */
app.use('/api', router);
 
...

Agora nós criamos a rota POST para a nossa aplicação. Observem que estamos usando o router.route (que é do Express.Js) para poder lidar com múltiplas rotas para o mesmo URI. Assim, ficará mais fácil da aplicação lidar com todas as solicitações que terminam em: /usuarios Agora vem a hora da verdade (MEDO!!!). Vamos testar para ver se a nossa rota irá realmente criar um novo usuário!! Para isso, abrem o Postman e segue conforme a imagem abaixo:

p.s.: um detalhe muito importante.... qualquer requisição que for fazer, procurem reiniciar o serviço do node!!! ;)


p.s: o formato a ser incluso no Postman deverá ser x-www-urlencoded. Pois isso irá enviar todos os nossos dados para o server do Node como querys strings!!
screen-shot-10-13-16-at-10-44-pm UFA! Deu tudo certo! E olha o nosso middleware funcionando gente!!! :D screen-shot-10-13-16-at-10-46-pm
 
Isso é um bom sinal!! :D Bom... vamos que ainda tem mais rotas para desenvolver! :D

Selecionando Todos os Usuarios: GET /api/usuarios

Esta será uma rota bem simples que iremos adicionar dentro do router.route() que nós criamos para o POST. Com o router.route(), seremos capazes de encadear diferentes rotas. Isso nos ajudará a manter o código mais organizado e limpo. Novamente, inclua o código abaixo no arquivo 'server.js':

...
----> abaixo do método POST <---
 
    /* 2) Método: Selecionar Todos (acessar em: GET http://locahost:8080/api/usuarios) */
    .get(function(req, res) {
 
        //Função para Selecionar Todos os 'usuarios' e verificar se há algum erro:
        Usuario.find(function(err, usuarios) {
            if(err)
                res.send(err);
 
            res.json(usuarios);
        });
    });
 
/* Todas as nossas rotas serão prefixadas com '/api' */
app.use('/api', router);
 
...


Rota simples. Não é mesmo?! Agora.... vamos testar ela no Postman! :D Lembrando que essa rota terá que retornar os usuários criados em formato de JSON!

screen-shot-10-13-16-at-11-02-pm

Nem preciso falar nada né!!! Show de bola!!! :D

 yeah 

Vamos que ainda faltam mais 3 rotas!!!

Criando rotas para um único item

Temos desenvolvido grupo de rotas que terminam com: /usuarios. Agora, vamos desenvolver as rotas que terminarão com um parâmetro: id do usuário.

As rotas que irão terminar em: /usuarios/:usuario_id serão:

  • Selecionar o Usuário por Id;
  • Atualizar o Usuário;
  • Deletar o Usuário;

O :usuario_id será acessado graças ao pacote do body-parser que definimos anteriormente.

Selecionar o Usuario por Id: GET /api/usuarios/:usuario_id

Vamos adicionar um outro 'router.route() na aplicação para lidar com os requests que tem o :usuario_id:

...
 
// Rotas que irão terminar em '/usuarios/:usuario_id' - (servem tanto para GET by Id, PUT, & DELETE)
router.route('/usuarios/:usuario_id')
 
    /* 3) Método: Selecionar Por Id (acessar em: GET http://localhost:8080/api/usuarios/:usuario_id) */
    .get(function(req, res) {
 
        //Função para Selecionar Por Id e verificar se há algum erro:
        Usuario.findById(req.params.usuario_id, function(error, usuario) {
            if(error)
                res.send(error);
 
            res.json(usuario);
        });
    });
 
/* Todas as nossas rotas serão prefixadas com '/api' */
app.use('/api', router);
 
...

Definido a nossa rota que irá selecionar um determinado usuário pelo id. Vamos agora testar no Postman, se tudo está dentro dos conformes! Para isso, vamos pegar o Id do usuário que recém criamos. :D
p.s.: procure criar um outro usuário para realizar esse teste!! ;)

screen-shot-10-13-16-at-11-22-pm screen-shot-10-13-16-at-11-23-pm Notem que eu criei 2 usuários. Pedi para a aplicação retornar todos os usuários via POST. Com isso, peguei o id de um deles, usei o método GET passando o parâmetro do id e retornou um único usuário! Excelente! :D

Atualizando o Usuário: PUT /api/usuarios/:usuario_id

Preciso nem dizer o que precisa fazer aqui né.. segue o código abaixo:

...
 
        /* 4) Método: Atualizar (acessar em: PUT http://localhost:8080/api/usuarios/:usuario_id) */
    .put(function(req, res) {
 
        //Primeiro: Para atualizarmos, precisamos primeiro achar o Usuario. Para isso, vamos selecionar por id:
        Usuario.findById(req.params.usuario_id, function(error, usuario) {
            if(error)
                res.send(error);
 
            //Segundo: Diferente do Selecionar Por Id... a resposta será a atribuição do que encontramos na classe modelo:
            usuario.nome = req.body.nome;
            usuario.login = req.body.login;
            usuario.senha = req.body.senha;
 
            //Terceiro: Agora que já atualizamos os campos, precisamos salvar essa alteração....
            usuario.save(function(error) {
                if(error)
                    res.send(error);
 
                res.json({ message: 'Usuário Atualizado!' });
            });
        });
    });
 
/* Todas as nossas rotas serão prefixadas com '/api' */
app.use('/api', router
 
...

Agora, testaremos essa rota no PostMan. Para isso, vamos usar novamente o id, só que dessa vez passando o
PUT e claro realizar as alterações necessárias:

screen-shot-10-13-16-at-11-40-pm Essa rota também foi tranks de criar! Agora vamos para a última rota: a exclusão!

Excluindo Usuário: DELETE /api/usuarios/:usuario_id

Para que possamos excluir um determinado usuário na nossa aplicação, tudo o que necessitaremos é enviar o request do DELETE para /api/usuarios/:usuario_id Adicione esse bloco de código no arquivo: 'server.js':

...
 
    /* 5) Método: Excluir (acessar em: http://localhost:8080/api/usuarios/:usuario_id) */
    .delete(function(req, res) {
 
        //Função para excluir os dados e também verificar se há algum erro no momento da exclusão:
        Usuario.remove({
        _id: req.params.usuario_id
        }, function(error) {
            if(error)
                res.send(error);
 
            res.json({ message: 'Usuário excluído com Sucesso! '});
        });
    });
 
/* Todas as nossas rotas serão prefixadas com '/api' */
app.use('/api', router);
 
...


Agora.... vamos testar se excluirá o usuário pelo id! Voltemos ao Postman!

screen-shot-10-13-16-at-11-48-pm Usuário foi excluído! E para testar que ele realmente foi deletado, vamos chamar a API que retorna todos os usuários! E o resultado foi.....

screen-shot-10-13-16-at-11-49-pm

Antes, tínhamos 2 usários. Agora depois da exclusão só temos um único usuário! Interessante não é mesmo?!

Palavras finais....

Bom.... foi um tutorial e tanto! Mas, bastante produtivo e podemos aprender bastante coisa! Agora procurem praticar criando novos projetos CRUD parecidos como esse para que possam fixar tudo o que foi visto aqui! Agora, vocês já sabem como desenvolver uma API simples via Node.Js, Express.Js & MongoDb. :D :D :D

Lembrando que há muitas outras coisas que podemos fazer com as nossas APIs. Podemos adicionar uma autenticação, criar melhores mensagens de erro, adicionar seções diferentes. Sem contar que podemos trabalhar com testes de unidade! Assunto para o próximo post! :D

Espero que tenham gostado desse tutorial! E caso desejam fazer um fork do projeto desenvolvido, bastam clicar AQUI! Um forte abraço a todos e até a próxima! <3 :D