Error Handling

func retryableRequest(fn func() error, maxRetries int) error {
    retryableErrors := map[int]bool{
        429: true, // Rate limit
        500: true, // Internal server error
        503: true, // Service unavailable
    }

    for attempt := 0; attempt < maxRetries; attempt++ {
        err := fn()
        if err == nil {
            return nil
        }

        // Check if error is retryable
        if httpErr, ok := err.(*HTTPError); ok {
            if retryableErrors[httpErr.StatusCode] {
                backoff := time.Duration(math.Pow(2, float64(attempt))) * time.Second
                time.Sleep(backoff)
                continue
            }
        }

        return err // Non-retryable error
    }

    return errors.New("max retries exceeded")
}

async function retryableRequest(apiCall, maxRetries = 3) {
  const retryableStatuses = [429, 500, 503];

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await apiCall();
    } catch (error) {
      if (retryableStatuses.includes(error.response?.status)) {
        const backoff = Math.pow(2, attempt) * 1000;
        console.log(`Retrying after ${backoff}ms...`);
        await new Promise(resolve => setTimeout(resolve, backoff));
        continue;
      }
      throw error; // Non-retryable error
    }
  }

  throw new Error('Max retries exceeded');
}

// Usage
try {
  const order = await retryableRequest(() => createOrder(data));
} catch (error) {
  console.error('Failed to create order:', error);
}

func handleAPIError(err error) string {
    apiErr, ok := err.(*APIError)
    if !ok {
        return "An unexpected error occurred. Please try again."
    }

    switch apiErr.Code {
    case "insufficient_funds":
        return "Unable to process payment. Please contact support."
    case "invalid_amount":
        return "Invalid payment amount. Please check and try again."
    case "rate_limit_exceeded":
        return "Too many requests. Please wait a moment and try again."
    default:
        return apiErr.Message
    }
}

function getUserFriendlyMessage(error) {
  const messages = {
    'insufficient_funds': 'Payment cannot be processed at this time.',
    'invalid_amount': 'Invalid payment amount. Please check and try again.',
    'rate_limit_exceeded': 'Too many requests. Please wait and try again.',
    'order_already_paid': 'This order has already been paid.',
  };

  return messages[error.code] || 'An error occurred. Please try again.';
}

// Display to user
catch (error) {
  const friendlyMessage = getUserFriendlyMessage(error);
  showNotification(friendlyMessage, 'error');
}

import "github.com/google/uuid"

func createOrderWithIdempotency(payload OrderRequest) (*OrderResponse, error) {
    idempotencyKey := uuid.New().String()

    req.Header.Set("X-Idempotency-Key", idempotencyKey)

    // Safe to retry - same idempotency key returns same result
    return callAPI(req)
}

const { v4: uuidv4 } = require('uuid');

async function createOrder(orderData) {
  const idempotencyKey = uuidv4();

  const response = await axios.post(url, orderData, {
    headers: {
      'X-Idempotency-Key': idempotencyKey,
      ...authHeaders
    }
  });

  return response.data;
}