[111] Criando um servidor HTTP com Node.js puro

Antes de usar o Express — o framework que simplifica tudo — é fundamental entender o que acontece por baixo dos panos. Todo servidor web em Node.js, seja Express, Fastify ou qualquer outro, é construído sobre o módulo nativo http. Entender esse módulo faz você um desenvolvedor melhor, capaz de depurar problemas que frameworks escondem.

Neste artigo vamos construir um servidor HTTP do zero, entender o ciclo de requisição e resposta, e gradualmente adicionar funcionalidades até termos uma mini API funcional.

O protocolo HTTP em 60 segundos

Antes do código, o conceito:

CLIENTE (navegador/fetch)         SERVIDOR (Node.js)
─────────────────────────────────────────────────────

1. Cliente envia uma REQUISIÇÃO:
   GET /usuarios HTTP/1.1
   Host: localhost:3000
   Accept: application/json

2. Servidor processa e envia uma RESPOSTA:
   HTTP/1.1 200 OK
   Content-Type: application/json

   [{ "id": 1, "nome": "Ana" }]

Toda comunicação HTTP segue este padrão:
  Método + URL + Headers → Corpo (opcional)
  Status + Headers → Corpo (opcional)

O primeiro servidor

// servidor.js
const http = require("http");

const servidor = http.createServer((req, res) => {
  // req → IncomingMessage — a requisição que chegou
  // res → ServerResponse — a resposta que vamos enviar

  res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
  res.end("Olá, mundo!");
});

servidor.listen(3000, () => {
  console.log("🚀 Servidor rodando em http://localhost:3000");
});

node servidor.js
# Abra http://localhost:3000 no navegador

Três coisas aconteceram:

1. createServer registrou uma função que será chamada a cada requisição
2. listen(3000) fez o servidor começar a escutar conexões na porta 3000
3. O callback é chamado quando o servidor está pronto

Inspecionando a requisição

O objeto req contém tudo sobre o que o cliente enviou:

const http = require("http");

const servidor = http.createServer((req, res) => {
  console.log("─".repeat(40));
  console.log("Método:", req.method);         // GET, POST, PUT, DELETE...
  console.log("URL:", req.url);               // /usuarios/1?ativo=true
  console.log("Headers:", req.headers);       // { host, accept, ... }
  console.log("HTTP Version:", req.httpVersion); // 1.1

  // Parseando a URL manualmente
  const url = new URL(req.url, `http://${req.headers.host}`);
  console.log("Pathname:", url.pathname);     // /usuarios/1
  console.log("Search:", url.search);         // ?ativo=true
  console.log("Params:", url.searchParams.get("ativo")); // "true"

  res.writeHead(200, { "Content-Type": "text/plain" });
  res.end("OK");
});

servidor.listen(3000, () => console.log("http://localhost:3000"));

Construindo a resposta

O objeto res controla tudo que enviamos de volta:

// Definindo status e headers
res.statusCode = 200;
res.setHeader("Content-Type", "application/json");
res.setHeader("X-Powered-By", "Node.js");

// Atalho — define status e múltiplos headers de uma vez
res.writeHead(201, {
  "Content-Type": "application/json",
  "Location": "/usuarios/42",
});

// Enviando o corpo — finaliza a resposta
res.end(JSON.stringify({ id: 42, nome: "Ana" }));

// Ou em partes (útil para streams)
res.write("parte 1");
res.write("parte 2");
res.end("parte final");

Lendo o corpo da requisição

Ao contrário da URL e dos headers, o corpo chega em pedaços (chunks) via stream:

function lerCorpo(req) {
  return new Promise((resolve, reject) => {
    const chunks = [];

    req.on("data", (chunk) => {
      chunks.push(chunk);

      // Proteção contra corpos muito grandes (10MB)
      const totalBytes = chunks.reduce((acc, c) => acc + c.length, 0);
      if (totalBytes > 10 * 1024 * 1024) {
        reject(new Error("Corpo da requisição muito grande."));
      }
    });

    req.on("end", () => {
      const corpo = Buffer.concat(chunks).toString("utf-8");
      resolve(corpo);
    });

    req.on("error", reject);
  });
}

// Usando
const corpo = await lerCorpo(req);
const dados = JSON.parse(corpo);

Roteamento manual

