Promises and async

A promise is a value that is not ready yet. await waits for it.

async function load(id: string): Promise<User> {
  const res = await fetch(`/api/users/${id}`);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json() as Promise<User>;
}

An async function always returns a promise, whatever you write inside it. Returning 5 returns Promise<number>.

The try/catch that never catches

try {
  sendWelcomeEmail(user.email);   // no await
} catch (err) {
  logger.warn(err);               // never runs
}

try guards the synchronous execution of its block. The call returns a promise immediately, the block finishes, and the rejection arrives later with nothing on the stack to catch it — as an unhandled rejection, which under Node's default policy takes the process down.

The fix is await. Every promise should be awaited, returned, or explicitly discarded with a comment saying why it is fire-and-forget. A bare promise used as a statement always deserves a second look.

Sequential against parallel

const a = await loadUser(id);     // waits
const b = await loadOrders(id);   // then waits again

Those two do not depend on each other, so waiting twice wastes the first wait. Promise.all starts both and waits once:

const [a, b] = await Promise.all([loadUser(id), loadOrders(id)]);

Fifty sequential calls at 500 microseconds each is 25 milliseconds of pure waiting. In parallel it is closer to one round trip.

Promise.all rejects as soon as any one rejects. When you want every result including the failures, Promise.allSettled gives you both.

Try it