Lo que estás pensando suena mucho a desencadenantes. MongoDB no tiene ningún soporte para disparadores, sin embargo algunas personas han "lanzado sus propios" usando algunos trucos. La clave aquí es el oplog.

Cuando ejecuta MongoDB en un Conjunto de réplicas, todas las acciones de MongoDB se registran en un registro de operaciones (conocido como oplog). El oplog es básicamente una lista en ejecución de las modificaciones realizadas a los datos. Réplicas Establece la función de escuchar los cambios en este oplog y luego aplicar el cambios locales.

¿Te suena familiar?

No puedo detallar todo el proceso aquí, son varias páginas de documentación, pero las herramientas que necesita están disponibles.

Primero algunas reseñas sobre el oplog - Breve descripción - Diseño de la colección local (que contiene el oplog)

También querrá aprovechar cursores adaptables. Esto le proporcionará una manera de escuchar los cambios en lugar de sondear para ellos. Tenga en cuenta que la replicación utiliza cursores adaptables, por lo que esta es una característica compatible.

Desde MongoDB 3.6 habrá una nueva API de notificaciones llamada Flujos de cambio que puede usar para esto. Ver esta entrada del blog para un ejemplo. Ejemplo de ello:

cursor = client.my_db.my_collection.changes([
    {'$match': {
        'operationType': {'$in': ['insert', 'replace']}
    }},
    {'$match': {
        'newDocument.n': {'$gte': 1}
    }}
])

# Loops forever.
for change in cursor:
    print(change['newDocument'])

Mira esto: Cambiar flujos

10 de enero de 2018 - Release 3.6

* EDITAR: Escribí un artículo sobre cómo hacer esto https://medium.com/riow/mongodb-data-collection-change-85b63d96ff76

Https://docs.mongodb.com/v3.6/changeStreams /

Es nuevo en mongodb 3.6 https://docs.mongodb.com/manual/release-notes/3.6/ 2018/01/10

$ mongod --version
db version v3.6.2

Para usar changeStreams la base de datos debe ser un Conjunto de Replicación

Más información sobre los Conjuntos de Replicación: https://docs.mongodb.com/manual/replication/

Su base de datos será " Independiente" por defecto.

Cómo convertir un Standalone en un Conjunto de Réplicas: https://docs.mongodb.com/manual/tutorial/convert-standalone-to-replica-set /

El siguiente ejemplo es una práctica aplicación para saber cómo usar esto.
* Específicamente para Nodo.

/* file.js */
'use strict'


module.exports = function (
    app,
    io,
    User // Collection Name
) {
    // SET WATCH ON COLLECTION 
    const changeStream = User.watch();  

    // Socket Connection  
    io.on('connection', function (socket) {
        console.log('Connection!');

        // USERS - Change
        changeStream.on('change', function(change) {
            console.log('COLLECTION CHANGED');

            User.find({}, (err, data) => {
                if (err) throw err;

                if (data) {
                    // RESEND ALL USERS
                    socket.emit('users', data);
                }
            });
        });
    });
};
/* END - file.js */

Útil links:
https://docs.mongodb.com/manual/tutorial/convert-standalone-to-replica-set
https://docs.mongodb.com/manual/tutorial/change-streams-example

Https://docs.mongodb.com/v3.6/tutorial/change-streams-example
http://plusnconsulting.com/post/MongoDB-Change-Streams

MongoDB versión 3.6 ahora incluye flujos de cambio que es esencialmente una API en la parte superior de la OpLog que permite trigger/notificación-como casos de uso.

Aquí hay un enlace a un ejemplo de Java: http://mongodb.github.io/mongo-java-driver/3.6/driver/tutorials/change-streams /

Un ejemplo de NodeJS podría verse como:

 var MongoClient = require('mongodb').MongoClient;
    MongoClient.connect("mongodb://localhost:22000/MyStore?readConcern=majority")
     .then(function(client){
       let db = client.db('MyStore')

       let change_streams = db.collection('products').watch()
          change_streams.on('change', function(change){
            console.log(JSON.stringify(change));
          });
      });

Alternativamente, puede usar el método estándar Mongo FindAndUpdate, y dentro de la devolución de llamada, disparar un evento EventEmitter (en el nodo) cuando se ejecuta la devolución de llamada.

Cualquier otra parte de la aplicación o arquitectura que escuche este evento será notificada de la actualización, y cualquier dato relevante enviado allí también. Esta es una manera muy simple de lograr notificaciones de Mongo.

Hay un ejemplo de java que funciona que se puede encontrar aquí.

 MongoClient mongoClient = new MongoClient();
    DBCollection coll = mongoClient.getDatabase("local").getCollection("oplog.rs");

    DBCursor cur = coll.find().sort(BasicDBObjectBuilder.start("$natural", 1).get())
            .addOption(Bytes.QUERYOPTION_TAILABLE | Bytes.QUERYOPTION_AWAITDATA);

    System.out.println("== open cursor ==");

    Runnable task = () -> {
        System.out.println("\tWaiting for events");
        while (cur.hasNext()) {
            DBObject obj = cur.next();
            System.out.println( obj );

        }
    };
    new Thread(task).start();

La clave es LAS OPCIONES DE CONSULTA dadas aquí.

También puede cambiar la consulta de búsqueda, si no necesita cargar todos los datos cada vez.

BasicDBObject query= new BasicDBObject();
query.put("ts", new BasicDBObject("$gt", new BsonTimestamp(1471952088, 1))); //timestamp is within some range
query.put("op", "i"); //Only insert operation

DBCursor cur = coll.find(query).sort(BasicDBObjectBuilder.start("$natural", 1).get())
.addOption(Bytes.QUERYOPTION_TAILABLE | Bytes.QUERYOPTION_AWAITDATA);

En realidad, en lugar de ver la salida, ¿por qué no recibe aviso cuando se inserta algo nuevo utilizando middle-ware que fue proporcionado por mongoose schema

Puede capturar el evento de insertar un nuevo documento y hacer algo después de esta inserción hecho

Muchas de estas respuestas solo le darán nuevos registros y no actualizaciones y / o son extremadamente ineficaces

La única forma fiable y eficaz de hacer esto es crear un cursor personalizable en la base de datos local: oplog.rs colección para obtener TODOS los cambios en MongoDB y hacer con él lo que quieras. (MongoDB incluso hace esto internamente más o menos para soportar la replicación!)

Explicación de lo que el oplog contener: https://www.compose.com/articles/the-mongodb-oplog-and-node-js /

Ejemplo de nodo.biblioteca js que proporciona una API en torno a lo que está disponible para hacer con el oplog: https://github.com/cayasso/mongo-oplog