HTTP all 3 written

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24import { createServer } from "node:http";
import { once } from "node:events";

// This function runs once for every request that arrives.
const server = createServer((req, res) => {
  res.setHeader("content-type", "text/plain; charset=utf-8");
  res.end("Hello from Node");
});

server.listen(0, "127.0.0.1");            // port 0: any free port
await once(server, "listening");
const { port } = server.address();
console.log("listening on port", port);

// Be the browser for a moment.
const response = await fetch(`http://127.0.0.1:${port}/`);
const body = await response.text();
console.log(response.status, response.statusText);
console.log(body);

server.close();

check("the server answered 200 OK", response.status, 200);
check("with the body it wrote", body, "Hello from Node");

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29import { createServer } from "node:http";
import { connect } from "node:net";
import { once } from "node:events";

const server = createServer((req, res) => {
  res.setHeader("content-type", "text/plain");
  res.end("hello");
});
server.listen(0, "127.0.0.1");
await once(server, "listening");

// An HTTP request, typed out: a request line, headers, then a blank line.
const request = "GET /hello HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n";

const socket = connect(server.address().port, "127.0.0.1");
socket.write(request);
let raw = "";
for await (const chunk of socket) raw += chunk;
server.close();

console.log("--- sent ---");
for (const line of request.split("\r\n").slice(0, -1)) console.log(line || "(blank line)");
console.log("--- received ---");
for (const line of raw.split("\r\n")) console.log(line || "(blank line)");

const lines = raw.split("\r\n");
check("the first line is the status", lines[0], "HTTP/1.1 200 OK");
check("Node worked out the length itself", lines.includes("Content-Length: 5"), true);
check("and the body comes after a blank line", lines.at(-1), "hello");

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37import { createServer } from "node:http";
import { once } from "node:events";

let seen;
const server = createServer(async (req, res) => {
  // req.url is only the path and query. URL needs a base to parse it.
  const url = new URL(req.url, "http://localhost");

  // req is a readable stream: the body arrives in chunks.
  let body = "";
  for await (const chunk of req) body += chunk;

  seen = {
    method: req.method,
    path: url.pathname,
    query: Object.fromEntries(url.searchParams),
    contentType: req.headers["content-type"],
    body: JSON.parse(body),
  };
  res.end("thanks");
});
server.listen(0, "127.0.0.1");
await once(server, "listening");

await fetch(`http://127.0.0.1:${server.address().port}/orders?express=true&qty=2`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ item: "tea" }),
});
server.close();

console.log("the server saw:", seen);

check("the method and the path", [seen.method, seen.path], ["POST", "/orders"]);
check("query values are always strings", seen.query, { express: "true", qty: "2" });
check("header names arrive in lower case", seen.contentType, "application/json");
check("and the body was read from the stream", seen.body, { item: "tea" });

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40import { createServer, STATUS_CODES } from "node:http";
import { once } from "node:events";

const server = createServer((req, res) => {
  const { pathname } = new URL(req.url, "http://localhost");

  if (pathname === "/") {
    res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
    return res.end("<h1>Home</h1>");
  }
  if (pathname === "/health") {
    res.writeHead(200, { "content-type": "application/json" });
    return res.end(JSON.stringify({ ok: true }));
  }
  if (pathname === "/old-home") {
    res.writeHead(301, { location: "/" });
    return res.end();
  }
  res.writeHead(404, { "content-type": "text/plain" });
  res.end("not found");
});
server.listen(0, "127.0.0.1");
await once(server, "listening");
const base = `http://127.0.0.1:${server.address().port}`;

const results = [];
for (const path of ["/", "/health", "/old-home", "/nope"]) {
  const r = await fetch(base + path, { redirect: "manual" });
  const location = r.headers.get("location");
  results.push({
    path,
    status: `${r.status} ${STATUS_CODES[r.status]}`,
    header: location ? `location: ${location}` : r.headers.get("content-type"),
    body: await r.text(),
  });
}
server.close();
console.table(results);

check("each route got its status", results.map((r) => r.status.split(" ")[0]), ["200", "200", "301", "404"]);

example.mjs

1
2
3
4
5
6
7
8
9import { STATUS_CODES } from "node:http";

const codes = [200, 201, 204, 301, 400, 401, 403, 404, 405, 500];
for (const code of codes) console.log(code, STATUS_CODES[code]);

