object-container v0.9.0

object-container

A simple javascript dependency injection container.

Install

$ npm install object-container

Usage

const { ObjectContainer, ref } = require('object-container');

let X = class X { constructor(args1) { this.args1 = args1; } };
let Y = class Y { constructor(args1, x, val) { this.args1 = args1; this.x = x; this.val = val; } };

let objectContainer = new ObjectContainer();
objectContainer.registerType('x', X, 'testX')
    .registerType('y', Y, 'testY', ref('x'), ref('z'))
    .registerValue('z', 10);

let x = objectContainer.get('x');
let y = objectContainer.get('y');

console.log(y.x === x); 
console.log(y.val == 10); 

Api

ObjectContainer

• (constructor) new (...definitions: Definition[]): ObjectContainer

• (method) register(...definitions: Definition[]): ObjectContainer

• (method) registerType(name: string, type: class | function, ...args: any[]): ObjectContainer
• (method) registerValue(name: string, value: any): ObjectContainer
• (method) get(name: any, renew?: boolean, ...overrideArgs: any[]): any
• (method) remove(name: string): void
• (method) contains(name: string): boolean

• (method) clear(): void

• (property) length: number

Reference (ref)

• (constructor) new (name: string, renew?: boolean, ...overrideArgs: any[]): Reference
• (method) ref (name: string, renew?: boolean, ...overrideArgs: any[]): Reference

Definition (abstract)

• (constructor) new (name: string): Definition
• (abstract method) resolve(objectContainer: ObjectContainer): any

TypeDefinition (extends Definition)

• (constructor) new (name: string, type: class | function, ...args: any[]): TypeDefinition

ValueDefinition (extends Definition)

• (constructor) new (name: string, value: any): ValueDefinition

Custom Definition

const { ObjectContainer, Reference, ref, Definition } = require('object-container');

let TypeFromPackageDefinition = class extends Definition {
    constructor(name, $package, ...args) {
        super(name);
        this.package = $package;
        this.args = args;
    }
    resolve(objectContainer) {
        let Type = require(this.package),
            processedArgs = this.args.map(function (argument) {
                return (argument instanceof Reference) ?
                    objectContainer.get(argument.name) : argument;
            }, this);

        return new Type(...processedArgs);
    }
};

let objectContainer = new ObjectContainer();
objectContainer.register(new TypeFromPackageDefinition('x', './x.js', 'testX'));

let x = objectContainer.get('x');

console.log(x.args1 === 'testX');

Convert

const { ObjectContainer, convert } = require('object-container');

let X = class X { constructor(args1) { this.args1 = args1; } };
let Y = class Y { constructor(args1, x, val) { this.args1 = args1; this.x = x; this.val = val; } };

let definitions = convert({
    '$x': { type: X, args: 'testX' },
    '$y': { type: Y, args: ['testY', '$x', '$z'] },
    'z': 10
}, '$');

console.log(definitions.length == 3);
console.log(definitions.every((d) => d instanceof Definition));

//
// let objectContainer = new ObjectContainer(...definitions);
// or
// objectContainer.register(...definitions);
//

License

MIT