Codes d’erreur

{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Paramètres de requête invalides",
    "status": 400,
    "fields": {
      "amount": "Le montant doit être un entier positif",
      "phone_number": "Format invalide — utilisez +235XXXXXXXX"
    }
  }
}

{
  "error": {
    "code": "UNAUTHORIZED",
    "message": "Clé API invalide ou expirée",
    "status": 401
  }
}

// Ajoutez ce log temporaire pour vérifier que la clé est bien chargée
console.log('Clé API chargée:', process.env.KADRYZA_API_KEY ? '✅ Présente' : '❌ Absente')
console.log('Préfixe correct:', process.env.KADRYZA_API_KEY?.startsWith('kadryza_live_') ? '✅ Oui' : '❌ Non')

{
  "error": {
    "code": "NOT_FOUND",
    "message": "Transaction introuvable",
    "status": 404
  }
}

{
  "error": {
    "code": "DUPLICATE_REFERENCE",
    "message": "Une transaction avec la référence 'order_abc123' existe déjà",
    "status": 409,
    "existing_transaction_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
}

{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Données de requête invalides",
    "status": 422,
    "fields": {
      "amount": "Le montant minimum est 100 XAF",
      "operator": "L'opérateur ORANGE n'est pas supporté au Tchad"
    }
  }
}

{
  "error": {
    "code": "GATEWAY_UNAVAILABLE",
    "message": "La passerelle Airtel Money est temporairement indisponible",
    "status": 503,
    "retry_after": 60
  }
}

import Kadryza from '@kadryza/sdk'
 
const kadryza = new Kadryza({
  apiKey: process.env.KADRYZA_API_KEY
})
 
async function initierPaiementAvecRetry(params, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await kadryza.transactions.initiate(params)
    } catch (error) {
      if (error.code === 'GATEWAY_UNAVAILABLE' && attempt < maxRetries) {
        // Backoff exponentiel : 1s, 4s, 9s
        const delai = attempt * attempt * 1000
        console.log(`Gateway indisponible — retry dans ${delai / 1000}s (tentative ${attempt}/${maxRetries})`)
        await new Promise(resolve => setTimeout(resolve, delai))
      } else {
        throw error
      }
    }
  }
}
 
// Utilisation
const transaction = await initierPaiementAvecRetry({
  reference: 'order_retry_001',
  amount: 10000,
  currency: 'XAF',
  operator: 'MOOV',
  phone_number: '+23566000000'
})

import Kadryza, {
  KadryzaAuthError,
  KadryzaValidationError,
  KadryzaNotFoundError,
  KadryzaDuplicateError,
  KadryzaNetworkError,
  KadryzaGatewayUnavailableError
} from '@kadryza/sdk'
 
const kadryza = new Kadryza({
  apiKey: process.env.KADRYZA_API_KEY
})
 
async function traiterPaiement() {
  try {
    const transaction = await kadryza.transactions.initiate({
      reference: 'order_err_demo',
      amount: 7500,
      currency: 'XAF',
      operator: 'AIRTEL',
      phone_number: '+23566000000',
      description: 'Test gestion erreurs'
    })
 
    console.log('✅ Transaction créée:', transaction.id)
    return transaction
 
  } catch (error) {
    if (error instanceof KadryzaAuthError) {
      // 401 — Clé API invalide
      console.error('🔐 Erreur d\'authentification:', error.message)
      console.error('   → Vérifiez votre clé API dans le dashboard')
      // Action : alerter l'équipe DevOps, la clé est peut-être révoquée
 
    } else if (error instanceof KadryzaValidationError) {
      // 400 / 422 — Paramètres invalides
      console.error('📋 Erreur de validation:', error.message)
      for (const [champ, message] of Object.entries(error.fields || {})) {
        console.error(`   → ${champ}: ${message}`)
      }
      // Action : corriger les paramètres et réessayer
 
    } else if (error instanceof KadryzaNotFoundError) {
      // 404 — Transaction introuvable
      console.error('🔍 Transaction introuvable:', error.message)
      // Action : vérifier l'UUID ou lister les transactions
 
    } else if (error instanceof KadryzaDuplicateError) {
      // 409 — Doublon (idempotence)
      console.error('🔄 Transaction déjà existante:', error.message)
      // Action : récupérer la transaction existante
      // Ce n'est généralement pas une erreur critique
 
    } else if (error instanceof KadryzaGatewayUnavailableError) {
      // 503 — Gateway indisponible
      console.error('📡 Passerelle indisponible:', error.message)
      console.error('   → Réessayez dans quelques minutes')
      // Action : implémenter un retry avec backoff exponentiel
 
    } else if (error instanceof KadryzaNetworkError) {
      // Erreur réseau (pas de connexion, timeout)
      console.error('🌐 Erreur réseau:', error.message)
      console.error('   → Vérifiez votre connexion internet')
      // Action : réessayer la requête
 
    } else {
      // Erreur inattendue
      console.error('💥 Erreur inattendue:', error)
      throw error
    }
  }
}
 
traiterPaiement()

Error
 └── KadryzaError (classe de base)
      ├── KadryzaAuthError          (401)
      ├── KadryzaValidationError    (400, 422)
      ├── KadryzaNotFoundError      (404)
      ├── KadryzaDuplicateError     (409)
      ├── KadryzaNetworkError       (réseau)
      └── KadryzaGatewayUnavailableError (503)

import Kadryza, { KadryzaError } from '@kadryza/sdk'
 
try {
  const tx = await kadryza.transactions.initiate({ /* ... */ })
} catch (error) {
  if (error instanceof KadryzaError) {
    // Toute erreur Kadryza (auth, validation, réseau, etc.)
    console.error(`Erreur Kadryza [${error.code}]:`, error.message)
  } else {
    // Erreur non liée à Kadryza
    throw error
  }
}