Um guia para iniciantes em APIs RESTful em Node.js

Uma API REST (Representational State Transfer) — às vezes chamada de RESTful AP — é uma API que usa solicitações HTTP para acessar e usar recursos.

Esses recursos geralmente são representados no formato JSON, embora em algumas ocasiões os formatos XML, texto e HTML sejam usados. As APIs REST tornaram-se uma maneira padrão para os aplicativos trocarem dados em uma rede por meio de métodos HTTP como GET, PUT, POST e DELETE. Eles facilitam a criação, leitura, atualização e exclusão de recursos comumente chamados de operações CRUD.

Este guia explora como você pode usar o Node. JS para criar uma API CRUD Restful simples.

O que você precisa para acompanhar

Certifique-se de ter o Node.js instalado em sua máquina local. Corre nó -v para verificar se o Node. JS está instalado. Este comando deve retornar o número da versão.

Relacionado: Como instalar o Node.js no Windows

Você também deve ter uma instância de trabalho do seu favorito editor de texto (por exemplo, Código VS).

Configuração do projeto

Crie uma pasta para seu aplicativo e navegue até ela. No terminal e no diretório que você acabou de criar, inicialize

pacote.json Correndo npm init.

$ npm init -y 

O pacote.json irá ajudá-lo a instalar e gerenciar pacotes npm. O -y flag cria o arquivo package.json usando as opções padrão sem que você precise configurar os detalhes individuais. A saída no seu terminal deve ficar assim. Observe que o nome será diferente dependendo de como você nomeou sua pasta.

Configurar o servidor

Para criar um servidor, primeiro instale o Express.js e o Nodemon. Express.js é um nó. Js que foi projetado para facilitar o desenvolvimento de aplicações web e APIs. Você vai usá-lo para configurar o servidor e os pontos de extremidade da API. O Nodemon, por outro lado, é uma ferramenta de desenvolvimento que reiniciará seu servidor quando o código do aplicativo for alterado.

Execute o seguinte comando para instalar expressar e nómon:

npm eu expresso nodemon 

Em seguida, para criar seu servidor, crie um arquivo e chame-o server.js em seguida, adicione o seguinte código.

// Requer expresso
const expresso = require("expresso");
// Inicializa expresso
const app = express();
const PORTA = 8080;
// analisa JSON
app.use (express.json());
// analisa dados codificados de URL
app.use (express.urlencoded({ extended: true }));
//cria um servidor
app.listen (PORT, () => {
console.log(`Servidor rodando na porta ${PORT}`);
});

No código acima, exija express em seu server.js arquivo e inicializá-lo. Em seguida, configure o express para analisar dados codificados em JSON e URL. Finalmente, crie um servidor usando o ouço() método do Express.

Relacionado: O que é Express.js e por que você deve usá-lo?

Introdução: criar uma matriz para armazenar dados do usuário

Para fins de simplicidade, você não usará um banco de dados, mas sim uma matriz de usuário simples. Em seu app.js, adicione o código a seguir após a linha que analisa os dados codificados de URL.

const usuários = [{
 código: 1,
 nome: "Jane Doe",
 idade: "22",
 },
 {
 identificação: 2,
 nome: "John Doe",
 idade: "31",
}];

Relacionado: Como criar um banco de dados e uma coleção no MongoDB

Como configurar rotas no Express.js

Para realizar operações em seus dados, você precisa configurar o roteamento. As rotas determinarão como seu aplicativo responderá às solicitações feitas a um determinado endpoint. Cada rota tem um método HTTP, uma URL e uma função de manipulador que trata da solicitação e resposta HTTP. Para configurar as rotas, adicione o seguinte ao seu server.js arquivo após o seu Comercial variedade.

app.post('/criar', (req, res) => {
 //Cria um usuário
});
app.get('/usuários', (req, res) => {
 // Recupera todos os usuários
});
app.get('/user/:userID', (req, res) => {
 // Retorna um usuário por ID
});
app.put('/user/:userID', (req, res) => {
 // Atualiza um usuário por ID
});
app.delete('/delete/:userID', (req, res) => {
 // Excluir um usuário por ID
});
app.delete('/users', (req, res) => {
 // Excluir todos os usuários
});

Como executar operações CRUD no Node. J

Você precisa criar as funções que irão manipular os dados do usuário e retornar uma resposta de acordo com a rota correspondida. Essas funções criarão, lerão, atualizarão e excluirão dados do usuário.

Relacionado: Como executar operações CRUD no MongoDB

Como criar um novo usuário

Para criar um novo usuário, você precisará:

• Verifique se o corpo da solicitação está vazio — se estiver, envie uma resposta de erro.
• Extraia os dados do usuário do corpo da solicitação.
• Valide os dados do usuário.
• Envie os dados do usuário para a matriz.

Observe que você está usando uma matriz apenas para fins de simplicidade. Em um cenário de caso real, você estaria interagindo com um banco de dados.

Edite sua rota POST conforme abaixo.

