Hvordan fungerer skemavalidering i MongoDB?

Question

Accepted Answer

Selv om MongoDB er fleksibelt som standard, støtter det **skemavalidering** på databasenivå — definering av regler (obligatoriske felt, typer, verdibegrensninger) som dokumenter må oppfylle. Dette legger til dataintegritet *innenfor* MongoDB selv (ikke bare i applikasjonskode), og balanserer fleksibilitet med konsistens.

## Definering 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 bruker **JSON Schema** til å definere valideringsregler — obligatoriske felt, typer, mønstre, områder — som håndheves av databasen når dokumenter settes inn eller oppdateres.

## Valideringsnivåer og handlinger

```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` kontrollerer hvilke dokumenter som sjekkes; `validationAction` kontrollerer om brudd på reglene resulterer i feil (avvisning) eller bare advarsel.

## Hvorfor validere i databasen (i stedet for bare 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 fleksibilitet og 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.)
```

## Hvorfor det betyr noe

Å forstå MongoDB-skemavalidering er verdifullt for **balansering av MongoDBs fleksibilitet med dataintegritet**, så det er nyttig kunnskap for å bygge pålitelige MongoDB-applikasjoner.

MongoDB-dens skjemaløse fleksibilitet er en stor fordel (som passer til utviklende og variert data), men **ukontrollert fleksibilitet kan føre til inkonsistente data** (manglende felt, feil typer, ugyldige verdier) — en reell bekymring for datakvalitet.

Skemavalidering løser dette ved å la deg håndheve regler (obligatoriske felt, typer, mønstre, områder via JSON Schema) **på databasenivå**, slik at dokumenter må oppfylle dem.

Hovedfordelen med **validering på databasenivå** (i motsetning til bare på applikasjonsnivå) er at den håndheves uavhengig av hvilken applikasjon, tjeneste, skript eller manuell operasjon som skriver dataene — og gir en konsistent integritetsgaranti og et sikkerhetsnett selv om applikasjonsvalidering omgås eller er feilaktig (samme resonnement som SQL-begrensninger: databasen som siste forsvarlinje).

Å forstå **valideringsnivåer og handlinger** (kontroll over hvilke dokumenter som sjekkes og om brudd på reglene avvises eller gir advarsel) tillater fleksibel innføring.

Mest av alt reflekterer forståelse av hvordan man **balanserer fleksibilitet og struktur** — legger til validering der konsistens betyr noe, mens man beholder fleksibilitet andre steder, ofte starter fleksibel og legger til validering når skjemaet stabiliseres — moden MongoDB-bruk som får fordelene av fleksibilitet uten å ofre kritisk dataintegritet.

Å vite at validering ofte også gjøres i applaglaget (f.eks. Mongoose-skjemaer) er også relevant.

Ettersom dataintegritet betyr noe selv i fleksible databaser, og siden MongoDBs skemavalidering lar deg håndheve struktur der det er nødvendig (på databasenivå for en sterk garanti) samtidig som du beholder fleksibilitet, er det verdifullt, praktisk relevant kunnskap å forstå skemavalidering — hvordan det fungerer, fordeler med håndhevelse på databasenivå, og balansering av fleksibilitet med struktur — for å bygge MongoDB-applikasjoner som opprettholder datakvalitet, en nyttig evne som løser den vanlige bekymringen om inkonsistente data i fleksible-skjema-databaser.