Mongoose how to listen for collection changes

When using Mongoose for MongoDB data management, if you need to listen for changes in data collections, you can primarily use the following two methods:

1. Using Change Streams

Change Streams is a feature introduced in MongoDB 3.6+, enabling applications to access real-time data changes without polling the collection for updates. Mongoose supports this functionality through its API, providing convenient listening for collection changes.

Implementation Example:

Suppose you have a model named Product that you want to monitor for changes:

javascript
const mongoose = require('mongoose');
const Product = require('./models/product'); // Import your model

// Connect to the database
mongoose.connect('mongodb://localhost:27017/yourdb', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

const changeStream = Product.watch();

changeStream.on('change', (change) => {
  console.log('Change detected:', change);
  // Handle different business logic based on the change.operationType
  // For example 'insert', 'delete', 'update', 'replace', etc.
});

In this example, the Product.watch() method creates a stream to listen for changes to the current Product collection. Any modifications to the Product collection trigger the change event, which is processed by the callback function.

2. Using Middleware

Mongoose provides middleware functionality that allows you to execute custom code before or after database operations such as saving (save) or updating (update). This enables you to implement specific logic during data changes.

Implementation Example:

javascript
const ProductSchema = new mongoose.Schema({
  name: String,
  price: Number,
});

// Use pre middleware to execute before saving data
ProductSchema.pre('save', function (next) {
  console.log('A new product is about to be saved:', this);
  next();
});

// Use post middleware to execute after saving data
ProductSchema.post('save', function(doc) {
  console.log('A product has been saved:', doc);
});

const Product = mongoose.model('Product', ProductSchema);

In this example, whenever a Product instance is saved, the pre('save', ...) middleware executes first, followed by the post('save', ...) middleware. This approach allows you to add logging, error checking, or other business logic before and after data modifications.

Summary

Both methods offer distinct advantages and use cases. Change Streams are ideal for applications requiring real-time feedback, while Middleware is suitable for scenarios where specific logic must be inserted before or after data operations. Choose the appropriate method based on your requirements to effectively listen for and respond to data changes.