Errors

class ProxyCharmError(RuntimeError):
    """Normalised error for both response shapes."""

    def __init__(self, code, message, suggestion=None, status=None):
        super().__init__(message)
        self.code = code
        self.suggestion = suggestion
        self.status = status


def unwrap(response):
    """Return data, or raise ProxyCharmError with a usable code."""
    payload = response.json()

    if response.status_code >= 400:
        detail = payload.get("detail") or {}
        if isinstance(detail, str):
            detail = {"code": "HTTP_ERROR", "message": detail}
        raise ProxyCharmError(
            detail.get("code", "HTTP_ERROR"),
            detail.get("message", response.reason),
            detail.get("suggestion"),
            response.status_code,
        )

    if not payload["success"]:
        error = payload["error"]
        raise ProxyCharmError(
            error["code"],
            error["message"],
            error.get("suggestion"),
            response.status_code,
        )

    return payload["data"]

export class ProxyCharmError extends Error {
  constructor({ code, message, suggestion, status }) {
    super(message);
    this.name = "ProxyCharmError";
    this.code = code;
    this.suggestion = suggestion;
    this.status = status;
  }
}

/** Return data, or throw ProxyCharmError with a usable code. */
export async function unwrap(response) {
  const payload = await response.json();

  if (!response.ok) {
    const detail =
      typeof payload.detail === "string"
        ? { code: "HTTP_ERROR", message: payload.detail }
        : (payload.detail ?? {});
    throw new ProxyCharmError({
      code: detail.code ?? "HTTP_ERROR",
      message: detail.message ?? response.statusText,
      suggestion: detail.suggestion,
      status: response.status,
    });
  }

  if (!payload.success) {
    throw new ProxyCharmError({ ...payload.error, status: response.status });
  }

  return payload.data;
}