O servidor precisa responder diferente dependendo da URL e do método:

const http = require("http");
const { URL } = require("url");

// Banco de dados em memória
let usuarios = [
  { id: 1, nome: "Ana Paula", email: "ana@email.com" },
  { id: 2, nome: "Carlos Silva", email: "carlos@email.com" },
];
let proximoId = 3;

// ── Utilitários ─────────────────────────────────

function lerCorpo(req) {
  return new Promise((resolve, reject) => {
    const chunks = [];
    req.on("data", chunk => chunks.push(chunk));
    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
    req.on("error", reject);
  });
}

function enviarJSON(res, status, dados) {
  res.writeHead(status, {
    "Content-Type": "application/json; charset=utf-8",
    "Access-Control-Allow-Origin": "*",
  });
  res.end(JSON.stringify(dados, null, 2));
}

function enviarErro(res, status, mensagem) {
  enviarJSON(res, status, { erro: mensagem, status });
}

function extrairId(pathname) {
  const partes = pathname.split("/").filter(Boolean);
  // /usuarios/42 → ["usuarios", "42"]
  const id = Number(partes[1]);
  return isNaN(id) ? null : id;
}

// ── Roteador ────────────────────────────────────

async function roteador(req, res) {
  const url = new URL(req.url, `http://${req.headers.host}`);
  const pathname = url.pathname;
  const metodo = req.method;

  console.log(`[${new Date().toLocaleTimeString("pt-BR")}] ${metodo} ${pathname}`);

  // CORS preflight
  if (metodo === "OPTIONS") {
    res.writeHead(204, {
      "Access-Control-Allow-Origin": "*",
      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
      "Access-Control-Allow-Headers": "Content-Type",
    });
    return res.end();
  }

  // GET /
  if (pathname === "/" && metodo === "GET") {
    return enviarJSON(res, 200, {
      mensagem: "API funcionando!",
      versao: "1.0.0",
      rotas: [
        "GET /usuarios",
        "GET /usuarios/:id",
        "POST /usuarios",
        "PUT /usuarios/:id",
        "DELETE /usuarios/:id",
      ],
    });
  }

  // GET /usuarios
  if (pathname === "/usuarios" && metodo === "GET") {
    const busca = url.searchParams.get("busca")?.toLowerCase();
    const lista = busca
      ? usuarios.filter(u =>
          u.nome.toLowerCase().includes(busca) ||
          u.email.toLowerCase().includes(busca)
        )
      : usuarios;

    return enviarJSON(res, 200, {
      dados: lista,
      total: lista.length,
    });
  }

  // GET /usuarios/:id
  if (pathname.match(/^\/usuarios\/\d+$/) && metodo === "GET") {
    const id = extrairId(pathname);
    const usuario = usuarios.find(u => u.id === id);

    if (!usuario) return enviarErro(res, 404, `Usuário ${id} não encontrado.`);
    return enviarJSON(res, 200, usuario);
  }

  // POST /usuarios
  if (pathname === "/usuarios" && metodo === "POST") {
    let corpo;
    try {
      const texto = await lerCorpo(req);
      corpo = JSON.parse(texto);
    } catch {
      return enviarErro(res, 400, "Corpo da requisição inválido. Envie JSON válido.");
    }

    // Validação
    const erros = [];
    if (!corpo.nome?.trim()) erros.push("nome é obrigatório.");
    if (!corpo.email?.trim()) erros.push("email é obrigatório.");
    if (corpo.email && !corpo.email.includes("@")) erros.push("email inválido.");
    if (usuarios.some(u => u.email === corpo.email)) erros.push("email já cadastrado.");

    if (erros.length > 0) {
      return enviarJSON(res, 422, { erro: "Dados inválidos.", detalhes: erros });
    }

    const novoUsuario = {
      id: proximoId++,
      nome: corpo.nome.trim(),
      email: corpo.email.trim().toLowerCase(),
      criadoEm: new Date().toISOString(),
    };

    usuarios.push(novoUsuario);

    res.setHeader("Location", `/usuarios/${novoUsuario.id}`);
    return enviarJSON(res, 201, novoUsuario);
  }

  // PUT /usuarios/:id
  if (pathname.match(/^\/usuarios\/\d+$/) && metodo === "PUT") {
    const id = extrairId(pathname);
    const indice = usuarios.findIndex(u => u.id === id);

    if (indice === -1) return enviarErro(res, 404, `Usuário ${id} não encontrado.`);

    let corpo;
    try {
      corpo = JSON.parse(await lerCorpo(req));
    } catch {
      return enviarErro(res, 400, "JSON inválido.");
    }

    const erros = [];
    if (corpo.nome !== undefined && !corpo.nome.trim()) erros.push("nome não pode ser vazio.");
    if (corpo.email !== undefined && !corpo.email.includes("@")) erros.push("email inválido.");
    if (corpo.email && usuarios.some(u => u.email === corpo.email && u.id !== id)) {
      erros.push("email já cadastrado por outro usuário.");
    }

    if (erros.length > 0) {
      return enviarJSON(res, 422, { erro: "Dados inválidos.", detalhes: erros });
    }

    usuarios[indice] = {
      ...usuarios[indice],
      ...(corpo.nome && { nome: corpo.nome.trim() }),
      ...(corpo.email && { email: corpo.email.trim().toLowerCase() }),
      atualizadoEm: new Date().toISOString(),
    };

    return enviarJSON(res, 200, usuarios[indice]);
  }

  // DELETE /usuarios/:id
  if (pathname.match(/^\/usuarios\/\d+$/) && metodo === "DELETE") {
    const id = extrairId(pathname);
    const indice = usuarios.findIndex(u => u.id === id);

    if (indice === -1) return enviarErro(res, 404, `Usuário ${id} não encontrado.`);

    const removido = usuarios.splice(indice, 1)[0];
    return enviarJSON(res, 200, {
      mensagem: `Usuário "${removido.nome}" removido com sucesso.`,
    });
  }

  // Rota não encontrada
  enviarErro(res, 404, `Rota ${metodo} ${pathname} não encontrada.`);
}

