Error Handling

class CredoApiError extends Error {
  constructor(status, message, errors) {
    super(message);
    this.status = status;
    this.errors = errors;
  }
}

async function credoRequest(path, options = {}) {
  const baseUrl = process.env.CREDO_API_URL;
  const response = await fetch(`${baseUrl}${path}`, {
    ...options,
    headers: {
      "Content-Type": "application/json",
      ...options.headers,
    },
  });

  const body = await response.json();

  if (body.status !== 200) {
    throw new CredoApiError(body.status, body.message, body.error);
  }

  return body.data;
}

// Usage
try {
  const data = await credoRequest("/transaction/initialize", {
    method: "POST",
    headers: { "Authorization": process.env.CREDO_PUBLIC_KEY },
    body: JSON.stringify(payload),
  });
  // Redirect to data.authorizationUrl
} catch (error) {
  if (error instanceof CredoApiError) {
    if (error.status === 401) {
      // Handle auth error
    } else if (error.status === 400) {
      // Handle validation - show error.errors to user
    }
  } else {
    // Network error - retry or show generic message
  }
}

import requests

class CredoApiError(Exception):
    def __init__(self, status, message, errors):
        self.status = status
        self.message = message
        self.errors = errors
        super().__init__(message)

def credo_request(path, method="GET", data=None, api_key=None):
    base_url = os.environ["CREDO_API_URL"]
    response = requests.request(
        method,
        f"{base_url}{path}",
        headers={
            "Authorization": api_key,
            "Content-Type": "application/json",
        },
        json=data,
    )

    body = response.json()

    if body["status"] != 200:
        raise CredoApiError(body["status"], body["message"], body.get("error", []))

    return body["data"]

# Usage
try:
    data = credo_request(
        "/transaction/initialize",
        method="POST",
        data=payload,
        api_key=os.environ["CREDO_PUBLIC_KEY"],
    )
except CredoApiError as e:
    if e.status == 401:
        # Handle auth error
        pass
    elif e.status == 400:
        # Handle validation
        pass

<?php
class CredoApiError extends Exception {
    public $status;
    public $errors;

    public function __construct($status, $message, $errors = []) {
        parent::__construct($message);
        $this->status = $status;
        $this->errors = $errors;
    }
}

function credoRequest($path, $method = "GET", $data = null, $apiKey = null) {
    $baseUrl = getenv("CREDO_API_URL");
    $ch = curl_init($baseUrl . $path);

    $headers = [
        "Authorization: " . $apiKey,
        "Content-Type: application/json",
    ];

    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CUSTOMREQUEST => $method,
        CURLOPT_HTTPHEADER => $headers,
    ]);

    if ($data) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    }

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    $body = json_decode($response, true);

    if ($body["status"] !== 200) {
        throw new CredoApiError($body["status"], $body["message"], $body["error"] ?? []);
    }

    return $body["data"];
}

// Usage
try {
    $data = credoRequest("/transaction/initialize", "POST", $payload, getenv("CREDO_PUBLIC_KEY"));
    // Redirect to $data["authorizationUrl"]
} catch (CredoApiError $e) {
    if ($e->status === 401) {
        // Handle auth error
    } elseif ($e->status === 400) {
        // Handle validation
    }
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class CredoApiClient {
    private static final ObjectMapper mapper = new ObjectMapper();
    private final String baseUrl;
    private final HttpClient client;

    public CredoApiClient() {
        this.baseUrl = System.getenv("CREDO_API_URL");
        this.client = HttpClient.newHttpClient();
    }

    public JsonNode request(String path, String method, String apiKey, String jsonBody) throws CredoApiException {
        HttpRequest.Builder builder = HttpRequest.newBuilder()
            .uri(URI.create(baseUrl + path))
            .header("Authorization", apiKey)
            .header("Content-Type", "application/json");

        if ("POST".equals(method)) {
            builder.POST(HttpRequest.BodyPublishers.ofString(jsonBody));
        } else {
            builder.GET();
        }

        try {
            HttpResponse<String> response = client.send(builder.build(), HttpResponse.BodyHandlers.ofString());
            JsonNode body = mapper.readTree(response.body());

            if (body.get("status").asInt() != 200) {
                throw new CredoApiException(
                    body.get("status").asInt(),
                    body.get("message").asText(),
                    body.get("error")
                );
            }

            return body.get("data");
        } catch (Exception e) {
            throw new CredoApiException(0, "Network error", null);
        }
    }
}

class CredoApiException extends Exception {
    public final int status;
    public final JsonNode errors;

    public CredoApiException(int status, String message, JsonNode errors) {
        super(message);
        this.status = status;
        this.errors = errors;
    }
}

using System.Text;
using System.Text.Json;

public class CredoApiException : Exception
{
    public int Status { get; }
    public JsonElement Errors { get; }

    public CredoApiException(int status, string message, JsonElement errors)
        : base(message)
    {
        Status = status;
        Errors = errors;
    }
}

public class CredoApiClient
{
    private readonly string _baseUrl;
    private readonly HttpClient _client;

    public CredoApiClient(IConfiguration config)
    {
        _baseUrl = config["CREDO_API_URL"];
        _client = new HttpClient();
    }

    public async Task<JsonElement> RequestAsync(string path, HttpMethod method, string apiKey, object data = null)
    {
        var request = new HttpRequestMessage(method, $"{_baseUrl}{path}");
        request.Headers.Add("Authorization", apiKey);

        if (data != null)
        {
            request.Content = new StringContent(
                JsonSerializer.Serialize(data),
                Encoding.UTF8,
                "application/json"
            );
        }

        var response = await _client.SendAsync(request);
        var body = await response.Content.ReadAsStringAsync();
        var doc = JsonDocument.Parse(body);
        var root = doc.RootElement;

        if (root.GetProperty("status").GetInt32() != 200)
        {
            throw new CredoApiException(
                root.GetProperty("status").GetInt32(),
                root.GetProperty("message").GetString(),
                root.TryGetProperty("error", out var err) ? err : default
            );
        }

        return root.GetProperty("data");
    }
}

// Usage
try
{
    var data = await client.RequestAsync("/transaction/initialize", HttpMethod.Post, apiKey, payload);
    // Redirect to data.GetProperty("authorizationUrl")
}
catch (CredoApiException ex)
{
    if (ex.Status == 401)
    {
        // Handle auth error
    }
    else if (ex.Status == 400)
    {
        // Handle validation
    }
}