Classes et hiérarchies d’erreurs typées

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

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

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

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

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

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

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

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

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

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