Wat zijn change streams?

Question

Accepted Answer

**Change streams** stellen applicaties in staat om **real-time wijzigingen in MongoDB-data te volgen** — door meldingen te ontvangen wanneer documenten worden ingevoegd, bijgewerkt of verwijderd. Ze maken reactieve, event-driven functies mogelijk (real-time updates, synchronisatie, triggers) zonder de database te pollen. Gebouwd op de replica set oplog.

## Volgen van wijzigingen

```js
// watch a collection for changes — get notified in real time
const changeStream = db.collection("orders").watch();

changeStream.on("change", (change) => {
  console.log(change.operationType);   // "insert", "update", "delete", "replace"
  console.log(change.fullDocument);     // the changed document (for inserts/updates)
  // react: push to websockets, update a cache, trigger a workflow, etc.
});
```

Een change stream geeft een event af voor elke wijziging (insert/update/delete), met details over wat er is gewijzigd — zodat de applicatie in real-time reageert.

## Filteren en hervatten

```js
// watch only specific changes with an aggregation pipeline filter
db.collection("orders").watch([
  { $match: { operationType: "insert", "fullDocument.status": "urgent" } }
]);

// resume from where you left off (resilient to disconnections)
db.collection("orders").watch([], { resumeAfter: lastChangeToken });
```

Je kunt wijzigingen **filteren** (alleen bepaalde bewerkingen of documenten volgen) en **hervatten** na een verbreking (met behulp van een resume token) — wat change streams veerkrachtig maakt.

## Veelvoorkomende use cases

```text
✓ REAL-TIME features — push live updates to clients (websockets) when data changes
✓ SYNCING — keep a cache, search index (Elasticsearch), or another system in sync
✓ EVENT-DRIVEN architecture — trigger workflows/notifications on data changes
✓ AUDITING — log changes; analytics on data modifications
→ All WITHOUT polling the database repeatedly (efficient, real-time)
```

## Change streams versus polling

```text
❌ POLLING — repeatedly query "what changed?" → inefficient, latency, load on the DB
✅ CHANGE STREAMS — the database PUSHES changes to you in real time → efficient, instant
→ The right way to react to data changes (requires a replica set).
```

## Waarom het belangrijk is

Change streams zijn een waardevol MongoDB-feature voor het bouwen van **real-time, reactieve, event-driven applicaties**, dus inzicht hierin is nuttige kennis op seniorniveau voor moderne applicaties die live data reactivity nodig hebben.

De kernwaarde is dat applicaties **real-time op gewijzigde data kunnen reageren** — door push-meldingen te ontvangen wanneer documenten worden ingevoegd, bijgewerkt of verwijderd — wat belangrijke mogelijkheden mogelijk maakt: **real-time functies** (live updates naar clients pushen via websockets wanneer data wijzigt — een veel voorkomende behoefte voor samenwerkingsapps, dashboards, meldingen), **synchronisatie** (caches, zoekindexen zoals Elasticsearch, of andere systemen consistent houden met MongoDB naarmate data wijzigt), **event-driven architectuur** (workflows, meldingen of verwerking triggeren bij gewijzigde data), en **auditing**.

Het belangrijkste voordeel is dit allemaal doen **zonder polling** — change streams laten de database wijzigingen *pushen* naar de applicatie direct en efficiënt, ter vervanging van het verspillende, hogere-latency patroon van herhaaldelijk "wat is er gewijzigd?" opvragen (wat de database belast en vertraging oplevert).

Inzicht in het volgen van verzamelingen, het filteren van wijzigingen (alleen relevante bewerkingen/documenten) en het hervatten na verbreking (met resume tokens voor veerkracht) bestrijkt het praktische gebruik.

Weten dat change streams een replica set vereisen is ook relevant.

Omdat real-time reactivity en het synchroon houden van systemen steeds belangrijkere applicatiebehoeften worden, en omdat change streams een efficiënte, push-gebaseerde manier bieden om op MongoDB-gewijzigingen te reageren (veel beter dan polling), is inzicht in change streams — wat ze doen, hun use cases (real-time functies, synchronisatie, event-driven verwerking), de resume/filter-mogelijkheden, en het voordeel ten opzichte van polling — waardevol seniorkennis voor het bouwen van moderne, reactieve MongoDB-applicaties, een nuttig feature voor de veel voorkomende behoefte om real-time op gewijzigde data te reageren en een onderwerp dat inzicht weerspiegelt in event-driven en real-time applicatiepatronen met MongoDB.