Hur fungerar schemavalidering i MongoDB?

Question

Accepted Answer

Även om MongoDB är flexibelt som standard, stöder det **schemavalidering** på databasnivå — definiering av regler (obligatoriska fält, typer, värdebegränsningar) som dokument måste uppfylla. Detta lägger till dataintegritet *inom* MongoDB själv (inte bara i programkod), och balanserar flexibilitet med konsistens.

## Definiering av valideringsregler

```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 använder **JSON Schema** för att definiera valideringsregler — obligatoriska fält, typer, mönster, intervall — som tillämpas av databasen när dokument infogas eller uppdateras.

## Valideringsnivåer och åtgärder

```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` styr vilka dokument som kontrolleras; `validationAction` styr om överträdelser resulterar i fel (reject) eller endast varning.

## Varför validera i databasen (istället för endast i appen)?

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

## Balansering av flexibilitet och struktur

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

## Varför det är viktigt

Att förstå MongoDB-schemavalidering är värdefullt för att **balansera MongoDBs flexibilitet med dataintegritet**, så det är användbar kunskap för att bygga tillförlitliga MongoDB-applikationer.

MongoDBs schemafria flexibilitet är en stor fördel (lämplig för utvecklande och varierande data), men **okontrollerad flexibilitet kan leda till inkonsistent data** (saknade fält, fel typer, ogiltiga värden) — ett verkligt problem för datakvalitet.

Schemavalidering löser detta genom att låta dig tillämpa regler (obligatoriska fält, typer, mönster, intervall via JSON Schema) **på databasnivå**, så dokument måste uppfylla dem.

Huvudvärdet av **databasnivåvalidering** (i motsats till endast applikationsnivå) är att den tillämpas oavsett vilken applikation, tjänst, skript eller manuell operation som skriver data — vilket ger en konsistent integritetgaranti och ett säkerhetsnät även om applikationsvalidering kringgås eller är felaktig (samma motivering som SQL-begränsningar: databasen som förstnivå försvar).

Att förstå **valideringsnivåer och åtgärder** (styr vilka dokument som kontrolleras och om överträdelser avvisas eller varnas) möjliggör flexibel införande.

Viktigast av allt är att förstå hur man **balanserar flexibilitet och struktur** — att lägga till validering där konsistens är viktig medan flexibilitet bevaras på andra ställen, ofta med start i flexibilitet och tillägg av validering när schemat stabiliseras — reflekterar en mogen MongoDB-användning som får fördelarna med flexibilitet utan att offra kritisk dataintegritet.

Att veta att validering ofta också görs i applagret (t.ex. Mongoose-scheman) är också relevant.

Därför att dataintegritet är viktig även i flexibla databaser, och därför att MongoDBs schemavalidering låter dig tillämpa struktur där det behövs (på databasnivå för en stark garanti) samtidigt som flexibilitet bevaras, är det värdefullt och praktiskt relevant att förstå schemavalidering — hur det fungerar, fördelar med databasnivåtillämpning och balansering av flexibilitet med struktur — praktisk kunskap för att bygga MongoDB-applikationer som upprätthåller datakvalitet, en användbar förmåga som löser det vanliga problemet med inkonsistent data i databaser med flexibelt schema.