check("the table's names are Node's own", codes.map((c) => STATUS_CODES[c]), [
  "OK", "Created", "No Content", "Moved Permanently", "Bad Request",
  "Unauthorized", "Forbidden", "Not Found", "Method Not Allowed", "Internal Server Error",
]);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36import { createServer } from "node:http";
import { once } from "node:events";

// Wrap a handler so that any error, sync or async, becomes a 500.
function safely(handler) {
  return async (req, res) => {
    try {
      await handler(req, res);
    } catch (err) {
      console.error("request failed:", req.method, req.url, "-", err.name);
      if (!res.headersSent) res.writeHead(500, { "content-type": "text/plain" });
      res.end("something went wrong\n");
    }
  };
}

const server = createServer(safely(async (req, res) => {
  if (req.url === "/broken") {
    const user = JSON.parse('{ "name": "Ada" }');
    return res.end(`hello ${user.profile.name}`);
  }
  res.end("fine\n");
}));
server.listen(0, "127.0.0.1");
await once(server, "listening");
const base = `http://127.0.0.1:${server.address().port}`;

const statuses = [];
for (const path of ["/", "/broken", "/"]) {
  const r = await fetch(base + path);
  statuses.push(r.status);
  console.log(path, r.status, (await r.text()).trim());
}
server.close();

check("the broken request got a 500, and the server kept serving", statuses, [200, 500, 200]);

server.mjs

1
2
3
4
5
6
7
8
9
10
11import { createServer } from "node:http";

let served = 0;
const server = createServer((req, res) => {
  served++;
  res.end(`request number ${served}\n`);
});

server.listen(0, "127.0.0.1", () => {
  console.log(`listening on http://127.0.0.1:${server.address().port}`);
});

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25import { spawn } from "node:child_process";
import { createInterface } from "node:readline";
import { once } from "node:events";
import { setTimeout as sleep } from "node:timers/promises";

// node server.mjs, as its own process.
const server = spawn(process.execPath, ["server.mjs"], { stdio: ["ignore", "pipe", "inherit"] });
const [firstLine] = await once(createInterface({ input: server.stdout }), "line");
console.log("server.mjs printed:", firstLine);

const url = firstLine.replace("listening on ", "");
for (let i = 0; i < 3; i++) {
  console.log("  " + (await (await fetch(url)).text()).trim());
}

await sleep(500);
const stillRunning = server.exitCode === null && server.signalCode === null;
console.log("half a second later, still running:", stillRunning);

server.kill("SIGTERM");
const [code, signal] = await once(server, "exit");
console.log("stopped by", signal);

check("a server never finishes on its own", stillRunning, true);
check("it ended when it was sent a signal", [code, signal], [null, "SIGTERM"]);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66import { createServer } from "node:http";
import { once } from "node:events";

class HttpError extends Error {
  constructor(status, message) {
    super(message);
    this.status = status;
  }
}

async function readJson(req, limit = 10_000) {
  if (!req.headers["content-type"]?.startsWith("application/json")) {
    throw new HttpError(415, "send JSON, with Content-Type: application/json");
  }
  let size = 0;
  const chunks = [];
  for await (const chunk of req) {
    size += chunk.length;
    if (size > limit) throw new HttpError(413, `the body is over ${limit} bytes`);
    chunks.push(chunk);
  }
  try {
    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
  } catch {
    throw new HttpError(400, "the body is not valid JSON");
  }
}

function sendJson(res, status, data) {
  const text = JSON.stringify(data);
  res.writeHead(status, {
    "content-type": "application/json; charset=utf-8",
    "content-length": Buffer.byteLength(text),      // bytes, not characters
  });
  res.end(text);
}

const server = createServer(async (req, res) => {
  try {
    const order = await readJson(req);
    sendJson(res, 200, { received: order });
  } catch (err) {
    if (err instanceof HttpError) return sendJson(res, err.status, { error: err.message });
    console.error(err);
    sendJson(res, 500, { error: "internal error" });
  }
});
server.listen(0, "127.0.0.1");
await once(server, "listening");
const url = `http://127.0.0.1:${server.address().port}/orders`;

const attempts = [
  ["JSON",           "application/json", '{ "item": "café", "qty": 2 }'],
  ["a trailing comma", "application/json", '{ "item": "tea", }'],
  ["plain text",     "text/plain",       "one tea please"],
  ["a megabyte",     "application/json", JSON.stringify({ note: "x".repeat(1_000_000) })],
];
const statuses = [];
for (const [what, type, body] of attempts) {
  const res = await fetch(url, { method: "POST", headers: { "content-type": type }, body });
  statuses.push(res.status);
  console.log(`${what.padEnd(17)} ${res.status}  ${await res.text()}`);
}
server.close();

