http-proxy-middleware 0.17.0 → 0.17.3

package/examples/websocket/index.js

@@ -1,41 +0,0 @@
-/**
- * Module dependencies.
- */
-var express = require('express');
-var proxy = require('../../index'); // require('http-proxy-middleware');
-
-/**
- * Configure proxy middleware
- */
-var wsProxy = proxy('/', {
-                target: 'http://echo.websocket.org',
-                // pathRewrite: {
-                //  '^/websocket' : '/socket',          // rewrite path.
-                //  '^/removepath' : ''                 // remove path.
-                // },
-                changeOrigin: true,                     // for vhosted sites, changes host header to match to target's host
-                ws: true,                               // enable websocket proxy
-                logLevel: 'debug'
-            });
-
-var app = express();
-app.use('/', express.static(__dirname));                // demo page
-app.use(wsProxy);                                       // add the proxy to express
-
-var server = app.listen(3000);
-server.on('upgrade', wsProxy.upgrade);                  // optional: upgrade externally
-
-console.log('[DEMO] Server: listening on port 3000');
-console.log('[DEMO] Opening: http://localhost:3000');
-
-require('opn')('http://localhost:3000');
-
-/**
- * Example:
- * Open http://localhost:3000 in WebSocket compatible browser.
- * In browser console:
- * 1. `var socket = new WebSocket('ws://localhost:3000');`          // create new WebSocket
- * 2. `socket.onmessage = function (msg) {console.log(msg)};`       // listen to socket messages
- * 3. `socket.send('hello world');`                                 // send message
- * >  {data: "hello world"}                                         // server should echo back your message.
- **/

package/recipes/README.md

@@ -1,110 +0,0 @@
-# Recipes
-
-Common usages of `http-proxy-middleware`.
-
-# Configuration example
-
-Overview of `http-proxy-middleware` specific options.
-
-http-proxy-middleware uses Nodejitsu's [http-proxy](https://github.com/nodejitsu/node-http-proxy) to do the actual proxying. All of its [options](https://github.com/nodejitsu/node-http-proxy#options) are exposed via http-proxy-middleware's configuration object.
-
-
-```javascript
-var proxy = require("http-proxy-middleware");
-var winston = require('winston');
-
-/**
- * Context matching: decide which path(s) should be proxied. (wildcards supported)
- **/
-var context = '/api';
-
-/**
- * Proxy options
- */
-var options = {
-    // hostname to the target server
-    target: 'http://localhost:3000',
-
-    // set correct host headers for name-based virtual hosted sites
-    changeOrigin: true,
-
-    // enable websocket proxying
-    ws: true,
-
-    // additional request headers
-    headers: {
-        'x-powered-by': 'foobar'
-    },
-
-    // rewrite paths
-    pathRewrite: {
-        '^/old/api': '/new/api',    // rewrite path
-        '^/remove/api': ''          // remove path
-    },
-
-    // re-target based on the request's host header and/or path
-    router: {
-      // host[/path]                 :  <new target>
-      // /path                       :  <new target>
-        'integration.localhost:8000' : 'http://localhost:8001',  // host only
-        'staging.localhost:8000'     : 'http://localhost:8002',  // host only
-        'localhost:8000/api'         : 'http://localhost:8003',  // host + path
-        '/rest'                      : 'http://localhost:8004'   // path only
-    },
-
-    // control logging
-    logLevel: 'silent',
-
-    // use a different lib for logging;
-    // i.e., write logs to file or server
-    logProvider: function (provider) {
-        return winston;
-    },
-
-    // subscribe to http-proxy's error event
-    onError: function onError(err, req, res) {
-        res.writeHead(500, {'Content-Type': 'text/plain'});
-        res.end('Something went wrong.');
-    },
-
-    // subscribe to http-proxy's proxyRes event
-    onProxyRes: function (proxyRes, req, res) {
-        proxyRes.headers['x-added'] = 'foobar';
-        delete proxyRes.headers['x-removed'];
-    },
-
-    // subscribe to http-proxy's proxyReq event
-    onProxyReq: function (proxyReq, req, res) {
-        // add custom header to request
-        proxyReq.setHeader('x-powered-by', 'foobar');
-    }
-
-    /**
-     * The following options are provided by Nodejitsu's http-proxy
-     */
-
-    // target
-    // forward
-    // agent
-    // ssl
-    // ws
-    // xfwd
-    // secure
-    // toProxy
-    // prependPath
-    // ignorePath
-    // localAddress
-    // changeOrigin
-    // auth
-    // hostRewrite
-    // autoRewrite
-    // protocolRewrite
-    // headers
-
-};
-
-/**
- * Create the proxy middleware, so it can be used in a server.
- */
-var apiProxy = proxy(context, options);
-```

