Watch method for real-time updates in MongoDB - Mini Project: Build & Apply

Real-Time Updates with MongoDB Watch Method

📖 Scenario: You are building a simple notification system for a small online store. You want to watch the orders collection in MongoDB to get real-time updates whenever a new order is placed.

🎯 Goal: Create a MongoDB watch method setup that listens for new inserts in the orders collection and logs the change events.

📋 What You'll Learn

Create a MongoDB collection named orders with sample order documents.

Set up a watch method on the orders collection to listen for insert events.

Log the change events to the console in real-time.

Use the watch method with a pipeline to filter only insert operations.

💡 Why This Matters

🌍 Real World

Real-time monitoring of database changes is useful for notifications, analytics, and syncing data across systems.

💼 Career

Understanding MongoDB change streams is valuable for backend developers working with real-time applications and event-driven architectures.

1

Create the orders collection with sample data

Create a MongoDB collection called orders and insert these exact documents: { _id: 1, item: 'Book', quantity: 3 } and { _id: 2, item: 'Pen', quantity: 10 }.

MongoDB

// Insert the sample documents into the orders collection
// Your code here

Hint

Use insertMany on db.orders to add multiple documents at once.

2

Define a change stream pipeline to filter insert operations

Create a variable called pipeline that filters change events to only include those where operationType is 'insert'.

MongoDB

db.orders.insertMany([
  { _id: 1, item: 'Book', quantity: 3 },
  { _id: 2, item: 'Pen', quantity: 10 }
])

// Define the pipeline to filter for insert operations
// Your code here

Hint

Use $match in the pipeline to filter for operationType: 'insert'.

3

Start watching the orders collection with the pipeline

Create a variable called changeStream that calls db.orders.watch(pipeline) to start watching for insert events.

MongoDB

db.orders.insertMany([
  { _id: 1, item: 'Book', quantity: 3 },
  { _id: 2, item: 'Pen', quantity: 10 }
])

const pipeline = [
  { $match: { operationType: 'insert' } }
]

// Start watching the orders collection with the pipeline
// Your code here

Hint

Use db.orders.watch(pipeline) to create the change stream.

4

Listen for change events and log them

Use changeStream.on('change', callback) to listen for change events and log the event document using console.log(change) inside the callback function.

MongoDB

db.orders.insertMany([
  { _id: 1, item: 'Book', quantity: 3 },
  { _id: 2, item: 'Pen', quantity: 10 }
])

const pipeline = [
  { $match: { operationType: 'insert' } }
]

const changeStream = db.orders.watch(pipeline)

// Listen for change events and log them
// Your code here

Hint

Use changeStream.on('change', callback) to handle real-time updates.

Practice

1. What is the main purpose of the watch method in MongoDB?

easy

A. To backup the database automatically

B. To create indexes on collections

C. To listen for real-time changes in the database

D. To delete documents in bulk

Solution

1. Step 1: Understand the watch method's role

   The watch method is designed to monitor changes in the database as they happen.

2. Step 2: Compare with other options

   Backup, indexing, and deleting are unrelated to real-time monitoring.

3. Final Answer:

   To listen for real-time changes in the database -> Option C

4. Quick Check:

   watch method = real-time updates [OK]

Hint: Remember: watch means 'listen' for changes [OK]

Common Mistakes:

• Confusing watch with backup or indexing
• Thinking watch deletes data
• Assuming watch modifies data

2. Which of the following is the correct way to start watching changes on a collection named orders in MongoDB?

easy

A. db.orders.watch()

B. db.orders.listen()

C. db.orders.observe()

D. db.orders.track()

Solution

1. Step 1: Recall the correct method name

   The method to watch changes is watch(), not listen, observe, or track.

2. Step 2: Apply method to collection

   Calling watch() on db.orders is the correct syntax.

3. Final Answer:

   db.orders.watch() -> Option A

4. Quick Check:

   Correct method is watch() [OK]

Hint: watch() is the exact method name to monitor changes [OK]

Common Mistakes:

• Using listen(), observe(), or track() which don't exist
• Forgetting parentheses after watch
• Calling watch on the database instead of collection

3. Given the following code snippet, what will be the output when a new document is inserted into the users collection?

const changeStream = db.users.watch();
changeStream.on('change', (change) => {
  console.log(change.operationType);
});

medium

A. 'insert'

B. 'update'

C. 'delete'

D. No output

Solution

1. Step 1: Understand the event listener

   The code listens for any change event on the users collection and logs the operationType.

2. Step 2: Identify the operation type for insertion

   When a new document is inserted, the operationType is insert.

3. Final Answer:

   'insert' -> Option A

4. Quick Check:

   Insert triggers operationType 'insert' [OK]

Hint: Insert operationType is 'insert' in change events [OK]

Common Mistakes:

• Expecting 'update' or 'delete' for insert events
• Thinking no output occurs without explicit fetch
• Confusing operationType with full document

4. Identify the error in this MongoDB watch usage:

const changeStream = db.products.watch({ fullDocument: 'updateLookup' });
changeStream.on('change', (change) => {
  console.log(change.fullDocument);
});

medium

A. The watch method does not accept an object as argument

B. The options should be passed as the second argument, not as the first argument object

C. fullDocument option should be set to 'default', not 'updateLookup'

D. The on method is not valid for change streams

Solution

1. Step 1: Check watch method parameters

   The watch method accepts an optional array pipeline as the first argument, not an object with options.

2. Step 2: Understand where options go

   Options like fullDocument should be passed as the second argument, not inside the pipeline array.

3. Final Answer:

   The options should be passed as the second argument, not as the first argument object -> Option B

4. Quick Check:

   Pipeline is array, options are separate [OK]

Hint: Pass pipeline as array, options as separate object [OK]

Common Mistakes:

• Passing options as first argument instead of second
• Using invalid values for fullDocument
• Misusing event handlers on change streams

5. You want to watch only update operations on the messages collection and get the full updated document in real-time. Which code snippet correctly achieves this?

hard

A. db.messages.watch([{ $match: { operationType: 'update' } }])

B. db.messages.watch({ operationType: 'update' }, { fullDocument: 'default' })

C. db.messages.watch([{ $match: { operationType: 'update' } }], { fullDocument: 'default' })

D. db.messages.watch([{ $match: { operationType: 'update' } }], { fullDocument: 'updateLookup' })

Solution

1. Step 1: Filter for update operations

   Use a pipeline with $match to watch only update operation types.

2. Step 2: Get full updated document

   Set fullDocument option to 'updateLookup' to receive the full document on update.

3. Step 3: Verify correct syntax

   Pass the pipeline array as first argument and options object as second argument to watch.

4. Final Answer:

   db.messages.watch([{ $match: { operationType: 'update' } }], { fullDocument: 'updateLookup' }) -> Option D

5. Quick Check:

   Pipeline filter + fullDocument 'updateLookup' = db.messages.watch([{ $match: { operationType: 'update' } }], { fullDocument: 'updateLookup' }) [OK]

Hint: Use $match pipeline and fullDocument: 'updateLookup' option [OK]

Common Mistakes:

• Passing options as first argument instead of second
• Using fullDocument: 'default' which doesn't guarantee full doc on update
• Not filtering operationType in pipeline