Error Reference

interface AarokyaError {
  error: {
    type: string;
    message: string;
    code: string;
  };
}

async function apiFetch(url: string, options: RequestInit): Promise<any> {
  const res = await fetch(url, options);

  if (!res.ok) {
    const { error }: AarokyaError = await res.json();

    switch (error.code) {
      case "AUE_301": // token missing / expired / malformed
      case "AE_07": // missing Authorization header
        // Fetch a fresh token from your backend, then retry once.
        if (await refreshTokenFromBackend()) return apiFetch(url, options);
        navigateTo("/login");
        return;

      case "AUE_302": // user account not active
        navigateTo("/account-inactive");
        return;

      default:
        if (res.status >= 500) {
          // Retry up to 3 times with exponential back-off.
          for (let attempt = 1; attempt <= 3; attempt++) {
            await sleep(Math.pow(2, attempt) * 1000);
            try {
              return await apiFetch(url, options);
            } catch {}
          }
          throw new Error("Service temporarily unavailable");
        }
        throw new Error(error.message);
    }
  }

  return res.json();
}

data class ApiErrorBody(val error: ApiErrorDetail)
data class ApiErrorDetail(val type: String, val message: String, val code: String)

sealed class AarokyaResult<out T> {
    data class Success<T>(val data: T) : AarokyaResult<T>()
    data class Error(val code: String, val message: String) : AarokyaResult<Nothing>()
}

suspend fun <T> handleApiResponse(
    response: Response<T>,
    onTokenExpired: suspend () -> Boolean,
    onNavigate: (String) -> Unit
): AarokyaResult<T> {
    if (response.isSuccessful) {
        return AarokyaResult.Success(response.body()!!)
    }

    val body = gson.fromJson(response.errorBody()?.string(), ApiErrorBody::class.java)
    val detail = body.error

    return when (detail.code) {
        "AUE_301", "AE_07" -> {
            if (onTokenExpired()) {
                AarokyaResult.Error("RETRY", "Token refreshed")
            } else {
                onNavigate("login")
                AarokyaResult.Error(detail.code, detail.message)
            }
        }
        else -> AarokyaResult.Error(detail.code, detail.message)
    }
}

struct ApiErrorBody: Decodable { let error: ApiErrorDetail }
struct ApiErrorDetail: Decodable { let type: String; let message: String; let code: String }

enum AarokyaAPIError: Error {
    case tokenExpired
    case accountInactive
    case notFound
    case serverError(String)
    case unknown(String, Int)
}

func handleAPIError(_ data: Data, statusCode: Int) throws -> Never {
    let body = try JSONDecoder().decode(ApiErrorBody.self, from: data)
    let detail = body.error

    switch detail.code {
    case "AUE_301", "AE_07":
        throw AarokyaAPIError.tokenExpired
    case "AUE_302":
        throw AarokyaAPIError.accountInactive
    default:
        if statusCode >= 500 {
            throw AarokyaAPIError.serverError(detail.message)
        }
        throw AarokyaAPIError.unknown(detail.code, statusCode)
    }
}