Validation des paramètres de chemin

1. Utilisation basique de l'étiquette path

Dans les fichiers de description d'API, il est possible de définir des règles de validation pour les paramètres de chemin via l'étiquette path.

type Requete struct {
    Nom string `path:"nom,options=vous|moi"`
}

Ici, options=vous|moi restreint la valeur du paramètre nom à une liste prédéfinie. Cette approche convient lorsque les valeurs possibles sont limitées et connues à l'avance, comme pour des types d'opérations ou des rôles utilisateurs fixes.

2. Validation par expression régulière

Pour un contrôle plus précis du format, les expressions régulières peuvent être employées.

type Requete struct {
    Id string `path:"id,regex=^\\d+$"`
}

Cet exemple impose que id soit une chaîne composée uniquement de chiffres. Les regex sont utiles pour valider des formats spécifiques comme les numéros de téléphone (^1[3-9]\\d{9}$) ou d'identité.

3. Validation de la longueur

type Requete struct {
    NomUtilisateur string `path:"nomUtilisateur,minLength=3,maxLength=20"`
}

Les attributs minLength et maxLength définissent les limites de taille pour les chaînes de caractères. Cela permet d'éviter des valeurs trop courtes ou trop longues qui pourraient perturber la logique métier ou le stockage en base de données.

Validation des paramètres JSON

1. Validation via étiquettes de structure (avec framework web)

En liant le corps de la requête à une structure Go, les étiquettes de champ peuvent assurer une validation basique. Exemple avec le framework Gin :

type RequeteInscription struct {
    NomUtilisateur string `json:"nomUtilisateur" binding:"required,min=3,max=20"`
    MotDePasse     string `json:"motDePasse" binding:"required,min=8"`
    Email          string `json:"email" binding:"required,email"`
}

Les directives comme required, min, max et email effectuent des contrôles de base : champ obligatoire, limites de longueur, format valide. Cette méthode est adaptée à la majorité des cas courants.

2. Fonctions de validation personnalisées

Quand la logique métier dépasse les règles intégrées, on peut créer des validateurs sur mesure. Par exemple, pour vérifier qu'un mot de passe contient chiffres, lettres et caractères spéciaux :

func ValiderMotDePasse(mdp string) bool {
    chiffre, lettre, special := false, false, false
    for _, c := range mdp {
        if unicode.IsDigit(c) {
            chiffre = true
        } else if unicode.IsLetter(c) {
            lettre = true
        } else {
            special = true
        }
    }
    return chiffre && lettre && special
}

type RequeteInscription struct {
    MotDePasse string `json:"motDePasse" binding:"required,validerMotDePasse"`
}

Cette technique est appropriée pour des règles complexes, comme la force d'un mot de passe ou des dépendances entre champs.

3. Bibliothèques de validation tierces

Pour des besoins avancés, une bibliothèque comme validator en Go offre une grande flexibilité.

go get github.com/go-playground/validator/v10

package main

import (
    "fmt"
    "github.com/go-playground/validator/v10"
)

type RequeteInscription struct {
    NomUtilisateur string `json:"nomUtilisateur" validate:"required,min=3,max=20"`
    MotDePasse     string `json:"motDePasse" validate:"required,min=8"`
    Email          string `json:"email" validate:"required,email"`
}

func main() {
    valideur := validator.New()
    requete := RequeteInscription{
        NomUtilisateur: "abc",
        MotDePasse:     "faible",
        Email:          "email_invalide",
    }
    erreur := valideur.Struct(requete)
    if erreur != nil {
        for _, e := range erreur.(validator.ValidationErrors) {
            fmt.Println(e.Champ(), e.Etiquette())
        }
    }
}

Ces bibliothèques excellent pour la validation de structures imbriquées, les relations entre champs (confirmation de mot de passe) ou la gestion multilingue des messages d'erreur.

4. Validation manuelle (déconseillée)

Dans un contexte simple et sans framework, on peut parser le JSON manuellement :

func Gestionnaire(w http.ResponseWriter, r *http.Request) {
    var donnees map[string]interface{}
    erreur := json.NewDecoder(r.Body).Decode(&donnees)
    if erreur != nil {
        http.Error(w, "JSON invalide", http.StatusBadRequest)
        return
    }
    nom, ok := donnees["nomUtilisateur"].(string)
    if !ok || len(nom) < 3 || len(nom) > 20 {
        http.Error(w, "Nom d'utilisateur invalide", http.StatusBadRequest)
        return
    }
    // Vérification des autres champs...
}

Cette méthode est rapide à écrire mais devient vite verbeuse, source d'erreurs et difficile à maintenir. Elle ne constitue qu'une solutoin temporaire en l'absence d'outils dédiés.