SoException

abstract class SoException extends Error {
  constructor(
    public readonly statusCode: number,
    public message: string,
    public payload?: unknown,
  );
}

readonly statusCode: number

message: string

payload?: unknown

throw new BadRequestException("유효하지 않은 이메일 형식입니다", {
  field: "email",
  providedValue: "invalid-email",
  expectedFormat: "[email protected]"
});

function isSoException(err: unknown): err is SoException

try {
  // 어떤 작업
} catch (err) {
  if (isSoException(err)) {
    console.log(`Status: ${err.statusCode}`);
    console.log(`Message: ${err.message}`);
    console.log(`Payload:`, err.payload);
  } else {
    // 다른 타입의 에러 처리
  }
}

class BadRequestException extends SoException

@api()
async createUser(email: string, password: string) {
  if (!email.includes("@")) {
    throw new BadRequestException("유효하지 않은 이메일 형식입니다");
  }
  
  if (password.length < 8) {
    throw new BadRequestException("비밀번호는 최소 8자 이상이어야 합니다", {
      minLength: 8,
      providedLength: password.length
    });
  }
  
  // 사용자 생성 로직
}

class UnauthorizedException extends SoException

@api()
async getMyProfile(ctx: Context) {
  if (!ctx.user) {
    throw new UnauthorizedException("로그인이 필요합니다");
  }
  
  return this.findById(ctx.user.id);
}

class NotFoundException extends SoException

@api()
async getUserById(id: number) {
  const user = await this.findById(id);
  
  if (!user) {
    throw new NotFoundException(`사용자를 찾을 수 없습니다 (ID: ${id})`);
  }
  
  return user;
}

class InternalServerErrorException extends SoException

@api()
async processPayment(orderId: number) {
  try {
    const result = await externalPaymentAPI.charge(orderId);
    return result;
  } catch (err) {
    throw new InternalServerErrorException(
      "결제 처리 중 오류가 발생했습니다",
      { orderId, originalError: err }
    );
  }
}

class ServiceUnavailableException extends SoException

@api()
async getRecommendations() {
  if (!this.mlServiceAvailable) {
    throw new ServiceUnavailableException(
      "추천 서비스가 일시적으로 사용 불가능합니다"
    );
  }
  
  return this.fetchRecommendations();
}

class TargetNotFoundException extends SoException

@api()
async deleteUserPosts(userId: number) {
  const posts = await this.findByUserId(userId);
  
  if (posts.length === 0) {
    throw new TargetNotFoundException(
      `삭제할 게시물이 없습니다 (사용자 ID: ${userId})`
    );
  }
  
  await this.deleteMany(posts.map(p => p.id));
}

class AlreadyProcessedException extends SoException

@api()
async processOrder(orderId: number) {
  const order = await this.findById(orderId);
  
  if (order.status === "processed") {
    throw new AlreadyProcessedException(
      `주문이 이미 처리되었습니다 (ID: ${orderId})`,
      { processedAt: order.processedAt }
    );
  }
  
  // 주문 처리 로직
}

class DuplicateRowException extends SoException

@api()
async createUser(email: string, username: string) {
  const existingUser = await this.findByEmail(email);
  
  if (existingUser) {
    throw new DuplicateRowException(
      "이미 등록된 이메일입니다",
      { field: "email", value: email }
    );
  }
  
  // 사용자 생성 로직
}

// API 메서드에서 예외 발생
@api()
async createPost(title: string) {
  if (!title) {
    throw new BadRequestException("제목은 필수입니다");
  }
  // ...
}

// 클라이언트는 다음과 같은 응답을 받음:
// HTTP 400 Bad Request
// {
//   "statusCode": 400,
//   "message": "제목은 필수입니다"
// }

throw new BadRequestException("유효하지 않은 데이터", {
  errors: [
    { field: "email", message: "이메일 형식이 올바르지 않습니다" },
    { field: "age", message: "나이는 0보다 커야 합니다" }
  ]
});

// 클라이언트 응답:
// HTTP 400 Bad Request
// {
//   "statusCode": 400,
//   "message": "유효하지 않은 데이터",
//   "payload": {
//     "errors": [
//       { "field": "email", "message": "이메일 형식이 올바르지 않습니다" },
//       { "field": "age", "message": "나이는 0보다 커야 합니다" }
//     ]
//   }
// }

// Guards 사용 (권장)
@api({ guards: ["user"] })
async getMyData(ctx: Context) {
  // ctx.user가 보장됨
  return this.findById(ctx.user!.id);
}

// 수동 체크 (더 복잡한 로직에 사용)
@api()
async updateProfile(ctx: Context, data: ProfileData) {
  if (!ctx.user) {
    throw new UnauthorizedException("로그인이 필요합니다");
  }
  
  if (ctx.user.id !== data.userId) {
    throw new UnauthorizedException("본인의 프로필만 수정할 수 있습니다");
  }
  
  // 프로필 업데이트 로직
}