I'm in early stages of a node.js project, and I'm looking to improve the overall app organization. In the past I worked with Symfony2 (PHP) and now I code a lot in Angular, both of which relly heavily on DI. So, I really like the idea of applying the same principles in my node.js project.

I know the existence of packages like Rewire, but for now I'll like to try the DI approach. The issue is, how to achieve an equilibrium to keep the lightweight feeling that gives working with node with the solidity of a well tested dependency injected app (I know that well tested is what gives the solidity ;-)).

Node modules

One of the issues, would be how to manage the external modules, what to do if some object needs fs module? As Vojta Jina (from AngularJS) states in this article:

So the best way that works for me right now is something like this: Modules are stateless. They only contain definitions of classes/functions/constants.

So, I suppose that I would have to inject everything:

function Foo(fs) {
    this.fs = fs;
}

Foo.prototype.doSomething: function () {
    // this.fs...
};

module.exports = Foo;

Somewhere:

var fs  = require('fs');
var Foo = require('./Foo');
var foo = new Foo(fs);

foo.doSomething();

Express

Since Express uses apply() to call the handlers the context is lost and we can't use this. So we're left with these:

// foo.js
function Foo(fs) {
    this.fs = fs;
}

Foo.prototype.index = function () {
    var self = this;

    return function (req, res, next) {
        // self.fs...
    };
};

module.exports = Foo;

// bar.js
module.exports.index = function (fs) {
    return function (req, res, next) {
        // fs...
    };
};

// app.js
var express = require('express');
var fs      = require('fs');
var app     = express();
var Foo     = require('./foo');
var foo     = new Foo(fs);
var bar     = require('./bar');

app.get('/foo', foo.index());
app.get('/bar', bar.index(fs));

So...

Has someone taken this approach? What about the use of DI frameworks? (like di.js) And how to keep the experience lean? All ideas are welcome. Thanks!

I'm in early stages of a node.js project, and I'm looking to improve the overall app organization. In the past I worked with Symfony2 (PHP) and now I code a lot in Angular, both of which relly heavily on DI. So, I really like the idea of applying the same principles in my node.js project.

I know the existence of packages like Rewire, but for now I'll like to try the DI approach. The issue is, how to achieve an equilibrium to keep the lightweight feeling that gives working with node with the solidity of a well tested dependency injected app (I know that well tested is what gives the solidity ;-)).

Node modules

One of the issues, would be how to manage the external modules, what to do if some object needs fs module? As Vojta Jina (from AngularJS) states in this article:

So the best way that works for me right now is something like this: Modules are stateless. They only contain definitions of classes/functions/constants.

So, I suppose that I would have to inject everything:

function Foo(fs) {
    this.fs = fs;
}

Foo.prototype.doSomething: function () {
    // this.fs...
};

module.exports = Foo;

Somewhere:

var fs  = require('fs');
var Foo = require('./Foo');
var foo = new Foo(fs);

foo.doSomething();

Express

Since Express uses apply() to call the handlers the context is lost and we can't use this. So we're left with these:

// foo.js
function Foo(fs) {
    this.fs = fs;
}

Foo.prototype.index = function () {
    var self = this;

    return function (req, res, next) {
        // self.fs...
    };
};

module.exports = Foo;

// bar.js
module.exports.index = function (fs) {
    return function (req, res, next) {
        // fs...
    };
};

// app.js
var express = require('express');
var fs      = require('fs');
var app     = express();
var Foo     = require('./foo');
var foo     = new Foo(fs);
var bar     = require('./bar');

app.get('/foo', foo.index());
app.get('/bar', bar.index(fs));

So...

Has someone taken this approach? What about the use of DI frameworks? (like di.js) And how to keep the experience lean? All ideas are welcome. Thanks!

• javascript
• node.js
• express
• dependency-injection

• One doubt, does it make sense to inject to the controller something like "async"? Or wouldn't it be more convenient just require it in place? Same for modules like "path". – doup Commented Jul 2, 2014 at 12:22
• try inversify.io – SET001 Commented Aug 16, 2016 at 23:52
• 1 Require it in place would defeat the prourpose of DI because you'll have to update your require every time you want to replace your dependency by another implementation – danielrvt Commented Jun 3, 2020 at 13:31

2 Answers 2

You have some good thoughts to which I'd like to add:

• Having stateless modules will help you to scale your app horizontally. If all state is in a database it will be easy to run multiple node.js instances in parallel.
• I also prefer to inject everything. Otherwise the time will come when I would like to write a unit test and it gets hard because I have a hardcoded (not injected) dependencies I can't mock.

To keep this lightweight feeling when working with node you need an approach for dependency injection that doesn't add too much complexity. Your express example above reminds me of a talk by Vojta Jina in which he makes an important point about the wiring part of dependency injection. (Watch minute 3:35 to 8:05) I can't explain it any better than Vojtja does in his talk but basically he says that we need a di framework that takes care of the wiring (what is injected into what). Otherwise the code we manually write to set up the wiring won't be maintainable. Also each unit test would need such wiring code. And that IMO is where manual dependency injection is not an option anymore.

When you use a di framework (or a di container as many people say) the basic idea is that each individual module states which dependencies it requires and through which id it can be required by other modules. Then the di framework can be invoked to initialize the module that serves as an entry point (e.g. app.js) and the framework will look up all dependencies and takes over the hard work of injecting the appropriate module instances.

There are many di frameworks for node.js to which I'd like to add my own: "Fire Up!" If you would use it your example would look like this:

foo.js

// Fire me up!

function Foo(fs) {
    this.fs = fs;
}

Foo.prototype.index = function () {
    var self = this;

    return function (req, res, next) {
        // self.fs...
    };
};

module.exports = {
    implements: 'foo',
    inject: ['require(fs)'],
    _constructor: Foo
};

bar.js

// Fire me up!

module.exports = {
    implements: 'bar',
    inject: ['require(fs)'],
    factory: function (fs) {
        return {
            index: function (req, res, next) {
                // fs...
            }
        };
    }
};

app.js

// Fire me up!

module.exports = {
    implements: 'app',
    inject: ['require(express)', 'foo', 'bar']
};

module.exports.factory = function (express, foo, bar) {
    var app = express();

    app.get('/foo', foo.index());
    app.get('/bar', bar.index);
};

index.js

var fireUpLib = require('fire-up');

var fireUp = fireUpLib.newInjector({
    basePath: __dirname,
    modules: ['./lib/**/*.js'] // foo.js, bar.js, app.js are on this path
});

fireUp('app'); // This is where the injection is kicked off.

When running node index.js you get the following output:

fireUp# INFO  Requested: app, implemented in: lib/app.js
fireUp# INFO  |-- Requested: require(express)
fireUp# INFO  |-- Requested: foo, implemented in: lib/foo.js
fireUp# INFO      |-- Requested: require(fs)
fireUp# INFO  |-- Requested: bar, implemented in: lib/bar.js
fireUp# INFO      |-- Requested: require(fs)

If this looks worth trying out you might be interested in the Getting Started section which shows an example based on express.

Hope that helps!

You can check https://www.npmjs.com/package/plus.container

This is close to DIC in Symfony