index.js

'use strict';
var extend = require("extend");
var debug = require('debug')("pigfarm-fetcher");
var hrtime = require("process.hrtime");
var get = require('lodash.get');

var getProtocol = {
	parse: function (str) {
		var protocol = str.indexOf('//') == -1 ? null : str.split('//')[0];
		return {
			protocol: protocol.slice(0, -1)
		}
	}
};

function buildRequestMethod(config) {
	// 兼容直接传入url的情况
	if (typeof config == 'string') {
		config = { url: config };
	}

	// 从url中获取出协议
	var protocol = getProtocol.parse(config.url).protocol;

	var requestor;
	// 检查是否有对应的requestor
	if (!(requestors[protocol] || requestors['default'])) {
		throw new Error('unsupport protocol: ' + protocol);
	} else {
		requestor = requestors[protocol] || requestors['default'];
	}

	// 找到对应的配置预处理器
	var compiler = compilers[protocol];

	var urlstring = config.url;
	var urltemplate = function (data) {
			return urlstring.replace(/\{([\w\.]*)\}/g, function (a, b) { 
				return get(data, b); 
			});
	}

	// 预处理传入的请求配置
	compiler && compiler(config);

	// 默认的请求逻辑处理hook
	config.fixParam = config.fixParam || config.fixBefore || function (a) {
		return a
	};
	config.fixResult = config.fixResult || config.fixAfter || function (a) {
		return a;
	};
	config.onError = config.onError || function (a) {
		return false;
	};
	/**
	 * 返回出去的函数
	 * @param data 请求数据
	 * @return promise
	 */
	return function (data) {
		var timestat = {};  // 请求的耗时数据
		var param; 		    // 要传入请求器的数据
		var result;			// 返回出来的数据
		var requestCfg = {};// 传给请求器的配置

		var self = this;
		return new Promise(function (resolve, reject) {
			data = data || {};

			// 调用fixBefore来调整处理请求数据
			// fixBefore的this指针与调用该函数的this指针相同
			var err;

			debug('call fixParam');
			timestat.fixParam = hrtime();
			try {
				param = config.fixParam.call(self, data);
			} catch (e) {
				err = e;
			}
			timestat.fixParam = hrtime(timestat.fixParam, 'us');
			debug('called fixParam');

			if (isInvalid(param) || err) {
				debug('fixParam failed', param);
				err = err || new Error('fixParam(fixBefore) returned ' + param);
				param = data; // 把请求参数回复到调用fixBefore之前的状态
				return reject(err);
			}

			debug('start fixUrl');
			timestat.fixUrl = hrtime();
			// 复制一份请求数据
			var requestData;
			if (param instanceof Array) {
				requestData = param.slice(0);
			} else {
				requestData = extend({}, param, config.data);
			}

			// 如果url上存在{var}这样的配置，就替换掉
			var url = urltemplate(param);

			timestat.fixUrl = hrtime(timestat.fixUrl, 'us');
			debug('end fixUrl');

			// 拷贝一份请求配置
			Object.keys(config).forEach(function (key) {
				if (typeof config[key] != 'function') {
					requestCfg[key] = config[key];
				}
			});

			requestCfg.url = url;
			debug('start globalBeforeHook');
			globalBeforeHook.forEach(function (hook) {
				var hookData = requestData;
				try {
					hookData = hook.call(self, hookData);
					hookData != void 0 && (requestData = hookData);
				} catch (e) {
				}
			});
			requestCfg.data = requestData;
			requestCfg.originalData = data;
			debug('end globalBeforeHook');

			timestat.request = hrtime();
			// 调用请求器
			debug('do request');
			try {
				requestor.call({
					log: onlog.bind(self, requestCfg)
				}, requestCfg, function (err, res, requestinfo) {
					requestinfo = requestinfo || {};
					err ? reject(extend(err, { // 出错时把请求信息挂在err上
						requestinfo: requestinfo,
						fetcherErrorType: 'requestor'
					})) : resolve({
						data: res,
						requestinfo: requestinfo
					});
				});
			} catch (e) {
				e.fetcherErrorType = 'requestor'; // 确认是请求器的错误
				reject(e);
			}

		}).then(function (res) {
			timestat.request = hrtime(timestat.request, 'us');

			debug('call fixResult');
			timestat.fixResult = hrtime();

			debug('start globalAfterHook');
			globalAfterHook.forEach(function (hook) {
				var hookRequestInfo = extend({}, {time: timestat.request}, res.requestinfo);

				try {
					hook.call(self, res.data, param, hookRequestInfo, requestCfg);
				} catch (e) {
				}
			});
			debug('end globalAfterHook');

			try {
				// check if the result is legal by invoking fixResult。
				result = config.fixResult.call(self, res.data, param, extend({
					time: timestat.request
				}, res.requestinfo));
			} catch (e) {
				throw extend(e, {
					requestinfo: res.requestinfo
				});
			}
			// if fixResult returned false, treat as an error
			if (isInvalid(result)) {
				throw extend(new Error('fixResult(fixAfter) returned' + result), {
					requestinfo: res.requestinfo
				});
			}
			timestat.fixResult = hrtime(timestat.fixResult, 'us');
			debug('called fixResult');

			return result

		}, function (e) {
			timestat.request = hrtime(timestat.request, 'us');
			throw e

		}).catch(function (err) {
			debug('start globalErrorHook');
			globalErrorHook.forEach(function (hook) {
				var hookResult = extend({}, result);
				var hookParam = extend({}, param);
				var hookRequestCfg = extend({}, requestCfg);
				try {
					hook.call(self, err, hookResult, hookParam, hookRequestCfg);
				} catch (e) {
				}
			});
			debug('end globalErrorHook');

			// if there is an error, use the onError fixer
			//
			// and the user can ignore the error by returning false in onError fixer.
			debug('call onError');
			timestat.onError = hrtime();
			try {
				err = config.onError.call(self, err, result, param);
			} catch (e) {
				err = e;
			}
			// if onError returned something and it is not an Error
			// treat it as a result
			if ((err && !(err instanceof Error)) || err === '') {
				var ret = err;
				err = null;
			}

			timestat.onError = hrtime(timestat.onError, 'us');
			debug('called onError', ret);
			if (err) {
				throw err

			} else {
				return ret;
			}

		}).then(function (ret) {
			timestat.all = Object.keys(timestat)
				.map(function (key) {
					return timestat[key]
				})
				.reduce(function (prev, cur) {
					return prev + cur
				});
			// otherwise, return result or null
			return {
				result: isInvalid(ret) ? null : ret,
				timestat: timestat
			}

		}, function (err) {
			err.timestat = timestat;
			throw err;
		});
	}
}


