Asynchronous Node all 5 written

notes.txt

1buy milk

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15import { readFile } from "node:fs";

const order = [];

readFile("notes.txt", "utf8", (err, text) => {
  order.push("3. the file arrived");
  console.log("callback:", JSON.stringify(text.trim()));
  check("the callback ran last", order, ["1. asked for the file", "2. carried on", "3. the file arrived"]);
});

order.push("1. asked for the file");
console.log("asked for the file");

order.push("2. carried on");
console.log("carried on with the next line");

present.txt

1here I am

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 { readFile } from "node:fs";

const results = {};
const finished = [];

function load(name) {
  readFile(name, "utf8", (err, text) => {
    finished.push(name);
    if (err) {
      results[name] = err.code;
      console.log(`${name}: failed with ${err.code}`);
      return;                     // stop here -- there is no text
    }
    results[name] = text.trim();
    console.log(`${name}: ${text.trim()}`);
  });
}

load("present.txt");
load("missing.txt");

setTimeout(() => {
  check("one worked, one failed with a code", results, { "present.txt": "here I am", "missing.txt": "ENOENT" });
  check("and the one asked for second finished first", finished, ["missing.txt", "present.txt"]);
}, 50);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14import { readFile } from "node:fs";

let caughtByTry = false;

try {
  readFile("missing.txt", "utf8", (err) => {
    console.log("the callback got:", err.code);
  });
} catch {
  caughtByTry = true;
}

console.log("try/catch caught something?", caughtByTry);
check("the try finished before the error existed", caughtByTry, false);

price.txt

110

rate.txt

10.2

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import { readFile, writeFile } from "node:fs";

readFile("price.txt", "utf8", (err, price) => {
  if (err) return console.log("read failed", err.code);
  readFile("rate.txt", "utf8", (err, rate) => {
    if (err) return console.log("read failed", err.code);
    const total = (Number(price) * (1 + Number(rate))).toFixed(2);
    writeFile("total.txt", total, (err) => {
      if (err) return console.log("write failed", err.code);
      readFile("total.txt", "utf8", (err, saved) => {
        console.log("saved total:", saved);
        check("four dependent steps, four levels deep", saved, "12.00");
      });
    });
  });
});

notes.txt

1buy milk

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12import { readFile } from "node:fs";
import { readFile as readFileP } from "node:fs/promises";
import { promisify } from "node:util";

const readFileQ = promisify(readFile);

const a = (await readFileP("notes.txt", "utf8")).trim();    // the built-in promise version
const b = (await readFileQ("notes.txt", "utf8")).trim();    // made from the callback version

console.log(a, "|", b);

check("both give the same text", a, b);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12const order = [];

setTimeout(() => order.push("timer (0 ms)"), 0);
Promise.resolve().then(() => order.push("promise callback"));
order.push("synchronous code, line 1");
order.push("synchronous code, line 2");

setTimeout(() => {
  console.log(order);
  check("all synchronous code ran before any callback",
        order.slice(0, 2), ["synchronous code, line 1", "synchronous code, line 2"]);
}, 20);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const order = [];
const log = (what) => order.push(what);

setTimeout(() => log("setTimeout 0"), 0);
setImmediate(() => log("setImmediate"));
process.nextTick(() => log("process.nextTick"));
Promise.resolve().then(() => log("promise .then"));
queueMicrotask(() => log("queueMicrotask"));
log("synchronous");

setTimeout(() => {
  order.forEach((what, i) => console.log(i + 1, what));
  check("in an ES module, promise callbacks ran before nextTick",
        order.slice(0, 4), ["synchronous", "promise .then", "queueMicrotask", "process.nextTick"]);
}, 20);

example.cjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const order = [];
const log = (what) => order.push(what);

setTimeout(() => log("setTimeout 0"), 0);
setImmediate(() => log("setImmediate"));
process.nextTick(() => log("process.nextTick"));
Promise.resolve().then(() => log("promise .then"));
queueMicrotask(() => log("queueMicrotask"));
log("synchronous");

