Typowane klasy błędów i hierarchie

Wprowadzenie

Rozszerzanie Error

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

Hierarchia błędów

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

Używanie instanceof

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

Rozłączna unia błędów

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

Fabryczne funkcje błędów

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

Serializacja błędów

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

Ustawianie this.name

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

Błędy w 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' });
  }
});

Wzorzec rejestrowania błędów

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

Testowanie typów błędów

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

Szybki sprawdzian

Podsumowanie