Status e Códigos

{
  "success": false,
  "error": {
    "code": "PIX_IN_001",
    "message": "Valor deve ser maior que R$ 0,01",
    "field": "amountInCents",
    "details": {
      "minimumValue": 1,
      "providedValue": 0
    }
  },
  "timestamp": "2024-01-20T10:30:00.000Z",
  "requestId": "req_abc123def456ghi789"
}

class APIErrorHandler {
  static handle(error) {
    switch (error.status) {
      case 400:
        return this.handleBadRequest(error)
      case 401:
        return this.handleUnauthorized(error)
      case 403:
        return this.handleForbidden(error)
      case 404:
        return this.handleNotFound(error)
      case 422:
        return this.handleUnprocessableEntity(error)
      case 429:
        return this.handleRateLimit(error)
      case 500:
        return this.handleInternalError(error)
      default:
        return this.handleUnknownError(error)
    }
  }

  static handleBadRequest(error) {
    const errorCode = error.response?.data?.error?.code
    
    switch (errorCode) {
      case 'PIX_IN_001':
        throw new Error('Valor inválido. Verifique se o valor está dentro dos limites permitidos.')
      case 'PIX_IN_002':
        throw new Error('CPF/CNPJ inválido. Verifique o número do documento.')
      case 'PIX_OUT_002':
        throw new Error('Chave PIX inválida. Verifique o formato da chave.')
      default:
        throw new Error('Dados inválidos. Verifique os parâmetros enviados.')
    }
  }

  static async handleUnauthorized(error) {
    console.log('Token expirado, renovando...')
    
    // Tentar renovar token automaticamente
    try {
      await auth.renewToken()
      return { shouldRetry: true }
    } catch (renewError) {
      throw new Error('Falha na autenticação. Verifique suas credenciais.')
    }
  }

  static async handleRateLimit(error) {
    const retryAfter = error.response?.headers['retry-after'] || 60
    
    console.log(`Rate limit atingido. Aguardando ${retryAfter} segundos...`)
    
    return { 
      shouldRetry: true, 
      retryAfter: retryAfter * 1000 
    }
  }

  static handleInternalError(error) {
    const requestId = error.response?.data?.requestId
    
    throw new Error(
      `Erro interno do servidor. ` +
      `Entre em contato com o suporte informando o ID: ${requestId}`
    )
  }
}

// Uso
async function makeAPICall(apiFunction, ...args) {
  const maxRetries = 3
  let attempt = 0

  while (attempt < maxRetries) {
    try {
      return await apiFunction(...args)
    } catch (error) {
      attempt++
      
      const handled = APIErrorHandler.handle(error)
      
      if (handled?.shouldRetry && attempt < maxRetries) {
        if (handled.retryAfter) {
          await new Promise(resolve => setTimeout(resolve, handled.retryAfter))
        }
        continue
      }
      
      throw error
    }
  }
}

class RateLimiter {
  constructor() {
    this.requests = new Map()
  }

  async waitIfNeeded(endpoint) {
    const now = Date.now()
    const requests = this.requests.get(endpoint) || []
    
    // Limpar requisições antigas (mais de 1 minuto)
    const recentRequests = requests.filter(time => now - time < 60000)
    
    // Verificar limite por endpoint
    const limits = {
      '/api/auth': 5,
      '/api/v1/pix/in/qrcode': 100,
      '/api/v1/pix/out/pixkey': 50,
      '/api/v1/webhook': 30
    }
    
    const limit = limits[endpoint] || 100
    
    if (recentRequests.length >= limit) {
      const oldestRequest = Math.min(...recentRequests)
      const waitTime = 60000 - (now - oldestRequest)
      
      console.log(`Rate limit atingido para ${endpoint}. Aguardando ${waitTime}ms...`)
      await new Promise(resolve => setTimeout(resolve, waitTime))
    }
    
    // Registrar nova requisição
    recentRequests.push(now)
    this.requests.set(endpoint, recentRequests)
  }
}