TypeScript Academy · Lesson

Error Handling in Async TypeScript Code

Manage async errors with typed wrappers and utilities.

Error Handling in Async TypeScript Code is a free TypeScript Academy lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the TypeScript Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Welcome

Async functions add complexity to error handling. TypeScript ensures you handle Promise rejections properly.

Async/Await Try-Catch

Wrap await calls in try-catch to handle Promise rejections.

async function loadUser(id: number): Promise<User> {
  try {
    return await api.getUser(id);
  } catch (err: unknown) {
    if (err instanceof Error) throw new AppError(err.message);
    throw new AppError('Unknown error');
  }
}

Promise.all Errors

Promise.all rejects with the first rejection. Wrap in try-catch.

try {
  const [user, posts] = await Promise.all([getUser(id), getPosts(id)]);
} catch (err) { /* one or both failed */ }

Promise.allSettled

allSettled returns both successes and failures without throwing.

const results = await Promise.allSettled([getUser(1), getPosts(1)]);
results.forEach(r => {
  if (r.status === 'fulfilled') console.log(r.value);
  else console.error(r.reason);
});

Typed Async Result

Combine async with the Result pattern for explicit error handling.

async function safeGet<T>(fn: () => Promise<T>): Promise<Result<T>> {
  try { return { ok: true, value: await fn() }; }
  catch (e) { return { ok: false, error: e as Error }; }
}

Unhandled Rejections

Listen for unhandled rejections in Node.js to prevent crashes.

process.on('unhandledRejection', (reason: unknown) => {
  console.error('Unhandled rejection:', reason);
  process.exit(1);
});

Timeout with Promise.race

Implement a typed timeout pattern with Promise.race.

function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
  const timeout = new Promise<never>((_, reject) =>
    setTimeout(() => reject(new Error('Timeout')), ms));
  return Promise.race([promise, timeout]);
}

Retry Pattern

Implement typed async retry with typed errors.

async function retry<T>(fn: () => Promise<T>, times: number): Promise<T> {
  for (let i = 0; i < times; i++) {
    try { return await fn(); } catch (e) { if (i === times - 1) throw e; }
  }
  throw new Error('Unreachable');
}

Concurrent Error Handling

Handle errors when running concurrent async operations.

const [userResult, postsResult] = await Promise.allSettled([
  getUser(id).then(u => ({ ok: true, value: u })).catch(e => ({ ok: false, error: e })),
  getPosts(id).then(p => ({ ok: true, value: p })).catch(e => ({ ok: false, error: e })),
]);

AsyncQueue Error Propagation

Errors in async iterators propagate correctly with for-await.

async function* generate() {
  yield await fetchA();
  yield await fetchB(); // error here stops the loop
}
for await (const item of generate()) { process(item); }

Typed Error Middleware in Next.js

Use typed error boundaries in server actions.

'use server';
async function createUser(data: CreateUserDto): Promise<Result<User>> {
  return safeGet(() => db.user.create({ data }));
}

Quick Check

What happens if you do not catch a rejected Promise in an async/await function?

Recap

Error Handling in Async TypeScript Code: you learned the key concepts of this topic and how to apply them in real TypeScript projects.

Frequently asked questions

Is the “Error Handling in Async TypeScript Code” lesson free?

Yes — the full text of “Error Handling in Async TypeScript Code” is free to read here on the web, and the TypeScript Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the TypeScript Academy course, upgrade to CoddyKit PRO.

What will I learn in “Error Handling in Async TypeScript Code”?

Manage async errors with typed wrappers and utilities. You practise TypeScript Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start TypeScript Academy?

No prior experience is required. TypeScript Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Error Handling in Async TypeScript Code” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this TypeScript Academy lesson?

Yes. Every TypeScript Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

Typed Error Classes and Hierarchies
The Result Pattern: Ok and Err
Narrowing Caught Errors (unknown vs Error)
Error Handling in Async TypeScript Code

← Back to TypeScript Academy