Node.js é um runtime JavaScript de código aberto construído no mecanismo v8 do Chrome que permite executar código JavaScript fora de um navegador.
Seu modelo de evento, ecossistema e velocidade tornaram o Node.js um dos tempos de execução mais procurados e usados para aplicativos do lado do servidor.
A maioria dos servidores de API Node.js usa Express ou outra estrutura. No entanto, você também pode criar uma API Node.js simples sem uma estrutura em apenas algumas etapas.
Etapa 1: configurando seu ambiente de desenvolvimento
Crie um diretório de projeto e cd nele executando:
mkdir nodejs-api
cd nodejs-api
A seguir, inicialize npm em seu projeto executando:
npm init -y
Esta API CRUD contará com o uso do MongoDB, um banco de dados NoSQL, e seu popular ODM, o mongoose.
Execute o seguinte comando para instalar mangusto:
npm instalar mangusto
A seguir, crie um server.js arquivo no diretório raiz do seu projeto e adicione o bloco de código abaixo para criar um servidor:
const http = exigir("http");
const server = http.createServer((req, res) => {});
server.listen (3000, () => {
console.registro(`Servidor está rodando`);
});
Este bloco de código importa o módulo http, um módulo Node.js principal. O módulo http permite que o Node.js transfira dados por HTTP. Este módulo contém os métodos necessários para criar um servidor.
Em seguida, ele chama o módulo http criarServidor método que cria e retorna uma instância de um servidor. o criarServidor O método recebe uma função de retorno de chamada com um objeto de solicitação e resposta como parâmetros.
Em seguida, o código chama o ouço método na instância do servidor retornada. Isso permite que o servidor comece a ouvir o tráfego na porta especificada. o ouço O método dispara um retorno de chamada — o segundo argumento — quando é bem-sucedido.
Finalmente, crie dois diretórios chamados rotas e modelos no diretório raiz do seu projeto. o rotas pasta conterá a lógica de roteamento para sua API, enquanto modelo conterá tudo relacionado ao banco de dados.
Etapa 2: conectando seu aplicativo a um banco de dados
Dentro server.js, importar mangusto:
const mangusto = exigir("mangusto");
Ligar para conectar método em mangusto e passe seu URI do MongoDB como um argumento:
mangusto.conectar("MongoDB_URI")
Etapa 3: criar um modelo de API
Crie uma API CRUD para um aplicativo de blog simples. Na tua modelos pasta, crie um blogModel.js arquivo e adicione o seguinte código ao seu arquivo:
const mangusto = exigir("mangusto");
const blogSchema = mangusto. Esquema({
título: {
modelo: Corda,
obrigatório: [verdadeiro, "O blog deve ter um título"],
},
corpo: {
modelo: Corda,
obrigatório: [verdadeiro, "O blog deve ter um corpo"],
},
});
módulo.exportações = mongoose.model("Blog", blogSchema);
O bloco de código acima cria um modelo mongoose com duas propriedades e as mapeia para um banco de dados MongoDB.
Ambas as propriedades neste modelo têm um Corda digite com requeridos definido como verdadeiro. As mensagens de erro que acompanham serão exibidas se um corpo de solicitação não contiver nenhuma das propriedades.
A linha final cria e exporta um modelo de mangusto chamando o método modelo método em mangusto. Passe o nome do modelo (Blogue) como o primeiro argumento e um esquema (blogSchema) como o segundo argumento.
Etapa 4: implementando o roteamento em seu aplicativo
Sem a ajuda de frameworks como Express, você terá que criar manualmente a lógica para lidar com cada solicitação feita à sua API.
Primeiro, crie um blogRoutes.js arquivo em seu rotas pasta e importe o modelo de blog:
const Blogue = exigir(""../models/blogModel");
Em seguida, crie um arquivo assíncrono roteador função, passe req e res como parâmetros e exporte a função:
const roteador = assíncronofunção (req, res) {};
módulo.exportações = roteador;
Esta função conterá toda a sua lógica de roteamento.
Em seguida, você implementará a lógica de roteamento rota por rota.
GET Rotas
Adicione o bloco de código abaixo ao seu roteador função para implementar o PEGUE manipulador de rotas para solicitações feitas a /api/blogs:
// OBTER: /api/blogs
se (req.url "/api/blogs"&& req.método "PEGUE") {
// obtém todos os blogs
const blogs = aguardam Blog.find();// definir a status código econtente-modelo
res.writeHead (200, { "Tipo de conteúdo": "aplicativo/json" });
//envia dados
res.fim(JSON.stringify(blogs));
}
O bloco de código acima verifica o URL e método propriedades do objeto de solicitação. Em seguida, ele busca todos os blogs do banco de dados por meio do achar método no modelo mangusto (Blogue).
A seguir, chama o escrever Cabeçalho método em res, o objeto de resposta. Esse método envia um cabeçalho de resposta com três argumentos: um código de status, uma mensagem de status opcional e cabeçalhos. o 200 código de status representa uma resposta bem-sucedida e o tipo de conteúdo para esta chamada de API é definido como aplicativo/json.
Por fim, feche a solicitação para garantir que o servidor não seja interrompido chamando o fim método em res. A chamada para JSON.stringify converte o blogs objeto para uma string JSON e passando isso para o fim O método retorna como o corpo da resposta.
Adicione o bloco de código abaixo ao seu roteador função para implementar o PEGUE manipulador de rota para um único recurso:
// OBTER: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.método "PEGUE") {
tentar {
//extrai id da url
const id = req.url.split("/")[3];// obtém o blog do banco de dados
const blog = aguardam Blog.findById (id);
if (blogue) {
res.writeHead (200, { "Tipo de conteúdo": "aplicativo/json" });
res.fim(JSON.stringify(blog));
} senão {
lançarnovoErro("Blog não existe");
}
} truque (erro) {
res.writeHead (404, { "Tipo de conteúdo": "aplicativo/json" });
res.fim(JSON.stringify({ mensagem: erro }));
}
}
Este código usa o Combine método, que recebe uma expressão regex como argumento, para verificar se a url corresponde ao formato: /api/blogs/.
A seguir, extraia o Eu iria propriedade do URL string chamando seu dividir método. Este método recebe um padrão como argumento (/), divide a string com base no padrão e retorna uma matriz. O terceiro elemento dessa matriz é o Eu iria.
Por fim, recupere o documento com a correspondência Eu iria do seu banco de dados. Se existir, envie um código de resposta de 200, feche a solicitação e envie o blog recuperado. Se não existir, lance um erro e envie-o como resposta no bloco catch.
Rota POST
Adicione o bloco de código abaixo à função do seu roteador para implementar o PUBLICAR manipulador de rotas:
// POST: /api/blogs/
se (req.url "/api/blogs"&& req.método "PUBLICAR") {
tentar {
deixe corpo = "";// Escuta o evento de dados
req.on("dados", (pedaço) => {
corpo += pedaço.toString();
});// Escute fimevento
req.on("fim", assíncrono () => {
// Criar blog
deixar blog = novo Blog(JSON.parse (corpo));
// Salva no banco de dados
aguardam blog.salvar();
res.writeHead (200, { "Tipo de conteúdo": "aplicativo/json" });
res.fim(JSON.stringify(blog));
});
} truque (erro) {
console.log (erro);
}
}
O objeto de solicitação implementa o Node.js ReadableStream interface. Este fluxo emite um dados e um fim evento que lhe dá acesso aos dados do corpo da solicitação.
Esse código escuta o evento de dados e o trata convertendo-o em uma string e concatenando-o ao corpo variável. No fim manipulador de eventos, ele cria um Blogue instância com a string do corpo analisada. Em seguida, ele salva o novo blog, envia o código de status e o cabeçalho de conteúdo e fecha a solicitação.
PUT Rota
Adicione o bloco de código abaixo à função do seu roteador para implementar o COLOCAR manipulador de rotas:
// COLOCAR: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.método "COLOCAR") {
tentar {
//extrai id da url
const id = req.url.split("/")[3];
deixe corpo = "";req.on("dados", (pedaço) => {
corpo += pedaço.toString();
});
req.on("fim", assíncrono () => {
// Encontre e atualizardocumento
deixar atualizadoBlog = aguardam Blog.findByIdAndUpdate (id, JSON.parse (corpo), {
novo: verdadeiro,
});
res.writeHead (200, { "Tipo de conteúdo": "aplicativo/json" });
res.fim(JSON.stringify(atualizadoBlog));
});
} truque (erro) {
console.log (erro);
}
}
O manipulador de solicitação PUT é quase idêntico ao PUBLICAR manipulador de solicitação, exceto que ele extrai o Eu iria propriedade do URL para atualizar o blog relevante.
APAGAR Rota
Adicione o bloco de código abaixo à função do seu roteador para implementar seu EXCLUIR manipulador de rotas:
// EXCLUIR: /api/blogs/:Eu iria
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.método "EXCLUIR") {
tentar {
const id = req.url.split("/")[3];
// Excluir blog a partir de BD
aguardam Blog.findByIdAndDelete (id);
res.writeHead (200, { "Tipo de conteúdo": "aplicativo/json" });
res.end (JSON.stringify({ mensagem: "Blog excluído com sucesso" }));
} truque (erro) {
res.writeHead (404, { "Tipo de conteúdo": "aplicativo/json" });
res.fim(JSON.stringify({ mensagem: erro }));
}
}
Este bloco de código extrai o Eu iria de URL, exclui o documento com a correspondência Eu iria, envia o código de status e os cabeçalhos e fecha a solicitação.
Por fim, importe roteador na tua server.js arquivo e ligue para o seu roteador função, passando req e res como argumentos:
const roteador = exigir("./routes/blogRoutes");
const server = http.createServer((req, res) => {
roteador (req, res);
});
Isso permite que seu servidor intercepte e lide com as solicitações de forma adequada.
Você pode encontrar o projeto concluído neste Repositório do GitHub.
Usando uma estrutura Node.js
Embora seja possível criar uma API da Web manualmente, pode ser uma tarefa difícil. Você precisará ter certeza de que cobriu muitos casos extremos e é melhor que seu código esteja livre de bugs.
Ao longo dos anos, os desenvolvedores construíram estruturas como ExpressJS, NestJS, Fastify, etc., para facilitar muito.
