Construindo APIs com Node.js, Express e Axios: Um Guia Abrangente

Oi pessoal, desenvolvedores! Hoje, vamos mergulhar fundo no mundo da construção de APIs usando Node.js, Express e Axios. Seja você um programador experiente ou alguém que está começando, este post vai te guiar na criação de APIs robustas de forma eficiente. Além disso, vou te apresentar uma ferramenta incrível chamada Apidog que vai agilizar seu processo de teste e documentação de APIs.

Introdução

APIs (Interfaces de Programação de Aplicações) tornaram-se a espinha dorsal das aplicações web modernas. Elas permitem que diferentes sistemas de software se comuniquem e compartilhem dados de forma fluida. Seja desenvolvendo um aplicativo web, um aplicativo móvel, ou até mesmo um aplicativo desktop, as APIs são essenciais.

Por que Node.js, Express e Axios?

Node.js, Express e Axios formam um trio dinâmico quando se trata de construir e consumir APIs. Aqui está o porquê:

• Node.js: Conhecido por sua arquitetura não bloqueante e orientada a eventos, o Node.js é perfeito para criar aplicações de rede escaláveis.
• Express: Este framework web minimalista e flexível para Node.js oferece um conjunto robusto de recursos para desenvolver aplicações web e móveis.
• Axios: Um cliente HTTP baseado em promessas para o navegador e Node.js, o Axios torna fácil enviar requisições HTTP assíncronas para pontos finais REST e realizar operações CRUD.

Combinando essas três ferramentas poderosas, você pode construir APIs eficientes, escaláveis e fáceis de manter.

Configurando Seu Ambiente

Antes de mergulharmos no código, vamos configurar nosso ambiente. Você precisará do Node.js e npm (Gerenciador de Pacotes do Node) instalados na sua máquina.

1. Instalar Node.js e npm: Acesse o site do Node.js e baixe a versão mais recente. O npm vem junto com o Node.js.
2. Inicializar um novo projeto: Abra seu terminal e execute:

mkdir nodejs-express-axios-api
cd nodejs-express-axios-api
npm init -y

Isso criará um novo diretório e inicializará um novo projeto Node.js com um arquivo package.json padrão.

1. Instalar Express e Axios:

npm install express axios

Criando Sua Primeira API com Node.js e Express

Agora que nosso ambiente está configurado, vamos criar uma API simples.

Configurando o Express

Primeiro, precisamos configurar nosso servidor Express. Crie um arquivo chamado server.js e adicione o seguinte código:

const express = require('express');
const app = express();
const PORT = 3000;

// Middleware para parsear JSON
app.use(express.json());

// Iniciar o servidor
app.listen(PORT, () => {
    console.log(`Servidor rodando em http://localhost:${PORT}`);
});

Definindo Pontos Finais da API

Em seguida, vamos definir alguns pontos finais da API. Vamos criar pontos finais para uma aplicação CRUD simples que gerencia uma lista de livros.

1. Criar um Livro: Este ponto final permitirá que os usuários adicionem um novo livro à lista.
2. Ler Livros: Este ponto final retornará a lista de todos os livros.
3. Atualizar um Livro: Este ponto final permitirá que os usuários atualizem os detalhes de um livro existente.
4. Deletar um Livro: Este ponto final permitirá que os usuários deletam um livro da lista.

Adicione o seguinte código a server.js:

let books = [];

// Criar um Livro
app.post('/books', (req, res) => {
    const book = req.body;
    books.push(book);
    res.status(201).send('Livro adicionado com sucesso');
});

// Ler Livros
app.get('/books', (req, res) => {
    res.json(books);
});

// Atualizar um Livro
app.put('/books/:id', (req, res) => {
    const bookId = req.params.id;
    const updatedBook = req.body;
    books = books.map(book => book.id === bookId ? updatedBook : book);
    res.send('Livro atualizado com sucesso');
});

// Deletar um Livro
app.delete('/books/:id', (req, res) => {
    const bookId = req.params.id;
    books = books.filter(book => book.id !== bookId);
    res.send('Livro deletado com sucesso');
});

Executando Sua API

Para executar sua API, use simplesmente o seguinte comando no seu terminal:

node server.js

Você deve ver a mensagem: Servidor rodando em http://localhost:3000.

Consumindo APIs com Axios

Agora que temos nossa API rodando, vamos aprender como consumi-la usando Axios.

Fazendo Requisições HTTP com Axios