check("good JSON, bad JSON, not JSON, too much JSON", statuses, [200, 400, 415, 413]);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42import { createServer } from "node:http";
import { once } from "node:events";

const routes = [];
function route(method, pathname, handler) {
  routes.push({ method, pattern: new URLPattern({ pathname }), handler });
}

route("GET", "/todos", () => "all the todos");
route("GET", "/todos/:id", ({ id }) => `todo number ${id}`);
route("DELETE", "/todos/:id", ({ id }) => `deleted todo ${id}`);

const server = createServer((req, res) => {
  const { pathname } = new URL(req.url, "http://localhost");
  const matches = routes.filter((r) => r.pattern.test({ pathname }));
  if (matches.length === 0) {
    res.writeHead(404);
    return res.end("no such path");
  }
  const match = matches.find((r) => r.method === req.method);
  if (!match) {
    res.writeHead(405, { allow: matches.map((r) => r.method).join(", ") });
    return res.end("that path does not take that method");
  }
  const params = match.pattern.exec({ pathname }).pathname.groups;
  res.end(match.handler(params));
});
server.listen(0, "127.0.0.1");
await once(server, "listening");
const base = `http://127.0.0.1:${server.address().port}`;

const seen = [];
for (const [method, path] of [["GET", "/todos"], ["GET", "/todos/7"], ["DELETE", "/todos/7"],
                              ["PUT", "/todos/7"], ["GET", "/users"]]) {
  const res = await fetch(base + path, { method });
  const allow = res.headers.get("allow");
  seen.push(res.status);
  console.log(`${(method + " " + path).padEnd(16)} ${res.status}  ${await res.text()}${allow ? `  (allow: ${allow})` : ""}`);
}
server.close();

check("routes, a parameter, the wrong method, the wrong path", seen, [200, 200, 200, 405, 404]);

app.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130import { createServer } from "node:http";

export class HttpError extends Error {
  constructor(status, message) {
    super(message);
    this.status = status;
  }
}

// ---- JSON in and out ------------------------------------------------------

async function readJson(req, limit = 10_000) {
  if (!req.headers["content-type"]?.startsWith("application/json")) {
    throw new HttpError(415, "send JSON, with Content-Type: application/json");
  }
  let size = 0;
  const chunks = [];
  for await (const chunk of req) {
    size += chunk.length;
    if (size > limit) throw new HttpError(413, `the body is over ${limit} bytes`);
    chunks.push(chunk);
  }
  try {
    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
  } catch {
    throw new HttpError(400, "the body is not valid JSON");
  }
}

function send(res, status, body, headers = {}) {
  if (body === undefined) {
    res.writeHead(status, headers);
    return res.end();
  }
  const text = JSON.stringify(body);
  res.writeHead(status, {
    "content-type": "application/json; charset=utf-8",
    "content-length": Buffer.byteLength(text),
    ...headers,
  });
  res.end(text);
}

// ---- validation -------------------------------------------------------------

function checkTodo(input, { partial = false } = {}) {
  if (typeof input !== "object" || input === null || Array.isArray(input)) {
    throw new HttpError(400, "send a JSON object");
  }
  const unknown = Object.keys(input).filter((key) => key !== "title" && key !== "done");
  if (unknown.length > 0) throw new HttpError(400, `unknown field: ${unknown.join(", ")}`);

  if (!partial || "title" in input) {
    if (typeof input.title !== "string" || input.title.trim() === "") {
      throw new HttpError(400, "title must be a non-empty string");
    }
  }
  if ("done" in input && typeof input.done !== "boolean") {
    throw new HttpError(400, "done must be true or false");
  }
  return input;
}

// ---- the app ------------------------------------------------------------------