var requestors = {};
var compilers = {};

/**
 * entry
 *
 * @param configs: request configs.
 * @returns the request methods.
 */
function factory(configs) {
	var exportee = {};
	for (var i in configs) {
		exportee[i] = buildRequestMethod(configs[i]);
	}

	return exportee;
}
/**
 * parse single config
 * @param config
 * @returns the request method.
 */
factory.build = buildRequestMethod;

/**
 * @param protocol: which protocol will the requestor serve.
 * @param fn: request behavior
 */

factory.registerRequestor = function (protocol, fn) {
	requestors[protocol] = fn;
};

factory.registerCompiler = function (protocol, fn) {
	compilers[protocol] = fn;
};

// 全局钩子的参数与局部钩子一样，但是多了一个请求配置的参数
var globalBeforeHook = [];
var globalAfterHook = []; // 不准用来做修改数据的操作，支持业务做一些数据上报、监控等额外操作
var globalErrorHook = []; // 不准用来做修改数据的操作
factory.registerHook = function (type, cb) {
	if (type == 'before') {
		globalBeforeHook.push(cb);

	} else if (type == 'after') {
		globalAfterHook.push(cb);

	} else if (type == 'error') {
		globalErrorHook.push(cb);

	} else {
		throw new Error('invalid hook');
	}
};

function onlog(config, log) {
	debug(log);
}

factory.on = function (event, hook) {
	if (event == 'log' && typeof hook == 'function') {
		onlog = hook;
	}
};

module.exports = factory;

function isInvalid(e) {
	return e === null || e === void 0 || e === false;
}