setTimeout(() => {
  order.forEach((what, i) => console.log(i + 1, what));
  check("in CommonJS, nextTick ran before promise callbacks",
        order.slice(0, 4), ["synchronous", "process.nextTick", "promise .then", "queueMicrotask"]);
}, 20);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12import { readFile } from "node:fs";

readFile(import.meta.filename, () => {
  const order = [];
  setTimeout(() => order.push("setTimeout 0"), 0);
  setImmediate(() => order.push("setImmediate"));

  setTimeout(() => {
    console.log(order);
    check("after I/O, setImmediate always runs first", order, ["setImmediate", "setTimeout 0"]);
  }, 20);
});

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16let t = performance.now();
setTimeout(() => {
  const waited = performance.now() - t;
  console.log(`asked for 50 ms, waited ${waited.toFixed(1)} ms`);

  // Now keep the thread busy for 200 ms, and ask for 10.
  t = performance.now();
  setTimeout(() => {
    const late = performance.now() - t;
    console.log(`asked for 10 ms, waited ${late.toFixed(0)} ms, behind 200 ms of busy code`);
    check("a timer never fires early", waited >= 49, true);
    check("and fires late -- here, 20 times late -- if the thread is busy", late >= 190, true);
  }, 10);
  const until = performance.now() + 200;
  while (performance.now() < until) {}   // busy: nothing else can run
}, 50);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const t = performance.now();
let timerAt;
setTimeout(() => {
  timerAt = performance.now() - t;
  console.log(`the 0 ms timer fired after ${timerAt.toFixed(0)} ms`);
  check("it waited for every queued microtask first", timerAt > microtasksAt, true);
}, 0);

let microtasksAt;
let n = 0;
function again() {
  if (++n < 2_000_000) queueMicrotask(again);   // each one queues the next
  else microtasksAt = performance.now() - t;
}
queueMicrotask(again);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import { pbkdf2 } from "node:crypto";

const size = process.env.UV_THREADPOOL_SIZE ?? "4 (the default)";
const start = performance.now();
const finished = [];

for (let i = 0; i < 8; i++) {
  pbkdf2("password", "salt", 200_000, 64, "sha512", () => {
    finished.push(Math.round(performance.now() - start));
    if (finished.length === 8) {
      console.log("thread pool size:", size);
      console.log("each hash finished at (ms):", finished.join(" "));
      check("with 4 threads, the 8 hashes finished in two waves", finished[4] > finished[3] * 1.5, true);
    }
  });
}

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import { pbkdf2 } from "node:crypto";

const size = process.env.UV_THREADPOOL_SIZE;
const start = performance.now();
const finished = [];

for (let i = 0; i < 8; i++) {
  pbkdf2("password", "salt", 200_000, 64, "sha512", () => {
    finished.push(Math.round(performance.now() - start));
    if (finished.length === 8) {
      console.log("thread pool size:", size);
      console.log("each hash finished at (ms):", finished.join(" "));
      check("with 8 threads, they finished as one group", finished[7] < finished[0] * 1.4, true);
    }
  });
}

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15import { setTimeout as sleep } from "node:timers/promises";

const later = sleep(50, "the value");         // resolves after 50 ms
const now = Promise.resolve(42);             // already fulfilled
const broken = Promise.reject(new Error("no"));
broken.catch(() => {});                       // handled, so it does not crash the program

console.log(later);
console.log(now);
console.log(broken);

await later;
console.log(later);

check("a promise starts pending and settles once", await later, "the value");

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22function wait(ms, value) {
  return new Promise((resolve) => {
    setTimeout(() => resolve(value), ms);
  });
}

function mustBePositive(n) {
  return new Promise((resolve, reject) => {
    if (n > 0) resolve(n);
    else reject(new RangeError(`${n} is not positive`));
  });
}

console.log(await wait(20, "done waiting"));
console.log(await mustBePositive(5));
try {
  await mustBePositive(-1);
} catch (err) {
  console.log("rejected:", err.message);
}

