Preventing database-related race conditions in Node.js

Question

Overview

I am attempting to understand how to ensure aynchronous safety when using an instance of a model when using Node.js. Here, I use the Mongoose ODM in code samples, but the question applies to any case where a database is used with the asynchronous event-driven I/O approach that Node.js employs.

Consider the following code (which uses Mongoose for MongoDB queries):

Snippet A

MyModel.findOne( { _id : <id #1> }, function( err, doc ) {     MyOtherModel.findOne( { _id : someOtherId }, ( function(err, otherDoc ) {         if (doc.field1 === otherDoc.otherField) {             doc.field2 = 0; // assign some new value to a field on the model         }         doc.save( function() { console.log( 'success' ); }     }); }); 

In a separate part of the application, the document described by MyModel could be updated. Consider the following code:

Snippet B

MyModel.update( { _id : <id #1> }, { $set : { field1 : someValue }, callback ); 

In Snippet A, a MongoDB query is issued with a registered callback to be fired once the document is ready. An instance of the document described by MyModel is retained in memory (in the "doc" object). The following sequence could occur:

1. Snippet A executes
2. A query is initiated for MyModel, registering a callback (callback A) for later use
3. << The Node event loop runs >>
4. MyModel is retrieved from the database, executing the registered callback (callback A)
5. A query is initiated for MyOtherModel, registering a callback for later use (callback B)
6. << The Node event loop runs >>
7. Snippet B executes
8. The document (id #1) is updated
9. << The Node event loop runs >>
10. MyOtherModel is retrieved from the database, executing the registered callback (callback B)
11. The stale version of the document (id #1) is incorrectly used in a comparison.

Questions

1. Are there any guarantees that this type of race condition won't happen in Node.js/MongoDB?
2. What can I do to deterministically prevent this scenario from happening?

While Node runs code in a single-threaded manner, it seems to me that any allowance of the event loop to run opens the door for potentially stale data. Please correct me if this observance is wrong.

Answer 1

No, there are no guarantees that this type of race condition won't occur in node.js/MongoDB. It doesn't have anything to do with node.js though, and this is possible with any database that supports concurrent access, not just MongoDB.

The problem is, however, trickier to solve with MongoDB because it doesn't support transactions like your typical SQL database would. So you have to solve it in your application layer using a strategy like the one outlined in the MongoDB cookbook here.