Node.js – Project Implementation Details

Short answer:

No, synchronous processing in node.js WILL cause performance problems.

Long answer:

You want to avoid synchronous processing in node as much as possible. Obviously, sometimes you're going to need it, but that may be a point at which you move the relevant synchronous code out of node and into something more suitable.

Basically, as node follows an evented model of concurrency, where a single thread runs a stack of events one at a time, any long-running events are going to block the execution of anything else. So, what you'll be looking to do is to scythe off as much functionality as possible into small, asynchronous, function calls.

What you'll want to do is look to use a library, such as async or Step, which allows you to avoid the "callback hell" approach to node programming. JQuery has a similar thing in the browser that you may have used, which is its promise() method and Deferred objects. This will make it much quicker to write, and maintain, your node source.

If you really do need to put a large synchronous procedure in your web app, then node is not the right tool for that job. Try looking at having another API that node can call out to when it needs to accomplish a long-running task, whether that's a command-line C++ app or a web API in a more standard-concurrency model language.

In case you're using Express + Sequelize, you can do this by using a module called continuation-local-storage (henceforth cls, for brevity).

Show me the code

// When initializing your Sequelize instance
var Sequelize = require( "sequelize" );
Sequelize.cls = require( "continuation-local-storage" ).createNamespace( "db" );

module.exports = new Sequelize(...);

Then, create some middleware to initialize your transaction in every request (in case no one has come up with one yet):

var sequelize = require(...);
app.use(function ( req, res, next ) {
  sequelize.transaction(function () {
    // Do something else, but be sure to invoke next middleware
    next();    
  });
});

What's going on here?

1. A cls namespace is declared for Sequelize to use. Must be set on the constructor;
2. A transaction is initialized in an Express middleware;
3. Every subsequent sequelize query will use the request transaction by default (you can override this behavior, obviously).

How this works?

This works because cls assigns a new storage for each new async chain (the request in this example), and they are passed down consistently and transparently.
It's some kind of magic that happens inside Node :)

Tips

It's very likely that you'll need to use some monkeypatch to take that approach. Depends on your Promises implementation.

• https://www.npmjs.com/package/cls-bluebird
• https://www.npmjs.com/package/cls-q

Further info

Check the Sequelize documentation.