http-proxy-middleware 0.21.0-beta.2 → 1.0.0

package/CHANGELOG.md

@@ -1,9 +1,17 @@
 # Changelog
 
-## next
+## [v1.0.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v1.0.0)
 
-- feat: async router ([#379](https://github.com/chimurai/http-proxy-middleware/issues/335)) ([LiranBri](https://github.com/LiranBri))
+- feat(createProxyMiddleware): explicit import http-proxy-middleware (BREAKING CHANGE)([#400](https://github.com/chimurai/http-proxy-middleware/issues/400#issuecomment-587162378))
+- feat(typescript): export http-proxy-middleware types ([#400](https://github.com/chimurai/http-proxy-middleware/issues/400))
+- fix(typescript): ES6 target - TS1192 ([#400](https://github.com/chimurai/http-proxy-middleware/issues/400#issuecomment-587064349))
+
+## [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/379)) ([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)
 

package/README.md

@@ -10,20 +10,40 @@ Node.js proxying made simple. Configure proxy middleware with ease for [connect]
 
 Powered by the popular Nodejitsu [`http-proxy`](https://github.com/nodejitsu/node-http-proxy). [![GitHub stars](https://img.shields.io/github/stars/nodejitsu/node-http-proxy.svg?style=social&label=Star)](https://github.com/nodejitsu/node-http-proxy)
 
+## ⚠️ Note
+
+This page is showing documentation for version v1.x.x ([release notes](https://github.com/chimurai/http-proxy-middleware/releases))
+
+If you're looking for v0.x documentation. Go to:
+https://github.com/chimurai/http-proxy-middleware/tree/v0.21.0#readme
+
 ## TL;DR
 
 Proxy `/api` requests to `http://www.example.org`
 
 ```javascript
-var express = require('express');
-var proxy = require('http-proxy-middleware');
+// javascript
+
+const express = require('express');
+const { createProxyMiddleware } = require('http-proxy-middleware');
+
+const app = express();
+
+app.use('/api', createProxyMiddleware({ target: 'http://www.example.org', changeOrigin: true }));
+app.listen(3000);
 
-var app = express();
+// http://localhost:3000/api/foo/bar -> http://www.example.org/api/foo/bar
+```
+
+```typescript
+// typescript
+
+import * as express from 'express';
+import { createProxyMiddleware, Filter, Options, RequestHandler } from 'http-proxy-middleware';
 
-app.use(
-  '/api',
-  proxy({ target: 'http://www.example.org', changeOrigin: true })
-);
+const app = express();
+
+app.use('/api', createProxyMiddleware({ target: 'http://www.example.org', changeOrigin: true }));
 app.listen(3000);
 
 // http://localhost:3000/api/foo/bar -> http://www.example.org/api/foo/bar
@@ -60,7 +80,7 @@ _All_ `http-proxy` [options](https://github.com/nodejitsu/node-http-proxy#option
 
 ## Install
 
-```javascript
+```bash
 $ npm install --save-dev http-proxy-middleware
 ```
 
@@ -68,15 +88,15 @@ $ npm install --save-dev http-proxy-middleware
 
 Proxy middleware configuration.
 
-#### proxy([context,] config)
+#### createProxyMiddleware([context,] config)
 
 ```javascript
-var proxy = require('http-proxy-middleware');
+const { createProxyMiddleware } = require('http-proxy-middleware');
 
-var apiProxy = proxy('/api', { target: 'http://www.example.org' });
-//                   \____/   \_____________________________/
-//                     |                    |
-//                   context             options
+const apiProxy = createProxyMiddleware('/api', { target: 'http://www.example.org' });
+//                                    \____/   \_____________________________/
+//                                      |                    |
+//                                    context             options
 
 // 'apiProxy' is now ready to be used as middleware in a server.
 ```
@@ -87,11 +107,11 @@ var apiProxy = proxy('/api', { target: 'http://www.example.org' });
 
 (full list of [`http-proxy-middleware` configuration options](#options))
 
-#### proxy(uri [, config])
+#### createProxyMiddleware(uri [, config])
 
 ```javascript
 // shorthand syntax for the example above:
-var apiProxy = proxy('http://www.example.org/api');
+const apiProxy = createProxyMiddleware('http://www.example.org/api');
 ```
 
 More about the [shorthand configuration](#shorthand).
@@ -102,11 +122,11 @@ An example with `express` server.
 
 ```javascript
 // include dependencies
-var express = require('express');
-var proxy = require('http-proxy-middleware');
+const express = require('express');
+const { createProxyMiddleware } = require('http-proxy-middleware');
 
 // proxy middleware options
-var options = {
+const options = {
   target: 'http://www.example.org', // target host
   changeOrigin: true, // needed for virtual hosted sites
   ws: true, // proxy websockets
@@ -122,10 +142,10 @@ var options = {
 };
 
 // create the proxy (without context)
-var exampleProxy = proxy(options);
+const exampleProxy = createProxyMiddleware(options);
 
 // mount `exampleProxy` in web server
-var app = express();
+const app = express();
 app.use('/api', exampleProxy);
 app.listen(3000);
 ```
@@ -136,7 +156,7 @@ Providing an alternative way to decide which requests should be proxied; In case
 
 [RFC 3986 `path`](https://tools.ietf.org/html/rfc3986#section-3.3) is used for context matching.
 
-```
+```ascii
          foo://example.com:8042/over/there?name=ferret#nose
          \_/   \______________/\_________/ \_________/ \__/
           |           |            |            |        |
@@ -145,24 +165,24 @@ Providing an alternative way to decide which requests should be proxied; In case
 
 - **path matching**
 
-  - `proxy({...})` - matches any path, all requests will be proxied.
-  - `proxy('/', {...})` - matches any path, all requests will be proxied.
-  - `proxy('/api', {...})` - matches paths starting with `/api`
+  - `createProxyMiddleware({...})` - matches any path, all requests will be proxied.
+  - `createProxyMiddleware('/', {...})` - matches any path, all requests will be proxied.
+  - `createProxyMiddleware('/api', {...})` - matches paths starting with `/api`
 
 - **multiple path matching**
 
-  - `proxy(['/api', '/ajax', '/someotherpath'], {...})`
+  - `createProxyMiddleware(['/api', '/ajax', '/someotherpath'], {...})`
 
 - **wildcard path matching**
 
   For fine-grained control you can use wildcard matching. Glob pattern matching is done by _micromatch_. Visit [micromatch](https://www.npmjs.com/package/micromatch) or [glob](https://www.npmjs.com/package/glob) for more globbing examples.
 
-  - `proxy('**', {...})` matches any path, all requests will be proxied.
-  - `proxy('**/*.html', {...})` matches any path which ends with `.html`
-  - `proxy('/*.html', {...})` matches paths directly under path-absolute
-  - `proxy('/api/**/*.html', {...})` matches requests ending with `.html` in the path of `/api`
-  - `proxy(['/api/**', '/ajax/**'], {...})` combine multiple patterns
-  - `proxy(['/api/**', '!**/bad.json'], {...})` exclusion
+  - `createProxyMiddleware('**', {...})` matches any path, all requests will be proxied.
+  - `createProxyMiddleware('**/*.html', {...})` matches any path which ends with `.html`
+  - `createProxyMiddleware('/*.html', {...})` matches paths directly under path-absolute
+  - `createProxyMiddleware('/api/**/*.html', {...})` matches requests ending with `.html` in the path of `/api`
+  - `createProxyMiddleware(['/api/**', '/ajax/**'], {...})` combine multiple patterns
+  - `createProxyMiddleware(['/api/**', '!**/bad.json'], {...})` exclusion
 
   **Note**: In multiple path matching, you cannot use string paths and wildcard paths together.
 
@@ -174,11 +194,13 @@ Providing an alternative way to decide which requests should be proxied; In case
   /**
    * @return {Boolean}
    */
-  var filter = function(pathname, req) {
+  const filter = function(pathname, req) {
     return pathname.match('^/api') && req.method === 'GET';
   };
 
-  var apiProxy = proxy(filter, { target: 'http://www.example.org' });
+  const apiProxy = createProxyMiddleware(filter, {
+    target: 'http://www.example.org'
+  });
   ```
 
 ## Options
@@ -199,6 +221,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) {
+    const 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.
@@ -240,9 +270,9 @@ 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();
+    const logger = new (require('winston').Logger)();
 
-    var myCustomProvider = {
+    const myCustomProvider = {
       log: logger.log,
       debug: logger.debug,
       info: logger.info,
@@ -264,9 +294,7 @@ Subscribe to [http-proxy events](https://github.com/nodejitsu/node-http-proxy#li
     res.writeHead(500, {
       'Content-Type': 'text/plain'
     });
-    res.end(
-      'Something went wrong. And we are reporting a custom error message.'
-    );
+    res.end('Something went wrong. And we are reporting a custom error message.');
   }
   ```
 
@@ -308,6 +336,7 @@ Subscribe to [http-proxy events](https://github.com/nodejitsu/node-http-proxy#li
   ```
 
 - **option.onClose**: function, subscribe to http-proxy's `close` event.
+
   ```javascript
   function onClose(res, socket, head) {
     // view disconnected websocket connections
@@ -341,7 +370,7 @@ The following options are provided by the underlying [http-proxy](https://github
   - String: new domain, for example `cookieDomainRewrite: "new.domain"`. To remove the domain, use `cookieDomainRewrite: ""`.
   - Object: mapping of domains to new domains, use `"*"` to match all domains.  
     For example keep one domain unchanged, rewrite one domain and remove other domains:
-    ```
+    ```json
     cookieDomainRewrite: {
       "unchanged.domain": "unchanged.domain",
       "old.domain": "new.domain",
@@ -353,7 +382,7 @@ The following options are provided by the underlying [http-proxy](https://github
   - String: new path, for example `cookiePathRewrite: "/newPath/"`. To remove the path, use `cookiePathRewrite: ""`. To set path to root use `cookiePathRewrite: "/"`.
   - Object: mapping of paths to new paths, use `"*"` to match all paths.
     For example, to keep one path unchanged, rewrite one path and remove other paths:
-    ```
+    ```json
     cookiePathRewrite: {
       "/unchanged.path/": "/unchanged.path/",
       "/old.path/": "/new.path/",
@@ -367,7 +396,7 @@ The following options are provided by the underlying [http-proxy](https://github
 - **option.selfHandleResponse** true/false, if set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the `proxyRes` event
 - **option.buffer**: stream of data to send as the request body. Maybe you have some middleware that consumes the request stream before proxying it on e.g. If you read the body of a request into a field called 'req.rawbody' you could restream this field in the buffer option:
 
-  ```
+  ```javascript
   'use strict';
 
   const streamify = require('stream-array');
@@ -375,12 +404,15 @@ The following options are provided by the underlying [http-proxy](https://github
   const proxy = new HttpProxy();
 
   module.exports = (req, res, next) => {
-
-    proxy.web(req, res, {
-      target: 'http://localhost:4003/',
-      buffer: streamify(req.rawBody)
-    }, next);
-
+    proxy.web(
+      req,
+      res,
+      {
+        target: 'http://localhost:4003/',
+        buffer: streamify(req.rawBody)
+      },
+      next
+    );
   };
   ```
 
@@ -389,14 +421,14 @@ The following options are provided by the underlying [http-proxy](https://github
 Use the shorthand syntax when verbose configuration is not needed. The `context` and `option.target` will be automatically configured when shorthand is used. Options can still be used if needed.
 
 ```javascript
-proxy('http://www.example.org:8000/api');
-// proxy('/api', {target: 'http://www.example.org:8000'});
+createProxyMiddleware('http://www.example.org:8000/api');
+// createProxyMiddleware('/api', {target: 'http://www.example.org:8000'});
 
-proxy('http://www.example.org:8000/api/books/*/**.json');
-// proxy('/api/books/*/**.json', {target: 'http://www.example.org:8000'});
+createProxyMiddleware('http://www.example.org:8000/api/books/*/**.json');
+// createProxyMiddleware('/api/books/*/**.json', {target: 'http://www.example.org:8000'});
 
-proxy('http://www.example.org:8000/api', { changeOrigin: true });
-// proxy('/api', {target: 'http://www.example.org:8000', changeOrigin: true});
+createProxyMiddleware('http://www.example.org:8000/api', { changeOrigin: true });
+// createProxyMiddleware('/api', {target: 'http://www.example.org:8000', changeOrigin: true});
 ```
 
 ### app.use(path, proxy)
@@ -405,28 +437,26 @@ If you want to use the server's `app.use` `path` parameter to match requests;
 Create and mount the proxy without the http-proxy-middleware `context` parameter:
 
 ```javascript
-app.use(
-  '/api',
-  proxy({ target: 'http://www.example.org', changeOrigin: true })
-);
+app.use('/api', createProxyMiddleware({ target: 'http://www.example.org', changeOrigin: true }));
 ```
 
 `app.use` documentation:
 
 - express: http://expressjs.com/en/4x/api.html#app.use
 - connect: https://github.com/senchalabs/connect#mount-middleware
+- polka: https://github.com/lukeed/polka#usebase-fn
 
 ## WebSocket
 
 ```javascript
 // verbose api
-proxy('/', { target: 'http://echo.websocket.org', ws: true });
+createProxyMiddleware('/', { target: 'http://echo.websocket.org', ws: true });
 
 // shorthand
-proxy('http://echo.websocket.org', { ws: true });
+createProxyMiddleware('http://echo.websocket.org', { ws: true });
 
 // shorter shorthand
-proxy('ws://echo.websocket.org');
+createProxyMiddleware('ws://echo.websocket.org');
 ```
 
 ### External WebSocket upgrade
@@ -434,12 +464,12 @@ proxy('ws://echo.websocket.org');
 In the previous WebSocket examples, http-proxy-middleware relies on a initial http request in order to listen to the http `upgrade` event. If you need to proxy WebSockets without the initial http request, you can subscribe to the server's http `upgrade` event manually.
 
 ```javascript
-var wsProxy = proxy('ws://echo.websocket.org', { changeOrigin: true });
+const wsProxy = createProxyMiddleware('ws://echo.websocket.org', { changeOrigin: true });
 
-var app = express();
+const app = express();
 app.use(wsProxy);
 
-var server = app.listen(3000);
+const server = app.listen(3000);
 server.on('upgrade', wsProxy.upgrade); // <-- subscribe to http 'upgrade'
 ```
 
@@ -464,6 +494,7 @@ View the [recipes](https://github.com/chimurai/http-proxy-middleware/tree/master
 - [express](https://www.npmjs.com/package/express)
 - [browser-sync](https://www.npmjs.com/package/browser-sync)
 - [lite-server](https://www.npmjs.com/package/lite-server)
+- [polka](https://github.com/lukeed/polka)
 - [grunt-contrib-connect](https://www.npmjs.com/package/grunt-contrib-connect)
 - [grunt-browser-sync](https://www.npmjs.com/package/grunt-browser-sync)
 - [gulp-connect](https://www.npmjs.com/package/gulp-connect)
@@ -501,4 +532,4 @@ $ yarn cover
 
 The MIT License (MIT)
 
-Copyright (c) 2015-2019 Steven Chim
+Copyright (c) 2015-2020 Steven Chim

package/dist/config-factory.js

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

package/dist/context-matcher.js

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

package/dist/handlers.js

@@ -1,9 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = __importDefault(require("lodash"));
+const _ = require("lodash");
 const logger_1 = require("./logger");
 const logger = logger_1.getInstance();
 function init(proxy, option) {
@@ -16,31 +13,24 @@ function init(proxy, option) {
 exports.init = init;
 function getHandlers(options) {
     // https://github.com/nodejitsu/node-http-proxy#listening-for-proxy-events
-    const proxyEvents = [
-        'error',
-        'proxyReq',
-        'proxyReqWs',
-        'proxyRes',
-        'open',
-        'close'
-    ];
+    const proxyEvents = ['error', 'proxyReq', 'proxyReqWs', 'proxyRes', 'open', 'close'];
     const handlers = {};
     for (const event of proxyEvents) {
         // 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 = lodash_1.default.camelCase('on ' + event);
-        const fnHandler = lodash_1.default.get(options, eventName);
-        if (lodash_1.default.isFunction(fnHandler)) {
+        const eventName = _.camelCase('on ' + event);
+        const fnHandler = _.get(options, eventName);
+        if (_.isFunction(fnHandler)) {
             handlers[event] = fnHandler;
         }
     }
     // add default error handler in absence of error handler
-    if (!lodash_1.default.isFunction(handlers.error)) {
+    if (!_.isFunction(handlers.error)) {
         handlers.error = defaultErrorHandler;
     }
     // add default close handler in absence of close handler
-    if (!lodash_1.default.isFunction(handlers.close)) {
+    if (!_.isFunction(handlers.close)) {
         handlers.close = logClose;
     }
     return handlers;

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

@@ -1,4 +1,4 @@
-import { Filter, IRequestHandler, Options } from './types';
+import { Filter, RequestHandler, Options } from './types';
 export declare class HttpProxyMiddleware {
     private logger;
     private config;
@@ -7,7 +7,7 @@ export declare class HttpProxyMiddleware {
     private proxy;
     private pathRewriter;
     constructor(context: Filter | Options, opts?: Options);
-    middleware: IRequestHandler;
+    middleware: RequestHandler;
     private catchUpgradeRequest;
     private handleUpgrade;
     /**

package/dist/http-proxy-middleware.js

@@ -1,31 +1,22 @@
 "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 http_proxy_1 = __importDefault(require("http-proxy"));
-const lodash_1 = __importDefault(require("lodash"));
+const httpProxy = require("http-proxy");
+const _ = require("lodash");
 const config_factory_1 = require("./config-factory");
-const contextMatcher = __importStar(require("./context-matcher"));
-const handlers = __importStar(require("./handlers"));
+const contextMatcher = require("./context-matcher");
+const handlers = require("./handlers");
 const logger_1 = require("./logger");
-const PathRewriter = __importStar(require("./path-rewriter"));
-const Router = __importStar(require("./router"));
+const PathRewriter = require("./path-rewriter");
+const Router = require("./router");
 class HttpProxyMiddleware {
     constructor(context, opts) {
         this.logger = logger_1.getInstance();
@@ -85,12 +76,12 @@ class HttpProxyMiddleware {
             req.url = req.originalUrl || req.url;
             // store uri before it gets rewritten for logging
             const originalPath = req.url;
-            const newProxyOptions = lodash_1.default.assign({}, this.proxyOptions);
+            const newProxyOptions = _.assign({}, this.proxyOptions);
             // Apply in order:
             // 1. option.router
             // 2. option.pathRewrite
             yield this.applyRouter(req, newProxyOptions);
-            this.applyPathRewrite(req, this.pathRewriter);
+            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);
@@ -110,9 +101,9 @@ class HttpProxyMiddleware {
             }
         });
         // 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;
                 }
@@ -120,9 +111,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
@@ -131,7 +122,7 @@ class HttpProxyMiddleware {
         this.config = config_factory_1.createConfig(context, opts);
         this.proxyOptions = this.config.options;
         // create proxy
-        this.proxy = http_proxy_1.default.createProxyServer({});
+        this.proxy = httpProxy.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

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

package/dist/index.js

@@ -1,7 +1,8 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const http_proxy_middleware_1 = require("./http-proxy-middleware");
-function middleware(context, options) {
+function createProxyMiddleware(context, options) {
     const { middleware } = new http_proxy_middleware_1.HttpProxyMiddleware(context, options);
     return middleware;
 }
-module.exports = middleware;
+exports.createProxyMiddleware = createProxyMiddleware;

package/dist/logger.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = __importDefault(require("lodash"));
-const util_1 = __importDefault(require("util"));
+const _ = require("lodash");
+const util = require("util");
 let loggerInstance;
 const defaultProvider = {
     // tslint:disable: no-console
@@ -71,7 +68,7 @@ class Logger {
     }
     isValidProvider(fnProvider) {
         const result = true;
-        if (fnProvider && !lodash_1.default.isFunction(fnProvider)) {
+        if (fnProvider && !_.isFunction(fnProvider)) {
             throw new Error('[HPM] Log provider config error. Expecting a function.');
         }
         return result;
@@ -100,8 +97,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 = lodash_1.default.spread(util_1.default.format);
-        const result = fn(lodash_1.default.slice(arguments));
+        const fn = _.spread(util.format);
+        const result = fn(_.slice(arguments));
         return result;
     }
 }

package/dist/path-rewriter.js

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

package/dist/router.js

@@ -1,27 +1,25 @@
 "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 };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = __importDefault(require("lodash"));
+const _ = require("lodash");
 const logger_1 = require("./logger");
 const logger = logger_1.getInstance();
 function getTarget(req, config) {
     return __awaiter(this, void 0, void 0, function* () {
         let newTarget;
         const router = config.router;
-        if (lodash_1.default.isPlainObject(router)) {
+        if (_.isPlainObject(router)) {
             newTarget = getTargetFromProxyTable(req, router);
         }
-        else if (lodash_1.default.isFunction(router)) {
+        else if (_.isFunction(router)) {
             newTarget = yield router(req);
         }
         return newTarget;
@@ -33,7 +31,7 @@ function getTargetFromProxyTable(req, table) {
     const host = req.headers.host;
     const path = req.url;
     const hostAndPath = host + path;
-    lodash_1.default.forIn(table, (value, key) => {
+    _.forIn(table, (value, key) => {
         if (containsPath(key)) {
             if (hostAndPath.indexOf(key) > -1) {
                 // match 'localhost:3000/api'

package/dist/types.d.ts

@@ -1,34 +1,31 @@
 /// <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 {
+import * as express from 'express';
+import * as http from 'http';
+import * as httpProxy from 'http-proxy';
+import * as net from 'net';
+export interface Request extends express.Request {
 }
-export interface IResponse extends express.Response {
+export interface Response extends express.Response {
 }
-export interface IRequestHandler extends express.RequestHandler {
-    upgrade?: (req: IRequest, socket: net.Socket, head: any) => void;
+export interface RequestHandler extends express.RequestHandler {
+    upgrade?: (req: Request, socket: net.Socket, head: any) => void;
 }
-export declare type Filter = FilterPath | FilterWildcards | FilterFn;
-export declare type FilterFn = (pathname: string, req: IRequest) => boolean;
-export declare type FilterPath = string;
-export declare type FilterWildcards = string[];
+export declare type Filter = string | string[] | ((pathname: string, req: Request) => boolean);
 export interface Options extends httpProxy.ServerOptions {
     pathRewrite?: {
         [regexp: string]: string;
-    } | ((path: string, req: IRequest) => string);
+    } | ((path: string, req: Request) => string) | ((path: string, req: Request) => Promise<string>);
     router?: {
         [hostOrPath: string]: string;
-    } | ((req: IRequest) => string) | ((req: IRequest) => Promise<string>);
+    } | ((req: Request) => string) | ((req: Request) => 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;
+    onError?(err: Error, req: Request, res: Response): void;
+    onProxyRes?(proxyRes: http.ServerResponse, req: Request, res: Response): void;
+    onProxyReq?(proxyReq: http.ClientRequest, req: Request, res: Response): void;
+    onProxyReqWs?(proxyReq: http.ClientRequest, req: Request, socket: net.Socket, options: httpProxy.ServerOptions, head: any): void;
     onOpen?(proxySocket: net.Socket): void;
-    onClose?(res: IResponse, socket: net.Socket, head: any): void;
+    onClose?(res: Response, socket: net.Socket, head: any): void;
 }
 interface LogProvider {
     log: Logger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "http-proxy-middleware",
-  "version": "0.21.0-beta.2",
+  "version": "1.0.0",
   "description": "The one-liner node.js proxy middleware for connect, express and browser-sync",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,6 +35,7 @@
     "https",
     "connect",
     "express",
+    "polka",
     "browser-sync",
     "gulp",
     "grunt-contrib-connect",
@@ -47,35 +48,35 @@
   "bugs": {
     "url": "https://github.com/chimurai/http-proxy-middleware/issues"
   },
-  "homepage": "https://github.com/chimurai/http-proxy-middleware",
+  "homepage": "https://github.com/chimurai/http-proxy-middleware#readme",
   "devDependencies": {
     "@commitlint/cli": "^8.0.0",
     "@commitlint/config-conventional": "^8.0.0",
     "@types/express": "^4.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": {
-    "@types/http-proxy": "^1.17.0",
-    "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": {