Hoe werkt schemavalidatie in MongoDB?

Question

Accepted Answer

Hoewel MongoDB standaard flexibel is, ondersteunt het **schemavalidatie** op databaseniveau — het definiëren van regels (verplichte velden, types, waardeconstraints) die documenten moeten voldoen. Dit voegt gegevensintegriteit *binnen* MongoDB zelf toe (niet alleen in toepassingscode), wat flexibiliteit met consistentie in balans brengt.

## Validatieregels definiëren

```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 gebruikt **JSON Schema** om validatieregels te definiëren — verplichte velden, types, patronen, bereiken — afgedwongen door de database wanneer documenten worden ingevoegd of bijgewerkt.

## Validatieniveaus en acties

```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` bepaalt welke documenten worden gecontroleerd; `validationAction` bepaalt of schendingen een fout veroorzaken (afwijzen) of alleen waarschuwen.

## Waarom valideren in de database (versus alleen in de app)?

```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.
```

## Flexibiliteit en structuur in balans brengen

```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.)
```

## Waarom het belangrijk is

MongoDB-schemavalidatie begrijpen is waardevol voor **het balanceren van de flexibiliteit van MongoDB met gegevensintegriteit**, dus het is nuttige kennis voor het bouwen van betrouwbare MongoDB-toepassingen.

Hoewel de schemaloze flexibiliteit van MongoDB een groot voordeel is (geschikt voor zich ontwikkelende en gevarieerde gegevens), **kan ongecontroleerde flexibiliteit leiden tot inconsistente gegevens** (ontbrekende velden, verkeerde types, ongeldige waarden) — een echt probleem voor gegevenskwaliteit.

Schemavalidatie lost dit op door u toe te staan regels af te dwingen (verplichte velden, types, patronen, bereiken via JSON Schema) **op databaseniveau**, zodat documenten hieraan moeten voldoen.

De sleutelwaarde van **validatie op databaseniveau** (in tegenstelling tot alleen validatie op toepassingsniveau) is dat het wordt afgedwongen ongeacht welke toepassing, service, script of handmatige bewerking de gegevens schrijft — wat een consistente integriteitsgarantie biedt en een veiligheidsmechanisme zelfs als toepassingsvalidatie wordt omzeild of foutief is (dezelfde redenering als SQL-constraints: de database als laatste verdedigingslinie).

Het begrijpen van **validatieniveaus en acties** (bepalen welke documenten worden gecontroleerd en of schendingen afwijzen of waarschuwen) maakt flexibele invoering mogelijk.

Het belangrijkste is het begrijpen hoe je **flexibiliteit en structuur in balans brengt** — validatie toevoegen waar consistentie belangrijk is terwijl je flexibiliteit elders bewaart, vaak flexibel te beginnen en validatie toe te voegen naarmate het schema stabiliseert — wat volwassen MongoDB-gebruik weerspiegelt dat de voordelen van flexibiliteit krijgt zonder kritieke gegevensintegriteit op te offeren.

Weten dat validatie ook vaak in de applaag wordt gedaan (bv. Mongoose-schema's) is ook relevant.

Omdat gegevensintegriteit belangrijk is zelfs in flexibele databases, en omdat MongoDB's schemavalidatie je in staat stelt structuur af te dwingen waar nodig (op databaseniveau voor een sterke garantie) terwijl je flexibiliteit bewaart, is het begrijpen van schemavalidatie — hoe het werkt, voordelen van validatie op databaseniveau en het balanceren van flexibiliteit met structuur — waardevol, praktisch relevant kennis voor het bouwen van MongoDB-toepassingen die gegevenskwaliteit handhaven, een nuttig vermogen dat het veelvoorkomende probleem van inconsistente gegevens in flexibel-schemadatabases aanpakt.