export function createApp() {
  const todos = new Map();           // the data lives here, one store per app
  let nextId = 1;
  const routes = [];
  const route = (method, pathname, handler) =>
    routes.push({ method, pattern: new URLPattern({ pathname }), handler });

  const find = (id) => {
    const todo = todos.get(Number(id));
    if (!todo) throw new HttpError(404, `no todo with id ${id}`);
    return todo;
  };

  route("GET", "/todos", ({ url }) => {
    let list = [...todos.values()];
    const done = url.searchParams.get("done");
    if (done !== null) list = list.filter((todo) => String(todo.done) === done);
    return { status: 200, body: list };
  });

  route("POST", "/todos", async ({ req }) => {
    const input = checkTodo(await readJson(req));
    const todo = { id: nextId++, title: input.title.trim(), done: input.done ?? false };
    todos.set(todo.id, todo);
    return { status: 201, body: todo, headers: { location: `/todos/${todo.id}` } };
  });

  route("GET", "/todos/:id(\\d+)", ({ params }) => ({ status: 200, body: find(params.id) }));

  route("PATCH", "/todos/:id(\\d+)", async ({ req, params }) => {
    const todo = find(params.id);
    const changes = checkTodo(await readJson(req), { partial: true });
    if ("title" in changes) todo.title = changes.title.trim();
    if ("done" in changes) todo.done = changes.done;
    return { status: 200, body: todo };
  });

  route("DELETE", "/todos/:id(\\d+)", ({ params }) => {
    find(params.id);
    todos.delete(Number(params.id));
    return { status: 204 };
  });

  return createServer(async (req, res) => {
    try {
      const url = new URL(req.url, "http://localhost");
      const matches = routes.filter((r) => r.pattern.test({ pathname: url.pathname }));
      if (matches.length === 0) throw new HttpError(404, `nothing at ${url.pathname}`);

      const match = matches.find((r) => r.method === req.method);
      if (!match) {
        res.setHeader("allow", matches.map((r) => r.method).join(", "));
        throw new HttpError(405, `${req.method} is not allowed here`);
      }

      const params = match.pattern.exec({ pathname: url.pathname }).pathname.groups;
      const { status, body, headers } = await match.handler({ req, url, params });
      send(res, status, body, headers);
    } catch (err) {
      if (err instanceof HttpError) return send(res, err.status, { error: err.message });
      console.error(err);
      send(res, 500, { error: "internal error" });
    }
  });
}

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37import { once } from "node:events";
import { createApp } from "./app.mjs";

const server = createApp().listen(0, "127.0.0.1");
await once(server, "listening");
const base = `http://127.0.0.1:${server.address().port}`;

async function call(method, path, body) {
  const res = await fetch(base + path, {
    method,
    headers: body === undefined ? {} : { "content-type": "application/json" },
    body: body === undefined ? undefined : JSON.stringify(body),
  });
  const text = await res.text();
  console.log(`${method} ${path}${body === undefined ? "" : " " + JSON.stringify(body)}`);
  console.log(`   ${res.status} ${text}`);
  return { status: res.status, location: res.headers.get("location"), data: text ? JSON.parse(text) : null };
}

const tea = await call("POST", "/todos", { title: "Buy tea" });
const report = await call("POST", "/todos", { title: "Write the report" });
await call("PATCH", `/todos/${tea.data.id}`, { done: true });
const finished = await call("GET", "/todos?done=true");
const empty = await call("POST", "/todos", { title: "  " });
const sneaky = await call("POST", "/todos", { title: "Pay me", done: false, owner: "admin" });
const removed = await call("DELETE", `/todos/${report.data.id}`);
const gone = await call("GET", `/todos/${report.data.id}`);
const notANumber = await call("GET", "/todos/abc");
const all = await call("GET", "/todos");
server.close();

check("POST answers 201 and says where the new todo lives", [tea.status, tea.location], [201, "/todos/1"]);
check("the filter found the finished one", finished.data, [{ id: 1, title: "Buy tea", done: true }]);
check("a blank title and an unknown field are both refused", [empty.status, sneaky.status], [400, 400]);
check("DELETE answers 204 with no body", [removed.status, removed.data], [204, null]);
check("afterwards the todo is gone, and ids must be numbers", [gone.status, notANumber.status], [404, 404]);
check("one todo is left", all.data.length, 1);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import { createServer } from "node:http";
import { once } from "node:events";

// Standing in for someone else's API.
const api = createServer((req, res) => {
  res.writeHead(200, { "content-type": "application/json" });
  res.end(JSON.stringify({ id: 1, name: "Ada Lovelace", languages: ["en", "fr"] }));
});
api.listen(0, "127.0.0.1");
await once(api, "listening");

const res = await fetch(`http://127.0.0.1:${api.address().port}/users/1`);
console.log("status:", res.status, res.statusText, " ok:", res.ok);
console.log("content-type:", res.headers.get("content-type"));