Axios torna fácil enviar requisições HTTP assíncronas para pontos finais REST e realizar operações CRUD. Vamos demonstrar como realizar cada operação (Criar, Ler, Atualizar, Deletar) usando Axios.

Primeiro, instale o Axios no seu projeto, caso ainda não tenha feito:

npm install axios

Exemplo: Usando Axios para Interagir com Nossa API de Livros

Crie um novo arquivo chamado client.js e adicione o seguinte código:

const axios = require('axios');
const API_URL = 'http://localhost:3000/books';

// Criar um novo livro
const createBook = async (book) => {
    try {
        const response = await axios.post(API_URL, book);
        console.log(response.data);
    } catch (error) {
        console.error(error);
    }
};

// Ler todos os livros
const getBooks = async () => {
    try {
        const response = await axios.get(API_URL);
        console.log(response.data);
    } catch (error) {
        console.error(error);
    }
};

// Atualizar um livro
const updateBook = async (bookId, updatedBook) => {
    try {
        const response = await axios.put(`${API_URL}/${bookId}`, updatedBook);
        console.log(response.data);
    } catch (error) {
        console.error(error);
    }
};

// Deletar um livro
const deleteBook = async (bookId) => {
    try {
        const response = await axios.delete(`${API_URL}/${bookId}`);
        console.log(response.data);
    } catch (error) {
        console.error(error);
    }
};

// Exemplos de uso
const newBook = { id: '1', title: 'Node.js para Iniciantes', author: 'John Doe' };
createBook(newBook);
getBooks();
updateBook('1', { id: '1', title: 'Node.js Avançado', author: 'John Doe' });
deleteBook('1');

Explicação

1. createBook: Envia uma requisição POST para adicionar um novo livro.
2. getBooks: Envia uma requisição GET para recuperar todos os livros.
3. updateBook: Envia uma requisição PUT para atualizar um livro existente.
4. deleteBook: Envia uma requisição DELETE para remover um livro.

Uso Avançado do Axios e Tratamento de Erros

O tratamento de erros é crucial ao lidar com requisições HTTP. O Axios oferece várias maneiras de lidar com erros de forma eficaz.

Tratando Erros

Modifique o arquivo client.js para lidar com erros de forma mais elegante:

const axios = require('axios');
const API_URL = 'http://localhost:3000/books';

// Criar um novo livro
const createBook = async (book) => {
    try {
        const response = await axios.post(API_URL, book);
        console.log(response.data);
    } catch (error) {
        handleError(error);
    }
};

// Ler todos os livros
const getBooks = async () => {
    try {
        const response = await axios.get(API_URL);
        console.log(response.data);
    } catch (error) {
        handleError(error);
    }
};

// Atualizar um livro
const updateBook = async (bookId, updatedBook) => {
    try {
        const response = await axios.put(`${API_URL}/${bookId}`, updatedBook);
        console.log(response.data);
    } catch (error) {
        handleError(error);
    }
};

// Deletar um livro
const deleteBook = async (bookId) => {
    try {
        const response = await axios.delete(`${API_URL}/${bookId}`);
        console.log(response.data);
    } catch (error) {
        handleError(error);
    }
};

// Função de tratamento de erros
const handleError = (error) => {
    if (error.response) {
        // A requisição foi feita e o servidor respondeu com um código de status
        console.error('Erro:', error.response.data);
        console.error('Status:', error.response.status);
        console.error('Headers:', error.response.headers);
    } else if (error.request) {
        // A requisição foi feita, mas nenhuma resposta foi recebida
        console.error('Erro: Nenhuma resposta recebida', error.request);
    } else {
        // Algo aconteceu ao configurar a requisição
        console.error('Erro:', error.message);
    }
};

Configurando Cabeçalhos Personalizados e Interceptadores

O Axios permite que você configure cabeçalhos personalizados e intercepte requisições ou respostas. Isso pode ser útil para adicionar tokens de autenticação ou fazer logging.

const axios = require('axios');
const API_URL = 'http://localhost:3000/books';

// Instância do axios com cabeçalhos personalizados
const axiosInstance = axios.create({
    baseURL: API_URL,
    headers: { 'Authorization': 'Bearer SEU_TOKEN_AQUI' }
});

// Interceptor de requisição
axiosInstance.interceptors.request.use(config => {
    console.log('Requisição enviada em:', new Date().toISOString());
    return config;
}, error => {
    return Promise.reject(error);
});

