Comment fonctionne la validation de schéma dans MongoDB ?

Question

Accepted Answer

Bien que MongoDB soit flexible par défaut, il supporte la **validation de schéma** au niveau de la base de données — définissant des règles (champs obligatoires, types, contraintes de valeurs) que les documents doivent satisfaire. Cela ajoute l'intégrité des données *dans* MongoDB lui-même (pas seulement dans le code de l'application), équilibrant flexibilité et cohérence.

## Définir les règles de validation

```js
// add a JSON Schema validator when creating (or modifying) a collection
db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "email"],            // required fields
      properties: {
        name: { bsonType: "string" },
        email: { bsonType: "string", pattern: "^.+@.+$" },   // type + pattern
        age: { bsonType: "int", minimum: 0, maximum: 120 }   // range
      }
    }
  }
});
// → documents that don't satisfy this are REJECTED on insert/update
```

MongoDB utilise **JSON Schema** pour définir les règles de validation — champs obligatoires, types, motifs, plages — appliquées par la base de données lors de l'insertion ou de la mise à jour de documents.

## Niveaux de validation et actions

```js
db.runCommand({
  collMod: "users",
  validator: { $jsonSchema: { ... } },
  validationLevel: "moderate",     // "strict" (all) or "moderate" (only valid existing docs)
  validationAction: "error"        // "error" (reject) or "warn" (log but allow)
});
```

`validationLevel` contrôle quels documents sont vérifiés ; `validationAction` contrôle si les violations génèrent une erreur (reject) ou un simple avertissement.

## Pourquoi valider dans la base de données (par rapport à seulement l'application) ?

```text
✓ DATABASE-LEVEL guarantee — enforced regardless of which app/code writes data
  (multiple services, scripts, manual changes) → consistent data integrity
✓ A safety net even if application validation is bypassed or buggy
→ Similar reasoning to SQL constraints: the DB is the last line of defense for integrity.
```

## Équilibrer flexibilité et structure

```text
MongoDB's flexibility is valuable, but UNCONTROLLED flexibility → inconsistent data.
Schema validation lets you add structure WHERE you need it:
  → enforce critical fields/types while keeping flexibility elsewhere
  → start flexible, add validation as the schema stabilizes
(Often validation is also/instead done in the app layer, e.g. via Mongoose schemas.)
```

## Pourquoi c'est important

Comprendre la validation de schéma MongoDB est précieuse pour **équilibrer la flexibilité de MongoDB avec l'intégrité des données**, c'est donc une connaissance utile pour construire des applications MongoDB fiables.

Bien que la flexibilité sans schéma de MongoDB soit un avantage majeur (convenant aux données évolutives et variées), **une flexibilité incontrôlée peut conduire à des données incohérentes** (champs manquants, mauvais types, valeurs invalides) — une préoccupation réelle pour la qualité des données.

La validation de schéma résout cela en vous permettant d'appliquer des règles (champs obligatoires, types, motifs, plages via JSON Schema) **au niveau de la base de données**, de sorte que les documents doivent les satisfaire.

La valeur clé de la **validation au niveau de la base de données** (par opposition à seulement au niveau de l'application) est qu'elle est appliquée indépendamment de l'application, du service, du script ou de l'opération manuelle qui écrit les données — fournissant une garantie d'intégrité cohérente et un filet de sécurité même si la validation de l'application est contournée ou bugguée (le même raisonnement que les contraintes SQL : la base de données comme dernière ligne de défense).

Comprendre les **niveaux de validation et les actions** (contrôlant quels documents sont vérifiés et si les violations rejettent ou avertissent) permet une adoption flexible.

Plus important encore, comprendre comment **équilibrer flexibilité et structure** — ajouter de la validation où la cohérence compte tandis que conserver la flexibilité ailleurs, souvent commencer flexible et ajouter de la validation à mesure que le schéma se stabilise — reflète une utilisation mature de MongoDB qui obtient les bénéfices de la flexibilité sans sacrifier l'intégrité critique des données.

Savoir que la validation se fait souvent également dans la couche application (p. ex. schémas Mongoose) est également pertinent.

Puisque l'intégrité des données est importante même dans les bases de données flexibles, et puisque la validation de schéma MongoDB vous permet d'appliquer de la structure où nécessaire (au niveau de la base de données pour une garantie forte) tout en préservant la flexibilité, comprendre la validation de schéma — comment elle fonctionne, les bénéfices de l'application au niveau de la base de données, et équilibrer flexibilité et structure — est une connaissance précieuse et pratiquement pertinente pour construire des applications MongoDB qui maintiennent la qualité des données, une capacité utile qui résout la préoccupation commune de données incohérentes dans les bases de données avec schémas flexibles.