const user = await res.json();
console.log(user);
api.close();

check("res.json() parsed the body", user.name, "Ada Lovelace");

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33import { createServer } from "node:http";
import { once } from "node:events";

const api = createServer((req, res) => {
  res.writeHead(req.url === "/users/1" ? 200 : 404, { "content-type": "application/json" });
  res.end(JSON.stringify(req.url === "/users/1" ? { name: "Ada" } : { error: "no such user" }));
});
api.listen(0, "127.0.0.1");
await once(api, "listening");
const base = `http://127.0.0.1:${api.address().port}`;

// The way it is usually written first.
const careless = await (await fetch(`${base}/users/99`)).json();
console.log(`Hello, ${careless.name}`);

// Check the status before trusting the body.
async function getJson(url) {
  const res = await fetch(url);
  if (!res.ok) throw new Error(`GET ${url} failed: ${res.status} ${res.statusText}`);
  return res.json();
}

let failure;
try {
  await getJson(`${base}/users/99`);
} catch (err) {
  failure = err.message.replace(base, "");
  console.log(failure);
}
api.close();

check("fetch resolved happily with the 404, and the name was undefined", careless.name, undefined);
check("getJson turned it into an error", failure, "GET /users/99 failed: 404 Not Found");

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33import { createServer } from "node:http";
import { once } from "node:events";

let serverNoticed = false;
const api = createServer((req, res) => {
  // A slow endpoint: it answers after five seconds...
  const timer = setTimeout(() => res.end("finally"), 5000);
  // ...unless the client gives up first, in which case it stops working.
  res.on("close", () => {
    if (!res.writableFinished) serverNoticed = true;
    clearTimeout(timer);
  });
});
api.listen(0, "127.0.0.1");
await once(api, "listening");

const started = performance.now();
let outcome;
try {
  await fetch(`http://127.0.0.1:${api.address().port}/report`, { signal: AbortSignal.timeout(200) });
  outcome = "answered";
} catch (err) {
  outcome = err.name;
}
const waited = Math.round(performance.now() - started);
console.log(`${outcome} after ${Math.round(waited / 100) * 100} ms`);
await new Promise((resolve) => setTimeout(resolve, 20));
console.log("the server saw the client leave:", serverNoticed);
api.close();

