> ## Documentation Index
> Fetch the complete documentation index at: https://chariow.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Erreurs

> Codes d'erreur API et leur gestion

L'API Chariow utilise des codes de réponse HTTP conventionnels pour indiquer le succès ou l'échec.

## Codes de statut HTTP

| Code | Description              |
| ---- | ------------------------ |
| 200  | Succès                   |
| 201  | Créé                     |
| 400  | Requête incorrecte       |
| 401  | Non autorisé             |
| 403  | Interdit                 |
| 404  | Non trouvé               |
| 422  | Erreur de validation     |
| 429  | Limite de débit atteinte |
| 500  | Erreur serveur           |

## Format de réponse d'erreur

```json theme={null}
{
  "message": "Description de l'erreur",
  "data": [],
  "errors": {
    "nom_du_champ": ["Message d'erreur de validation"]
  }
}
```

## Erreurs courantes

### Erreur de validation (422)

Se produit lorsque les données envoyées ne passent pas la validation :

```json theme={null}
{
  "message": "Les données fournies sont invalides.",
  "data": [],
  "errors": {
    "email": ["Le champ email est requis."],
    "product_id": ["Le produit sélectionné est invalide."]
  }
}
```

**Comment résoudre :**

* Vérifiez que tous les champs requis sont présents
* Assurez-vous que les formats sont corrects (email, téléphone, etc.)
* Vérifiez que les IDs référencés existent

### Non trouvé (404)

Se produit lorsque la ressource demandée n'existe pas :

```json theme={null}
{
  "message": "Aucun résultat trouvé.",
  "data": [],
  "errors": []
}
```

**Comment résoudre :**

* Vérifiez que l'ID de la ressource est correct
* Assurez-vous que la ressource n'a pas été supprimée
* Vérifiez l'orthographe du slug si utilisé

### Non autorisé (401)

Se produit lorsque l'authentification échoue :

```json theme={null}
{
  "message": "La clé API est manquante. Veuillez fournir une clé API valide.",
  "data": [],
  "errors": []
}
```

**Comment résoudre :**

* Vérifiez que l'en-tête `Authorization` est présent
* Assurez-vous que la clé API est valide et non révoquée
* Vérifiez le format : `Bearer VOTRE_CLE_API`

### Limite de débit atteinte (429)

Se produit lorsque vous dépassez la limite de requêtes :

```json theme={null}
{
  "message": "Trop de requêtes. Veuillez réessayer plus tard.",
  "data": [],
  "errors": []
}
```

**Comment résoudre :**

* Attendez le temps indiqué dans l'en-tête `Retry-After`
* Implémentez un backoff exponentiel
* Réduisez la fréquence de vos requêtes

### Erreur serveur (500)

Se produit en cas de problème côté serveur :

```json theme={null}
{
  "message": "Une erreur interne s'est produite.",
  "data": [],
  "errors": []
}
```

**Comment résoudre :**

* Réessayez la requête après quelques secondes
* Vérifiez le [statut du service](https://status.chariow.com)
* Contactez le support si le problème persiste

## Gestion des erreurs

### Exemple en JavaScript

```javascript theme={null}
async function makeApiRequest(endpoint, options = {}) {
  try {
    const response = await fetch(`https://api.chariow.com/v1${endpoint}`, {
      ...options,
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json',
        ...options.headers
      }
    });

    const data = await response.json();

    if (!response.ok) {
      switch (response.status) {
        case 401:
          throw new Error('Authentification requise');
        case 404:
          throw new Error('Ressource non trouvée');
        case 422:
          const fieldErrors = Object.entries(data.errors)
            .map(([field, messages]) => `${field}: ${messages.join(', ')}`)
            .join('; ');
          throw new Error(`Erreur de validation: ${fieldErrors}`);
        case 429:
          throw new Error('Limite de débit atteinte, réessayez plus tard');
        default:
          throw new Error(data.message || 'Une erreur est survenue');
      }
    }

    return data;
  } catch (error) {
    console.error('Erreur API:', error.message);
    throw error;
  }
}
```

### Exemple en PHP

```php theme={null}
function makeApiRequest($endpoint, $method = 'GET', $body = null) {
    $ch = curl_init("https://api.chariow.com/v1{$endpoint}");

    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => [
            'Authorization: Bearer ' . API_KEY,
            'Content-Type: application/json'
        ],
        CURLOPT_CUSTOMREQUEST => $method
    ]);

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

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

    $data = json_decode($response, true);

    if ($httpCode >= 400) {
        switch ($httpCode) {
            case 401:
                throw new Exception('Authentification requise');
            case 404:
                throw new Exception('Ressource non trouvée');
            case 422:
                $errors = [];
                foreach ($data['errors'] as $field => $messages) {
                    $errors[] = "{$field}: " . implode(', ', $messages);
                }
                throw new Exception('Erreur de validation: ' . implode('; ', $errors));
            case 429:
                throw new Exception('Limite de débit atteinte');
            default:
                throw new Exception($data['message'] ?? 'Une erreur est survenue');
        }
    }

    return $data;
}
```

## Bonnes pratiques

<AccordionGroup>
  <Accordion title="Toujours vérifier le code de statut" icon="check">
    Ne présumez jamais qu'une requête a réussi. Vérifiez toujours le code de statut HTTP.
  </Accordion>

  <Accordion title="Journaliser les erreurs" icon="list">
    Conservez un journal des erreurs API pour le débogage et la surveillance.
  </Accordion>

  <Accordion title="Afficher des messages clairs" icon="message">
    Traduisez les erreurs techniques en messages compréhensibles pour vos utilisateurs.
  </Accordion>

  <Accordion title="Implémenter des réessais" icon="arrows-rotate">
    Pour les erreurs transitoires (500, 429), implémentez une logique de réessai avec backoff.
  </Accordion>
</AccordionGroup>