|
var Promise = require('any-promise');
|
var co = require('co');
|
|
module.exports = compose;
|
|
compose.Wrap = Wrap;
|
|
function compose(middleware) {
|
return function (next) {
|
next = next || new Wrap(noop);
|
var i = middleware.length;
|
while (i--) next = new Wrap(middleware[i], this, next);
|
return next
|
}
|
}
|
|
/**
|
* Wrap a function, then lazily call it,
|
* always returning both a promise and a generator.
|
*
|
* @param {Function} fn
|
* @param {Object} ctx
|
* @param {Wrap} next
|
*/
|
|
function Wrap(fn, ctx, next) {
|
if (typeof fn !== 'function') throw TypeError('Not a function!');
|
this._fn = fn;
|
this._ctx = ctx;
|
this._next = next;
|
this._called = false;
|
this._value = undefined;
|
this._promise = undefined;
|
this._generator = undefined;
|
}
|
|
/**
|
* Lazily call the function.
|
* Note that if it's not an async or generator function,
|
*
|
* @returns {Mixed}
|
*/
|
|
Wrap.prototype._getValue = function () {
|
if (!this._called) {
|
this._called = true;
|
try {
|
this._value = this._fn.call(this._ctx, this._next);
|
} catch (e) {
|
this._value = Promise.reject(e);
|
}
|
}
|
return this._value
|
};
|
|
/**
|
* Lazily create a promise from the return value.
|
*
|
* @returns {Promise}
|
*/
|
|
Wrap.prototype._getPromise = function () {
|
if (this._promise === undefined) {
|
var value = this._getValue();
|
this._promise = isGenerator(value)
|
? co.call(this._ctx, value)
|
: Promise.resolve(value);
|
}
|
return this._promise
|
}
|
|
/**
|
* Lazily create a generator from the return value.
|
*
|
* @returns {Iterator}
|
*/
|
|
Wrap.prototype._getGenerator = function () {
|
if (this._generator === undefined) {
|
var value = this._getValue();
|
this._generator = isGenerator(value)
|
? value
|
: promiseToGenerator.call(this._ctx, value);
|
}
|
return this._generator
|
}
|
|
/**
|
* In later version of v8,
|
* `yield*` works on the `[@@iterator]` method.
|
*
|
* @returns {Iterator}
|
*/
|
|
if (typeof Symbol !== 'undefined') {
|
Wrap.prototype[Symbol.iterator] = function () {
|
return this._getGenerator();
|
}
|
}
|
|
/**
|
* This creates a generator from a promise or a value.
|
*
|
* TODO: try to avoid using a generator function for this.
|
*
|
* @returns {Iterator}
|
*/
|
|
var loggedDeprecationMessage = false;
|
function* promiseToGenerator(promise) {
|
if (!loggedDeprecationMessage) {
|
console.error('A promise was converted into a generator, which is an anti-pattern. Please avoid using `yield* next`!')
|
loggedDeprecationMessage = true;
|
}
|
return yield Promise.resolve(promise);
|
}
|
|
/**
|
* Proxy generator and promise methods.
|
*/
|
|
Wrap.prototype.then = function (resolve, reject) {
|
return this._getPromise().then(resolve, reject);
|
}
|
|
Wrap.prototype.catch = function (reject) {
|
return this._getPromise().catch(reject);
|
}
|
|
Wrap.prototype.next = function (val) {
|
return this._getGenerator().next(val);
|
}
|
|
Wrap.prototype.throw = function (err) {
|
return this._getGenerator().throw(err);
|
}
|
|
/**
|
* Check if `obj` is a generator.
|
*
|
* @param {Mixed} obj
|
* @return {Boolean}
|
*/
|
|
function isGenerator(obj) {
|
return obj
|
&& typeof obj.next === 'function'
|
&& typeof obj.throw === 'function';
|
}
|
|
function noop() {}
|
