Async Context & Cancellation

import { createServer } from 'node:http';
import { AsyncLocalStorage } from 'node:async_hooks';
import { randomUUID } from 'node:crypto';
import { setTimeout as sleep } from 'node:timers/promises';

const requestContext = new AsyncLocalStorage();

function log(message) {
  const ctx = requestContext.getStore();
  console.log(JSON.stringify({ requestId: ctx?.requestId ?? '-', message }));
}

async function findBook(id) {
  await sleep(10);            // stands in for a database call
  log(`loaded book ${id}`);   // no requestId argument is passed down
  return { id, title: 'Bookshelf' };
}

const server = createServer((req, res) => {
  const requestId = req.headers['x-request-id'] ?? randomUUID();
  requestContext.run({ requestId }, async () => {
    log(`${req.method} ${req.url}`);
    const book = await findBook(1);
    res.setHeader('x-request-id', requestId);
    res.end(JSON.stringify(book));
    log('done');
  });
});

await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
const { port } = server.address();
await Promise.all(
  ['a', 'b'].map((id) =>
    fetch(`http://127.0.0.1:${port}/books/1`, { headers: { 'x-request-id': id } }).then((r) => r.text()),
  ),
);
server.close();

{"requestId":"a","message":"GET /books/1"}
{"requestId":"b","message":"GET /books/1"}
{"requestId":"a","message":"loaded book 1"}
{"requestId":"a","message":"done"}
{"requestId":"b","message":"loaded book 1"}
{"requestId":"b","message":"done"}

import { AsyncLocalStorage, AsyncResource, createHook, executionAsyncId } from 'node:async_hooks';
import { writeSync } from 'node:fs';

const kinds = new Map();
const hook = createHook({
  init(asyncId, type) { kinds.set(type, (kinds.get(type) ?? 0) + 1); },
}).enable();

setTimeout(() => {}, 1);
await Promise.resolve();
hook.disable();
writeSync(1, `executionAsyncId: ${executionAsyncId()}\n`);
writeSync(1, `seen types: ${['PROMISE', 'Timeout'].map((t) => `${t}=${kinds.has(t)}`).join(' ')}\n`);

// A callback-style queue that would lose the request context unless the callback is bound
const als = new AsyncLocalStorage();
const queue = [];
const enqueue = (callback) => queue.push(callback);

als.run('request-1', () => enqueue((v) => console.log('plain callback :', als.getStore(), v)));
als.run('request-2', () => enqueue(AsyncLocalStorage.bind((v) => console.log('ALS.bind        :', als.getStore(), v))));
als.run('request-3', () => enqueue(AsyncResource.bind((v) => console.log('AsyncResource.bind:', als.getStore(), v))));
for (const callback of queue) callback(42);

executionAsyncId: 4
seen types: PROMISE=true Timeout=true
plain callback : undefined 42
ALS.bind        : request-2 42
AsyncResource.bind: request-3 42

const ac = new AbortController();
const { signal } = ac;

signal.addEventListener('abort', () => console.log('abort event, reason:', signal.reason.name), { once: true });
console.log('aborted before:', signal.aborted);
ac.abort();                       // default reason is a DOMException named AbortError
console.log('aborted after:', signal.aborted, signal.reason instanceof DOMException);

const custom = new AbortController();
custom.abort(new Error('user clicked cancel'));
console.log(custom.signal.reason.message);
try {
  custom.signal.throwIfAborted();
} catch (err) {
  console.log('throwIfAborted threw:', err.message);
}

const timed = AbortSignal.timeout(20);
const keepAlive = setTimeout(() => {}, 1000);   // the timeout signal's own timer does not keep the process alive
await new Promise((resolve) => timed.addEventListener('abort', resolve, { once: true }));
clearTimeout(keepAlive);
console.log('timeout reason:', timed.reason.name, timed.reason.code);

console.log('pre-aborted:', AbortSignal.abort().aborted);

aborted before: false
abort event, reason: AbortError
aborted after: true true
user clicked cancel
throwIfAborted threw: user clicked cancel
timeout reason: TimeoutError 23
pre-aborted: true

import { open } from 'node:fs/promises';
import { createServer } from 'node:http';
import { addAbortListener } from 'node:events';

