param-injection v0.1.0
Param Injection
(Node.js) Wraps a function so that one or some of the parameters can be auto-loaded at run time. Mainly used to build modules or functions that may have some run time dependencies.
This is similar to "Dependency Injection" but much simpler.
What
It exports a function.
var injectify = require('param-injection');
And that can be used to wrap a function, so that one or some of the parameters of the function can be actively retrieved (with a given getter) at run time.
For example, say you have a function that does something, and requires some arguments.
var request = require('request');
var Promise = require('bluebird');
function requestSomething(url, other, args) {
return new Promise(function(resolve, reject) {
request(url, function(err, res) {
if (err) return reject(err);
resolve(res);
});
})
}
And one of the arguments can be from another function (or say you want to build it with another function).
function getUrl() {
return new Promise(function(resolve) {
setTimeout(function() {
resolve('http://www.google.com');
}, 10);
});
}
Now instead of calling them together all the time, you can wrap the original function and you get a new function.
var myRequest = injectify(requestSomething, 'url');
And inject the getter function.
myRequest.inject('url', getUrl);
Tip: you can do the above 2 lines in one step.
var myRequest = injectify(requestSomething, 'url').inject('url', getUrl);
Now you can run the wrapper, with only the other arguments (meaning that the new function has a different API with the original function).
myRequest('other', 'args').then(function(res) {
// res.should.be.type('object');
// res.should.have.property('statusCode', 200);
});
Why
This small tool solves a very specific problem, where:
- You are building a module (not an application where you could do whatever you want).
- And you are building a function that has some asynchronous dependencies.
- And you want to give it a default parameter while still give your user a chance to change it.
Without this tool it is usually hard to achieve the same thing but with this tool the code can be a bit more complex; your choice.
API
TODO
Variants
Return self
A variant that returns the context or this
.
Can be used to build some callback based APIs.
However note that the dependencies are still promise based.
Return auto
A variant that returns either the promise or the context, depending on if a callback function is given.
Can be used to build something with both a promise API and a callback API.
However note that 1) the dependencies are still promise based and 2) the last argument is considered as a callback if it is a function and 3) we assume the callback will be properly handled.
Cached result (caching the promise)
TODO
Bonus
As a flow control tool
TODO