AsyncIoC for Node JS

Asyncronous IoC and dependency injection for Node JS.

Usage

First create a container:

var ioc = require('async-ioc').createContainer();

Then register services on that container:

ioc.register('service', someFunction);
ioc.register('anotherService', require('./anotherservice'));

You can specify dependencies for a service:

ioc.register('serviceThree', serviceThreeFactory, ['service', 'anotherService']);

Load an entire folder:

ioc.registerAll('/path/to/services');

...all registered services will be named by the file/folder unless the $implement attribute is set.

And start a service with dependency injection:

ioc.start('serviceThree');

You can also chain the methods:

require('async-ioc').createContainer()
	.register('service', someFunction)
	.register('anotherService', require('./anotherservice'))
	.register('serviceThree', serviceThreeFactory, ['service', 'anotherService'])
	.start('serviceThree')
	.then(function(serviceThree) {
		// do something with serviceThree
	});

Service Signature

The factory/function for the service should have the following signature:

var someService = function(services) {
	// ...
	// service initialization logic
	// ...

	return theService;
};

Typically you would expose this in a module:

module.exports = function(services) { };

... where services is an object containing the injected services

Attributes

$implement

Alias of $implements

$implements

Defines the service or interface name this module implements.

Type: String or Array[String]

Default: The file or folder name.

Notes: A module can implement multiple services or interfaces.

// implement a service or interface
module.exports = function(services) { };
module.exports.$implements = 'serviceName';

// implement multiple services or interfaces
module.exports = function(services) { };
module.exports.$implements = ['service1', 'service2'];

$inject

Defines the services to be injected for this service. These should be supplied as an array of string values containing the service names.

Default: No services ([])

module.exports = myService;
module.exports.$inject = ['dependencyOne', 'dependencyTwo'];

function myService(services) {
	services.dependencyOne.someMethod();
}

Asyncronous Services

Method 1: Promises

Simply return a promise from the service factory.

module.exports = myService;

function myService(services) {
	var deferred = Q.defer();

	// this service will finish loading in 1 second
	setTimeout(function() {
		deferred.resolve();
	},1000);

	return deferred.promise;
}

Method 2: start() method

Return an object that defines a .start() method that accepts a Node-style callback (ie: function(err)) to be called on completion. The start method will be called before injecting into the first service.

module.exports = myService;

function myService(services) {

	return {
		start: function(done) {

			// if an error occurs, call done() with the error
			if (someErrorOccurred) done(someErrorOccurred);

			// this service will finish loading in 1 second
			setTimeout(function() {
				done();
			},1000);
		}
	};

}

Shutdown / Stop process

TODO:

Method Summary

All container methods are chainable, except for get and start.

Still To Document

A lot to do!

• debug
• define
• defineAll / defineFolder
• get
• logTo
• recurseServices
• recurseInterfaces
• register
• registerAll / registerFolder
• reset
• start
• stopOn
• stopTimeout