// ── Servidor ─────────────────────────────────────
const servidor = http.createServer(async (req, res) => {
  try {
    await roteador(req, res);
  } catch (erro) {
    console.error("Erro interno:", erro);
    enviarErro(res, 500, "Erro interno do servidor.");
  }
});

servidor.listen(3000, () => {
  console.log("🚀 API rodando em http://localhost:3000");
  console.log("📋 Rotas disponíveis:");
  console.log("   GET  /usuarios");
  console.log("   GET  /usuarios/:id");
  console.log("   POST /usuarios");
  console.log("   PUT  /usuarios/:id");
  console.log("   DELETE /usuarios/:id");
});

Testando a API

# Instale o curl ou use o httpie para testar

# GET todos
curl http://localhost:3000/usuarios

# GET com busca
curl "http://localhost:3000/usuarios?busca=ana"

# GET por ID
curl http://localhost:3000/usuarios/1

# POST — criar
curl -X POST http://localhost:3000/usuarios \
  -H "Content-Type: application/json" \
  -d '{"nome": "Beatriz", "email": "bia@email.com"}'

# PUT — atualizar
curl -X PUT http://localhost:3000/usuarios/1 \
  -H "Content-Type: application/json" \
  -d '{"nome": "Ana Paula Souza"}'

# DELETE
curl -X DELETE http://localhost:3000/usuarios/2

Ou crie um arquivo testar.js:

// testar.js
const BASE = "http://localhost:3000";

async function req(metodo, url, corpo = null) {
  const opcoes = {
    method: metodo,
    headers: { "Content-Type": "application/json" },
  };
  if (corpo) opcoes.body = JSON.stringify(corpo);

  const res = await fetch(`${BASE}${url}`, opcoes);
  const dados = await res.json();
  console.log(`\n${metodo} ${url} → ${res.status}`);
  console.log(JSON.stringify(dados, null, 2));
  return dados;
}

async function main() {
  await req("GET", "/");
  await req("GET", "/usuarios");
  await req("POST", "/usuarios", { nome: "Beatriz", email: "bia@email.com" });
  await req("GET", "/usuarios/3");
  await req("PUT", "/usuarios/1", { nome: "Ana Paula Souza" });
  await req("DELETE", "/usuarios/2");
  await req("GET", "/usuarios");
  await req("GET", "/usuarios/99"); // teste de 404
}

main().catch(console.error);

node testar.js

Servindo arquivos estáticos

