diyai
Dependency Injection (DI) made easy in JavaScript/ES6
Installation
With npm:
$ npm install --save diyai
With unpkg CDN:
<script src="https://unpkg.com/diyai@0.x/dist/diyai.min.js"></script>
<script>
</script>
Usage
Direct values
Let's start by defining a simple container first.
When defining the providers, we can directly assign values for them via the useValue
key.
import { createContainer, resolveContainer } from 'diyai';
const Container = createContainer([
{ name: 'foo', useValue: 'foo value' },
{ name: 'bar', useValue: 'bar value' }
]);
Now, let's resolve it to get the Container's instance:
const container = resolveContainer(Container);
Once resolved, you can get instaces of your providers as follows:
container.get('foo');
container.get('bar');
If there is any chance of having a cyclic reference, you can use useDefinedValue
:
const myObj = {};
const Container = createContainer([
{ name: 'myObj', useDefinedValue: myObj }
]);
myObj.container = resolveContainer(Container);
Doing so would set a self-refernce of myObj
in myObj.container.registry.myObj
using Object.defineProperty
via a getter function.
Values from factories
We can also pass functions in the Container definition for the providers, and their returned values will be used as the actual value then.
For that, we will use the useFactory
key:
import { createContainer, resolveContainer } from 'diyai';
const Container = createContainer([
{ name: 'foo', useFactory: () => 'foo value' },
]);
const container = resolveContainer(Container);
container.get('foo');
Classes
Some providers can even be classes, and can be passed in the Container definition in useClass
key.
Once resolved, the container would then return the instance of the class.
Classes can be just plain ES6 classes:
class Foo {
text() {
return 'foo text'
}
}
Or, they can be created with the handy createClass
function shipped with this library:
import { createClass } from 'diyai';
const Foo = createClass({
text: function () {
return 'foo text';
}
});
Once the class is written, we can define our container:
const Container = createContainer([
{ name: 'foo', useClass: Foo }
]);
Which can now be resolved as follows:
const container = resolveContainer(Container);
const fooInstance = container.get('foo');
fooInstance.text();
Dependencies
Dependencies can be handled while defining the providers.
Let's say you have a Foo
and Bar
classes, and Bar depends on Foo:
class Foo {
text() {
return 'foo text';
}
}
class Bar {
constructor({ foo }) {
this.foo = foo;
}
fooText() {
return this.foo.text();
}
}
Once we have them as classes, we can pass them on to our container definition as follows:
const Container = createContainer([
{ name: 'foo', useClass: Foo },
{ name: 'bar', useClass: Bar, deps: ['foo'] }
]);
We are telling our Container that when bar
is instantiated, pass the instance of foo
to its constructor.
const container = resolveContainer(Container);
const bar = container.get('bar');
bar.fooText();
The deps
key can also be provided as an object instead of an array, where the keys are the container's provider names, and values are the names the target class is expecting.
API
createClass(extend = {})
Creates and returns a class.
import { createClass } from 'diyai';
const MyClass = createClass({
initialize(deps) {
},
someMethod() {
return true;
}
});
resolveContainer(Container)
Returns instance of resolved container.
createContainer(providers = [], options = {})
Creates and returns a container class.
providers
An array of providers.
A single provider object would contain:
{
name: 'uniqueNameHere',
useValue: 'direct value of any type',
useFactory: () => 'returned value of any type', OR
useClass: SomeClass,
deps: ['depName1', 'depName2', ...]
deps: { nameInContainer: 'nameExpectedInArgs' }
}
options
containerName
: defaults to container
.
This means, the container instance itself can be obtained as:
container.get('container');
Thanks
- Angular 2: For their
Injector
, since this project is an implementation of that in ES6 with no external dependencies.
License
MIT © Fahad Ibnay Heylaal