// Interceptor de resposta
axiosInstance.interceptors.response.use(response => {
    console.log('Resposta recebida em:', new Date().toISOString());
    return response;
}, error => {
    return Promise.reject(error);
});

// Exemplo de uso com interceptores
const getBooks = async () => {
    try {
        const response = await axiosInstance.get('/');
        console.log(response.data);
    } catch (error) {
        console.error(error);
    }
};

getBooks

();

Testando e Documentando Sua API com APIdog

Testar e documentar suas APIs é crucial para garantir que funcionem como esperado e sejam fáceis de usar por outros desenvolvedores. É aí que o APIdog entra em cena.

O que é Apidog?

APIdog é uma ferramenta poderosa que te ajuda a testar e documentar suas APIs sem esforço. Com o APIdog, você pode criar documentação abrangente de API, realizar testes automatizados e compartilhar suas APIs com sua equipe.

Testando API com Apidog

Vamos passar por um breve tutorial sobre como usar o Apidog para fazer uma requisição [post].

Passo 1: Abra o Apidog e crie uma nova requisição.

• Inicie o Apidog e selecione Nova Requisição

Passo 2: Insira a API

• Encontre ou insira manualmente os detalhes da API para a requisição POST que você deseja fazer.

Passo 3: Insira Parâmetros

• Preencha os parâmetros necessários e qualquer dado que você deseja incluir no corpo da requisição.

Usar o Apidog pode economizar tempo e esforço ao trabalhar com requisições POST.

Documentando Nossa API com Apidog

Para gerar documentação de API facilmente, basta seguir estes guias passo a passo:

Passo 1: Cadastre-se no Apidog

Para começar a usar o Apidog para documentação de API, crie uma conta e faça login. Ao fazer login, você será direcionado ao Centro de Projetos, onde poderá selecionar o projeto padrão ou criar um novo.

Passo 2: Crie uma Nova API

Seu projeto de API consistirá em vários pontos finais. Adicione um ponto final clicando no botão "+" ou "Adicionar Ponto Final" dentro do seu projeto.

Passo 3: Preencha as Informações da API

Forneça detalhes como a URL do ponto final, descrição e especificidades de requisição/resposta. Documentar os pontos finais inclui:

• Especificar o método HTTP (GET, POST, PUT, DELETE, etc.) e o caminho da requisição da API
• Definir os parâmetros da requisição (nomes, tipos, descrições)
• Descrever as respostas esperadas (códigos de status, formatos, exemplos de respostas)

Passo 4: Salve a Documentação da API

Após inserir as informações necessárias, clique em "Salvar" para salvar a documentação da API.

Passo 5: Teste a API Diretamente da Documentação Online da API

Uma vez que você salvar a documentação da API, haverá uma opção para "Executar" sua API. Clicar no botão "Executar" enviará uma requisição API e buscará a resposta para você testar os pontos finais. Durante esse processo, você pode identificar quaisquer erros e problemas que precisam ser resolvidos.

Uma vez que a documentação da API atenda às necessidades do negócio, você pode compartilhá-la com outros através de um único link.

Benefícios de Gerar Documentação de API Online Usando Apidog

• Depuração Online: Depure suas APIs facilmente diretamente na documentação clicando no botão "Executar", permitindo testes rápidos e eficientes.

• Geração Automática de Documentação: Gere automaticamente documentação abrangente da API preenchendo as informações necessárias, eliminando a necessidade de configuração manual extensa.

• Geração de Código: Gere instantaneamente código de modelo de requisição e resposta em várias linguagens, como JavaScript, com opções para Fetch, Axios e JQuery, etc., simplificando o processo de desenvolvimento.

• Mock em Nuvem: Utilize o Mock em Nuvem para simular serviços Backend e criar servidores virtuais para testes sem restrições, aumentando a flexibilidade e reduzindo a dependência de serviços backend reais.

Conclusão

Parabéns! Você construiu uma API robusta usando Node.js, Express e Axios com sucesso. Você também aprendeu a consumir APIs com Axios, a lidar com erros de forma eficaz e a aprimorar seus testes e documentação de API com o APIdog.

APIs são a espinha dorsal do desenvolvimento web moderno, e dominar essas ferramentas irá colocá-lo no caminho para criar aplicações poderosas e escaláveis. Não se esqueça de baixar o APIdog gratuitamente para agilizar seu processo de desenvolvimento e teste de API.