const http = require("http");
const fs = require("fs/promises");
const path = require("path");

const TIPOS_MIME = {
  ".html": "text/html; charset=utf-8",
  ".css":  "text/css",
  ".js":   "application/javascript",
  ".json": "application/json",
  ".png":  "image/png",
  ".jpg":  "image/jpeg",
  ".svg":  "image/svg+xml",
  ".ico":  "image/x-icon",
  ".txt":  "text/plain",
};

const PASTA_PUBLICA = path.join(__dirname, "public");

async function servirArquivo(res, caminhoRelativo) {
  const caminho = path.join(PASTA_PUBLICA, caminhoRelativo);

  // Segurança — evita path traversal (../../etc/passwd)
  if (!caminho.startsWith(PASTA_PUBLICA)) {
    res.writeHead(403);
    return res.end("Acesso negado.");
  }

  try {
    const conteudo = await fs.readFile(caminho);
    const ext = path.extname(caminho);
    const tipo = TIPOS_MIME[ext] || "application/octet-stream";

    res.writeHead(200, { "Content-Type": tipo });
    res.end(conteudo);
  } catch (erro) {
    if (erro.code === "ENOENT") {
      res.writeHead(404);
      res.end("Arquivo não encontrado.");
    } else {
      res.writeHead(500);
      res.end("Erro ao ler arquivo.");
    }
  }
}

const servidor = http.createServer(async (req, res) => {
  const url = new URL(req.url, `http://${req.headers.host}`);
  let pathname = url.pathname;

  // Redireciona / para index.html
  if (pathname === "/") pathname = "/index.html";

  await servirArquivo(res, pathname);
});

servidor.listen(3000, () => console.log("http://localhost:3000"));

Eventos do servidor

const servidor = http.createServer(handler);

// Quando uma conexão TCP é estabelecida
servidor.on("connection", (socket) => {
  console.log(`Nova conexão de ${socket.remoteAddress}`);
});

// Quando ocorre um erro no servidor
servidor.on("error", (erro) => {
  if (erro.code === "EADDRINUSE") {
    console.error(`❌ Porta 3000 já está em uso.`);
    process.exit(1);
  }
  console.error("Erro no servidor:", erro);
});

// Quando o servidor fecha
servidor.on("close", () => {
  console.log("Servidor encerrado.");
});

servidor.listen(3000);

// Encerramento gracioso — termina requisições em andamento
process.on("SIGTERM", () => {
  console.log("Encerrando servidor...");
  servidor.close(() => {
    console.log("Servidor encerrado com sucesso.");
    process.exit(0);
  });
});

As limitações do http puro — por que existe o Express

Depois de tudo que construímos, ficam claras as limitações do módulo http puro:

Problema                          Com http puro
──────────────────────────────────────────────────────
Roteamento                        if/else manual e verboso
Parâmetros de URL (/users/:id)   Regex manual
Middleware (logging, auth, cors)  Encadeamento manual
Body parsing (JSON, form)         Stream manual
Upload de arquivos                Muito complexo
Sessões e cookies                 Manual
Compressão (gzip)                 Manual
HTTPS                             Configuração trabalhosa

O Express resolve a maior parte desses problemas com APIs limpas e elegantes, e os que sobram têm middleware pronto — compression para gzip, cookie-parser e express-session para sessão. O HTTPS é a exceção: ele continua sendo o mesmo trabalho de sempre, feito com o módulo https ou, o mais comum em produção, delegado ao proxy reverso. E agora que você entende o que há por baixo, vai usar o Express com muito mais consciência.

Tarefa para você

Estenda a mini API de usuários adicionando:

// 1. Persistência em arquivo JSON
//    - Ao iniciar, carrega usuarios.json se existir
//    - Após cada POST, PUT, DELETE salva no arquivo
//    - Use fs/promises para leitura e escrita

// 2. Paginação no GET /usuarios
//    GET /usuarios?pagina=1&por_pagina=10
//    Resposta deve incluir:
//    { dados, total, pagina, por_pagina, total_paginas }

// 3. Rota GET /usuarios/:id/posts
//    Busca posts do usuário na JSONPlaceholder:
//    https://jsonplaceholder.typicode.com/posts?userId={id}

