커스텀 에러 클래스 설계

// 이렇게만 하면 에러 미들웨어에서 할 수 있는 게 별로 없다
throw new Error("사용자를 찾을 수 없습니다");

const err = new Error("잘못된 요청");
console.log(err.message);  // "잘못된 요청"
console.log(err.stack);    // 스택 트레이스
// err.statusCode → undefined
// err.isOperational → undefined

// 이런 식으로 하면 코드가 지저분해진다
const err = new Error("사용자를 찾을 수 없습니다");
err.statusCode = 404;
err.status = "fail";
err.isOperational = true;
throw err;

class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
    this.status = `${statusCode}`.startsWith("4") ? "fail" : "error";
    this.isOperational = true;

    Error.captureStackTrace(this, this.constructor);
  }
}

// 4xx → "fail"
new AppError("찾을 수 없습니다", 404);  // status: "fail"
new AppError("권한이 없습니다", 403);    // status: "fail"

// 5xx → "error"
new AppError("서버 내부 오류", 500);     // status: "error"

Error.captureStackTrace(this, this.constructor);

// 라우터나 서비스 레이어에서
const user = await User.findById(id);
if (!user) {
  throw new AppError("해당 사용자를 찾을 수 없습니다", 404);
}

// 인증 미들웨어에서
if (!req.session.userId) {
  throw new AppError("로그인이 필요합니다", 401);
}

// 권한 검증에서
if (task.ownerId !== req.session.userId) {
  throw new AppError("이 작업에 대한 권한이 없습니다", 403);
}

// 에러 처리 미들웨어
app.use((err, req, res, next) => {
  err.statusCode = err.statusCode || 500;
  err.status = err.status || "error";

  if (err.isOperational) {
    // 예상된 에러 → 클라이언트에 상세 메시지 전달
    res.status(err.statusCode).json({
      status: err.status,
      message: err.message,
    });
  } else {
    // 예상치 못한 에러 → 로깅하고 일반 메시지 응답
    console.error("ERROR 💥", err);
    res.status(500).json({
      status: "error",
      message: "서버 내부 오류가 발생했습니다",
    });
  }
});

const sendErrorDev = (err, res) => {
  // 개발 환경: 모든 정보 노출
  res.status(err.statusCode).json({
    status: err.status,
    error: err,
    message: err.message,
    stack: err.stack,
  });
};

const sendErrorProd = (err, res) => {
  if (err.isOperational) {
    // 운영 에러: 메시지 전달
    res.status(err.statusCode).json({
      status: err.status,
      message: err.message,
    });
  } else {
    // 프로그래밍 에러: 상세 정보 숨김
    console.error("ERROR 💥", err);
    res.status(500).json({
      status: "error",
      message: "서버 내부 오류가 발생했습니다",
    });
  }
};

app.use((err, req, res, next) => {
  err.statusCode = err.statusCode || 500;
  err.status = err.status || "error";

  if (process.env.NODE_ENV === "development") {
    sendErrorDev(err, res);
  } else {
    sendErrorProd(err, res);
  }
});

class NotFoundError extends AppError {
  constructor(resource = "리소스") {
    super(`해당 ${resource}을(를) 찾을 수 없습니다`, 404);
  }
}

class ValidationError extends AppError {
  constructor(message) {
    super(message, 400);
  }
}

class UnauthorizedError extends AppError {
  constructor(message = "인증이 필요합니다") {
    super(message, 401);
  }
}

class ForbiddenError extends AppError {
  constructor(message = "접근 권한이 없습니다") {
    super(message, 403);
  }
}

throw new NotFoundError("사용자");    // "해당 사용자을(를) 찾을 수 없습니다", 404
throw new ValidationError("이메일 형식이 올바르지 않습니다");  // 400
throw new UnauthorizedError();        // "인증이 필요합니다", 401

try {
  await someOperation();
} catch (err) {
  if (err instanceof NotFoundError) {
    // 404 처리
  } else if (err instanceof ValidationError) {
    // 400 처리
  } else {
    // 기타 에러
    throw err;
  }
}

// 데이터베이스 중복 키 에러를 AppError로 변환
const handleDuplicateKeyError = (err) => {
  const field = Object.keys(err.keyValue).join(", ");
  const message = `중복된 값입니다: ${field}. 다른 값을 사용해주세요.`;
  return new AppError(message, 400);
};

// JWT 에러 변환
const handleJWTError = () =>
  new AppError("유효하지 않은 토큰입니다. 다시 로그인해주세요.", 401);

const handleJWTExpiredError = () =>
  new AppError("토큰이 만료되었습니다. 다시 로그인해주세요.", 401);

app.use((err, req, res, next) => {
  let error = { ...err, message: err.message };

  if (error.code === 11000) error = handleDuplicateKeyError(error);
  if (error.name === "JsonWebTokenError") error = handleJWTError();
  if (error.name === "TokenExpiredError") error = handleJWTExpiredError();

  // 변환된 에러로 응답 처리
  sendError(error, res);
});