check("resolve fulfils it with a value", await wait(1, "x"), "x");

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14const steps = [];

const p = new Promise((resolve) => {
  steps.push("the executor runs immediately");
  resolve("first");
  resolve("second");              // ignored: a promise settles only once
  steps.push("and keeps running after resolve");
});
steps.push("then the next line");

console.log(steps, await p);

check("the executor ran before the next line", steps[0], "the executor runs immediately");
check("only the first resolve counts", await p, "first");

price.txt

110

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import { readFile } from "node:fs/promises";

const log = [];

const total = await readFile("price.txt", "utf8")
  .then((text) => Number(text))                  // each then gets the previous result
  .then((price) => price * 1.2)
  .then((withTax) => withTax.toFixed(2))
  .catch((err) => { log.push(`failed: ${err.code}`); return "0.00"; })
  .finally(() => log.push("finally: runs either way"));

const missing = await readFile("nope.txt", "utf8")
  .then((text) => Number(text))
  .catch((err) => { log.push(`failed: ${err.code}`); return 0; });

console.log(total, missing, log);

check("the chain passed each result to the next step", total, "12.00");
check("one catch handles a failure anywhere above it", missing, 0);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21import { setTimeout as sleep } from "node:timers/promises";

const fetchUser = () => sleep(100, { name: "Ada" });
const fetchOrders = () => sleep(100, [101, 102]);
const fetchPrefs = () => sleep(100, { theme: "dark" });

let t = performance.now();
const user = await fetchUser();
const orders = await fetchOrders();
const prefs = await fetchPrefs();
const oneByOne = performance.now() - t;

t = performance.now();
const [u, o, p] = await Promise.all([fetchUser(), fetchOrders(), fetchPrefs()]);
const together = performance.now() - t;

console.log(`one after another: ${oneByOne.toFixed(0)} ms`);
console.log(`Promise.all:       ${together.toFixed(0)} ms`);