// 4. Middleware de logging
//    Crie uma função que envolve o roteador e registra:
//    [timestamp] METHOD /path → STATUS (Xms)

// 5. Tratamento de Content-Type
//    Rejeite requisições POST/PUT que não enviem
//    Content-Type: application/json com erro 415

// ---- servidor.js
const http = require("node:http");
const fs = require("fs/promises");
const path = require("node:path");

const ARQUIVO = path.join(__dirname, "usuarios.json");
const PORTA = Number(process.env.PORT ?? 3000);

let usuarios = [];
let proximoId = 1;

// ---------------------------------------------------------------
// 1 — persistência em arquivo
// ---------------------------------------------------------------
async function carregar() {
  try {
    const conteudo = await fs.readFile(ARQUIVO, "utf-8");
    usuarios = JSON.parse(conteudo);
    proximoId = usuarios.reduce((maior, u) => Math.max(maior, u.id), 0) + 1;
  } catch (erro) {
    // ENOENT na primeira execução é esperado: o arquivo ainda não
    // existe. Qualquer outro erro (JSON corrompido, permissão) precisa
    // aparecer, senão o servidor sobe fingindo que o banco está vazio
    // e o próximo salvamento apaga tudo.
    if (erro.code !== "ENOENT") throw erro;
    usuarios = [];
  }
}

// Salvamento serializado: duas requisições simultâneas escrevendo no
// mesmo arquivo produzem JSON truncado. A fila garante uma de cada vez.
let escrevendo = Promise.resolve();

function salvar() {
  escrevendo = escrevendo.then(async () => {
    const temporario = `${ARQUIVO}.tmp`;
    // Escreve no temporário e RENOMEIA: rename é atômico no mesmo
    // sistema de arquivos. Se o processo morrer no meio, o arquivo
    // bom continua intacto em vez de virar metade de um JSON.
    await fs.writeFile(temporario, JSON.stringify(usuarios, null, 2), "utf-8");
    await fs.rename(temporario, ARQUIVO);
  });

  return escrevendo;
}

// ---------------------------------------------------------------
// Utilidades de resposta
// ---------------------------------------------------------------
function responder(res, status, dados) {
  const corpo = dados === null ? "" : JSON.stringify(dados);

  res.writeHead(status, {
    "Content-Type": "application/json; charset=utf-8",
    "Content-Length": Buffer.byteLength(corpo), // bytes, não caracteres
  });

  res.end(corpo);
}

function lerCorpo(req) {
  return new Promise((resolver, rejeitar) => {
    const partes = [];
    let tamanho = 0;

    req.on("data", (parte) => {
      tamanho += parte.length;

      // Sem teto, um POST de 2 GB derruba o processo por falta de
      // memória. É a defesa mais barata que existe.
      if (tamanho > 1_000_000) {
        rejeitar(Object.assign(new Error("Corpo grande demais"), { status: 413 }));
        req.destroy();
        return;
      }

      partes.push(parte);
    });

    req.on("error", rejeitar);

    req.on("end", () => {
      const texto = Buffer.concat(partes).toString("utf-8");
      if (texto === "") return resolver(null);

      try {
        resolver(JSON.parse(texto));
      } catch {
        rejeitar(Object.assign(new Error("JSON inválido"), { status: 400 }));
      }
    });
  });
}

// ---------------------------------------------------------------
// 5 — Content-Type obrigatório em POST e PUT
// ---------------------------------------------------------------
function exigirJSON(req) {
  if (!["POST", "PUT", "PATCH"].includes(req.method)) return;

  const tipo = req.headers["content-type"] ?? "";

  // startsWith e não ===: o header legítimo pode vir como
  // "application/json; charset=utf-8".
  if (!tipo.toLowerCase().startsWith("application/json")) {
    throw Object.assign(
      new Error("Use Content-Type: application/json"),
      { status: 415 }
    );
  }
}

// ---------------------------------------------------------------
// 2 — paginação
// ---------------------------------------------------------------
function paginar(lista, parametros) {
  const pagina = Math.max(1, Number(parametros.get("pagina") ?? 1) || 1);
  const porPagina = Math.min(
    100, // teto: sem ele, ?por_pagina=999999 vira um jeito fácil de derrubar a API
    Math.max(1, Number(parametros.get("por_pagina") ?? 10) || 10)
  );

  const inicio = (pagina - 1) * porPagina;

  return {
    dados: lista.slice(inicio, inicio + porPagina),
    total: lista.length,
    pagina,
    por_pagina: porPagina,
    total_paginas: Math.ceil(lista.length / porPagina) || 1,
  };
}