app.post("/criar", (req, res) => {
// Verifica se o corpo da requisição está vazio
if (!Object.keys (req.body).length) {
 return res.status (400).json({
 mensagem: "O corpo da solicitação não pode estar vazio",
 });
}
// Usa a desestruturação de objetos para obter o nome e a idade
const { nome, idade } = req.body;
if (!nome || !idade) {
 res.status (400).json({
 mensagem: "Certifique-se de que enviou o nome e a idade",
 });
}
const novoUsuário = {
 id: users.length + 1,
 nome,
 era,
};
experimentar {
 users.push (novoUsuário);
 res.status (201).json({
 mensagem: "Criado com sucesso um novo usuário",
 });
} pegar (erro) {
 res.status (500).json({
 mensagem: "Falha ao criar usuário",
 });
}
});

Como ler usuários

Para recuperar todos os usuários, retorne a matriz de usuários em sua resposta.

app.get("/usuários", (req, res) => {
 experimentar {
 res.status (200).json({
 Comercial
 });
 } pegar (erro) {
 res.status (500).json({
 mensagem: "Falha ao recuperar todos os usuários",
 });
 }
});

Se você testar essa rota usando o carteiro, deverá receber a matriz de usuários no corpo da resposta.

Para recuperar apenas um usuário:

• Obtenha o ID do usuário do parâmetro URL.
• Usar achar() para identificar quais dados de usuário específicos você está solicitando.
• Retorne o usuário na resposta.

app.get("/users/:userID", (req, res) => {
 const id = parseInt (req.params.userID);
 console.log (id);
 experimentar {
 deixe usuário = users.find((usuário) => user.id id);
 if (!usuário) {
 return res.status (404).json({
 mensagem: "Usuário não encontrado",
 });
 }
 res.status (200).json({
 do utilizador,
 });
 } pegar (erro) {
 res.status (500).json({
 mensagem: "Falha ao recuperar usuário",
 });
 }
});

Como atualizar usuários

Para atualizar o usuário:

• Recupere o ID do usuário da URL.
• Usar achar() para verificar se o usuário existe.
• Usar índice de() para obter o índice do usuário que está sendo referenciado.
• Use o índice para editar os dados do usuário com os dados enviados pelo corpo da solicitação.

app.put("/users/:userID", (req, res) => {
 experimentar {
 const id = parseInt (req.params.userID);
 deixe usuário = users.find((usuário) => user.id id);
 if (!usuário) {
 return res.status (404).json({
 mensagem: "Usuário não encontrado",
 });
 }
 const userIDX = users.indexOf (usuário);
 users[userIDX].name = req.body.name || usuários[userIDX].name;
 users[userIDX].age = req.body.age || usuários[userIDX].idade;
 res.status (200).json({
 mensagem: "Usuário atualizado com sucesso",
 do utilizador,
 });
 } pegar (erro) {
 res.status (500).json({
 mensagem: "Falha ao recuperar usuário",
 });
 }
});

Como excluir usuários

Você pode optar por excluir um usuário ou todos os usuários.

Para excluir um usuário:

• Recuperar o ID do usuário do URL
• Usar achar() para verificar se o usuário existe
• Usar findIndex() para obter o índice do usuário que está sendo referenciado.
• Usar emenda() para excluir o usuário nesse índice.

app.delete("/users/:userID", (req, res) => {
 experimentar {
 const id = req.params.userID;
 let userIDX = users.findIndex((usuário) => user.id id);
 if (!userIDX) {
 res.status (404).json({
 mensagem: "Usuário não encontrado",
 });
 }
 users.splice (userIDX, 1);
 res.status (200).json({
 mensagem: "Usuário excluído com sucesso",
 Comercial,
 });
 } pegar (erro) {
 res.status (500).json({
 mensagem: "Falha ao excluir usuário",
 });
 }
});

Para excluir todos os usuários, junte o array inteiro.

app.delete("/usuários", (req, res) => {
 experimentar {
 users.splice (0, users.length);
 res.status (200).json({
 mensagem: "Todos os usuários excluídos com sucesso",
 Comercial,
 });
 } pegar (erro) {
 res.status (500).json({
 mensagem: "Falha ao excluir usuários",
 x,
 });
 }
});

Saiba mais sobre APIs RESTful

Este tutorial discute como criar uma API RESTful básica no Node. JS. Você aprendeu como criar um servidor Express, configurar rotas e, finalmente, criar funções de manipulador que interagem com seus dados por meio de solicitações/respostas HTTP.

No entanto, existem alguns tópicos essenciais não abordados aqui que você deve pesquisar mais, incluindo como conectar seu aplicativo a um banco de dados como o MongoDB e como proteger rotas.

Como um banco de dados MongoDB pode organizar melhor seus dados

MongoDB (de "humongous") é um banco de dados orientado a documentos multiplataforma usado como uma alternativa ao MySQL. Mas o que isso significa?

Leia a seguir

Sobre o autor