Parte 3 – Crie uma API REST em NodeJS + TypeScript

Vamos gerenciar nossos clientes 

Agora que já temos nosso web service funcionando e conectado ao nosso banco de dados vamos começar a escrever o controller que será responsável pelo nosso CRUD de clientes 

Vamos começar criando os seguintes arquivos: 

touch server/{controller,model}.ts 

Vamos começar pelo arquivo model, onde vamos escrever os campos e tipos de campos que teremos para guardar as informações do nosso cliente, por ultimo vamos passar para o mongo criar a colletion. 
Sempre que quisermos executar algo com o mongo o mongoose tem a função de verificar se essa “tabela” existe, se não existir ele cria para nós e a usa em seguida sem que o usuário perceba o que está acontecendo. 

import * as mongoose from ‘mongoose’; 
 

const CrushSchema = new mongoose.Schema({ 
 

nome: {type: String, required: true}, 

telefone: {type: String, unique: true, required: true}, 

email: {type: String, unique: true, required: true}, 

observacoes: {type: String, required: true}, 

createdAt: {type: Date, default: Date.now} 
 

}); 

export default mongoose.model(Clientes, ClienteSchema); 

Agora vamos ao nosso arquivo controller onde vamos escrever nossos métodos de CRUD + as funções que terão a responsabilidade de enviar o conteúdo para o routes dentro do app.ts: 

import model from ‘./model’; 
class Controller { 
    constructor() { } 
    //select 
    getClientes() { 
        return model.find({}); 
    } 
    select(req, res) { 
        this. getClientes () 
     .then(clientes=> res.status(200).json({ ‘result’: clientes })) 
            .catch(err => res.status(400).json({ ‘result’: err })); 
    } 

     //selectone 
   getClienteByID(id) { 
        return model.find(id); 
   } 
   selectOne(req, res) { 
        const id = { _id: req.params.id } 
        this.getClienteByID(id) 
      .then(cliente => res.status(200).json({ ‘result’: cliente })) 
         .catch(err => res.status(400).json({ ‘result’: err })); 
    } 

     //delete 
    deleteByID(id) { 
        return model.deleteOne(id); 
    } 
    delete(req, res) { 
        const id = { _id: req.params.id } 
        this.deleteByID(id) 
            .then(clientes => res.status(200).json({ ‘result’: clientes })) 
            .catch(err => res.status(400).json({ ‘result’: err })); 
    } 

     //update 
    updateCliente(id, data) { 
        return model.findOneAndUpdate(id, data); 
    } 
    update(req, res) { 
        const id = { _id: req.params.id } 
        const cliente = req.body; 
        this.updateCliente(id, cliente) 
            .then(clientes => res.status(200).json({ ‘result’: clientes })) 
            .catch(err => res.status(400).json({ ‘result’: err })); 
    } 

     //insert 
    createCliente(data) { 
        return model.create(data); 
    } 
    insert(req, res) { 
        const cliente = req.body; 
        this.createCliente(cliente) 
            .then(clientes => res.status(200).json({ ‘result’: clientes })) 
            .catch(err => res.status(400).json({ ‘result’: err })); 
    } 
} 
export default Controller; 

Concluído! Com o nosso CRUD pronto vamos chamar tudo isso no arquivo app.ts, começamos importando o arquivo routes.ts que é o responsável por chamar toda a estrutura do módulo 

import database from ‘./db’;  
import controller from ‘./controller’; 

Em nosso método construtor vamos instanciar a classe database  

 
this.database = new database(); 

this.database.createConnection(); 
this.controller = new controller(); 

No método rotas onde chamamos o “/” que é a nossa URL base, vamos criar novas rotas para chamar cada função da nossa API que são: 

• Listar todos os nossos Clientes 
• Listar um Cliente específico 
• Editar um Cliente 
• Apagar um Cliente 
   

Vamos criar as rotas: 

this.app.route(‘/api/clientes’).get( (req,res)=> this.controller.select(req, res) ); 

 
this.app.route(‘/api/clientes/:id’).get( (req,res)=> this.controller.selectOne(req, res) ); 

 
this.app.route(‘/api/clientes/:id’).delete( (req,res)=> this.controller.delete(req, res) ); 

 
this.app.route(‘/api/clientes/:id’).put( (req,res)=> this.controller.update(req, res) ); 
 
this.app.route(‘/api/clientes’).post( (req,res)=> this.controller.insert(req, res) ); 

Se você digitar agora no seu navegador http://localhost:5000/api/clientes vai aparecer a lista (em json) de todos os Clientes e suas informações, para a função de insert e update funcionarem corretamente precisamos incluir um middleware executando o bodyparser para fazer a conversão do tudo que entra e do que sai em JSON, vamos começar pelo método, ainda dentro do arquivo app.ts. 

middleware(){  

this.app.use(bodyParser.json()); 

     this.app.use(bodyParser.urlencoded({ extended: true })); 

} 
 
Agora vamos chamá-lo dentro do método construtor, o método completo ficará assim: 
 

constructor(){ 

        this.app = express(); 

        this.middleware(); 

        this.database = new database(); 

        this.database.createConnection(); 

        this.controller = new controller(); 

        this.routes(); 

} 

Como podemos testar a API? 

Para testar a API é necessário um programa como o Postman, com ele é possível usar os métodos http POST, PUT e DELETE: https://www.getpostman.com/