Aller au contenu
Réussir mon BTS SIO

Tape une notion, une commande ou le nom d'une épreuve.

Par exemple

Exercice 3 / 6Difficile

Mini-validateur basé sur un schéma

À toi

Implémente validate(schema, data) qui valide data selon un schema déclaratif :

Format du schéma :

js
{ champ: { type: "string" | "number" | "boolean", min?, max?, optional? } }

Règles :

  • Si optional: true et le champ est undefined → OK, on l'ignore.
  • Sinon le champ est requis.
  • type doit matcher : typeof === type (et Number.isFinite pour number).
  • min / max : longueur pour string, valeur pour number.

Retour : { ok: true, data } ou { ok: false, errors: [{ champ, message }] }.

Validation déclarative : schéma + validateur

Au lieu d'écrire du code de validation par champ, tu écris une description (schema) et un validateur générique l'applique.

javascript
const produitSchema = {
  nom:         { type: "string", min: 1, max: 80 },
  prix:        { type: "number", min: 0 },
  description: { type: "string", optional: true },
};

validate(produitSchema, req.body);

C'est exactement ce que font Zod, Yup, Joi, etc. — leur DSL est plus riche, mais le principe est identique.

Avantages du schéma déclaratif

  • Lisible : la forme attendue est évidente d'un coup d'œil
  • Réutilisable : même schéma côté API, côté client (validation form), côté tests
  • Sérialisable : tu peux générer une doc OpenAPI à partir du schéma
  • Composable : un schéma peut imbriquer un autre schéma

Anatomie du validateur

Version la plus simple : chaque règle est une fonction qui renvoie un message d'erreur, ou null si tout va bien.

javascript
const reglesCommande = {
  quantite: (v) => (Number.isInteger(v) && v > 0 ? null : "entier > 0 attendu"),
  code:     (v) => (/^[A-Z]{3}$/.test(v) ? null : "3 majuscules attendues"),
};

function verifier(regles, data) {
  const erreurs = [];
  const propre = {};

  for (const [nom, tester] of Object.entries(regles)) {
    const probleme = tester(data[nom]);
    if (probleme) erreurs.push({ champ: nom, message: probleme });
    else propre[nom] = data[nom]; // seuls les champs du schéma sortent
  }

  return erreurs.length === 0 ? { ok: true, data: propre } : { ok: false, errors: erreurs };
}

console.log(verifier(reglesCommande, { quantite: 0, code: "ABC" }));
// { ok: false, errors: [{ champ: "quantite", message: "entier > 0 attendu" }] }

Avec des règles en objets ({ type, min, max, optional }), le validateur fait lui-même le travail de tester, dans cet ordre :

  1. Manquant ? Erreur, sauf si la règle est optional.
  2. Bon type ? Attention, typeof NaN vaut "number" : pour les nombres, Number.isFinite est plus sûr.
  3. Dans les bornes ? Pour une string, compare sa longueur. Pour un nombre, sa valeur.

L'idée du continue

Si un champ a un mauvais type, inutile d'aller checker min / max dessus — ça donnerait des erreurs cascadées peu lisibles ("prix type number attendu" + "prix min 0"). On continue pour passer au champ suivant.

Comparaison avec Zod (mental model)

javascript
// Notre mini-validateur
{ type: "string", min: 1, max: 50 }

// Zod
z.string().min(1).max(50)

// Yup
yup.string().required().min(1).max(50)

Le DSL change, l'idée est la même : décrire les contraintes, le validateur les applique.

Limites de ce mini-validateur

  • Pas de regex (email, url, uuid)
  • Pas de enum (valeurs autorisées)
  • Pas d'objets imbriqués (cf. exo-06)
  • Pas de coercion (cf. exo-05)
  • Pas de validations cross-field (a >= b)

Pour la prod, prends Zod. Pour comprendre, code le tien. C'est l'objectif de cet exo.

Ton code

Connecte-toi pour faire cet exercice

C'est gratuit, avec ton compte Google : un clic, et tu reviens ici. Ta progression te suit ensuite sur tous tes appareils.

Le site garde ton nom et ton email, rien d'autre. Tes données