http-proxy-middleware 0.22.0-alpha → 1.0.3

package/CHANGELOG.md

@@ -1,9 +1,27 @@
 # Changelog
 
+## [v1.0.3](https://github.com/chimurai/http-proxy-middleware/releases/tag/v1.0.3)
+
+- build(package): exclude build artifact tsconfig.tsbuildinfo ([#415](https://github.com/chimurai/http-proxy-middleware/pull/415))
+
+## [v1.0.2](https://github.com/chimurai/http-proxy-middleware/releases/tag/v1.0.2)
+
+- fix(router): handle rejected promise in custom router ([#410](https://github.com/chimurai/http-proxy-middleware/pull/413)) ([bforbis](https://github.com/bforbis))
+
+## [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
 
-var app = express();
+const express = require('express');
+const { createProxyMiddleware } = require('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
+```
+
+```typescript
+// typescript
+
+import * as express from 'express';
+import { createProxyMiddleware, Filter, Options, RequestHandler } from 'http-proxy-middleware';
+
+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
@@ -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);
 ```
@@ -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.');
   }
   ```
 
@@ -401,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)
@@ -417,10 +445,7 @@ 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:
@@ -433,13 +458,13 @@ app.use(
 
 ```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
@@ -447,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'
 ```
 

package/dist/handlers.js

@@ -13,14 +13,7 @@ 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'.

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

@@ -24,8 +24,13 @@ 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 = yield this.prepareProxyRequest(req);
-                this.proxy.web(req, res, activeProxyOptions);
+                try {
+                    const activeProxyOptions = yield this.prepareProxyRequest(req);
+                    this.proxy.web(req, res, activeProxyOptions);
+                }
+                catch (err) {
+                    next(err);
+                }
             }
             else {
                 next();

package/dist/index.d.ts

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

package/dist/types.d.ts

@@ -3,29 +3,29 @@ import * as express from 'express';
 import * as http from 'http';
 import * as httpProxy from 'http-proxy';
 import * as net from 'net';
-export interface IRequest extends express.Request {
+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 = string | string[] | ((pathname: string, req: IRequest) => boolean);
+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: IRequest) => Promise<string>);
+    } | ((path: string, req: Request) => string) | ((path: string, req: Request) => Promise<string>);
     router?: {
-        [hostOrPath: string]: string;
-    } | ((req: IRequest) => string) | ((req: IRequest) => Promise<string>);
+        [hostOrPath: string]: httpProxy.ServerOptions['target'];
+    } | ((req: Request) => httpProxy.ServerOptions['target']) | ((req: Request) => Promise<httpProxy.ServerOptions['target']>);
     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.IncomingMessage, 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.22.0-alpha",
+  "version": "1.0.3",
   "description": "The one-liner node.js proxy middleware for connect, express and browser-sync",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,13 +15,13 @@
     "lint:fix": "prettier --write \"**/*.{js,ts,md}\"",
     "build": "tsc",
     "pretest": "yarn build",
-    "test": "jest --runInBand",
+    "test": "jest",
     "precover": "yarn clean && yarn build",
-    "cover": "jest --runInBand --coverage",
+    "cover": "jest --coverage",
     "precoveralls": "yarn clean && yarn build",
-    "coveralls": "jest --runInBand --coverage --coverageReporters=text-lcov | coveralls",
+    "coveralls": "jest --coverage --coverageReporters=text-lcov | coveralls",
     "postcoveralls": "yarn clean",
-    "prepare": "yarn clean && yarn build"
+    "prepare": "yarn clean && yarn build && rm dist/tsconfig.tsbuildinfo"
   },
   "repository": {
     "type": "git",
@@ -48,29 +48,33 @@
   "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": "^25.1.2",
+    "@commitlint/cli": "^8.3.5",
+    "@commitlint/config-conventional": "^8.3.4",
+    "@types/express": "^4.17.2",
+    "@types/is-glob": "^4.0.1",
+    "@types/jest": "^25.1.3",
     "@types/lodash": "^4.14.149",
     "@types/micromatch": "^4.0.1",
-    "@types/node": "^12.6.2",
+    "@types/node": "^13.7.4",
+    "@types/supertest": "^2.0.8",
     "browser-sync": "^2.26.7",
-    "connect": "^3.6.6",
+    "connect": "^3.7.0",
     "coveralls": "^3.0.5",
-    "express": "^4.16.4",
-    "husky": "^3.0.0",
+    "express": "^4.17.1",
+    "husky": "^4.2.3",
     "jest": "^25.1.0",
+    "lint-staged": "^10.0.7",
+    "mockttp": "^0.19.3",
     "open": "^7.0.2",
     "prettier": "^1.19.1",
+    "supertest": "^4.0.2",
     "ts-jest": "^25.2.0",
     "tslint": "^6.0.0",
     "tslint-config-prettier": "^1.18.0",
-    "typescript": "^3.7.5",
-    "ws": "^7.1.0"
+    "typescript": "^3.8.2",
+    "ws": "^7.2.1"
   },
   "dependencies": {
     "@types/http-proxy": "^1.17.3",
@@ -84,7 +88,8 @@
   },
   "husky": {
     "hooks": {
-      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
+      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS",
+      "pre-commit": "lint-staged"
     }
   },
   "commitlint": {