// ---------------------------------------------------------------
// 3 — posts do usuário, vindos de fora
// ---------------------------------------------------------------
async function buscarPosts(id) {
  // Timeout explícito: sem ele, uma API externa lenta segura a
  // requisição do seu usuário até o navegador desistir.
  const controlador = new AbortController();
  const limite = setTimeout(() => controlador.abort(), 5000);

  try {
    const resposta = await fetch(
      `https://jsonplaceholder.typicode.com/posts?userId=${id}`,
      { signal: controlador.signal }
    );

    if (!resposta.ok) {
      throw Object.assign(
        new Error(`API externa respondeu ${resposta.status}`),
        { status: 502 } // 502, não 500: o defeito é de terceiro
      );
    }

    return resposta.json();
  } catch (erro) {
    if (erro.name === "AbortError") {
      throw Object.assign(new Error("API externa demorou demais"), { status: 504 });
    }
    throw erro;
  } finally {
    clearTimeout(limite);
  }
}

// ---------------------------------------------------------------
// 4 — middleware de log, envolvendo o roteador
// ---------------------------------------------------------------
function comLog(roteador) {
  return async (req, res) => {
    const inicio = process.hrtime.bigint();

    // O log só pode sair quando a resposta terminar — antes disso o
    // status ainda não existe.
    res.on("finish", () => {
      const ms = Number(process.hrtime.bigint() - inicio) / 1e6;
      const carimbo = new Date().toISOString();
      console.log(
        `[${carimbo}] ${req.method} ${req.url} → ${res.statusCode} (${ms.toFixed(1)}ms)`
      );
    });

    return roteador(req, res);
  };
}

// ---------------------------------------------------------------
// O roteador
// ---------------------------------------------------------------
async function rotear(req, res) {
  const url = new URL(req.url, `http://${req.headers.host}`);
  const partes = url.pathname.split("/").filter(Boolean);

  exigirJSON(req);

  // GET /usuarios
  if (req.method === "GET" && partes.length === 1 && partes[0] === "usuarios") {
    return responder(res, 200, paginar(usuarios, url.searchParams));
  }

  // GET /usuarios/:id/posts
  if (req.method === "GET" && partes.length === 3 && partes[2] === "posts") {
    const id = Number(partes[1]);
    const usuario = usuarios.find((u) => u.id === id);

    if (!usuario) throw Object.assign(new Error("Usuário não encontrado"), { status: 404 });

    return responder(res, 200, { usuario: usuario.nome, posts: await buscarPosts(id) });
  }

  // GET /usuarios/:id
  if (req.method === "GET" && partes.length === 2 && partes[0] === "usuarios") {
    const usuario = usuarios.find((u) => u.id === Number(partes[1]));

    if (!usuario) throw Object.assign(new Error("Usuário não encontrado"), { status: 404 });

    return responder(res, 200, usuario);
  }

  // POST /usuarios
  if (req.method === "POST" && partes.length === 1 && partes[0] === "usuarios") {
    const corpo = await lerCorpo(req);

    if (!corpo?.nome || !corpo?.email) {
      throw Object.assign(new Error("nome e email são obrigatórios"), { status: 422 });
    }

    const novo = { id: proximoId++, nome: corpo.nome, email: corpo.email };
    usuarios.push(novo);
    await salvar();

    res.setHeader("Location", `/usuarios/${novo.id}`); // 201 pede o Location
    return responder(res, 201, novo);
  }

  // PUT /usuarios/:id
  if (req.method === "PUT" && partes.length === 2) {
    const indice = usuarios.findIndex((u) => u.id === Number(partes[1]));

    if (indice === -1) throw Object.assign(new Error("Usuário não encontrado"), { status: 404 });

    const corpo = await lerCorpo(req);
    usuarios[indice] = { ...usuarios[indice], ...corpo, id: usuarios[indice].id };
    await salvar();

    return responder(res, 200, usuarios[indice]);
  }

  // DELETE /usuarios/:id
  if (req.method === "DELETE" && partes.length === 2) {
    const indice = usuarios.findIndex((u) => u.id === Number(partes[1]));

    if (indice === -1) throw Object.assign(new Error("Usuário não encontrado"), { status: 404 });

    usuarios.splice(indice, 1);
    await salvar();

    return responder(res, 204, null); // 204 não tem corpo
  }

  throw Object.assign(new Error("Rota não encontrada"), { status: 404 });
}

