Fehlerbehandlung in asynchronem TypeScript-Code

Willkommen

Try-Catch mit Async/Await

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');
  }
}

Fehler bei Promise.all

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

Promise.allSettled

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);
});

Typisiertes asynchrones Result

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 }; }
}

Nicht behandelte Ablehnungen

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

Timeout mit 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-Muster

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');
}

Nebenläufige Fehlerbehandlung

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 })),
]);

Fehlerweitergabe in AsyncQueue

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

Typisierte Error-Middleware in Next.js

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

Schnelltest

Zusammenfassung