http-proxy-middleware 0.20.0 → 0.21.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [v0.21.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.21.0)
+
+- feat(http-proxy): bump to v1.18.0
+- feat: async router ([#379](https://github.com/chimurai/http-proxy-middleware/issues/335)) ([LiranBri](https://github.com/LiranBri))
+- feat(typescript): types support ([#369](https://github.com/chimurai/http-proxy-middleware/pull/369))
+- feat: async pathRewrite ([#397](https://github.com/chimurai/http-proxy-middleware/pull/397)) ([rsethc](https://github.com/rsethc))
+
 ## [v0.20.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.20.0)
 
 - fix(ws): concurrent websocket requests do not get upgraded ([#335](https://github.com/chimurai/http-proxy-middleware/issues/335))

package/README.md

@@ -199,6 +199,14 @@ Providing an alternative way to decide which requests should be proxied; In case
 
   // custom rewriting
   pathRewrite: function (path, req) { return path.replace('/api', '/base/api') }
+
+  // custom rewriting, returning Promise
+  pathRewrite: async function (path, req) {
+    var should_add_something = await httpRequestToDecideSomething(path);
+    if (should_add_something) path += "something";
+    return path;
+  }
+
   ```
 
 - **option.router**: object/function, re-target `option.target` for specific requests.
@@ -217,6 +225,12 @@ Providing an alternative way to decide which requests should be proxied; In case
   router: function(req) {
       return 'http://localhost:8004';
   }
+
+  // Asynchronous router function which returns promise
+  router: async function(req) {
+      const url = await doSomeIO();
+      return url;
+  }
   ```
 
 - **option.logLevel**: string, ['debug', 'info', 'warn', 'error', 'silent']. Default: `'info'`
@@ -234,7 +248,7 @@ Providing an alternative way to decide which requests should be proxied; In case
   ```javascript
   // verbose replacement
   function logProvider(provider) {
-    var logger = new (require('winston')).Logger();
+    var logger = new (require('winston').Logger)();
 
     var myCustomProvider = {
       log: logger.log,
@@ -495,4 +509,4 @@ $ yarn cover
 
 The MIT License (MIT)
 
-Copyright (c) 2015-2019 Steven Chim
+Copyright (c) 2015-2020 Steven Chim

package/dist/config-factory.d.ts

@@ -0,0 +1,5 @@
+import { Options } from './types';
+export declare function createConfig(context: any, opts?: any): {
+    context: any;
+    options: Options;
+};

package/dist/config-factory.js

@@ -1,7 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const _ = require("lodash");
-const url = require("url");
+const lodash_1 = __importDefault(require("lodash"));
+const url_1 = __importDefault(require("url"));
 const errors_1 = require("./errors");
 const logger_1 = require("./logger");
 const logger = logger_1.getInstance();
@@ -14,15 +17,15 @@ function createConfig(context, opts) {
     // app.use('/api', proxy({target:'http://localhost:9000'}));
     if (isContextless(context, opts)) {
         config.context = '/';
-        config.options = _.assign(config.options, context);
+        config.options = lodash_1.default.assign(config.options, context);
         // app.use('/api', proxy('http://localhost:9000'));
         // app.use(proxy('http://localhost:9000/api'));
     }
     else if (isStringShortHand(context)) {
-        const oUrl = url.parse(context);
+        const oUrl = url_1.default.parse(context);
         const target = [oUrl.protocol, '//', oUrl.host].join('');
         config.context = oUrl.pathname || '/';
-        config.options = _.assign(config.options, { target }, opts);
+        config.options = lodash_1.default.assign(config.options, { target }, opts);
         if (oUrl.protocol === 'ws:' || oUrl.protocol === 'wss:') {
             config.options.ws = true;
         }
@@ -30,7 +33,7 @@ function createConfig(context, opts) {
     }
     else {
         config.context = context;
-        config.options = _.assign(config.options, opts);
+        config.options = lodash_1.default.assign(config.options, opts);
     }
     configureLogger(config.options);
     if (!config.options.target) {
@@ -51,8 +54,8 @@ exports.createConfig = createConfig;
  * @return {Boolean}         [description]
  */
 function isStringShortHand(context) {
-    if (_.isString(context)) {
-        return !!url.parse(context).host;
+    if (lodash_1.default.isString(context)) {
+        return !!url_1.default.parse(context).host;
     }
 }
 /**
@@ -67,7 +70,7 @@ function isStringShortHand(context) {
  * @return {Boolean}         [description]
  */
 function isContextless(context, opts) {
-    return _.isPlainObject(context) && _.isEmpty(opts);
+    return lodash_1.default.isPlainObject(context) && lodash_1.default.isEmpty(opts);
 }
 function configureLogger(options) {
     if (options.logLevel) {

package/dist/context-matcher.d.ts

@@ -0,0 +1 @@
+export declare function match(context: any, uri: any, req: any): any;

package/dist/context-matcher.js

@@ -1,9 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const isGlob = require("is-glob");
-const _ = require("lodash");
-const micromatch = require("micromatch");
-const url = require("url");
+const is_glob_1 = __importDefault(require("is-glob"));
+const lodash_1 = __importDefault(require("lodash"));
+const micromatch_1 = __importDefault(require("micromatch"));
+const url_1 = __importDefault(require("url"));
 const errors_1 = require("./errors");
 function match(context, uri, req) {
     // single path
@@ -25,7 +28,7 @@ function match(context, uri, req) {
         throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_INVALID_ARRAY);
     }
     // custom matching
-    if (_.isFunction(context)) {
+    if (lodash_1.default.isFunction(context)) {
         const pathname = getUrlPathName(uri);
         return context(pathname, req);
     }
@@ -43,7 +46,7 @@ function matchSingleStringPath(context, uri) {
 }
 function matchSingleGlobPath(pattern, uri) {
     const pathname = getUrlPathName(uri);
-    const matches = micromatch([pathname], pattern);
+    const matches = micromatch_1.default([pathname], pattern);
     return matches && matches.length > 0;
 }
 function matchMultiGlobPath(patternList, uri) {
@@ -71,11 +74,11 @@ function matchMultiPath(contextList, uri) {
  * @return {String}     RFC 3986 path
  */
 function getUrlPathName(uri) {
-    return uri && url.parse(uri).pathname;
+    return uri && url_1.default.parse(uri).pathname;
 }
 function isStringPath(context) {
-    return _.isString(context) && !isGlob(context);
+    return lodash_1.default.isString(context) && !is_glob_1.default(context);
 }
 function isGlobPath(context) {
-    return isGlob(context);
+    return is_glob_1.default(context);
 }

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+export declare enum ERRORS {
+    ERR_CONFIG_FACTORY_TARGET_MISSING = "[HPM] Missing \"target\" option. Example: {target: \"http://www.example.org\"}",
+    ERR_CONTEXT_MATCHER_GENERIC = "[HPM] Invalid context. Expecting something like: \"/api\" or [\"/api\", \"/ajax\"]",
+    ERR_CONTEXT_MATCHER_INVALID_ARRAY = "[HPM] Invalid context. Expecting something like: [\"/api\", \"/ajax\"] or [\"/api/**\", \"!**.html\"]",
+    ERR_PATH_REWRITER_CONFIG = "[HPM] Invalid pathRewrite config. Expecting object with pathRewrite config or a rewrite function"
+}

package/dist/handlers.d.ts

@@ -0,0 +1,2 @@
+export declare function init(proxy: any, option: any): void;
+export declare function getHandlers(options: any): any;

package/dist/handlers.js

@@ -1,6 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const _ = require("lodash");
+const lodash_1 = __importDefault(require("lodash"));
 const logger_1 = require("./logger");
 const logger = logger_1.getInstance();
 function init(proxy, option) {
@@ -26,18 +29,18 @@ function getHandlers(options) {
         // 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 = _.camelCase('on ' + event);
-        const fnHandler = _.get(options, eventName);
-        if (_.isFunction(fnHandler)) {
+        const eventName = lodash_1.default.camelCase('on ' + event);
+        const fnHandler = lodash_1.default.get(options, eventName);
+        if (lodash_1.default.isFunction(fnHandler)) {
             handlers[event] = fnHandler;
         }
     }
     // add default error handler in absence of error handler
-    if (!_.isFunction(handlers.error)) {
+    if (!lodash_1.default.isFunction(handlers.error)) {
         handlers.error = defaultErrorHandler;
     }
     // add default close handler in absence of close handler
-    if (!_.isFunction(handlers.close)) {
+    if (!lodash_1.default.isFunction(handlers.close)) {
         handlers.close = logClose;
     }
     return handlers;

package/dist/http-proxy-middleware.d.ts

@@ -0,0 +1,34 @@
+import { Filter, IRequestHandler, Options } from './types';
+export declare class HttpProxyMiddleware {
+    private logger;
+    private config;
+    private wsInternalSubscribed;
+    private proxyOptions;
+    private proxy;
+    private pathRewriter;
+    constructor(context: Filter | Options, opts?: Options);
+    middleware: IRequestHandler;
+    private catchUpgradeRequest;
+    private handleUpgrade;
+    /**
+     * Determine whether request should be proxied.
+     *
+     * @private
+     * @param  {String} context [description]
+     * @param  {Object} req     [description]
+     * @return {Boolean}
+     */
+    private shouldProxy;
+    /**
+     * 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
+     * @return {Object} proxy options
+     */
+    private prepareProxyRequest;
+    private applyRouter;
+    private applyPathRewrite;
+    private logError;
+}

package/dist/http-proxy-middleware.js

@@ -1,21 +1,32 @@
 "use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const httpProxy = require("http-proxy");
-const _ = require("lodash");
+const http_proxy_1 = __importDefault(require("http-proxy"));
+const lodash_1 = __importDefault(require("lodash"));
 const config_factory_1 = require("./config-factory");
-const contextMatcher = require("./context-matcher");
-const handlers = require("./handlers");
+const contextMatcher = __importStar(require("./context-matcher"));
+const handlers = __importStar(require("./handlers"));
 const logger_1 = require("./logger");
-const PathRewriter = require("./path-rewriter");
-const Router = require("./router");
+const PathRewriter = __importStar(require("./path-rewriter"));
+const Router = __importStar(require("./router"));
 class HttpProxyMiddleware {
     constructor(context, opts) {
         this.logger = logger_1.getInstance();
@@ -23,7 +34,7 @@ class HttpProxyMiddleware {
         // https://github.com/Microsoft/TypeScript/wiki/'this'-in-TypeScript#red-flags-for-this
         this.middleware = (req, res, next) => __awaiter(this, void 0, void 0, function* () {
             if (this.shouldProxy(this.config.context, req)) {
-                const activeProxyOptions = this.prepareProxyRequest(req);
+                const activeProxyOptions = yield this.prepareProxyRequest(req);
                 this.proxy.web(req, res, activeProxyOptions);
             }
             else {
@@ -42,13 +53,13 @@ class HttpProxyMiddleware {
                 this.wsInternalSubscribed = true;
             }
         };
-        this.handleUpgrade = (req, socket, head) => {
+        this.handleUpgrade = (req, socket, head) => __awaiter(this, void 0, void 0, function* () {
             if (this.shouldProxy(this.config.context, req)) {
-                const activeProxyOptions = this.prepareProxyRequest(req);
+                const activeProxyOptions = yield this.prepareProxyRequest(req);
                 this.proxy.ws(req, socket, head, activeProxyOptions);
                 this.logger.info('[HPM] Upgrading to WebSocket');
             }
-        };
+        });
         /**
          * Determine whether request should be proxied.
          *
@@ -69,40 +80,40 @@ class HttpProxyMiddleware {
          * @param {Object} req
          * @return {Object} proxy options
          */
-        this.prepareProxyRequest = req => {
+        this.prepareProxyRequest = (req) => __awaiter(this, void 0, void 0, function* () {
             // https://github.com/chimurai/http-proxy-middleware/issues/17
             // https://github.com/chimurai/http-proxy-middleware/issues/94
             req.url = req.originalUrl || req.url;
             // store uri before it gets rewritten for logging
             const originalPath = req.url;
-            const newProxyOptions = _.assign({}, this.proxyOptions);
+            const newProxyOptions = lodash_1.default.assign({}, this.proxyOptions);
             // Apply in order:
             // 1. option.router
             // 2. option.pathRewrite
-            this.applyRouter(req, newProxyOptions);
-            this.applyPathRewrite(req, this.pathRewriter);
+            yield this.applyRouter(req, newProxyOptions);
+            yield this.applyPathRewrite(req, this.pathRewriter);
             // debug logging for both http(s) and websockets
             if (this.proxyOptions.logLevel === 'debug') {
                 const arrow = logger_1.getArrow(originalPath, req.url, this.proxyOptions.target, newProxyOptions.target);
                 this.logger.debug('[HPM] %s %s %s %s', req.method, originalPath, arrow, newProxyOptions.target);
             }
             return newProxyOptions;
-        };
+        });
         // Modify option.target when router present.
-        this.applyRouter = (req, options) => {
+        this.applyRouter = (req, options) => __awaiter(this, void 0, void 0, function* () {
             let newTarget;
             if (options.router) {
-                newTarget = Router.getTarget(req, options);
+                newTarget = yield Router.getTarget(req, options);
                 if (newTarget) {
                     this.logger.debug('[HPM] Router new target: %s -> "%s"', options.target, newTarget);
                     options.target = newTarget;
                 }
             }
-        };
+        });
         // rewrite path
-        this.applyPathRewrite = (req, pathRewriter) => {
+        this.applyPathRewrite = (req, pathRewriter) => __awaiter(this, void 0, void 0, function* () {
             if (pathRewriter) {
-                const path = pathRewriter(req.url, req);
+                const path = yield pathRewriter(req.url, req);
                 if (typeof path === 'string') {
                     req.url = path;
                 }
@@ -110,9 +121,9 @@ class HttpProxyMiddleware {
                     this.logger.info('[HPM] pathRewrite: No rewritten path found. (%s)', req.url);
                 }
             }
-        };
+        });
         this.logError = (err, req, res) => {
-            const hostname = (req.headers && req.headers.host) || (req.hostname || req.host); // (websocket) || (node0.10 || node 4/5)
+            const hostname = (req.headers && req.headers.host) || req.hostname || req.host; // (websocket) || (node0.10 || node 4/5)
             const target = this.proxyOptions.target.host || this.proxyOptions.target;
             const errorMessage = '[HPM] 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
@@ -121,7 +132,7 @@ class HttpProxyMiddleware {
         this.config = config_factory_1.createConfig(context, opts);
         this.proxyOptions = this.config.options;
         // create proxy
-        this.proxy = httpProxy.createProxyServer({});
+        this.proxy = http_proxy_1.default.createProxyServer({});
         this.logger.info(`[HPM] Proxy created: ${this.config.context}  -> ${this.proxyOptions.target}`);
         this.pathRewriter = PathRewriter.createPathRewriter(this.proxyOptions.pathRewrite); // returns undefined when "pathRewrite" is not provided
         // attach handler to http-proxy events

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { Filter, Options } from './types';
+declare function middleware(context: Filter | Options, options?: Options): import("./types").IRequestHandler;
+export = middleware;

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 const http_proxy_middleware_1 = require("./http-proxy-middleware");
-function proxy(context, opts) {
-    const { middleware } = new http_proxy_middleware_1.HttpProxyMiddleware(context, opts);
+function middleware(context, options) {
+    const { middleware } = new http_proxy_middleware_1.HttpProxyMiddleware(context, options);
     return middleware;
 }
-module.exports = proxy;
+module.exports = middleware;

package/dist/logger.d.ts

@@ -0,0 +1,14 @@
+export declare function getInstance(): any;
+/**
+ * -> normal proxy
+ * => router
+ * ~> pathRewrite
+ * ≈> router + pathRewrite
+ *
+ * @param  {String} originalPath
+ * @param  {String} newPath
+ * @param  {String} originalTarget
+ * @param  {String} newTarget
+ * @return {String}
+ */
+export declare function getArrow(originalPath: any, newPath: any, originalTarget: any, newTarget: any): string;

package/dist/logger.js

@@ -1,7 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const _ = require("lodash");
-const util = require("util");
+const lodash_1 = __importDefault(require("lodash"));
+const util_1 = __importDefault(require("util"));
 let loggerInstance;
 const defaultProvider = {
     // tslint:disable: no-console
@@ -68,7 +71,7 @@ class Logger {
     }
     isValidProvider(fnProvider) {
         const result = true;
-        if (fnProvider && !_.isFunction(fnProvider)) {
+        if (fnProvider && !lodash_1.default.isFunction(fnProvider)) {
             throw new Error('[HPM] Log provider config error. Expecting a function.');
         }
         return result;
@@ -97,8 +100,8 @@ class Logger {
     // make sure logged messages and its data are return interpolated
     // make it possible for additional log data, such date/time or custom prefix.
     _interpolate() {
-        const fn = _.spread(util.format);
-        const result = fn(_.slice(arguments));
+        const fn = lodash_1.default.spread(util_1.default.format);
+        const result = fn(lodash_1.default.slice(arguments));
         return result;
     }
 }

package/dist/path-rewriter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Create rewrite function, to cache parsed rewrite rules.
+ *
+ * @param {Object} rewriteConfig
+ * @return {Function} Function to rewrite paths; This function should accept `path` (request.url) as parameter
+ */
+export declare function createPathRewriter(rewriteConfig: any): (...args: any[]) => any;

package/dist/path-rewriter.js

@@ -1,6 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const _ = require("lodash");
+const lodash_1 = __importDefault(require("lodash"));
 const errors_1 = require("./errors");
 const logger_1 = require("./logger");
 const logger = logger_1.getInstance();
@@ -15,7 +18,7 @@ function createPathRewriter(rewriteConfig) {
     if (!isValidRewriteConfig(rewriteConfig)) {
         return;
     }
-    if (_.isFunction(rewriteConfig)) {
+    if (lodash_1.default.isFunction(rewriteConfig)) {
         const customRewriteFn = rewriteConfig;
         return customRewriteFn;
     }
@@ -25,7 +28,7 @@ function createPathRewriter(rewriteConfig) {
     }
     function rewritePath(path) {
         let result = path;
-        _.forEach(rulesCache, rule => {
+        lodash_1.default.forEach(rulesCache, rule => {
             if (rule.regex.test(path)) {
                 result = result.replace(rule.regex, rule.value);
                 logger.debug('[HPM] Rewriting path from "%s" to "%s"', path, result);
@@ -37,15 +40,15 @@ function createPathRewriter(rewriteConfig) {
 }
 exports.createPathRewriter = createPathRewriter;
 function isValidRewriteConfig(rewriteConfig) {
-    if (_.isFunction(rewriteConfig)) {
+    if (lodash_1.default.isFunction(rewriteConfig)) {
         return true;
     }
-    else if (!_.isEmpty(rewriteConfig) && _.isPlainObject(rewriteConfig)) {
+    else if (!lodash_1.default.isEmpty(rewriteConfig) && lodash_1.default.isPlainObject(rewriteConfig)) {
         return true;
     }
-    else if (_.isUndefined(rewriteConfig) ||
-        _.isNull(rewriteConfig) ||
-        _.isEqual(rewriteConfig, {})) {
+    else if (lodash_1.default.isUndefined(rewriteConfig) ||
+        lodash_1.default.isNull(rewriteConfig) ||
+        lodash_1.default.isEqual(rewriteConfig, {})) {
         return false;
     }
     else {
@@ -54,8 +57,8 @@ function isValidRewriteConfig(rewriteConfig) {
 }
 function parsePathRewriteRules(rewriteConfig) {
     const rules = [];
-    if (_.isPlainObject(rewriteConfig)) {
-        _.forIn(rewriteConfig, (value, key) => {
+    if (lodash_1.default.isPlainObject(rewriteConfig)) {
+        lodash_1.default.forIn(rewriteConfig, (value, key) => {
             rules.push({
                 regex: new RegExp(key),
                 value: rewriteConfig[key]

package/dist/router.d.ts

@@ -0,0 +1 @@
+export declare function getTarget(req: any, config: any): Promise<any>;

package/dist/router.js

@@ -1,18 +1,32 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const _ = require("lodash");
+const lodash_1 = __importDefault(require("lodash"));
 const logger_1 = require("./logger");
 const logger = logger_1.getInstance();
 function getTarget(req, config) {
-    let newTarget;
-    const router = config.router;
-    if (_.isPlainObject(router)) {
-        newTarget = getTargetFromProxyTable(req, router);
-    }
-    else if (_.isFunction(router)) {
-        newTarget = router(req);
-    }
-    return newTarget;
+    return __awaiter(this, void 0, void 0, function* () {
+        let newTarget;
+        const router = config.router;
+        if (lodash_1.default.isPlainObject(router)) {
+            newTarget = getTargetFromProxyTable(req, router);
+        }
+        else if (lodash_1.default.isFunction(router)) {
+            newTarget = yield router(req);
+        }
+        return newTarget;
+    });
 }
 exports.getTarget = getTarget;
 function getTargetFromProxyTable(req, table) {
@@ -20,7 +34,7 @@ function getTargetFromProxyTable(req, table) {
     const host = req.headers.host;
     const path = req.url;
     const hostAndPath = host + path;
-    _.forIn(table, (value, key) => {
+    lodash_1.default.forIn(table, (value, key) => {
         if (containsPath(key)) {
             if (hostAndPath.indexOf(key) > -1) {
                 // match 'localhost:3000/api'

package/dist/types.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import express from 'express';
+import http from 'http';
+import httpProxy from 'http-proxy';
+import net from 'net';
+export interface IRequest extends express.Request {
+}
+export interface IResponse extends express.Response {
+}
+export interface IRequestHandler extends express.RequestHandler {
+    upgrade?: (req: IRequest, socket: net.Socket, head: any) => void;
+}
+export declare type Filter = string | string[] | ((pathname: string, req: IRequest) => boolean);
+export interface Options extends httpProxy.ServerOptions {
+    pathRewrite?: {
+        [regexp: string]: string;
+    } | ((path: string, req: IRequest) => string) | ((path: string, req: IRequest) => Promise<string>);
+    router?: {
+        [hostOrPath: string]: string;
+    } | ((req: IRequest) => string) | ((req: IRequest) => Promise<string>);
+    logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent';
+    logProvider?(provider: LogProvider): LogProvider;
+    onError?(err: Error, req: IRequest, res: IResponse): void;
+    onProxyRes?(proxyRes: http.ServerResponse, req: IRequest, res: IResponse): void;
+    onProxyReq?(proxyReq: http.ClientRequest, req: IRequest, res: IResponse): void;
+    onProxyReqWs?(proxyReq: http.ClientRequest, req: IRequest, socket: net.Socket, options: httpProxy.ServerOptions, head: any): void;
+    onOpen?(proxySocket: net.Socket): void;
+    onClose?(res: IResponse, socket: net.Socket, head: any): void;
+}
+interface LogProvider {
+    log: Logger;
+    debug?: Logger;
+    info?: Logger;
+    warn?: Logger;
+    error?: Logger;
+}
+declare type Logger = (...args: any[]) => void;
+export {};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "http-proxy-middleware",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "The one-liner node.js proxy middleware for connect, express and browser-sync",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
@@ -51,30 +52,30 @@
     "@commitlint/cli": "^8.0.0",
     "@commitlint/config-conventional": "^8.0.0",
     "@types/express": "^4.17.0",
-    "@types/http-proxy": "^1.17.0",
     "@types/is-glob": "^4.0.0",
-    "@types/jest": "^24.0.15",
-    "@types/lodash": "^4.14.136",
-    "@types/micromatch": "^3.1.0",
+    "@types/jest": "^25.1.2",
+    "@types/lodash": "^4.14.149",
+    "@types/micromatch": "^4.0.1",
     "@types/node": "^12.6.2",
     "browser-sync": "^2.26.7",
     "connect": "^3.6.6",
     "coveralls": "^3.0.5",
     "express": "^4.16.4",
     "husky": "^3.0.0",
-    "jest": "^24.5.0",
-    "open": "^6.4.0",
-    "prettier": "^1.18.2",
-    "ts-jest": "^24.0.0",
-    "tslint": "^5.18.0",
+    "jest": "^25.1.0",
+    "open": "^7.0.2",
+    "prettier": "^1.19.1",
+    "ts-jest": "^25.2.0",
+    "tslint": "^6.0.0",
     "tslint-config-prettier": "^1.18.0",
-    "typescript": "^3.5.3",
+    "typescript": "^3.7.5",
     "ws": "^7.1.0"
   },
   "dependencies": {
-    "http-proxy": "^1.17.0",
+    "@types/http-proxy": "^1.17.3",
+    "http-proxy": "^1.18.0",
     "is-glob": "^4.0.1",
-    "lodash": "^4.17.14",
+    "lodash": "^4.17.15",
     "micromatch": "^4.0.2"
   },
   "engines": {