MongoDB更改流-错误[ERR_HTTP_HEADERS_SENT]

Question

I'm trying to build an application which at the moment simply console logs Mongo documents in the client browser. I understand the Mongo change streams fine on the server side and have the following code to watch for inserts into the collection and when a change occurs, the dataset is reloaded:

MongoClient.connect(MongoConnection.url, { useNewUrlParser: true, useUnifiedTopology: true }, (err, client) => {
    const db = client.db('test');
    const collection = db.collection('options');
    const changeStream = collection.watch();
    changeStream.on('change', next => {
        // If there is a change in the collection, reload the data.
        reload();
    });
});
function reload() {
    MongoClient.connect(MongoConnection.url, { useNewUrlParser: true, useUnifiedTopology: true }, (err, client) => {
        const db = client.db('test');
        const collection = db.collection('options');
        collection.find({}).toArray(function (err, docs) {
            client.close();
            console.log(docs)
        });
    });
};

However, I'm struggling to replicate the same on the client side. So far what I have done is created an XHR request in a client side js file which looks like this:

$(window).on('load', () => {
    function load_options() {
        var data = null;
        var xhr = new XMLHttpRequest();
        xhr.withCredentials = true;
        xhr.addEventListener("readystatechange", function () {
            if (this.readyState === 4) {
                if (this.responseText === "") {

                } else {
                    data = $.parseJSON(this.responseText);
                    $.each(data, function (i, item) {
                        console.log(item)
                    });
                }
            }
        });
        xhr.open("GET", "/dashboard/load-options");
        xhr.setRequestHeader("cache-control", "no-cache");
        xhr.send(data);
    };
    load_options();
});

And I have changed the server side code to look like this:

router.get('/load-options', (req, res) => {
    MongoClient.connect(MongoConnection.url, { useNewUrlParser: true, useUnifiedTopology: true }, (err, client) => {
        const db = client.db('test');
        const collection = db.collection('options');
        const changeStream = collection.watch();
        changeStream.on('change', next => {
            // If there is a change in the collection, reload the data.
            reload();
        });
    });
    function reload() {
        MongoClient.connect(MongoConnection.url, { useNewUrlParser: true, useUnifiedTopology: true }, (err, client) => {
            const db = client.db('test');
            const collection = db.collection('options');
            collection.find({}).toArray(function (err, docs) {
                client.close();
                res.send(docs);
            });
        });
    };
});

The desired outcome from this is for every time I insert a new document into the collection, the console logs the entire collection again with the new changes. However, This works for the first insert and the console logs the collection, but after that I'm getting the following error:

Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client

I know this is because my server side code now has

res.send(docs)

So I'm trying to send the headers again every time after the first request. My issue is that I don't know how I should be sending the data over from the server to the client to prevent this error.

Can anyone guide me in the right direction?

Answer 1

Sorry, too long answer for comments.

It means that your response has been sent with res.send(docs) once done, you canot modify the response (it has been sent).

Some possible solutions are :

• use a websocket
• use a polling interval on /load-options
• use a stream on the output to send data to the client from the mongo stream.

The last solution which is non well known would be :

const out = new Readable();
const reload = () => {
        MongoClient.connect(MongoConnection.url, { useNewUrlParser: true, useUnifiedTopology: true }, (err, client) => {
            const db = client.db('test');
            const collection = db.collection('options');
            collection.find({}).toArray(function (err, docs) {
                client.close();
                out.push(docs);
            });
        });
    };
changeStream.on('change', next => {
  reload();
});
out._read = () => {};
res.type('application/json').send(out);

My advice would be also to avoid the mongo.connect each time a data is modified.