Typisierte Fehlerklassen und Hierarchien

Willkommen

Error erweitern

class AppError extends Error {
  constructor(public message: string, public statusCode = 500) {
    super(message);
    this.name = 'AppError';
  }
}

Error-Hierarchie

class NotFoundError extends AppError {
  constructor(resource: string) { super(`${resource} not found`, 404); }
}
class ValidationError extends AppError {
  constructor(public fields: string[]) { super('Validation failed', 400); }
}

instanceof verwenden

try { doSomething(); }
catch (err) {
  if (err instanceof NotFoundError) res.status(404).json({ error: err.message });
  else if (err instanceof ValidationError) res.status(400).json({ fields: err.fields });
}

Diskriminierte Error-Union

type AppError =
  | { kind: 'not_found'; resource: string }
  | { kind: 'unauthorized' }
  | { kind: 'validation'; fields: string[] };

Error-Factory-Funktionen

const errors = {
  notFound: (r: string) => new NotFoundError(r),
  unauthorized: () => new AppError('Unauthorized', 401),
};

Error-Serialisierung

function serializeError(err: AppError): Record<string, unknown> {
  return { error: err.message, code: err.statusCode, name: err.name };
}

this.name festlegen

class MyError extends Error {
  readonly name = 'MyError' as const;
  constructor(msg: string) { super(msg); }
}

Fehler in Express

app.use((err: unknown, req: Request, res: Response, next: NextFunction) => {
  if (err instanceof AppError) {
    res.status(err.statusCode).json({ error: err.message });
  } else {
    res.status(500).json({ error: 'Internal error' });
  }
});

Muster für Error-Logging

function logError(err: unknown): void {
  if (err instanceof Error) console.error(`[${err.name}] ${err.message}`);
  else console.error('Unknown error:', err);
}

Fehlertypen testen

test('throws NotFoundError for missing user', async () => {
  await expect(getUser(999)).rejects.toThrow(NotFoundError);
});

Kurztest

Zusammenfassung