TypeScript Cheatsheet 18 — Async Patterns

const p = new Promise<number>((resolve, reject) => {
  setTimeout(() => resolve(42), 100);
});

p.then((v) => v + 1).catch((e) => console.error(e));

const v = await p;     // 42

async function f(): Promise<number> {
  const x = await fetch1();
  const y = await fetch2(x);
  return y;
}

const [users, posts, tags] = await Promise.all([
  fetchUsers(),
  fetchPosts(),
  fetchTags(),
]);

const results = await Promise.allSettled([
  risky1(),
  risky2(),
]);

for (const r of results) {
  if (r.status === "fulfilled") console.log(r.value);
  else console.error(r.reason);
}

// First to settle (resolve OR reject):
const winner = await Promise.race([p1, p2, p3]);

// First to fulfill (skips rejections):
const success = await Promise.any([p1, p2, p3]);

// Sequential (slow)
for (const url of urls) {
  results.push(await fetch(url));
}

// Concurrent
const results = await Promise.all(urls.map(fetch));

async function pool<T, R>(
  items: T[],
  limit: number,
  fn: (item: T) => Promise<R>,
): Promise<R[]> {
  const results: R[] = [];
  const executing: Promise<void>[] = [];
  
  for (const [i, item] of items.entries()) {
    const p = fn(item).then((r) => { results[i] = r; });
    executing.push(p);
    if (executing.length >= limit) {
      await Promise.race(executing);
      executing.splice(executing.findIndex(p => p), 1);
    }
  }
  
  await Promise.all(executing);
  return results;
}

await pool(urls, 5, fetch);

import pLimit from "p-limit";
const limit = pLimit(5);
const results = await Promise.all(
  urls.map((u) => limit(() => fetch(u))),
);

function timeout<T>(p: Promise<T>, ms: number): Promise<T> {
  return Promise.race([
    p,
    new Promise<never>((_, rej) => setTimeout(() => rej(new Error("timeout")), ms)),
  ]);
}

await timeout(fetch("/x"), 5000);

await fetch("/x", { signal: AbortSignal.timeout(5000) });

const ctrl = new AbortController();

const p = fetch("/x", { signal: ctrl.signal });
setTimeout(() => ctrl.abort(), 1000);

try {
  await p;
} catch (e) {
  if (e instanceof DOMException && e.name === "AbortError") {
    // handled
  }
}

const sig = AbortSignal.any([ctrl.signal, AbortSignal.timeout(5000)]);
await fetch("/x", { signal: sig });

async function retry<T>(
  fn: () => Promise<T>,
  attempts = 3,
  base = 100,
): Promise<T> {
  let lastErr: unknown;
  for (let i = 0; i < attempts; i++) {
    try { return await fn(); }
    catch (e) {
      lastErr = e;
      await new Promise(r => setTimeout(r, base * 2 ** i));
    }
  }
  throw lastErr;
}

await retry(() => fetch("/x").then(r => r.json()));

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>();
setTimeout(() => d.resolve(42), 100);
const v = await d.promise;

import { promisify } from "node:util";
import fs from "node:fs";

const readFile = promisify(fs.readFile);
const buf = await readFile("a.txt");

// In an ESM module
const config = await loadConfig();
export { config };

async function* range(n: number) {
  for (let i = 0; i < n; i++) {
    yield i;
    await new Promise(r => setTimeout(r, 100));
  }
}

for await (const x of range(5)) {
  console.log(x);
}

class Queue<T> {
  private items: T[] = [];
  private waiters: Array<(v: T) => void> = [];
  
  push(item: T) {
    const w = this.waiters.shift();
    if (w) w(item);
    else this.items.push(item);
  }
  
  pop(): Promise<T> {
    const item = this.items.shift();
    if (item !== undefined) return Promise.resolve(item);
    return new Promise(res => this.waiters.push(res));
  }
}

process.on("unhandledRejection", (reason) => {
  console.error("unhandled:", reason);
});