Veja neste artigo como consumir dados armazenados em Cloud utilizando uma API RESTful desenvolvida em Node.js.

Para pular a etapa de desenvolvimento de uma API com Node.js, eu irei utilizar uma apresentada no artigo “Criando uma API em 10 passos“.

Eu fiz algumas alterações nesse projeto. Removi uma validação de portas no arquivo ./bin/server.js, e na estrutura, movendo tudo da pasta src para raiz do projeto. Caso tenha interesse em clonar a versão do projeto com essas alterações, eu subi ele no seguinte link: node-api-express.

Para os próximos passos será necessário ter uma conta no Azure, Caso você ainda não tenha uma, recomendo a leitura do seguinte artigo: “visual-studio-dev-essentials“, no qual eu apresento um programa de benefícios disponibilizados pela Microsoft, onde você consegue alguns créditos para utilizar no Azure.

Com a etapa da conta OK e logado no portal, siga os passos abaixo:

1 – Clique no link Azure Cosmos DB:

2 – Clique no ícone (+):

3 – Preencha os campos com as informações abaixo:

• Subscription: sua assinatura no Azure
• Resource group: em qual grupo de recursos que você criará esse serviço
• Account name: nome do seu serviço
• API: o Cosmos nos permite trabalhar com cinco tipos de API. Para esse artigo usaremos o Azure Cosmos DB for MongoDB API
• Location: localização para criação do seu serviço
• Geo-Redundancy e Multi-region Writes: flags para habilitar distribuição global da sua aplicação. Deixarei as duas como disable

Abaixo você tem uma imagem demonstrando o preenchimento dos campos do passo anterior:

Agora clique em “Review + create” para pular a etapa de tags e network. Essa etapa pode demorar alguns minutos – aguarde até retornar a mensagem abaixo:

Agora abra o projeto no seu editor de textos preferido e siga os passos abaixo:

1 – Crie um novo diretório chamado config, e dentro dele um arquivo chamado db.js. Em seguida, atualize-o com o trecho de código abaixo:

var mongoose = require('mongoose');

mongoose.connect("mongodb://{host}:{porta}/?ssl=true", {
    auth: {
      user: "{usuario}",
      password: "{password}"
    }
  })

PersonSchema = require('../models/person');

var Person = mongoose.model('Person', PersonSchema);
module.exports = Person;

Feito isso, volte no portal do Azure, acesse o serviço criado no passo anterior e clique em “Connection String“. Em seguida, copie a connection string e cole na linha 3 do arquivo db.js.

Abaixo você tem uma imagem demonstrando esse passo:

O próximo passo será criar a nossa model. Para isso, crie um novo diretório chamado models. Dentro dele, um arquivo chamado person.js, e em seguida atualize-o com o trecho de código abaixo:

var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var PersonSchema = new Schema({
    nome: String,
    foto: String
});

module.exports = PersonSchema;

Com a nossa model OK, o próximo passo será criar uma camada para as nossas queries. Para isso, crie um novo diretório chamado services, e dentro dele um arquivo chamado personService.js. Em seguida, atualize-o com o trecho de código abaixo:

'use strict';
var Person = require('../config/db');

module.exports = new class PersonService {

    getAll() {
        return Person.find();
    }

    getById(id) {
        return Person.findById(id);
    }

    create(person) {
        return Person.create(person);
    }

    update(id, person) {
        return Person.findByIdAndUpdate(id,person);
    }

    delete(id) {
        return Person.findByIdAndDelete(id);
    }
}

Analisando rapidamente o trecho de código anterior, nós temos uma camada que irá conectar com o nosso banco de dados e realizar as nossas queries.

Por fim, atualizaremos o arquivo personController.js para chamarmos os nossos services através de suas rotas.

const PersonService = require('../services/personService');

exports.get = (req, res, next) => {
    PersonService.getAll()
    .then((person) => {
        res.status(200).send(person);
    }).catch(err => res.status(500).send(err))
};


exports.getById = (req, res, next) => {
    const _id = req.params.id;

    PersonService.getById(_id)
        .then((person) => {
            res.status(200).send(person);
        }).catch(err => res.status(500).send(err))
};

exports.post = (req, res, next) => {
    const vm = req.body;

    PersonService.create(vm)
        .then(() => {
            res.status(200).send(`Person criada com sucesso!`);
        }).catch(err => res.status(500).send(err))
};


exports.put = (req, res, next) => {
    let id = req.params.id;
    
    const vm = req.body;

    PersonService.update(id,vm)
        .then(() => {
            res.status(200).send(`Person atualizada com sucesso!`);
        }).catch(err => res.status(500).send(err))

};

exports.delete = (req, res, next) => {
  
PersonService.delete(id)
    .then(() => {
        res.status(200).send(`Person deletada com sucesso!`);
    }) .catch(err => res.status(500).send(err)) 
};

Testando o código

Agora, para validar se os passos anteriores estão OK, eu usarei o Postman, ferramenta gratuita que nos auxilia nos testes a requisições HTTP. Com ele aberto, preencha os campos conforme estão preenchidos na imagem abaixo e clique em enviar.

Agora altere de POST para GET, e se tudo estiver OK, a API retornará os passos cadastrados no passo anterior. Abaixo você tem uma imagem demonstrando esse passo:

Bem simples, né?

Agora, para finalizar esse artigo, vamos verificar o registro que cadastramos no passo anterior dentro do Azure. Para isso, volte no portal e navegue até Data Explorer > Collections > Documents e clique em um dos IDs cadastrados. Abaixo você tem uma imagem demonstrando esse passo:

A ideia desse artigo era mostrar como dar os primeiros passos com o Cosmos DB utilizando uma API RESTful desenvolvida em Node.js.

Caso você tenha interesse em clonar a versão final do código apresentado nesse artigo, segue o seu link no meu Github: node-cosmosdb.

Espero que tenham gostado e até um próximo artigo, pessoal!