Async Patterns

async function load(id: string) {
  return { id, ok: true };
}
const user = await load("1");
user
// { id: "1", ok: true }

const results = await Promise.allSettled([
  Promise.resolve(1),
  Promise.reject(new Error("x")),
]);
results[0].status  // "fulfilled"
results[1].status  // "rejected"

const [a, b] = await Promise.all([
  Promise.resolve(1),
  Promise.resolve(2),
]);
a + b  // 3

const first = await Promise.any([
  Promise.reject(new Error("a")),
  Promise.resolve("ok"),
]);
first  // "ok"

const signal = AbortSignal.timeout(50);
await new Promise((r) => setTimeout(r, 0));
signal.aborted  // false until timeout fires
// await fetch(url, { signal });

async function mapPool<T, R>(items: T[], limit: number, fn: (t: T) => Promise<R>) {
  const ret: R[] = [];
  let i = 0;
  await Promise.all(Array.from({ length: limit }, async () => {
    while (i < items.length) {
      const idx = i++;
      ret[idx] = await fn(items[idx]);
    }
  }));
  return ret;
}
await mapPool([1, 2, 3], 2, async (n) => n * 2)
// [2, 4, 6]

async function* gen() {
  yield 1;
  yield 2;
}
const xs: number[] = [];
for await (const x of gen()) xs.push(x);
xs  // [1, 2]

const order: string[] = [];
process.nextTick(() => order.push("tick"));
setImmediate(() => order.push("immediate"));
await new Promise((r) => setImmediate(r));
order
// ["tick", "immediate"]

import { promisify } from "node:util";
const wait = promisify((ms: number, cb: (e: Error | null) => void) => setTimeout(cb, ms, null));
await wait(1);
// resolves after 1ms

function deferred<T>() {
  let resolve!: (v: T) => void;
  let reject!: (e: unknown) => void;
  const promise = new Promise<T>((res, rej) => {
    resolve = res; reject = rej;
  });
  return { promise, resolve, reject };
}
const d = deferred<number>();
d.resolve(7);
await d.promise  // 7

async function retry<T>(fn: () => Promise<T>, n = 3): Promise<T> {
  let err: unknown;
  for (let i = 0; i < n; i++) {
    try { return await fn(); }
    catch (e) { err = e; await new Promise((r) => setTimeout(r, 10 * 2 ** i)); }
  }
  throw err;
}
let tries = 0;
await retry(async () => {
  tries++;
  if (tries < 2) throw new Error("fail");
  return "ok";
})
// "ok"

let chain: Promise<unknown> = Promise.resolve();
function withLock<T>(fn: () => Promise<T>) {
  const run = chain.then(fn, fn);
  chain = run.then(() => {}, () => {});
  return run;
}
await withLock(async () => 1)  // 1

import { setTimeout as sleep } from "node:timers/promises";
const t0 = Date.now();
await sleep(10);
Date.now() - t0 >= 10  // true

const results = await Promise.allSettled([
  Promise.resolve("a"),
  Promise.reject(new Error("b")),
]);
results.filter((r) => r.status === "fulfilled").length  // 1

const config = await Promise.resolve({ port: 3000 });
config.port  // 3000