check("the same results either way", [u, o, p], [user, orders, prefs]);
check("but all three waited at the same time", together < oneByOne / 2, 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
26import { setTimeout as sleep } from "node:timers/promises";

const ok = (ms, v) => sleep(ms, v);
const fail = async (ms, why) => { await sleep(ms); throw new Error(why); };

// all: every one, or the first failure.
const all = await Promise.all([ok(10, "a"), fail(20, "b broke"), ok(30, "c")]).catch((e) => e.message);

// allSettled: every outcome, success or failure.
const settled = await Promise.allSettled([ok(10, "a"), fail(20, "b broke")]);

// race: whichever settles first, success or failure.
const race = await Promise.race([ok(30, "slow"), ok(10, "fast")]);

// any: the first success; only fails if every one fails.
const any = await Promise.any([fail(10, "x"), ok(20, "first success")]);
const none = await Promise.any([fail(10, "x"), fail(20, "y")]).catch((e) => e.constructor.name);

console.log({ all, race, any, none });
console.log(settled);

check("all rejects with the first failure", all, "b broke");
check("allSettled reports each outcome", settled.map((s) => s.status), ["fulfilled", "rejected"]);
check("race takes the fastest", race, "fast");
check("any ignores failures until one succeeds", any, "first success");
check("and rejects with an AggregateError if all fail", none, "AggregateError");

example.mjs

1
2
3
4
5
6
7
8const { promise, resolve } = Promise.withResolvers();

// Hand resolve to something else -- here, an event that happens later.
setTimeout(() => resolve("the event happened"), 20);

console.log(await promise);

check("resolve can be called from outside the executor", await promise, "the event happened");

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import { setTimeout as sleep } from "node:timers/promises";

const log = [];

async function makeTea() {
  log.push("tea: kettle on");
  await sleep(50);                  // this function pauses here...
  log.push("tea: poured");
  return "tea";
}

const ticker = setInterval(() => log.push("...other work carries on"), 15);

const drink = await makeTea();       // ...but the rest of the program does not
clearInterval(ticker);

console.log(log, drink);

check("an async function returns a promise", makeTea() instanceof Promise, true);
check("other callbacks ran while it was waiting", log.filter((l) => l.startsWith("...")).length >= 2, true);

price.txt

110

rate.txt

10.2

example.mjs

1
2
3
4
5
6
7
8
9
10import { readFile, writeFile } from "node:fs/promises";

const price = Number(await readFile("price.txt", "utf8"));
const rate = Number(await readFile("rate.txt", "utf8"));
await writeFile("total.txt", (price * (1 + rate)).toFixed(2));
const saved = await readFile("total.txt", "utf8");

console.log("saved total:", saved);

check("the same four steps, with no nesting", saved, "12.00");

broken.json

1{ not json

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import { readFile } from "node:fs/promises";

async function loadConfig(path) {
  try {
    return JSON.parse(await readFile(path, "utf8"));
  } catch (err) {
    if (err.code === "ENOENT") return { defaults: true };
    throw new Error(`bad config in ${path}`, { cause: err });
  }
}

console.log(await loadConfig("missing.json"));
try {
  await loadConfig("broken.json");
} catch (err) {
  console.log(err.message, "<- caused by", err.cause.name);
}

check("try/catch catches an awaited rejection", await loadConfig("missing.json"), { defaults: true });

example.mjs

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

const fetchPrice = (id) => sleep(100, id * 10);      // stands in for a request
const ids = [1, 2, 3, 4, 5];

let t = performance.now();
const oneAtATime = [];
for (const id of ids) {
  oneAtATime.push(await fetchPrice(id));             // waits for each before starting the next
}
const slow = performance.now() - t;

t = performance.now();
const together = await Promise.all(ids.map((id) => fetchPrice(id)));   // start all, then wait
const fast = performance.now() - t;

console.log(`await in a loop: ${slow.toFixed(0)} ms`);
console.log(`Promise.all:     ${fast.toFixed(0)} ms`);

check("same answers", together, oneAtATime);
check("the loop waited five times in a row", slow > 450, true);
check("Promise.all waited once", fast < 250, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import { setTimeout as sleep } from "node:timers/promises";

const orders = [{ total: 10 }, { total: 20 }, { total: 30 }];
let revenue = 0;

orders.forEach(async (order) => {
  await sleep(10);                  // e.g. look up a discount
  revenue += order.total;
});

const straightAfter = revenue;
console.log("revenue straight after forEach:", straightAfter);
await sleep(50);
console.log("revenue a moment later:        ", revenue);

check("forEach returned before any callback finished", straightAfter, 0);
check("the callbacks did run, eventually", revenue, 60);

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
30import { setTimeout as sleep } from "node:timers/promises";

async function mapLimit(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;
}

let inFlight = 0;
let peak = 0;
const job = async (n) => {
  inFlight++;
  peak = Math.max(peak, inFlight);
  await sleep(20);
  inFlight--;
  return n * n;
};

const squares = await mapLimit([1, 2, 3, 4, 5, 6, 7, 8], 2, job);
console.log(squares, "peak in flight:", peak);

check("every result, in order", squares, [1, 4, 9, 16, 25, 36, 49, 64]);
check("never more than two at a time", peak, 2);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import { setTimeout as sleep } from "node:timers/promises";

async function* ticks(count) {
  for (let i = 1; i <= count; i++) {
    await sleep(10);
    yield `tick ${i}`;
  }
}

const seen = [];
for await (const tick of ticks(3)) {
  seen.push(tick);
}

console.log(seen);

check("for await takes each value as it arrives", seen, ["tick 1", "tick 2", "tick 3"]);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import { setTimeout as sleep } from "node:timers/promises";

async function sendEmail(to) {
  await sleep(5);
  if (to.endsWith("@invalid")) throw new Error(`cannot deliver to ${to}`);
  return `sent to ${to}`;
}

// Fire-and-forget, done properly: we do not wait, but we do own the failure.
const failures = [];
sendEmail("someone@invalid").catch((err) => failures.push(err.message));

// Awaited: the failure arrives here, where we can decide what it means.
const results = await Promise.allSettled(["ada@example.com", "bob@invalid"].map(sendEmail));

await sleep(20);
console.log(results.map((r) => r.status), failures);

check("the awaited batch reported each outcome", results.map((r) => r.status), ["fulfilled", "rejected"]);
check("the fire-and-forget failure was caught, not crashed on", failures, ["cannot deliver to someone@invalid"]);

example.mjs

1
2
3
4
5
6
7
8
9
10
11process.on("unhandledRejection", (reason) => {
  console.error("unhandled:", reason.message);
  process.exitCode = 1;            // still fail -- just with a message we chose
});

Promise.reject(new Error("the payment job failed"));

setTimeout(() => {
  console.log("exit code will be", process.exitCode);
  check("the handler ran and marked the process as failed", process.exitCode, 1);
}, 10);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import { setTimeout as sleep } from "node:timers/promises";

const controller = new AbortController();

// Some time later, something decides the work is no longer wanted.
setTimeout(() => controller.abort(new Error("user closed the page")), 20);

const started = performance.now();
let outcome;
try {
  await sleep(10_000, null, { signal: controller.signal });
  outcome = "finished";
} catch (err) {
  outcome = `${err.name} after ${Math.round(performance.now() - started)} ms, because: ${err.cause.message}`;
}

console.log(outcome);

check("the 10-second wait was cut short", outcome.startsWith("AbortError"), true);
check("and the reason travelled with it", controller.signal.reason.message, "user closed the page");

example.mjs

1
2
3
4
5
6
7
8
9
10
11const started = Date.now();
process.on("exit", () => {
  const lifetime = Date.now() - started;
  console.log(`process lived for about ${Math.round(lifetime / 100) * 100} ms`);
  check("the process was kept alive by the losing timer", lifetime >= 1900, true);
});

const timeout = (ms) => new Promise((_, reject) => setTimeout(() => reject(new Error("timed out")), ms));
const work = new Promise((resolve) => setTimeout(() => resolve("work done in 10 ms"), 10));

console.log(await Promise.race([work, timeout(2000)]));

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import { setTimeout as sleep } from "node:timers/promises";

const started = Date.now();
process.on("exit", () => {
  const lifetime = Date.now() - started;
  console.log(`process lived for about ${Math.round(lifetime / 10) * 10} ms`);
  check("nothing kept it alive afterwards", lifetime < 500, true);
});

const result = await sleep(10, "work done in 10 ms", { signal: AbortSignal.timeout(2000) });
console.log(result);

try {
  await sleep(5_000, null, { signal: AbortSignal.timeout(30) });
} catch (err) {
  console.log("a slow one:", err.name, "caused by", err.cause.name);
}

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";

// A server that takes a second to answer.
const server = createServer((req, res) => setTimeout(() => res.end("finally"), 1000));
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
const url = `http://127.0.0.1:${server.address().port}/`;

let outcome;
try {
  await fetch(url, { signal: AbortSignal.timeout(50) });
  outcome = "answered";
} catch (err) {
  outcome = err.name;
}

console.log("fetch with a 50 ms timeout:", outcome);
server.closeAllConnections();
server.close();

check("fetch gave up after 50 ms", outcome, "TimeoutError");

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 { setTimeout as sleep } from "node:timers/promises";

async function withRetry(fn, { attempts = 4, baseMs = 10 } = {}) {
  for (let attempt = 1; ; attempt++) {
    try {
      return await fn(attempt);
    } catch (err) {
      if (attempt === attempts) throw err;
      const wait = baseMs * 2 ** (attempt - 1);       // 10, 20, 40...
      console.log(`attempt ${attempt} failed (${err.message}); retrying in ${wait} ms`);
      await sleep(wait);
    }
  }
}

const flaky = async (attempt) => {
  if (attempt < 3) throw new Error("service unavailable");
  return `succeeded on attempt ${attempt}`;
};

const result = await withRetry(flaky);
console.log(result);

check("it succeeded on the third try", result, "succeeded on attempt 3");