class Lease {
  constructor(name) { this.name = name; console.log('acquire', name); }
  [Symbol.dispose]() { console.log('release', this.name); }
}

class Connection {
  constructor(name) { this.name = name; console.log('open', name); }
  async [Symbol.asyncDispose]() {
    await Promise.resolve();                 // e.g. flush and close a socket
    console.log('close', this.name);
  }
}

function sync() {
  using a = new Lease('a');
  using b = new Lease('b');
  console.log('working with', a.name, b.name);
  throw new Error('boom');                   // both leases are still released, in reverse order
}
try { sync(); } catch (err) { console.log('caught', err.message); }

async function asyncWork() {
  await using conn = new Connection('db');
  await using file = await open(import.meta.filename);   // FileHandle has Symbol.asyncDispose
  const { size } = await file.stat();
  console.log('file bytes > 0:', size > 0);
  await using server = createServer();                     // http.Server too: calls server.close()
  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
  console.log('listening:', server.listening);
}
await asyncWork();
console.log('done');

// events.addAbortListener returns a Disposable that removes the listener
const ac = new AbortController();
{
  using _ = addAbortListener(ac.signal, () => console.log('never printed'));
}
ac.abort();
console.log('typeof Symbol.dispose:', typeof Symbol.dispose, typeof Symbol.asyncDispose);

acquire a
acquire b
working with a b
release b
release a
caught boom
open db
file bytes > 0: true
listening: true
close db
done
typeof Symbol.dispose: symbol symbol

import { spawn } from 'node:child_process';
import { setTimeout as sleep } from 'node:timers/promises';
{
  using child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)']);
  child.on('exit', (code, sig) => console.log('child exit:', code, sig));
  await sleep(100);
  console.log('leaving block, killed =', child.killed);
}
await sleep(200);
{
  using t = setTimeout(() => console.log('timer fired'), 50);   // Timeout has Symbol.dispose, cancels it
}
await sleep(100);
console.log('no timer fired');

leaving block, killed = false
child exit: null SIGTERM
no timer fired

console.log(typeof DisposableStack, typeof AsyncDisposableStack, typeof SuppressedError);
if (typeof AsyncDisposableStack === 'function') {
  await using stack = new AsyncDisposableStack();
  stack.defer(() => console.log('deferred cleanup 1'));
  stack.adopt({ id: 7 }, (res) => console.log('adopted cleanup for', res.id));
  stack.use({ [Symbol.dispose]: () => console.log('used disposable') });
  console.log('body');
}
const sync = {
  [Symbol.dispose]() { throw new Error('dispose failed'); },
};
try {
  using _ = sync;
  throw new Error('body failed');
} catch (err) {
  console.log(err.constructor.name, '|', err.error.message, '|', err.suppressed.message);
}

function function function
body
used disposable
adopted cleanup for 7
deferred cleanup 1
SuppressedError | dispose failed | body failed

import { open } from 'node:fs/promises';
import { createServer } from 'node:http';

console.log(typeof Symbol.dispose, typeof Symbol.asyncDispose, typeof DisposableStack);

const file = await open(import.meta.filename);
console.log('FileHandle async-disposable:', typeof file[Symbol.asyncDispose]);
try {
  console.log('bytes > 0:', (await file.stat()).size > 0);
} finally {
  await file[Symbol.asyncDispose]();      // what `await using` calls for you
}

const server = createServer();
console.log('Server async-disposable:', typeof server[Symbol.asyncDispose]);

symbol symbol undefined
FileHandle async-disposable: function
bytes > 0: true
Server async-disposable: function

import { createServer } from 'node:http';
import { once } from 'node:events';

// Deprecated (documentation-only, DEP0209): an AbortSignal used to tear a long-lived resource down.
async function before() {
  const ac = new AbortController();
  const server = createServer();
  server.listen({ port: 0, host: '127.0.0.1', signal: ac.signal });
  await once(server, 'listening');
  console.log('before: listening', server.listening);
  ac.abort();
  await once(server, 'close');
  console.log('before: closed');
}

// Preferred: the owner of the resource disposes of it with `using`.
async function after() {
  await using server = createServer();
  server.listen(0, '127.0.0.1');
  await once(server, 'listening');
  console.log('after: listening', server.listening);
}                                       // server.close() is awaited here

await before();
await after();

before: listening true
before: closed
after: listening true