check("the request was abandoned with a TimeoutError", outcome, "TimeoutError");
check("after about 200 ms, not five seconds", waited < 1000, true);
check("and the server stopped working on it", serverNoticed, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47import { createServer } from "node:http";
import { once } from "node:events";
import { setTimeout as sleep } from "node:timers/promises";

const calls = { "/flaky": 0, "/missing": 0 };
const api = createServer((req, res) => {
  calls[req.url]++;
  if (req.url === "/flaky" && calls["/flaky"] <= 2) res.writeHead(503);   // busy, twice
  else if (req.url === "/missing") res.writeHead(404);
  res.end();
});
api.listen(0, "127.0.0.1");
await once(api, "listening");
const base = `http://127.0.0.1:${api.address().port}`;

async function fetchWithRetry(url, { attempts = 4, baseDelay = 100 } = {}) {
  for (let attempt = 1; ; attempt++) {
    let res, error;
    try {
      res = await fetch(url, { signal: AbortSignal.timeout(2000) });
    } catch (err) {
      error = err;
    }
    // Worth another try: no response at all, "too many requests", or a server error.
    const retryable = error !== undefined || res.status === 429 || res.status >= 500;
    if (!retryable || attempt === attempts) {
      if (error) throw error;
      return res;
    }
    await res?.body?.cancel();                    // free the connection
    const delay = baseDelay * 2 ** (attempt - 1); // 100, 200, 400 ...
    console.log(`  attempt ${attempt}: ${error ? error.name : res.status}, waiting ${delay} ms`);
    await sleep(delay);
  }
}

console.log("GET /flaky");
const flaky = await fetchWithRetry(base + "/flaky");
console.log("  finally:", flaky.status);

console.log("GET /missing");
const missing = await fetchWithRetry(base + "/missing");
console.log("  finally:", missing.status);
api.close();

check("the busy server was tried three times and then answered", [calls["/flaky"], flaky.status], [3, 200]);
check("a 404 was not retried at all", [calls["/missing"], missing.status], [1, 404]);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50import { createServer } from "node:http";
import { once } from "node:events";

let inFlight = 0;
let peak = 0;
const api = createServer((req, res) => {
  inFlight++;
  peak = Math.max(peak, inFlight);
  setTimeout(() => { inFlight--; res.end(req.url); }, 50);    // 50 ms per request
});
api.listen(0, "127.0.0.1");
await once(api, "listening");
const base = `http://127.0.0.1:${api.address().port}`;
const ids = Array.from({ length: 20 }, (_, i) => i + 1);
const get = (id) => fetch(`${base}/items/${id}`).then((res) => res.text());

// At most `limit` requests in flight; results stay in order.
async function mapWithLimit(items, limit, fn) {
  const results = new Array(items.length);
  let next = 0;
  async function worker() {
    while (next < items.length) {
      const i = next++;
      results[i] = await fn(items[i]);
    }
  }
  await Promise.all(Array.from({ length: limit }, worker));
  return results;
}

const runs = {};
async function measure(name, work) {
  peak = 0;
  const started = performance.now();
  const results = await work();
  const ms = performance.now() - started;
  runs[name] = { peak, results, ms };
  console.log(`${name.padEnd(14)} ${String(peak).padStart(2)} at once, ${Math.round(ms / 10) * 10} ms`);
}

await measure("one by one", async () => { const r = []; for (const id of ids) r.push(await get(id)); return r; });
await measure("Promise.all", () => Promise.all(ids.map(get)));
await measure("four at a time", () => mapWithLimit(ids, 4, get));
api.close();

const expected = ids.map((id) => `/items/${id}`);
check("one by one never overlapped, and took over a second", [runs["one by one"].peak, runs["one by one"].ms >= 1000], [1, true]);
check("Promise.all sent all twenty at once, in a fraction of that", [runs["Promise.all"].peak, runs["Promise.all"].ms < 500], [20, true]);
check("the pool never had more than four", runs["four at a time"].peak, 4);
check("and every approach kept the results in order", [runs["Promise.all"].results, runs["four at a time"].results], [expected, expected]);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38import { createServer } from "node:http";
import { once } from "node:events";

// The other service: it wants a bearer token, and a JSON body.
const api = createServer(async (req, res) => {
  if (req.headers.authorization !== `Bearer ${process.env.API_TOKEN}`) {
    res.writeHead(401, { "content-type": "application/json" });
    return res.end(JSON.stringify({ error: "bad or missing token" }));
  }
  let body = "";
  for await (const chunk of req) body += chunk;
  res.writeHead(201, { "content-type": "application/json" });
  res.end(JSON.stringify({ id: "msg_1", ...JSON.parse(body) }));
});
api.listen(0, "127.0.0.1");
await once(api, "listening");
const url = `http://127.0.0.1:${api.address().port}/messages`;

async function send(message, token) {
  const res = await fetch(url, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      ...(token && { authorization: `Bearer ${token}` }),
    },
    body: JSON.stringify(message),
  });
  return { status: res.status, body: await res.json() };
}

const without = await send({ to: "ada", text: "hi" });
const withToken = await send({ to: "ada", text: "hi" }, process.env.API_TOKEN);
console.log("no token:  ", without);
console.log("with token:", withToken);
api.close();

check("refused without the token", without.status, 401);
check("accepted with it", withToken, { status: 201, body: { id: "msg_1", to: "ada", text: "hi" } });

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35import { createServer } from "node:http";
import { once } from "node:events";

const api = createServer((req, res) => {
  if (req.url === "/user") {
    res.writeHead(200, { "content-type": "application/json" });
    return res.end('{ "name": "Ada" }');
  }
  // What a proxy or a crashed server often sends instead of JSON.
  res.writeHead(502, { "content-type": "text/html" });
  res.end("<html><body>Bad Gateway</body></html>");
});
api.listen(0, "127.0.0.1");
await once(api, "listening");
const base = `http://127.0.0.1:${api.address().port}`;

const errors = [];
async function attempt(label, work) {
  try {
    await work();
  } catch (err) {
    errors.push(err.name);
    console.log(`${label}: ${err.name}: ${err.message}`);
  }
}

const res = await fetch(`${base}/user`);
console.log("first read:", await res.json());
await attempt("second read", () => res.json());

await attempt("HTML as JSON", async () => (await fetch(`${base}/orders`)).json());
api.close();

check("a body can only be read once", errors[0], "TypeError");
check("and an HTML error page is not JSON", errors[1], "SyntaxError");