http-proxy-middleware 0.21.0-beta.3 → 1.0.1

package/CHANGELOG.md

@@ -1,9 +1,19 @@
 # Changelog
 
-## next
+## [v1.0.1](https://github.com/chimurai/http-proxy-middleware/releases/tag/v1.0.1)
+
+- fix(typescript): fix proxyRes and router types ([#410](https://github.com/chimurai/http-proxy-middleware/issues/410)) ([dylang](https://github.com/dylang))
+
+## [v1.0.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v1.0.0)
+
+- feat(createProxyMiddleware): explicit import http-proxy-middleware ([BREAKING CHANGE](https://github.com/chimurai/http-proxy-middleware/releases))([#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/335)) ([LiranBri](https://github.com/LiranBri))
+- 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))
 

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
@@ -202,11 +224,10 @@ Providing an alternative way to decide which requests should be proxied; In case
 
   // custom rewriting, returning Promise
   pathRewrite: async function (path, req) {
-    var should_add_something = await httpRequestToDecideSomething(path);
+    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.
@@ -221,11 +242,20 @@ Providing an alternative way to decide which requests should be proxied; In case
       '/rest'                      : 'http://localhost:8004'   // path only
   }
 
-  // Custom router function
+  // Custom router function (string target)
   router: function(req) {
       return 'http://localhost:8004';
   }
 
+  // Custom router function (target object)
+  router: function(req) {
+      return {
+          protocol: 'https:', // The : is required
+          host: 'localhost',
+          port: 8004
+      };
+  }
+
   // Asynchronous router function which returns promise
   router: async function(req) {
       const url = await doSomeIO();
@@ -248,9 +278,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,
@@ -272,9 +302,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.');
   }
   ```
 
@@ -316,6 +344,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
@@ -349,7 +378,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",
@@ -361,7 +390,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/",
@@ -375,7 +404,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');
@@ -383,12 +412,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
+    );
   };
   ```
 
@@ -397,14 +429,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)
@@ -413,28 +445,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
@@ -442,12 +472,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'
 ```
 
@@ -472,6 +502,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)

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

@@ -8,25 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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();
@@ -86,7 +76,7 @@ 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
@@ -132,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;