feat: router (chimurai#85)

* feat(router): deprecate and rename `proxyTable` option to `router`

* feat(router): support for custom `router` function

* chore(router): add e2e router test

* docs: router

Author: chimurai

CHANGELOG.md

@@ -1,7 +1,11 @@
 # Changelog
 
+## [develop](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.16.0)
+- feat(router): support for custom `router` function.
+- feat(router): deprecate and renamed `proxyTable` option to `router`.
+
 ## [v0.15.2](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.15.2)
-- fix(websocket): fixes websocket upgrade
+- fix(websocket): fixes websocket upgrade.
 
 ## [v0.15.1](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.15.1)
 - feat(pathRewrite): expose `req` object to pathRewrite function.

README.md

@@ -179,14 +179,21 @@ Providing an alternative way to decide which requests should be proxied; In case
     pathRewrite: function (path, req) { return path.replace('/api', '/base/api') }
     ```
 
-* **option.proxyTable**: object, re-target `option.target` based on the request header `host` parameter. `host` can be used in conjunction with `path`. Only one instance of the proxy will be used. The order of the configuration matters.
+* **option.router**: object/function, re-target `option.target` for specific requests.
     ```javascript
-    proxyTable: {
+    // Use `host` and/or `path` to match requests. First match will be used.
+    // The order of the configuration matters.
+    router: {
         'integration.localhost:3000' : 'http://localhost:8001',  // host only
         'staging.localhost:3000'     : 'http://localhost:8002',  // host only
         'localhost:3000/api'         : 'http://localhost:8003',  // host + path
         '/rest'                      : 'http://localhost:8004'   // path only
     }
+
+    // Custom router function
+    router: function(req) {
+        return 'http://localhost:8004';
+    }
     ```
 
 *  **option.logLevel**: string, ['debug', 'info', 'warn', 'error', 'silent']. Default: `'info'`
@@ -216,6 +223,7 @@ Providing an alternative way to decide which requests should be proxied; In case
     }
     ```
 * (DEPRECATED) **option.proxyHost**: Use `option.changeOrigin = true` instead.
+* (DEPRECATED) **option.proxyTable**: Use `option.router` instead.
 
 
 ### http-proxy events

lib/config-factory.js

@@ -45,6 +45,9 @@ function createConfig(context, opts) {
     // Legacy option.proxyHost
     config.options = mapLegacyProxyHostOption(config.options);
 
+    // Legacy option.proxyTable > option.router
+    config.options = mapLegacyProxyTableOption(config.options);
+
     return config;
 }
 
@@ -96,6 +99,22 @@ function mapLegacyProxyHostOption(options) {
     return options;
 }
 
+// Warn deprecated proxyTable api usage
+function mapLegacyProxyTableOption(options) {
+    if (options.proxyTable) {
+        logger.warn('*************************************');
+        logger.warn('[HPM] Deprecated "option.proxyTable"');
+        logger.warn('      Use "option.router" instead');
+        logger.warn('      "option.proxyTable" will be removed in future release.');
+        logger.warn('*************************************');
+
+        options.router = _.clone(options.proxyTable);
+        _.omit(options, 'proxyTable');
+    }
+
+    return options;
+}
+
 function configureLogger(options) {
     if (options.logLevel) {
         logger.setLevel(options.logLevel);

lib/index.js

@@ -4,7 +4,7 @@ var configFactory  = require('./config-factory');
 var handlers       = require('./handlers');
 var contextMatcher = require('./context-matcher');
 var PathRewriter   = require('./path-rewriter');
-var ProxyTable     = require('./proxy-table');
+var Router         = require('./router');
 var logger         = require('./logger').getInstance();
 var getArrow       = require('./logger').getArrow;
 
@@ -17,7 +17,7 @@ function HttpProxyMiddleware(context, opts) {
     var proxyOptions        = config.options;
 
     // create proxy
-    var proxy = httpProxy.createProxyServer(proxyOptions);
+    var proxy = httpProxy.createProxyServer({});
     logger.info('[HPM] Proxy created:', config.context, ' -> ', proxyOptions.target);
 
     var pathRewriter = PathRewriter.create(proxyOptions.pathRewrite); // returns undefined when "pathRewrite" is not provided
@@ -63,44 +63,47 @@ function HttpProxyMiddleware(context, opts) {
     }
 
     /**
-     * Apply option.proxyTable and option.pathRewrite
+     * Apply option.router and option.pathRewrite
      * Order matters:
-          ProxyTable uses original path for routing;
+          Router uses original path for routing;
           NOT the modified path, after it has been rewritten by pathRewrite
      */
     function prepareProxyRequest(req) {
         // store uri before it gets rewritten for logging
         var originalPath = req.url;
+        var newProxyOptions = _.cloneDeep(proxyOptions);
 
         // Apply in order:
-        // 1. option.proxyTable
+        // 1. option.router
         // 2. option.pathRewrite
-        var alteredProxyOptions = __applyProxyTableOption(req, proxyOptions);
-        __applyPathRewrite(pathRewriter, req);
+        __applyRouter(req, newProxyOptions);
+        __applyPathRewrite(req, pathRewriter);
 
         // debug logging for both http(s) and websockets
         if (proxyOptions.logLevel === 'debug') {
-            var arrow = getArrow(originalPath, req.url, proxyOptions.target, alteredProxyOptions.target);
-            logger.debug('[HPM] %s %s %s %s', req.method, originalPath, arrow, alteredProxyOptions.target);
+            var arrow = getArrow(originalPath, req.url, proxyOptions.target, newProxyOptions.target);
+            logger.debug('[HPM] %s %s %s %s', req.method, originalPath, arrow, newProxyOptions.target);
         }
 
-        return alteredProxyOptions;
+        return newProxyOptions;
     }
 
-    // Modify option.target when proxyTable present.
-    // return altered options
-    function __applyProxyTableOption(req) {
-        var result = proxyOptions;
+    // Modify option.target when router present.
+    function __applyRouter(req, options) {
+        var newTarget;
 
-        if (proxyOptions.proxyTable) {
-            result = ProxyTable.createProxyOptions(req, proxyOptions);
-        }
+        if (options.router) {
+            newTarget = Router.getTarget(req, options);
 
-        return result;
+            if (newTarget) {
+                logger.debug('[HPM] Router new target: %s -> "%s"', options.target, newTarget);
+                options.target = newTarget;
+            }
+        }
     }
 
     // rewrite path
-    function __applyPathRewrite(pathRewriter, req) {
+    function __applyPathRewrite(req, pathRewriter) {
         if (pathRewriter) {
             var path = pathRewriter(req.url, req);
 

lib/logger.js

@@ -149,7 +149,7 @@ function Logger() {
  */
 function getArrow(originalPath, newPath, originalTarget, newTarget) {
     var arrow = ['>'];
-    var isNewTarget = (originalTarget !== newTarget); // proxyTable
+    var isNewTarget = (originalTarget !== newTarget); // router
     var isNewPath = (originalPath !== newPath); // pathRewrite
 
     if (isNewPath && !isNewTarget) {arrow.unshift('~');} else if (!isNewPath && isNewTarget) {arrow.unshift('=');} else if (isNewPath && isNewTarget) {arrow.unshift('≈');} else {arrow.unshift('-');}

lib/proxy-table.js

@@ -0,0 +1,53 @@
+var _      = require('lodash');
+var logger = require('./logger.js').getInstance();
+
+module.exports = {
+    getTarget: getTarget
+};
+
+function getTarget(req, config) {
+    var newTarget;
+    var router = config.router;
+
+    if (_.isPlainObject(router)) {
+        newTarget = getTargetFromProxyTable(req, router);
+    } else if (_.isFunction(router)) {
+        newTarget = router(req);
+    }
+
+    return newTarget;
+}
+
+function getTargetFromProxyTable(req, table) {
+    var result;
+    var host = req.headers.host;
+    var path = req.url;
+
+    var hostAndPath = host + path;
+
+    _.forIn(table, function(value, key) {
+        if (containsPath(key)) {
+
+            if (hostAndPath.indexOf(key) > -1) {    // match 'localhost:3000/api'
+                result = table[key];
+                logger.debug('[HPM] Router table match: "%s"', key);
+                return false;
+            }
+        } else {
+
+            if (key === host) {                     // match 'localhost:3000'
+                result = table[key];
+                logger.debug('[HPM] Router table match: "%s"', host);
+                return false;
+            }
+
+        }
+
+    });
+
+    return result;
+}
+
+function containsPath(v) {
+    return v.indexOf('/') > -1;
+}

lib/router.js

@@ -43,7 +43,7 @@ var options = {
     },
 
     // re-target based on the request's host header and/or path
-    proxyTable: {
+    router: {
       // host[/path]                 :  <new target>
       // /path                       :  <new target>
         'integration.localhost:8000' : 'http://localhost:8001',  // host only

recipes/README.md

@@ -1,6 +1,45 @@
-# proxyTable
+# router
 
-Use the Proxy Table to proxy requests to a different target based on:
+Allows you to route to a different `target` by using a table of a custom function.
+
+<!-- MarkdownTOC autolink=true bracket=round -->
+
+- [Custom router function](#custom-router-function)
+- [Proxy Table](#proxy-table)
+
+<!-- /MarkdownTOC -->
+
+
+## Custom router function
+
+Write your own router to dynamically route to a different `target`.
+The `req` object is provided to retrieve contextual data.
+
+```javascript
+var express = require('express');
+var proxy = require("http-proxy-middleware");
+
+var customRouter = function(req) {
+    return 'http://www.example.org'    // protocol + host
+};
+
+var options = {
+    target: 'http://localhost:8000',
+    router: customRouter
+};
+
+var myProxy = proxy(options);
+
+var app = express();
+app.use(myProxy);                      // add the proxy to express
+
+app.listen(3000);
+```
+
+
+## Proxy Table
+
+Use a Proxy Table to proxy requests to a different `target` based on:
 * Host [HTTP header](https://en.wikipedia.org/wiki/List_of_HTTP_header_fields#Request_fields).
 * Request path
 * Host HTTP header + path
@@ -18,18 +57,18 @@ var proxyTable = {
 
 var options = {
     target: 'http://localhost:8000',
-    proxyTable: proxyTable
+    router: proxyTable
 };
 
-var myProxy = proxy('/', options);
+var myProxy = proxy(options);
 
 var app = express();
 app.use(myProxy);                      // add the proxy to express
 
 app.listen(3000);
 ```
 
-## Example
+### Example
 
 In the example above; all requests will be proxied to `http://localhost:8000`.