const servidor = http.createServer(
  comLog(async (req, res) => {
    try {
      await rotear(req, res);
    } catch (erro) {
      const status = erro.status ?? 500;

      // Erro 500 é bug: registra o stack no servidor e mostra ao
      // cliente uma mensagem genérica. Vazar stack trace numa API
      // pública entrega estrutura de diretórios e versões.
      if (status === 500) console.error(erro);

      responder(res, status, {
        erro: status === 500 ? "Erro interno" : erro.message,
      });
    }
  })
);

carregar().then(() => {
  servidor.listen(PORTA, () => console.log(`http://localhost:${PORTA}`));
});

// Encerramento limpo: sem isto, Ctrl+C mata conexões no meio e pode
// deixar o usuarios.json.tmp para trás.
process.on("SIGINT", () => {
  console.log("\nencerrando...");
  servidor.close(() => process.exit(0));
});

Depois de escrever o roteamento no if, ler o corpo pedaço a pedaço e definir o Content-Type à mão, fica claro o que um framework faz — e, o que importa mais, o que ele continua não fazendo por você. O res.end() chamado duas vezes, o Content-Length medido em bytes e não em caracteres, o Host que vem do cliente e não do servidor: são detalhes do protocolo, e eles seguem valendo com ou sem Express no caminho.

Fontes e Referências

• Node.js Docs — HTTP module: https://nodejs.org/api/http.html
• Node.js Docs — URL module: https://nodejs.org/api/url.html
• MDN Web Docs — HTTP overview: https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Overview
• MDN Web Docs — HTTP response status codes: https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Status
• JavaScript.info — Node.js networking: https://javascript.info/network
• Node.js Design Patterns — Mario Casciaro (Packt Publishing)
• Learning Node.js Development — Andrew Mead (Packt Publishing)
• OWASP — Path Traversal: https://owasp.org/www-community/attacks/Path_Traversal

Exercícios

Exercício 1

Um return foi esquecido. O que o cliente recebe ao pedir GET /usuarios/99, e o que aparece no terminal do servidor?

if (pathname.match(/^\/usuarios\/\d+$/) && metodo === "GET") {
  const usuario = usuarios.find(u => u.id === extrairId(pathname));

  if (!usuario) enviarErro(res, 404, "Usuário não encontrado.");
  return enviarJSON(res, 200, usuario);
}

Exercício 2

Esta é a proteção de 10 MB do artigo. Um cliente envia um corpo de 2 GB. O que acontece com a memória do processo?

req.on("data", (chunk) => {
  chunks.push(chunk);

  const totalBytes = chunks.reduce((acc, c) => acc + c.length, 0);
  if (totalBytes > 10 * 1024 * 1024) {
    reject(new Error("Corpo da requisição muito grande."));
  }
});

Exercício 3

O nome do usuário é José Café. O cliente recebe o JSON cortado no meio. Por quê?

const corpo = JSON.stringify({ id: 1, nome: "José Café" });

res.writeHead(200, {
  "Content-Type": "application/json; charset=utf-8",
  "Content-Length": corpo.length,
});

res.end(corpo);

Exercício 4

Esta é a proteção contra path traversal do artigo. Ela barra /../../etc/passwd. Existe alguma coisa que ela deixa passar?

const PASTA_PUBLICA = path.join(__dirname, "public");

const caminho = path.join(PASTA_PUBLICA, caminhoRelativo);

if (!caminho.startsWith(PASTA_PUBLICA)) {
  res.writeHead(403);
  return res.end("Acesso negado.");
}

Exercício 5

Esta linha aparece em todos os exemplos do artigo. De onde vem req.headers.host, e o que um cliente mal-intencionado consegue fazer com ela?

const url = new URL(req.url, `http://${req.headers.host}`);

// e, mais adiante, num email de recuperação de senha:
const link = `${url.origin}/redefinir?token=${token}`;