molecule usage project

junk.js

// DEFINITION:
// Can be used with generals functions

// x.js
module.exports = function(a, b, $container) { // If has $container property, container will be passed
    $container.injectProperties(this); // Can be used list from $injectProperties to reduce constructor param list
};

exports.$require = [ // preloads modules - BEFORE init. Already accessible in $container
    __dirname + '/subfolder_1'
];

exports.$constructor = true; // Use 'new' method
exports.$singleton = true; // Singleton for each box.
exports.$name = 'locale';
exports.$async = true; // For asynchronous initialization. Is it ever reasonable way?

// Autoinjection with delayed initialiation - for cycle references and simplifying API
exports.$initMethod = 'init';
exports.$injectProperties = [
    'middleware1',
    'middleware2'
];

// USAGE:

// Preload modules namespace
// Validates all dependencies
// Throws on unresolved dependencies
// Throws on duplicate dependencies

Module.require(Module.relativePath(__dirname, [ // with batch && custom preferences
    'modules/*.js', //a.js, b.js
]));

Module.require({
    '__dirname/modules/a.js': {constructor: true, singleton: true} // Override preferences
});

// Instantiate modules - if required
Module.get('a');

// Override module for test stub
Module.override('a', Module.relativePath(__dirname, 'stubs/modules/a.js'));


// First initialization with inheritance and lange structure
var molecule = require('molecule');

var Server = module.exports = function(config, $container) {
    var ioc = new molecule();

    // I do require not redis library, but initialized redis client3
    this.redis = ioc.get("redis");
};

exports.$require = [
    {path: '__dirname/modules/a.js', name: 'stub'},
    '__dirname/core/*.js'
];

// redis.js - redis instance as sample
var redis = require('redis');

module.exports = function(config, logger) {
    return new redis.client(config, logger);
};

exports.$singleton = true;

// From external source

var container = new Molecule();
container.add('config', "__dirname/lib/config"); // Cool story, bro!
container.require("__dirname/lib/server.js");
var servers = {
    worker: container.get("worker"),
    cluster: container.get("cluster")
};

async.each(server, function(server, name, cb) {
    server.run(env, cb);
}, function(err) {
    console.log("We are running here");
});

userstory.js

// Using of DI for tests

// As a programmer I want to test 'UserManager' module

// 1. Register all modules.
var Molecule = require('molecure');
var container = new Molecule();

container.require(Molecule.retalivePath(__dirname, [
    "lib/managers/userManager.js"
]));

// 2. Stub testable interface for running module

// Override by path
container.override('logger', 'stubs/streamLogger');

// Override by name
container.override('chulthuCaller', {name: 'chickenCaller'});

// 3. Pass any external objects, to DI container, if required

container.add('config', new ConfigInstance());

// 4. Get instance of required service

var userManager = container.get('userManager');

// 5. Use in expected way

userManager.test();