:fix: some bugs

zyao89 · zyao89 · commit 42c495ab4bfa · 2019-05-25T02:28:47.000+08:00
diff --git a/lib/Proxy.js b/lib/Proxy.js
@@ -1,19 +1,21 @@
 'use strict';
 
 const utility = require('2o3t-utility');
-const isFunction = utility.is.function;
 const httpProxy = require('http-proxy');
-const logger = require('./logger');
-
 const createConfig = require('./createConfig');
 const handlers = require('./handlers');
-const PathRewriter = require('./path-rewriter');
 const contextMatcher = require('./context-matcher');
+const PathRewriter = require('./path-rewriter');
 const Router = require('./router');
+const logger = require('./logger');
+
+const isFunction = utility.is.function;
+
+module.exports = Proxy;
 
-function PROXY(context, opts) {
+function Proxy(context, opts) {
     // https://github.com/chimurai/http-proxy-middleware/issues/57
-    const wsUpgradeDebounced = utility.debounce(_handleUpgrade);
+    const wsUpgradeDebounced = utility.debounce(handleUpgrade);
     let wsInitialized = false;
     const config = createConfig(context, opts);
     const proxyOptions = config.options;
@@ -27,86 +29,89 @@ function PROXY(context, opts) {
     handlers.init(proxy, proxyOptions);
 
     // log errors for debug purpose
-    proxy.on('error', _handleLogError);
+    proxy.on('error', logError);
 
     // 新增加的功能
     proxy.on('proxyRes', _handleProxyResBody);
 
-
     // https://github.com/chimurai/http-proxy-middleware/issues/19
     // expose function to upgrade externally
     middleware.upgrade = wsUpgradeDebounced;
 
-    function _handleLogError(err, req /* res */) {
-        const hostname = (req.headers && req.headers.host) || (req.hostname || req.host); // (websocket) || (node0.10 || node 4/5)
-        const target = proxyOptions.target.host || proxyOptions.target;
-        const errorMessage = 'Error occurred while trying to proxy request %s from %s to %s (%s) (%s)';
-        const errReference = 'https://nodejs.org/api/errors.html#errors_common_system_errors'; // link to Node Common Systems Errors page
+    return middleware;
 
-        logger.error(errorMessage, req.url, hostname, target, err.code, errReference);
-    }
+    async function middleware(ctx, next) {
+        const req = ctx.req;
+        const res = ctx.res;
 
-    function _handleProxyResBody(proxyRes, req, res) {
-        const oriWrite = res.write;
-        const oriEnd = res.end;
-        const proxyBody = proxyOptions.proxyBody;
-        if (proxyBody) {
-            const ctx = res._ctx;
-            const jsonStrings = [];
-            Object.assign(res, {
-                write(chunk) {
-                    jsonStrings.push(chunk);
-                    oriWrite.apply(res, arguments);
-                },
-                end() {
-                    let buffer = jsonStrings.join();
-                    try {
-                        if (isFunction(proxyBody)) {
-                            const oriJSONRes = JSON.parse(buffer.toString());
-                            const handledJSONRes = proxyBody(oriJSONRes, proxyRes, req, res, ctx);
-                            buffer = new Buffer(JSON.stringify(handledJSONRes)); // 一定要转成buffer，buffer长度和string长度不一样
-                        } else {
-                            ctx.body = JSON.parse(buffer.toString());
-                        }
-                    } catch (error) {
-                        logger.warn(error);
-                    }
-                    oriEnd.apply(res, arguments);
-                },
-            });
+        if (proxyOptions.ws === true) {
+        // use initial request to access the server object to subscribe to http upgrade event
+            catchUpgradeRequest(req.connection.server);
         }
-        if (res.__resolve && isFunction(res.__resolve)) {
-            res.__resolve(proxyRes);
+
+        // function middleware(req, res, next) {
+        const proxyRes = await new Promise(resolve => {
+            if (shouldProxy(config.context, req)) {
+                ctx.respond = false;
+                ctx.status = 302;
+                const activeProxyOptions = prepareProxyRequest(req);
+                res._ctx = ctx;
+                res._resolve = resolve;
+                proxy.web(req, res, activeProxyOptions);
+            } else {
+                resolve();
+            }
+        });
+
+        if (proxyRes) {
+            res.proxyRes = proxyRes;
         }
+
+        await next();
     }
 
-    function _shouldProxy(req) {
-        const context = config.context;
-        const path = (req.originalUrl || req.url);
-        return contextMatcher.match(context, path, req);
+    function catchUpgradeRequest(server) {
+        // subscribe once; don't subscribe on every request...
+        // https://github.com/chimurai/http-proxy-middleware/issues/113
+        if (!wsInitialized) {
+            server.on('upgrade', wsUpgradeDebounced);
+            wsInitialized = true;
+        }
     }
 
-    function _handleUpgrade(req, socket, head) {
+    function handleUpgrade(req, socket, head) {
         // set to initialized when used externally
-        _wsInitialized = true;
+        wsInitialized = true;
 
-        if (_shouldProxy(req)) {
+        if (shouldProxy(config.context, req)) {
             const activeProxyOptions = prepareProxyRequest(req);
             proxy.ws(req, socket, head, activeProxyOptions);
             logger.system('Upgrading to WebSocket');
         }
     }
 
-    function _catchUpgradeRequest(server) {
-        // subscribe once; don't subscribe on every request...
-        // https://github.com/chimurai/http-proxy-middleware/issues/113
-        if (!_wsInitialized) {
-            server.on('upgrade', wsUpgradeDebounced);
-            _wsInitialized = true;
-        }
+    /**
+     * Determine whether request should be proxied.
+     *
+     * @private
+     * @param  {String} context [description]
+     * @param  {Object} req     [description]
+     * @return {Boolean} bool
+     */
+    function shouldProxy(context, req) {
+        const path = (req.originalUrl || req.url);
+        return contextMatcher.match(context, path, req);
     }
 
-    function _prepareProxyRequest(req) {
+    /**
+     * Apply option.router and option.pathRewrite
+     * Order matters:
+     *    Router uses original path for routing;
+     *    NOT the modified path, after it has been rewritten by pathRewrite
+     * @param {Object} req req
+     * @return {Object} proxy options
+     */
+    function prepareProxyRequest(req) {
         // https://github.com/chimurai/http-proxy-middleware/issues/17
         // https://github.com/chimurai/http-proxy-middleware/issues/94
         req.url = (req.originalUrl || req.url);
@@ -123,73 +128,78 @@ function PROXY(context, opts) {
         return newProxyOptions;
     }
 
-    middleware.upgrade = wsUpgradeDebounced;
-
-    logger.system('inited...');
+    // Modify option.target when router present.
+    function __applyRouter(req, options) {
+        let newTarget;
 
-    return middleware;
-
-    async function middleware(ctx, next) {
-        const req = ctx.req;
-        const res = ctx.res;
+        if (options.router) {
+            newTarget = Router.getTarget(req, options);
 
-        if (proxyOptions.ws === true) {
-            // use initial request to access the server object to subscribe to http upgrade event
-            _catchUpgradeRequest(req.connection.server);
+            if (newTarget) {
+                logger.system(
+                    '[Proxy] Router new target: %s -> "%s"',
+                    options.target,
+                    newTarget
+                );
+                options.target = newTarget;
+            }
         }
+    }
 
-        // function middleware(req, res, next) {
-        const proxyRes = await new Promise(resolve => {
-            if (_shouldProxy(req)) {
-                ctx.respond = false;
-                ctx.status = 302;
-                const activeProxyOptions = _prepareProxyRequest(req);
-                res._ctx = ctx;
-                res.__resolve = resolve;
+    // rewrite path
+    function __applyPathRewrite(req, pathRewriter) {
+        if (pathRewriter) {
+            const path = pathRewriter(req.url, req);
 
-                proxy.web(req, res, activeProxyOptions);
+            if (typeof path === 'string') {
+                req.url = path;
             } else {
-                resolve();
+                logger.system('pathRewrite: No rewritten path found. (%s)', req.url);
             }
-        });
-
-        if (proxyRes) {
-            res.proxyRes = proxyRes;
         }
-
-        await next();
     }
-}
 
-// Modify option.target when router present.
-function __applyRouter(req, options) {
-    let newTarget;
-
-    if (options.router) {
-        newTarget = Router.getTarget(req, options);
+    function logError(err, req /* res */) {
+        const hostname = (req.headers && req.headers.host) || (req.hostname || req.host); // (websocket) || (node0.10 || node 4/5)
+        const target = proxyOptions.target.host || proxyOptions.target;
+        const errorMessage = 'Error occurred while trying to proxy request %s from %s to %s (%s) (%s)';
+        const errReference = 'https://nodejs.org/api/errors.html#errors_common_system_errors'; // link to Node Common Systems Errors page
 
-        if (newTarget) {
-            logger.system(
-                'Router new target: %s -> "%s"',
-                options.target,
-                newTarget
-            );
-            options.target = newTarget;
-        }
+        logger.error(errorMessage, req.url, hostname, target, err.code, errReference);
     }
-}
 
-// rewrite path
-function __applyPathRewrite(req, pathRewriter) {
-    if (pathRewriter) {
-        const path = pathRewriter(req.url, req);
+    function _handleProxyResBody(proxyRes, req, res) {
+        const oriWrite = res.write;
+        const oriEnd = res.end;
 
-        if (typeof path === 'string') {
-            req.url = path;
-        } else {
-            logger.system('pathRewrite: No rewritten path found. (%s)', req.url);
+        const proxyBody = proxyOptions.proxyBody;
+        if (proxyBody) {
+            const ctx = res._ctx;
+            const jsonStrings = [];
+            Object.assign(res, {
+                write(chunk) {
+                    jsonStrings.push(chunk);
+                    oriWrite.apply(res, arguments);
+                },
+                end() {
+                    let buffer = jsonStrings.join();
+                    try {
+                        if (isFunction(proxyBody)) {
+                            const oriJSONRes = JSON.parse(buffer.toString());
+                            const handledJSONRes = proxyBody(oriJSONRes, proxyRes, req, res, ctx);
+                            buffer = new Buffer(JSON.stringify(handledJSONRes)); // 一定要转成buffer，buffer长度和string长度不一样
+                        } else {
+                            ctx.body = JSON.parse(buffer.toString());
+                        }
+                    } catch (error) {
+                        logger.warn(error);
+                    }
+                    oriEnd.apply(res, arguments);
+                },
+            });
+        }
+        if (res._resolve && isFunction(res._resolve)) {
+            res._resolve(proxyRes);
         }
     }
 }
-
-module.exports = PROXY;
diff --git a/lib/handlers.js b/lib/handlers.js
@@ -30,7 +30,7 @@ function getProxyEventHandlers(opts) {
         // all handlers for the http-proxy events are prefixed with 'on'.
         // loop through options and try to find these handlers
         // and add them to the handlers object for subscription in init().
-        const eventName = 'on' + defaultCamelize2Str(event);
+        const eventName = utility.defaultCamelize2Str('on_' + event, 'camel');
         const fnHandler = opts[eventName];
 
         if (isFunction(fnHandler)) {
@@ -77,9 +77,3 @@ function logClose(/* req, socket, head */) {
     // view disconnected websocket connections
     logger.system('Client disconnected');
 }
-
-function defaultCamelize2Str(str) {
-    let first = str[0];
-    first = first.toLowerCase();
-    return first + str.substring(1);
-}
diff --git a/lib/router.js b/lib/router.js
@@ -1,6 +1,6 @@
 'use strict';
 
-const utility = require('2o3t-utility');
+const _ = require('lodash');
 const logger = require('./logger');
 
 module.exports = {
@@ -11,9 +11,9 @@ function getTarget(req, config) {
     let newTarget;
     const router = config.router;
 
-    if (utility.isPlainObject(router)) {
+    if (_.isPlainObject(router)) {
         newTarget = getTargetFromProxyTable(req, router);
-    } else if (utility.isFunction(router)) {
+    } else if (_.isFunction(router)) {
         newTarget = router(req);
     }
 
@@ -27,7 +27,7 @@ function getTargetFromProxyTable(req, table) {
 
     const hostAndPath = host + path;
 
-    utility.forIn(table, function(value, key) {
+    _.forIn(table, function(value, key) {
         if (containsPath(key)) {
             if (hostAndPath.indexOf(key) > -1) {
                 // match 'localhost:3000/api'
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@2o3t/koa2-proxy-middleware",
-    "version": "0.0.3",
+    "version": "0.0.4",
     "description": "http proxy middleware for koa2",
     "main": "index.js",
     "scripts": {

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@2o3t/koa2-proxy-middleware",`
`3`		`- "version": "0.0.3",`
	`3`	`+ "version": "0.0.4",`
`4`	`4`	`"description": "http proxy middleware for koa2",`
`5`	`5`	`"main": "index.js",`
`6`	`6`	`"scripts": {`