package/recipes/basic.md

@@ -1,32 +0,0 @@
-# Basic usage
-
-This example will create a basic proxy middleware.
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var apiProxy = proxy('/api', {target: 'http://localhost:3000'});
-//                          \____/  \________________________________/
-//                            |                     |
-//                          context              options
-```
-
-## Alternative configuration
-
-The proxy behavior of the following examples are **exactly** the same; Just different ways to configure it.
-
-```javascript
-app.use(proxy('/api', {target: 'http://localhost:3000', changeOrigin:true}));
-```
-
-```javascript
-app.use(proxy('http://localhost:3000/api', {changeOrigin:true}));
-```
-
-```javascript
-app.use('/api', proxy('http://localhost:3000', {changeOrigin:true}));
-```
-
-```javascript
-app.use('/api', proxy({target: 'http://localhost:3000', changeOrigin:true}));
-```

package/recipes/context-matching.md

@@ -1,99 +0,0 @@
-# Context matching
-
-Determine which requests should be proxied.
-
-Context matching is optional and is useful in cases where you are not able to use the regular [middleware mounting](http://expressjs.com/en/4x/api.html#app.use).
-
-The [RFC 3986 `path`](https://tools.ietf.org/html/rfc3986#section-3.3) is used for context matching.
-
-```
-         foo://example.com:8042/over/there?name=ferret#nose
-         \_/   \______________/\_________/ \_________/ \__/
-          |           |            |            |        |
-       scheme     authority       path        query   fragment
-```
-
-
-`http-proxy-middleware` offers several ways to do this:
-
-<!-- MarkdownTOC autolink=true bracket=round -->
-
-- [Path](#path)
-- [Multi Path](#multi-path)
-- [Wildcard](#wildcard)
-- [Multi Wildcard](#multi-wildcard)
-- [Wildcard / Exclusion](#wildcard--exclusion)
-- [Custom filtering](#custom-filtering)
-
-<!-- /MarkdownTOC -->
-
-
-## Path
-
-This will match paths starting with `/api`
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var apiProxy = proxy('/api', {target: 'http://localhost:3000'});
-
-// `/api/foo/bar` -> `http://localhost:3000/api/foo/bar`
-```
-
-## Multi Path
-
-This will match paths starting with `/api` or `/rest`
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var apiProxy = proxy(['/api', '/rest'], {target: 'http://localhost:3000'});
-
-// `/api/foo/bar` -> `http://localhost:3000/api/foo/bar`
-// `/rest/lorum/ipsum` -> `http://localhost:3000/rest/lorum/ipsum`
-```
-
-## Wildcard
-
-This will match paths starting with `/api/` and should also end with `.json`
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var apiProxy = proxy('/api/**/*.json', {target: 'http://localhost:3000'});
-```
-
-## Multi Wildcard
-
-Multiple wildcards can be used.
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var apiProxy = proxy(['/api/**/*.json', '/rest/**'], {target: 'http://localhost:3000'});
-```
-
-## Wildcard / Exclusion
-
-This example will create a proxy with wildcard context matching.
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var apiProxy = proxy(['foo/*.js', '!bar.js'], {target: 'http://localhost:3000'});
-```
-
-## Custom filtering
-
-Write your custom context matching function to have full control on the matching behavior.
-The request `pathname` and `req` object are provided to determine which requests should be proxied or not.
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var filter = function (pathname, req) {
-    return (pathname.match('^/api') && req.method === 'GET');
-};
-
-var apiProxy = proxy(filter, {target: 'http://localhost:3000'});
-```

package/recipes/corporate-proxy.md

@@ -1,21 +0,0 @@
-# Corporate Proxy Support
-
-This example will create a basic proxy middleware with corporate proxy support.
-
-Provide a custom `http.agent` with [https-proxy-agent](https://github.com/TooTallNate/node-https-proxy-agent) to connect to the corporate proxy server.
-
-```javascript
-var HttpsProxyAgent = require('https-proxy-agent');
-var proxy = require("http-proxy-middleware");
-
-// corporate proxy to connect to
-var proxyServer = process.env.HTTPS_PROXY ||
-                  process.env.HTTP_PROXY;
-
-var options = {
-    target: 'http://localhost:3000',
-    agent: new HttpsProxyAgent(proxyServer)
-};
-
-var apiProxy = proxy('/api', options);
-```

package/recipes/delay.md

@@ -1,37 +0,0 @@
-# Delay proxied request/response
-
-Sometimes we need the ability to delay request to backend server or response from it back to client to test long execution time of particular url or all of them. With DevTool's [network throttling](https://developers.google.com/web/tools/chrome-devtools/profile/network-performance/network-conditions?hl=en) we can test slowdown of all request, not separately.
-But we can handle each request individually via our proxy, and add delay to its execution time.
-
-Let's assume that we want slow down the access to backend's `/api/get-me-something` resource. Delay request time by 2 seconds and increase response time by 5 seconds. 
-
-For achieving it just put additional route handler to your app before proxy handler:
-
-```javascript
-const myProxy = proxy({
-  target: 'http://www.example.com',
-  changeOrigin: true
-});
-const proxyDelay = function (req, res, next) {
-  if (req.originalUrl === '/api/get-me-something') {
-    // Delay request by 2 seconds
-    setTimeout(next, 2000);
-
-    // Delay response completion by 5 seconds
-    const endOriginal = res.end;
-    res.end = function (...args) {
-      setTimeout(function () {
-        endOriginal.apply(res, args);
-      }, 5000);
-    };
-  } else {
-    next();
-  }
-};
-
-app.use('/api', proxyDelay, myProxy);
-```
-
-And you will see result in devtools similar to this:
-
-![http-proxy-delay](https://cloud.githubusercontent.com/assets/576077/15839924/49ebe256-2bfb-11e6-8591-ef0101670885.png)

package/recipes/logLevel.md

@@ -1,40 +0,0 @@
-# Log Level
-
-Control the amount of logging of http-proxy-middleware.
-
-Possible values:
-* `debug`
-* `info`
-* `warn` (default)
-* `error`
-* `silent`
-
-## Level: debug
-
-Log everyting.
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var options = {
-    target: 'http://localhost:3000',
-    logLevel: 'debug'
-};
-
-var apiProxy = proxy('/api', options);
-```
-
-## Level: silent
-
-Suppress all logging.
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var options = {
-    target: 'http://localhost:3000',
-    logLevel: 'silent'
-};
-
-var apiProxy = proxy('/api', options);
-```

package/recipes/logProvider.md

@@ -1,77 +0,0 @@
-# Log Provider
-
-Configure your own logger with the `logProvider` option.
-
-In this example [winston](https://www.npmjs.com/package/winston) is configured to do the actual logging.
-
-```javascript
-var winston = require('winston');
-var proxy = require("http-proxy-middleware");
-
-var options = {
-    target: 'http://localhost:3000',
-    logProvider: function (provider) {
-        return winston;
-    }
-};
-
-var apiProxy = proxy('/api', options);
-```
-
-## Winston
-
-Configure your own logger with the `logProvider` option.
-
-In this example [winston](https://www.npmjs.com/package/winston) is configured to do the actual logging. Map the logging api if needed.
-
-```javascript
-
-var winston = require('winston');
-var proxy = require("http-proxy-middleware");
-
-var logProvider = function (provider) {
-    return {
-        log   : winston.log,
-        debug : winston.debug,
-        info  : winston.info,
-        warn  : winston.warn,
-        error : winston.error
-    };
-};
-
-var options = {
-    target: 'http://localhost:3000',
-    logProvider: logProvider
-};
-
-var apiProxy = proxy('/api', options);
-```
-
-# Winston Multi Transport
-
-Configure your own logger with the `logProvider` option.
-
-In this example [winston](https://www.npmjs.com/package/winston) is configured to do the actual logging.
-
-```javascript
-var winston = require('winston');
-var proxy = require("http-proxy-middleware");
-
-var logProvider = function (provider) {
-    var logger = new (winston.Logger)({
-        transports: [
-            new (winston.transports.Console)(),
-            new (winston.transports.File)({ filename: 'somefile.log' })
-        ]
-    });
-
-    return logger;
-};
-
-var options = {
-    target: 'http://localhost:3000',
-    logProvider: logProvider
-};
-
-var apiProxy = proxy('/api', options);
-```

package/recipes/modify-post.md

@@ -1,74 +0,0 @@
-##Modify Post Parameters:
-The code example below illustrates how to modify POST body data prior to forwarding to the proxy target.
-Key to this example is the *"OnProxyReq"* event handler  that creates a new POST body that can be manipulated to format the POST data as required.  For example: inject new POST parameters that should only be visible server side.
-
-This example uses the *"body-parser"* module in the main app to create a req.body object with the decoded POST parameters.   Side note - the code below will allow *"http-proxy-middleware"* to work with *"body-parser"*.
-
-Since this only modifys the request body stream the original POST body parameters remain in tact, so any POST data changes will not be sent back in the response to the client.
-
-## Example:
-
-    'use strict';
-    
-    var express = require('express');
-    var ProxyMiddleware = require('http-proxy-middleware');
-    var router = express.Router();
-    
-    var proxy_filter = function (path, req) {
-        return path.match('^/docs') && ( req.method === 'GET' || req.method === 'POST' );
-    };
-    
-    var proxy_options = {
-        target: 'http://localhost:8080',
-        pathRewrite: {
-            '^/docs' : '/java/rep/server1' // Host path & target path conversion
-        },
-        onError(err, req, res) {
-            res.writeHead(500, {
-                'Content-Type': 'text/plain'
-            });
-            res.end('Something went wrong. And we are reporting a custom error message.' + err);
-        },
-        onProxyReq(proxyReq, req, res) {
-            if ( req.method == "POST" && req.body ) {
-                // Add req.body logic here if needed....
-    
-               // ....
-    
-                // Remove body-parser body object from the request
-                if ( req.body ) delete req.body;
-    
-                // Make any needed POST parameter changes
-                let body = new Object();
-    
-                body.filename = 'reports/statistics/summary_2016.pdf';
-                body.routeid = 's003b012d002';
-                body.authid = 'bac02c1d-258a-4177-9da6-862580154960';
-    
-                // URI encode JSON object
-                body = Object.keys( body ).map(function( key ) {
-                    return encodeURIComponent( key ) + '=' + encodeURIComponent( body[ key ])
-                }).join('&');
-    
-                // Update header
-                proxyReq.setHeader( 'content-type', 'application/x-www-form-urlencoded' );
-                proxyReq.setHeader( 'content-length', body.length );
-    
-                // Write out body changes to the proxyReq stream
-                proxyReq.write( body );
-                proxyReq.end();
-            }
-        }
-    };
-    
-    // Proxy configuration
-    var proxy = ProxyMiddleware( proxy_filter, proxy_options );
-    
-    /* GET home page. */
-    router.get('/', function(req, res, next) {
-        res.render('index', { title: 'Node.js Express Proxy Test' });
-    });
-    
-    router.all('/docs', proxy );
-    
-    module.exports = router;

package/recipes/pathRewrite.md

@@ -1,93 +0,0 @@
-# pathRewrite
-
-Modify request paths before requests are send to the target.
-
-<!-- MarkdownTOC autolink=true bracket=round -->
-
-- [rewrite paths](#rewrite-paths)
-- [remove paths](#remove-paths)
-- [add paths](#add-paths)
-- [custom rewrite function](#custom-rewrite-function)
-
-<!-- /MarkdownTOC -->
-
-
-## rewrite paths
-
-Rewrite paths
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var options = {
-    target: 'http://localhost:3000',
-    pathRewrite: {
-        "^/old/api" : "/new/api"    // rewrite path
-    }
-};
-
-var apiProxy = proxy('/api', options);
-
-// `/old/api/foo/bar` -> `http://localhost:3000/new/api/foo/bar`
-```
-
-## remove paths
-
-Remove base path
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var options = {
-    target: 'http://localhost:3000',
-    pathRewrite: {
-        "^/remove/api" : ""          // remove base path
-    }
-};
-
-var apiProxy = proxy('/api', options);
-
-// `/remove/api/lorum/ipsum` -> `http://localhost:3000/lorum/ipsum`
-```
-
-## add paths
-
-Add base path 
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var options = {
-    target: 'http://localhost:3000',
-    pathRewrite: {
-        "^/" : "/extra/"          // add base path
-    }
-};
-
-var apiProxy = proxy('/api', options);
-
-// `/api/lorum/ipsum` -> `http://localhost:3000/extra/api/lorum/ipsum`
-```
-
-## custom rewrite function
-
-Implement you own path rewrite logic.
-
-The unmodified path will be used, when rewrite function returns `undefined`
-
-```javascript
-var proxy = require("http-proxy-middleware");
-
-var rewriteFn = function (path, req) {
-    return path.replace('/api/foo', '/api/bar');
-}
-
-var options = {
-    target: 'http://localhost:3000',
-    pathRewrite: rewriteFn
-};
-
-var apiProxy = proxy('/api', options);
-
-// `/api/foo/lorum/ipsum` -> `http://localhost:3000/api/bar/lorum/ipsum`
-```