Auto stash before merge of "main" and "origin/main"
This commit is contained in:
Minik Gaarde Lambrecht
+183
@@ -0,0 +1,183 @@
|
||||
# Changelog
|
||||
|
||||
## [v1.0.6](https://github.com/chimurai/http-proxy-middleware/releases/tag/v1.0.6)
|
||||
|
||||
- chore(deps): lodash 4.17.20 ([#475](https://github.com/chimurai/http-proxy-middleware/pull/475))
|
||||
|
||||
## [v1.0.5](https://github.com/chimurai/http-proxy-middleware/releases/tag/v1.0.6)
|
||||
|
||||
- chore(deps): lodash 4.17.19 ([#454](https://github.com/chimurai/http-proxy-middleware/pull/454))
|
||||
|
||||
## [v1.0.4](https://github.com/chimurai/http-proxy-middleware/releases/tag/v1.0.4)
|
||||
|
||||
- chore(deps): http-proxy 1.18.1 ([#442](https://github.com/chimurai/http-proxy-middleware/pull/442))
|
||||
|
||||
## [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/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)
|
||||
|
||||
- fix(ws): concurrent websocket requests do not get upgraded ([#335](https://github.com/chimurai/http-proxy-middleware/issues/335))
|
||||
- chore: drop node 6 (BREAKING CHANGE)
|
||||
- chore: update to micromatch@4 ([BREAKING CHANGE](https://github.com/micromatch/micromatch/blob/master/CHANGELOG.md#400---2019-03-20))
|
||||
- chore: update dev dependencies
|
||||
- refactor: migrate to typescript ([#328](https://github.com/chimurai/http-proxy-middleware/pull/328))
|
||||
- feat(middleware): Promise / async support ([#328](https://github.com/chimurai/http-proxy-middleware/pull/328/files#diff-7890bfeb41abb0fc0ef2670749c84077R50))
|
||||
- refactor: remove legacy options `proxyHost` and `proxyTable` (BREAKING CHANGE)
|
||||
|
||||
## [v0.19.1](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.19.1)
|
||||
|
||||
- fix(log): handle case when error code is missing ([#303](https://github.com/chimurai/http-proxy-middleware/pull/303))
|
||||
|
||||
## [v0.19.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.19.0)
|
||||
|
||||
- feat(http-proxy): bump to v1.17.0 ([#261](https://github.com/chimurai/http-proxy-middleware/pull/261))
|
||||
|
||||
## [v0.18.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.18.0)
|
||||
|
||||
- fix(vulnerability): update micromatch to v3.x ([npm:braces:20180219](https://snyk.io/test/npm/http-proxy-middleware?tab=issues&severity=high&severity=medium&severity=low#npm:braces:20180219))
|
||||
- test(node): drop node 0.x support ([#212](https://github.com/chimurai/http-proxy-middleware/pull/212))
|
||||
|
||||
## [v0.17.4](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.17.4)
|
||||
|
||||
- fix(ntlm authentication): fixed bug preventing proxying with ntlm authentication. ([#132](https://github.com/chimurai/http-proxy-middleware/pull/149)) (Thanks: [EladBezalel](https://github.com/EladBezalel), [oshri551](https://github.com/oshri551))
|
||||
|
||||
## [v0.17.3](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.17.3)
|
||||
|
||||
- fix(onError): improve default proxy error handling. http status codes (504, 502 and 500). ([#132](https://github.com/chimurai/http-proxy-middleware/pull/132)) ([graingert](https://github.com/graingert))
|
||||
|
||||
## [v0.17.2](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.17.2)
|
||||
|
||||
- feat(logging): improve error message & add link to Node errors page. ([#106](https://github.com/chimurai/http-proxy-middleware/pull/106)) ([cloudmu](https://github.com/cloudmu))
|
||||
- feat(pathRewrite): path can be empty string. ([#110](https://github.com/chimurai/http-proxy-middleware/pull/110)) ([sunnylqm](https://github.com/sunnylqm))
|
||||
- bug(websocket): memory leak when option 'ws:true' is used. ([#114](https://github.com/chimurai/http-proxy-middleware/pull/114)) ([julbra](https://github.com/julbra))
|
||||
- chore(package.json): reduce package size. ([#109](https://github.com/chimurai/http-proxy-middleware/pull/109))
|
||||
|
||||
## [v0.17.1](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.17.1)
|
||||
|
||||
- fix(Express sub Router): 404 on non-proxy routes ([#94](https://github.com/chimurai/http-proxy-middleware/issues/94))
|
||||
|
||||
## [v0.17.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.17.0)
|
||||
|
||||
- fix(context matching): Use [RFC 3986 path](https://tools.ietf.org/html/rfc3986#section-3.3) in context matching. (excludes query parameters)
|
||||
|
||||
## [v0.16.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.16.0)
|
||||
|
||||
- deprecated(proxyTable): renamed `proxyTable` to `router`.
|
||||
- feat(router): support for custom `router` function.
|
||||
|
||||
## [v0.15.2](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.15.2)
|
||||
|
||||
- fix(websocket): fixes websocket upgrade.
|
||||
|
||||
## [v0.15.1](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.15.1)
|
||||
|
||||
- feat(pathRewrite): expose `req` object to pathRewrite function.
|
||||
- fix(websocket): fixes websocket upgrade when both config.ws and external .upgrade() are used.
|
||||
|
||||
## [v0.15.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.15.0)
|
||||
|
||||
- feat(pathRewrite): support for custom pathRewrite function.
|
||||
|
||||
## [v0.14.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.14.0)
|
||||
|
||||
- feat(proxy): support proxy creation without context.
|
||||
- fix(connect mounting): use connect's `path` configuration to mount proxy.
|
||||
|
||||
## [v0.13.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.13.0)
|
||||
|
||||
- feat(context): custom context matcher; when simple `path` matching is not sufficient.
|
||||
|
||||
## [v0.12.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.12.0)
|
||||
|
||||
- add option `onProxyReqWs` (subscribe to http-proxy `proxyReqWs` event)
|
||||
- add option `onOpen` (subscribe to http-proxy `open` event)
|
||||
- add option `onClose` (subscribe to http-proxy `close` event)
|
||||
|
||||
## [v0.11.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.11.0)
|
||||
|
||||
- improved logging
|
||||
|
||||
## [v0.10.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.10.0)
|
||||
|
||||
- feat(proxyTable) - added proxyTable support for WebSockets.
|
||||
- fixed(proxyTable) - ensure original path (not rewritten path) is being used when `proxyTable` is used in conjunction with `pathRewrite`.
|
||||
|
||||
## [v0.9.1](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.9.1)
|
||||
|
||||
- fix server crash when socket error not handled correctly.
|
||||
|
||||
## [v0.9.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.9.0)
|
||||
|
||||
- support subscribing to http-proxy `proxyReq` event ([trbngr](https://github.com/trbngr))
|
||||
- add `logLevel` and `logProvider` support
|
||||
|
||||
## [v0.8.2](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.8.2)
|
||||
|
||||
- fix proxyError handler ([mTazelaar](https://github.com/mTazelaar))
|
||||
|
||||
## [v0.8.1](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.8.1)
|
||||
|
||||
- fix pathRewrite when `agent` is configured
|
||||
|
||||
## [v0.8.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.8.0)
|
||||
|
||||
- support external websocket upgrade
|
||||
- fix websocket shorthand
|
||||
|
||||
## [v0.7.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.7.0)
|
||||
|
||||
- support shorthand syntax
|
||||
- fix express/connect mounting
|
||||
|
||||
## [v0.6.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.6.0)
|
||||
|
||||
- support proxyTable
|
||||
|
||||
## [v0.5.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.5.0)
|
||||
|
||||
- support subscribing to http-proxy `error` event
|
||||
- support subscribing to http-proxy `proxyRes` event
|
||||
|
||||
## [v0.4.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.4.0)
|
||||
|
||||
- support websocket
|
||||
|
||||
## [v0.3.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.3.0)
|
||||
|
||||
- support wildcard / glob
|
||||
|
||||
## [v0.2.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.2.0)
|
||||
|
||||
- support multiple paths
|
||||
|
||||
## [v0.1.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.1.0)
|
||||
|
||||
- support path rewrite
|
||||
- deprecate proxyHost option
|
||||
|
||||
## [v0.0.5](https://github.com/chimurai/http-proxy-middleware/releases/tag/v0.0.5)
|
||||
|
||||
- initial release
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2015 Steven Chim
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
||||
+543
@@ -0,0 +1,543 @@
|
||||
# http-proxy-middleware
|
||||
|
||||
[](https://travis-ci.org/chimurai/http-proxy-middleware)
|
||||
[](https://coveralls.io/r/chimurai/http-proxy-middleware)
|
||||
[](https://david-dm.org/chimurai/http-proxy-middleware#info=dependencies)
|
||||
[](https://snyk.io/test/npm/http-proxy-middleware)
|
||||
[](https://github.com/prettier/prettier)
|
||||
|
||||
Node.js proxying made simple. Configure proxy middleware with ease for [connect](https://github.com/senchalabs/connect), [express](https://github.com/strongloop/express), [browser-sync](https://github.com/BrowserSync/browser-sync) and [many more](#compatible-servers).
|
||||
|
||||
Powered by the popular Nodejitsu [`http-proxy`](https://github.com/nodejitsu/node-http-proxy). [](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
|
||||
// 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);
|
||||
|
||||
// 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
|
||||
```
|
||||
|
||||
_All_ `http-proxy` [options](https://github.com/nodejitsu/node-http-proxy#options) can be used, along with some extra `http-proxy-middleware` [options](#options).
|
||||
|
||||
:bulb: **Tip:** Set the option `changeOrigin` to `true` for [name-based virtual hosted sites](http://en.wikipedia.org/wiki/Virtual_hosting#Name-based).
|
||||
|
||||
## Table of Contents
|
||||
|
||||
<!-- MarkdownTOC autolink=true bracket=round depth=2 -->
|
||||
|
||||
- [Install](#install)
|
||||
- [Core concept](#core-concept)
|
||||
- [Example](#example)
|
||||
- [Context matching](#context-matching)
|
||||
- [Options](#options)
|
||||
- [http-proxy-middleware options](#http-proxy-middleware-options)
|
||||
- [http-proxy events](#http-proxy-events)
|
||||
- [http-proxy options](#http-proxy-options)
|
||||
- [Shorthand](#shorthand)
|
||||
- [app.use\(path, proxy\)](#appusepath-proxy)
|
||||
- [WebSocket](#websocket)
|
||||
- [External WebSocket upgrade](#external-websocket-upgrade)
|
||||
- [Working examples](#working-examples)
|
||||
- [Recipes](#recipes)
|
||||
- [Compatible servers](#compatible-servers)
|
||||
- [Tests](#tests)
|
||||
- [Changelog](#changelog)
|
||||
- [License](#license)
|
||||
|
||||
<!-- /MarkdownTOC -->
|
||||
|
||||
## Install
|
||||
|
||||
```bash
|
||||
$ npm install --save-dev http-proxy-middleware
|
||||
```
|
||||
|
||||
## Core concept
|
||||
|
||||
Proxy middleware configuration.
|
||||
|
||||
#### createProxyMiddleware([context,] config)
|
||||
|
||||
```javascript
|
||||
const { createProxyMiddleware } = require('http-proxy-middleware');
|
||||
|
||||
const apiProxy = createProxyMiddleware('/api', { target: 'http://www.example.org' });
|
||||
// \____/ \_____________________________/
|
||||
// | |
|
||||
// context options
|
||||
|
||||
// 'apiProxy' is now ready to be used as middleware in a server.
|
||||
```
|
||||
|
||||
- **context**: Determine which requests should be proxied to the target host.
|
||||
(more on [context matching](#context-matching))
|
||||
- **options.target**: target host to proxy to. _(protocol + host)_
|
||||
|
||||
(full list of [`http-proxy-middleware` configuration options](#options))
|
||||
|
||||
#### createProxyMiddleware(uri [, config])
|
||||
|
||||
```javascript
|
||||
// shorthand syntax for the example above:
|
||||
const apiProxy = createProxyMiddleware('http://www.example.org/api');
|
||||
```
|
||||
|
||||
More about the [shorthand configuration](#shorthand).
|
||||
|
||||
## Example
|
||||
|
||||
An example with `express` server.
|
||||
|
||||
```javascript
|
||||
// include dependencies
|
||||
const express = require('express');
|
||||
const { createProxyMiddleware } = require('http-proxy-middleware');
|
||||
|
||||
// proxy middleware options
|
||||
const options = {
|
||||
target: 'http://www.example.org', // target host
|
||||
changeOrigin: true, // needed for virtual hosted sites
|
||||
ws: true, // proxy websockets
|
||||
pathRewrite: {
|
||||
'^/api/old-path': '/api/new-path', // rewrite path
|
||||
'^/api/remove/path': '/path', // remove base path
|
||||
},
|
||||
router: {
|
||||
// when request.headers.host == 'dev.localhost:3000',
|
||||
// override target 'http://www.example.org' to 'http://localhost:8000'
|
||||
'dev.localhost:3000': 'http://localhost:8000',
|
||||
},
|
||||
};
|
||||
|
||||
// create the proxy (without context)
|
||||
const exampleProxy = createProxyMiddleware(options);
|
||||
|
||||
// mount `exampleProxy` in web server
|
||||
const app = express();
|
||||
app.use('/api', exampleProxy);
|
||||
app.listen(3000);
|
||||
```
|
||||
|
||||
## Context matching
|
||||
|
||||
Providing an alternative way to decide which requests should be proxied; In case you are not able to use the server's [`path` parameter](http://expressjs.com/en/4x/api.html#app.use) to mount the proxy or when you need more flexibility.
|
||||
|
||||
[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
|
||||
\_/ \______________/\_________/ \_________/ \__/
|
||||
| | | | |
|
||||
scheme authority path query fragment
|
||||
```
|
||||
|
||||
- **path matching**
|
||||
|
||||
- `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**
|
||||
|
||||
- `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.
|
||||
|
||||
- `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.
|
||||
|
||||
- **custom matching**
|
||||
|
||||
For full control you can provide a custom function to determine which requests should be proxied or not.
|
||||
|
||||
```javascript
|
||||
/**
|
||||
* @return {Boolean}
|
||||
*/
|
||||
const filter = function (pathname, req) {
|
||||
return pathname.match('^/api') && req.method === 'GET';
|
||||
};
|
||||
|
||||
const apiProxy = createProxyMiddleware(filter, {
|
||||
target: 'http://www.example.org',
|
||||
});
|
||||
```
|
||||
|
||||
## Options
|
||||
|
||||
### http-proxy-middleware options
|
||||
|
||||
- **option.pathRewrite**: object/function, rewrite target's url path. Object-keys will be used as _RegExp_ to match paths.
|
||||
|
||||
```javascript
|
||||
// rewrite path
|
||||
pathRewrite: {'^/old/api' : '/new/api'}
|
||||
|
||||
// remove path
|
||||
pathRewrite: {'^/remove/api' : ''}
|
||||
|
||||
// add base path
|
||||
pathRewrite: {'^/' : '/basepath/'}
|
||||
|
||||
// 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.
|
||||
|
||||
```javascript
|
||||
// Use `host` and/or `path` to match requests. First match will be used.
|
||||
// The order of the configuration matters.
|
||||
router: {
|
||||
'integration.localhost:3000' : 'http://localhost:8001', // host only
|
||||
'staging.localhost:3000' : 'http://localhost:8002', // host only
|
||||
'localhost:3000/api' : 'http://localhost:8003', // host + path
|
||||
'/rest' : 'http://localhost:8004' // path only
|
||||
}
|
||||
|
||||
// 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();
|
||||
return url;
|
||||
}
|
||||
```
|
||||
|
||||
- **option.logLevel**: string, ['debug', 'info', 'warn', 'error', 'silent']. Default: `'info'`
|
||||
|
||||
- **option.logProvider**: function, modify or replace log provider. Default: `console`.
|
||||
|
||||
```javascript
|
||||
// simple replace
|
||||
function logProvider(provider) {
|
||||
// replace the default console log provider.
|
||||
return require('winston');
|
||||
}
|
||||
```
|
||||
|
||||
```javascript
|
||||
// verbose replacement
|
||||
function logProvider(provider) {
|
||||
const logger = new (require('winston').Logger)();
|
||||
|
||||
const myCustomProvider = {
|
||||
log: logger.log,
|
||||
debug: logger.debug,
|
||||
info: logger.info,
|
||||
warn: logger.warn,
|
||||
error: logger.error,
|
||||
};
|
||||
return myCustomProvider;
|
||||
}
|
||||
```
|
||||
|
||||
### http-proxy events
|
||||
|
||||
Subscribe to [http-proxy events](https://github.com/nodejitsu/node-http-proxy#listening-for-proxy-events):
|
||||
|
||||
- **option.onError**: function, subscribe to http-proxy's `error` event for custom error handling.
|
||||
|
||||
```javascript
|
||||
function onError(err, req, res) {
|
||||
res.writeHead(500, {
|
||||
'Content-Type': 'text/plain',
|
||||
});
|
||||
res.end('Something went wrong. And we are reporting a custom error message.');
|
||||
}
|
||||
```
|
||||
|
||||
- **option.onProxyRes**: function, subscribe to http-proxy's `proxyRes` event.
|
||||
|
||||
```javascript
|
||||
function onProxyRes(proxyRes, req, res) {
|
||||
proxyRes.headers['x-added'] = 'foobar'; // add new header to response
|
||||
delete proxyRes.headers['x-removed']; // remove header from response
|
||||
}
|
||||
```
|
||||
|
||||
- **option.onProxyReq**: function, subscribe to http-proxy's `proxyReq` event.
|
||||
|
||||
```javascript
|
||||
function onProxyReq(proxyReq, req, res) {
|
||||
// add custom header to request
|
||||
proxyReq.setHeader('x-added', 'foobar');
|
||||
// or log the req
|
||||
}
|
||||
```
|
||||
|
||||
- **option.onProxyReqWs**: function, subscribe to http-proxy's `proxyReqWs` event.
|
||||
|
||||
```javascript
|
||||
function onProxyReqWs(proxyReq, req, socket, options, head) {
|
||||
// add custom header
|
||||
proxyReq.setHeader('X-Special-Proxy-Header', 'foobar');
|
||||
}
|
||||
```
|
||||
|
||||
- **option.onOpen**: function, subscribe to http-proxy's `open` event.
|
||||
|
||||
```javascript
|
||||
function onOpen(proxySocket) {
|
||||
// listen for messages coming FROM the target here
|
||||
proxySocket.on('data', hybiParseAndLogMessage);
|
||||
}
|
||||
```
|
||||
|
||||
- **option.onClose**: function, subscribe to http-proxy's `close` event.
|
||||
|
||||
```javascript
|
||||
function onClose(res, socket, head) {
|
||||
// view disconnected websocket connections
|
||||
console.log('Client disconnected');
|
||||
}
|
||||
```
|
||||
|
||||
### http-proxy options
|
||||
|
||||
The following options are provided by the underlying [http-proxy](https://github.com/nodejitsu/node-http-proxy#options) library.
|
||||
|
||||
- **option.target**: url string to be parsed with the url module
|
||||
- **option.forward**: url string to be parsed with the url module
|
||||
- **option.agent**: object to be passed to http(s).request (see Node's [https agent](http://nodejs.org/api/https.html#https_class_https_agent) and [http agent](http://nodejs.org/api/http.html#http_class_http_agent) objects)
|
||||
- **option.ssl**: object to be passed to https.createServer()
|
||||
- **option.ws**: true/false: if you want to proxy websockets
|
||||
- **option.xfwd**: true/false, adds x-forward headers
|
||||
- **option.secure**: true/false, if you want to verify the SSL Certs
|
||||
- **option.toProxy**: true/false, passes the absolute URL as the `path` (useful for proxying to proxies)
|
||||
- **option.prependPath**: true/false, Default: true - specify whether you want to prepend the target's path to the proxy path
|
||||
- **option.ignorePath**: true/false, Default: false - specify whether you want to ignore the proxy path of the incoming request (note: you will have to append / manually if required).
|
||||
- **option.localAddress** : Local interface string to bind for outgoing connections
|
||||
- **option.changeOrigin**: true/false, Default: false - changes the origin of the host header to the target URL
|
||||
- **option.preserveHeaderKeyCase**: true/false, Default: false - specify whether you want to keep letter case of response header key
|
||||
- **option.auth** : Basic authentication i.e. 'user:password' to compute an Authorization header.
|
||||
- **option.hostRewrite**: rewrites the location hostname on (301/302/307/308) redirects.
|
||||
- **option.autoRewrite**: rewrites the location host/port on (301/302/307/308) redirects based on requested host/port. Default: false.
|
||||
- **option.protocolRewrite**: rewrites the location protocol on (301/302/307/308) redirects to 'http' or 'https'. Default: null.
|
||||
- **option.cookieDomainRewrite**: rewrites domain of `set-cookie` headers. Possible values:
|
||||
- `false` (default): disable cookie rewriting
|
||||
- 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",
|
||||
"*": ""
|
||||
}
|
||||
```
|
||||
- **option.cookiePathRewrite**: rewrites path of `set-cookie` headers. Possible values:
|
||||
- `false` (default): disable cookie rewriting
|
||||
- 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/",
|
||||
"*": ""
|
||||
}
|
||||
```
|
||||
- **option.headers**: object, adds [request headers](https://en.wikipedia.org/wiki/List_of_HTTP_header_fields#Request_fields). (Example: `{host:'www.example.org'}`)
|
||||
- **option.proxyTimeout**: timeout (in millis) when proxy receives no response from target
|
||||
- **option.timeout**: timeout (in millis) for incoming requests
|
||||
- **option.followRedirects**: true/false, Default: false - specify whether you want to follow redirects
|
||||
- **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');
|
||||
const HttpProxy = require('http-proxy');
|
||||
const proxy = new HttpProxy();
|
||||
|
||||
module.exports = (req, res, next) => {
|
||||
proxy.web(
|
||||
req,
|
||||
res,
|
||||
{
|
||||
target: 'http://localhost:4003/',
|
||||
buffer: streamify(req.rawBody),
|
||||
},
|
||||
next
|
||||
);
|
||||
};
|
||||
```
|
||||
|
||||
## Shorthand
|
||||
|
||||
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
|
||||
createProxyMiddleware('http://www.example.org:8000/api');
|
||||
// createProxyMiddleware('/api', {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'});
|
||||
|
||||
createProxyMiddleware('http://www.example.org:8000/api', { changeOrigin: true });
|
||||
// createProxyMiddleware('/api', {target: 'http://www.example.org:8000', changeOrigin: true});
|
||||
```
|
||||
|
||||
### app.use(path, proxy)
|
||||
|
||||
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', 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
|
||||
createProxyMiddleware('/', { target: 'http://echo.websocket.org', ws: true });
|
||||
|
||||
// shorthand
|
||||
createProxyMiddleware('http://echo.websocket.org', { ws: true });
|
||||
|
||||
// shorter shorthand
|
||||
createProxyMiddleware('ws://echo.websocket.org');
|
||||
```
|
||||
|
||||
### External WebSocket upgrade
|
||||
|
||||
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
|
||||
const wsProxy = createProxyMiddleware('ws://echo.websocket.org', { changeOrigin: true });
|
||||
|
||||
const app = express();
|
||||
app.use(wsProxy);
|
||||
|
||||
const server = app.listen(3000);
|
||||
server.on('upgrade', wsProxy.upgrade); // <-- subscribe to http 'upgrade'
|
||||
```
|
||||
|
||||
## Working examples
|
||||
|
||||
View and play around with [working examples](https://github.com/chimurai/http-proxy-middleware/tree/master/examples).
|
||||
|
||||
- Browser-Sync ([example source](https://github.com/chimurai/http-proxy-middleware/tree/master/examples/browser-sync/index.js))
|
||||
- express ([example source](https://github.com/chimurai/http-proxy-middleware/tree/master/examples/express/index.js))
|
||||
- connect ([example source](https://github.com/chimurai/http-proxy-middleware/tree/master/examples/connect/index.js))
|
||||
- WebSocket ([example source](https://github.com/chimurai/http-proxy-middleware/tree/master/examples/websocket/index.js))
|
||||
|
||||
## Recipes
|
||||
|
||||
View the [recipes](https://github.com/chimurai/http-proxy-middleware/tree/master/recipes) for common use cases.
|
||||
|
||||
## Compatible servers
|
||||
|
||||
`http-proxy-middleware` is compatible with the following servers:
|
||||
|
||||
- [connect](https://www.npmjs.com/package/connect)
|
||||
- [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)
|
||||
- [gulp-webserver](https://www.npmjs.com/package/gulp-webserver)
|
||||
|
||||
Sample implementations can be found in the [server recipes](https://github.com/chimurai/http-proxy-middleware/tree/master/recipes/servers.md).
|
||||
|
||||
## Tests
|
||||
|
||||
Run the test suite:
|
||||
|
||||
```bash
|
||||
# install dependencies
|
||||
$ yarn
|
||||
|
||||
# linting
|
||||
$ yarn lint
|
||||
$ yarn lint:fix
|
||||
|
||||
# building (compile typescript to js)
|
||||
$ yarn build
|
||||
|
||||
# unit tests
|
||||
$ yarn test
|
||||
|
||||
# code coverage
|
||||
$ yarn cover
|
||||
```
|
||||
|
||||
## Changelog
|
||||
|
||||
- [View changelog](https://github.com/chimurai/http-proxy-middleware/blob/master/CHANGELOG.md)
|
||||
|
||||
## License
|
||||
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2015-2020 Steven Chim
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
import { Options } from './types';
|
||||
export declare function createConfig(context: any, opts?: any): {
|
||||
context: any;
|
||||
options: Options;
|
||||
};
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.createConfig = void 0;
|
||||
const _ = require("lodash");
|
||||
const url = require("url");
|
||||
const errors_1 = require("./errors");
|
||||
const logger_1 = require("./logger");
|
||||
const logger = logger_1.getInstance();
|
||||
function createConfig(context, opts) {
|
||||
// structure of config object to be returned
|
||||
const config = {
|
||||
context: undefined,
|
||||
options: {},
|
||||
};
|
||||
// app.use('/api', proxy({target:'http://localhost:9000'}));
|
||||
if (isContextless(context, opts)) {
|
||||
config.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.parse(context);
|
||||
const target = [oUrl.protocol, '//', oUrl.host].join('');
|
||||
config.context = oUrl.pathname || '/';
|
||||
config.options = _.assign(config.options, { target }, opts);
|
||||
if (oUrl.protocol === 'ws:' || oUrl.protocol === 'wss:') {
|
||||
config.options.ws = true;
|
||||
}
|
||||
// app.use('/api', proxy({target:'http://localhost:9000'}));
|
||||
}
|
||||
else {
|
||||
config.context = context;
|
||||
config.options = _.assign(config.options, opts);
|
||||
}
|
||||
configureLogger(config.options);
|
||||
if (!config.options.target) {
|
||||
throw new Error(errors_1.ERRORS.ERR_CONFIG_FACTORY_TARGET_MISSING);
|
||||
}
|
||||
return config;
|
||||
}
|
||||
exports.createConfig = createConfig;
|
||||
/**
|
||||
* Checks if a String only target/config is provided.
|
||||
* This can be just the host or with the optional path.
|
||||
*
|
||||
* @example
|
||||
* app.use('/api', proxy('http://localhost:9000'));
|
||||
* app.use(proxy('http://localhost:9000/api'));
|
||||
*
|
||||
* @param {String} context [description]
|
||||
* @return {Boolean} [description]
|
||||
*/
|
||||
function isStringShortHand(context) {
|
||||
if (_.isString(context)) {
|
||||
return !!url.parse(context).host;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Checks if a Object only config is provided, without a context.
|
||||
* In this case the all paths will be proxied.
|
||||
*
|
||||
* @example
|
||||
* app.use('/api', proxy({target:'http://localhost:9000'}));
|
||||
*
|
||||
* @param {Object} context [description]
|
||||
* @param {*} opts [description]
|
||||
* @return {Boolean} [description]
|
||||
*/
|
||||
function isContextless(context, opts) {
|
||||
return _.isPlainObject(context) && _.isEmpty(opts);
|
||||
}
|
||||
function configureLogger(options) {
|
||||
if (options.logLevel) {
|
||||
logger.setLevel(options.logLevel);
|
||||
}
|
||||
if (options.logProvider) {
|
||||
logger.setProvider(options.logProvider);
|
||||
}
|
||||
}
|
||||
+1
@@ -0,0 +1 @@
|
||||
export declare function match(context: any, uri: any, req: any): any;
|
||||
+82
@@ -0,0 +1,82 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.match = void 0;
|
||||
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
|
||||
if (isStringPath(context)) {
|
||||
return matchSingleStringPath(context, uri);
|
||||
}
|
||||
// single glob path
|
||||
if (isGlobPath(context)) {
|
||||
return matchSingleGlobPath(context, uri);
|
||||
}
|
||||
// multi path
|
||||
if (Array.isArray(context)) {
|
||||
if (context.every(isStringPath)) {
|
||||
return matchMultiPath(context, uri);
|
||||
}
|
||||
if (context.every(isGlobPath)) {
|
||||
return matchMultiGlobPath(context, uri);
|
||||
}
|
||||
throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_INVALID_ARRAY);
|
||||
}
|
||||
// custom matching
|
||||
if (_.isFunction(context)) {
|
||||
const pathname = getUrlPathName(uri);
|
||||
return context(pathname, req);
|
||||
}
|
||||
throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_GENERIC);
|
||||
}
|
||||
exports.match = match;
|
||||
/**
|
||||
* @param {String} context '/api'
|
||||
* @param {String} uri 'http://example.org/api/b/c/d.html'
|
||||
* @return {Boolean}
|
||||
*/
|
||||
function matchSingleStringPath(context, uri) {
|
||||
const pathname = getUrlPathName(uri);
|
||||
return pathname.indexOf(context) === 0;
|
||||
}
|
||||
function matchSingleGlobPath(pattern, uri) {
|
||||
const pathname = getUrlPathName(uri);
|
||||
const matches = micromatch([pathname], pattern);
|
||||
return matches && matches.length > 0;
|
||||
}
|
||||
function matchMultiGlobPath(patternList, uri) {
|
||||
return matchSingleGlobPath(patternList, uri);
|
||||
}
|
||||
/**
|
||||
* @param {String} contextList ['/api', '/ajax']
|
||||
* @param {String} uri 'http://example.org/api/b/c/d.html'
|
||||
* @return {Boolean}
|
||||
*/
|
||||
function matchMultiPath(contextList, uri) {
|
||||
let isMultiPath = false;
|
||||
for (const context of contextList) {
|
||||
if (matchSingleStringPath(context, uri)) {
|
||||
isMultiPath = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return isMultiPath;
|
||||
}
|
||||
/**
|
||||
* Parses URI and returns RFC 3986 path
|
||||
*
|
||||
* @param {String} uri from req.url
|
||||
* @return {String} RFC 3986 path
|
||||
*/
|
||||
function getUrlPathName(uri) {
|
||||
return uri && url.parse(uri).pathname;
|
||||
}
|
||||
function isStringPath(context) {
|
||||
return _.isString(context) && !isGlob(context);
|
||||
}
|
||||
function isGlobPath(context) {
|
||||
return isGlob(context);
|
||||
}
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
export declare enum ERRORS {
|
||||
ERR_CONFIG_FACTORY_TARGET_MISSING = "[HPM] Missing \"target\" option. Example: {target: \"http://www.example.org\"}",
|
||||
ERR_CONTEXT_MATCHER_GENERIC = "[HPM] Invalid context. Expecting something like: \"/api\" or [\"/api\", \"/ajax\"]",
|
||||
ERR_CONTEXT_MATCHER_INVALID_ARRAY = "[HPM] Invalid context. Expecting something like: [\"/api\", \"/ajax\"] or [\"/api/**\", \"!**.html\"]",
|
||||
ERR_PATH_REWRITER_CONFIG = "[HPM] Invalid pathRewrite config. Expecting object with pathRewrite config or a rewrite function"
|
||||
}
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.ERRORS = void 0;
|
||||
var ERRORS;
|
||||
(function (ERRORS) {
|
||||
ERRORS["ERR_CONFIG_FACTORY_TARGET_MISSING"] = "[HPM] Missing \"target\" option. Example: {target: \"http://www.example.org\"}";
|
||||
ERRORS["ERR_CONTEXT_MATCHER_GENERIC"] = "[HPM] Invalid context. Expecting something like: \"/api\" or [\"/api\", \"/ajax\"]";
|
||||
ERRORS["ERR_CONTEXT_MATCHER_INVALID_ARRAY"] = "[HPM] Invalid context. Expecting something like: [\"/api\", \"/ajax\"] or [\"/api/**\", \"!**.html\"]";
|
||||
ERRORS["ERR_PATH_REWRITER_CONFIG"] = "[HPM] Invalid pathRewrite config. Expecting object with pathRewrite config or a rewrite function";
|
||||
})(ERRORS = exports.ERRORS || (exports.ERRORS = {}));
|
||||
+2
@@ -0,0 +1,2 @@
|
||||
export declare function init(proxy: any, option: any): void;
|
||||
export declare function getHandlers(options: any): any;
|
||||
+64
@@ -0,0 +1,64 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.getHandlers = exports.init = void 0;
|
||||
const _ = require("lodash");
|
||||
const logger_1 = require("./logger");
|
||||
const logger = logger_1.getInstance();
|
||||
function init(proxy, option) {
|
||||
const handlers = getHandlers(option);
|
||||
for (const eventName of Object.keys(handlers)) {
|
||||
proxy.on(eventName, handlers[eventName]);
|
||||
}
|
||||
logger.debug('[HPM] Subscribed to http-proxy events:', Object.keys(handlers));
|
||||
}
|
||||
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 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 = _.camelCase('on ' + event);
|
||||
const fnHandler = _.get(options, eventName);
|
||||
if (_.isFunction(fnHandler)) {
|
||||
handlers[event] = fnHandler;
|
||||
}
|
||||
}
|
||||
// add default error handler in absence of error handler
|
||||
if (!_.isFunction(handlers.error)) {
|
||||
handlers.error = defaultErrorHandler;
|
||||
}
|
||||
// add default close handler in absence of close handler
|
||||
if (!_.isFunction(handlers.close)) {
|
||||
handlers.close = logClose;
|
||||
}
|
||||
return handlers;
|
||||
}
|
||||
exports.getHandlers = getHandlers;
|
||||
function defaultErrorHandler(err, req, res) {
|
||||
const host = req.headers && req.headers.host;
|
||||
const code = err.code;
|
||||
if (res.writeHead && !res.headersSent) {
|
||||
if (/HPE_INVALID/.test(code)) {
|
||||
res.writeHead(502);
|
||||
}
|
||||
else {
|
||||
switch (code) {
|
||||
case 'ECONNRESET':
|
||||
case 'ENOTFOUND':
|
||||
case 'ECONNREFUSED':
|
||||
res.writeHead(504);
|
||||
break;
|
||||
default:
|
||||
res.writeHead(500);
|
||||
}
|
||||
}
|
||||
}
|
||||
res.end('Error occured while trying to proxy to: ' + host + req.url);
|
||||
}
|
||||
function logClose(req, socket, head) {
|
||||
// view disconnected websocket connections
|
||||
logger.info('[HPM] Client disconnected');
|
||||
}
|
||||
Generated
Vendored
Executable
+34
@@ -0,0 +1,34 @@
|
||||
import { Filter, RequestHandler, Options } from './types';
|
||||
export declare class HttpProxyMiddleware {
|
||||
private logger;
|
||||
private config;
|
||||
private wsInternalSubscribed;
|
||||
private proxyOptions;
|
||||
private proxy;
|
||||
private pathRewriter;
|
||||
constructor(context: Filter | Options, opts?: Options);
|
||||
middleware: RequestHandler;
|
||||
private catchUpgradeRequest;
|
||||
private handleUpgrade;
|
||||
/**
|
||||
* Determine whether request should be proxied.
|
||||
*
|
||||
* @private
|
||||
* @param {String} context [description]
|
||||
* @param {Object} req [description]
|
||||
* @return {Boolean}
|
||||
*/
|
||||
private shouldProxy;
|
||||
/**
|
||||
* Apply option.router and option.pathRewrite
|
||||
* Order matters:
|
||||
* Router uses original path for routing;
|
||||
* NOT the modified path, after it has been rewritten by pathRewrite
|
||||
* @param {Object} req
|
||||
* @return {Object} proxy options
|
||||
*/
|
||||
private prepareProxyRequest;
|
||||
private applyRouter;
|
||||
private applyPathRewrite;
|
||||
private logError;
|
||||
}
|
||||
Generated
Vendored
Executable
+147
@@ -0,0 +1,147 @@
|
||||
"use strict";
|
||||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.HttpProxyMiddleware = void 0;
|
||||
const httpProxy = require("http-proxy");
|
||||
const _ = require("lodash");
|
||||
const config_factory_1 = require("./config-factory");
|
||||
const contextMatcher = require("./context-matcher");
|
||||
const handlers = require("./handlers");
|
||||
const logger_1 = require("./logger");
|
||||
const PathRewriter = require("./path-rewriter");
|
||||
const Router = require("./router");
|
||||
class HttpProxyMiddleware {
|
||||
constructor(context, opts) {
|
||||
this.logger = logger_1.getInstance();
|
||||
this.wsInternalSubscribed = false;
|
||||
// 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)) {
|
||||
try {
|
||||
const activeProxyOptions = yield this.prepareProxyRequest(req);
|
||||
this.proxy.web(req, res, activeProxyOptions);
|
||||
}
|
||||
catch (err) {
|
||||
next(err);
|
||||
}
|
||||
}
|
||||
else {
|
||||
next();
|
||||
}
|
||||
if (this.proxyOptions.ws === true) {
|
||||
// use initial request to access the server object to subscribe to http upgrade event
|
||||
this.catchUpgradeRequest(req.connection.server);
|
||||
}
|
||||
});
|
||||
this.catchUpgradeRequest = (server) => {
|
||||
if (!this.wsInternalSubscribed) {
|
||||
server.on('upgrade', this.handleUpgrade);
|
||||
// prevent duplicate upgrade handling;
|
||||
// in case external upgrade is also configured
|
||||
this.wsInternalSubscribed = true;
|
||||
}
|
||||
};
|
||||
this.handleUpgrade = (req, socket, head) => __awaiter(this, void 0, void 0, function* () {
|
||||
if (this.shouldProxy(this.config.context, req)) {
|
||||
const activeProxyOptions = yield this.prepareProxyRequest(req);
|
||||
this.proxy.ws(req, socket, head, activeProxyOptions);
|
||||
this.logger.info('[HPM] Upgrading to WebSocket');
|
||||
}
|
||||
});
|
||||
/**
|
||||
* Determine whether request should be proxied.
|
||||
*
|
||||
* @private
|
||||
* @param {String} context [description]
|
||||
* @param {Object} req [description]
|
||||
* @return {Boolean}
|
||||
*/
|
||||
this.shouldProxy = (context, req) => {
|
||||
const path = req.originalUrl || req.url;
|
||||
return contextMatcher.match(context, path, req);
|
||||
};
|
||||
/**
|
||||
* Apply option.router and option.pathRewrite
|
||||
* Order matters:
|
||||
* Router uses original path for routing;
|
||||
* NOT the modified path, after it has been rewritten by pathRewrite
|
||||
* @param {Object} req
|
||||
* @return {Object} proxy options
|
||||
*/
|
||||
this.prepareProxyRequest = (req) => __awaiter(this, void 0, void 0, function* () {
|
||||
// https://github.com/chimurai/http-proxy-middleware/issues/17
|
||||
// https://github.com/chimurai/http-proxy-middleware/issues/94
|
||||
req.url = req.originalUrl || req.url;
|
||||
// store uri before it gets rewritten for logging
|
||||
const originalPath = req.url;
|
||||
const newProxyOptions = _.assign({}, this.proxyOptions);
|
||||
// Apply in order:
|
||||
// 1. option.router
|
||||
// 2. option.pathRewrite
|
||||
yield this.applyRouter(req, newProxyOptions);
|
||||
yield this.applyPathRewrite(req, this.pathRewriter);
|
||||
// debug logging for both http(s) and websockets
|
||||
if (this.proxyOptions.logLevel === 'debug') {
|
||||
const arrow = logger_1.getArrow(originalPath, req.url, this.proxyOptions.target, newProxyOptions.target);
|
||||
this.logger.debug('[HPM] %s %s %s %s', req.method, originalPath, arrow, newProxyOptions.target);
|
||||
}
|
||||
return newProxyOptions;
|
||||
});
|
||||
// Modify option.target when router present.
|
||||
this.applyRouter = (req, options) => __awaiter(this, void 0, void 0, function* () {
|
||||
let newTarget;
|
||||
if (options.router) {
|
||||
newTarget = yield Router.getTarget(req, options);
|
||||
if (newTarget) {
|
||||
this.logger.debug('[HPM] Router new target: %s -> "%s"', options.target, newTarget);
|
||||
options.target = newTarget;
|
||||
}
|
||||
}
|
||||
});
|
||||
// rewrite path
|
||||
this.applyPathRewrite = (req, pathRewriter) => __awaiter(this, void 0, void 0, function* () {
|
||||
if (pathRewriter) {
|
||||
const path = yield pathRewriter(req.url, req);
|
||||
if (typeof path === 'string') {
|
||||
req.url = path;
|
||||
}
|
||||
else {
|
||||
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 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
|
||||
this.logger.error(errorMessage, req.url, hostname, target, err.code || err, errReference);
|
||||
};
|
||||
this.config = config_factory_1.createConfig(context, opts);
|
||||
this.proxyOptions = this.config.options;
|
||||
// create proxy
|
||||
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
|
||||
handlers.init(this.proxy, this.proxyOptions);
|
||||
// log errors for debug purpose
|
||||
this.proxy.on('error', this.logError);
|
||||
// https://github.com/chimurai/http-proxy-middleware/issues/19
|
||||
// expose function to upgrade externally
|
||||
this.middleware.upgrade = (req, socket, head) => {
|
||||
if (!this.wsInternalSubscribed) {
|
||||
this.handleUpgrade(req, socket, head);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
exports.HttpProxyMiddleware = HttpProxyMiddleware;
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
import { Filter, Options } from './types';
|
||||
export declare function createProxyMiddleware(context: Filter | Options, options?: Options): import("./types").RequestHandler;
|
||||
export { Filter, Options, RequestHandler } from './types';
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.createProxyMiddleware = void 0;
|
||||
const http_proxy_middleware_1 = require("./http-proxy-middleware");
|
||||
function createProxyMiddleware(context, options) {
|
||||
const { middleware } = new http_proxy_middleware_1.HttpProxyMiddleware(context, options);
|
||||
return middleware;
|
||||
}
|
||||
exports.createProxyMiddleware = createProxyMiddleware;
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
export declare function getInstance(): any;
|
||||
/**
|
||||
* -> normal proxy
|
||||
* => router
|
||||
* ~> pathRewrite
|
||||
* ≈> router + pathRewrite
|
||||
*
|
||||
* @param {String} originalPath
|
||||
* @param {String} newPath
|
||||
* @param {String} originalTarget
|
||||
* @param {String} newTarget
|
||||
* @return {String}
|
||||
*/
|
||||
export declare function getArrow(originalPath: any, newPath: any, originalTarget: any, newTarget: any): string;
|
||||
+136
@@ -0,0 +1,136 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.getArrow = exports.getInstance = void 0;
|
||||
const _ = require("lodash");
|
||||
const util = require("util");
|
||||
let loggerInstance;
|
||||
const defaultProvider = {
|
||||
// tslint:disable: no-console
|
||||
log: console.log,
|
||||
debug: console.log,
|
||||
info: console.info,
|
||||
warn: console.warn,
|
||||
error: console.error,
|
||||
};
|
||||
// log level 'weight'
|
||||
var LEVELS;
|
||||
(function (LEVELS) {
|
||||
LEVELS[LEVELS["debug"] = 10] = "debug";
|
||||
LEVELS[LEVELS["info"] = 20] = "info";
|
||||
LEVELS[LEVELS["warn"] = 30] = "warn";
|
||||
LEVELS[LEVELS["error"] = 50] = "error";
|
||||
LEVELS[LEVELS["silent"] = 80] = "silent";
|
||||
})(LEVELS || (LEVELS = {}));
|
||||
function getInstance() {
|
||||
if (!loggerInstance) {
|
||||
loggerInstance = new Logger();
|
||||
}
|
||||
return loggerInstance;
|
||||
}
|
||||
exports.getInstance = getInstance;
|
||||
class Logger {
|
||||
constructor() {
|
||||
this.setLevel('info');
|
||||
this.setProvider(() => defaultProvider);
|
||||
}
|
||||
// log will log messages, regardless of logLevels
|
||||
log() {
|
||||
this.provider.log(this._interpolate.apply(null, arguments));
|
||||
}
|
||||
debug() {
|
||||
if (this._showLevel('debug')) {
|
||||
this.provider.debug(this._interpolate.apply(null, arguments));
|
||||
}
|
||||
}
|
||||
info() {
|
||||
if (this._showLevel('info')) {
|
||||
this.provider.info(this._interpolate.apply(null, arguments));
|
||||
}
|
||||
}
|
||||
warn() {
|
||||
if (this._showLevel('warn')) {
|
||||
this.provider.warn(this._interpolate.apply(null, arguments));
|
||||
}
|
||||
}
|
||||
error() {
|
||||
if (this._showLevel('error')) {
|
||||
this.provider.error(this._interpolate.apply(null, arguments));
|
||||
}
|
||||
}
|
||||
setLevel(v) {
|
||||
if (this.isValidLevel(v)) {
|
||||
this.logLevel = v;
|
||||
}
|
||||
}
|
||||
setProvider(fn) {
|
||||
if (fn && this.isValidProvider(fn)) {
|
||||
this.provider = fn(defaultProvider);
|
||||
}
|
||||
}
|
||||
isValidProvider(fnProvider) {
|
||||
const result = true;
|
||||
if (fnProvider && !_.isFunction(fnProvider)) {
|
||||
throw new Error('[HPM] Log provider config error. Expecting a function.');
|
||||
}
|
||||
return result;
|
||||
}
|
||||
isValidLevel(levelName) {
|
||||
const validLevels = Object.keys(LEVELS);
|
||||
const isValid = validLevels.includes(levelName);
|
||||
if (!isValid) {
|
||||
throw new Error('[HPM] Log level error. Invalid logLevel.');
|
||||
}
|
||||
return isValid;
|
||||
}
|
||||
/**
|
||||
* Decide to log or not to log, based on the log levels 'weight'
|
||||
* @param {String} showLevel [debug, info, warn, error, silent]
|
||||
* @return {Boolean}
|
||||
*/
|
||||
_showLevel(showLevel) {
|
||||
let result = false;
|
||||
const currentLogLevel = LEVELS[this.logLevel];
|
||||
if (currentLogLevel && currentLogLevel <= LEVELS[showLevel]) {
|
||||
result = true;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
// make sure logged messages and its data are return interpolated
|
||||
// make it possible for additional log data, such date/time or custom prefix.
|
||||
_interpolate() {
|
||||
const fn = _.spread(util.format);
|
||||
const result = fn(_.slice(arguments));
|
||||
return result;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* -> normal proxy
|
||||
* => router
|
||||
* ~> pathRewrite
|
||||
* ≈> router + pathRewrite
|
||||
*
|
||||
* @param {String} originalPath
|
||||
* @param {String} newPath
|
||||
* @param {String} originalTarget
|
||||
* @param {String} newTarget
|
||||
* @return {String}
|
||||
*/
|
||||
function getArrow(originalPath, newPath, originalTarget, newTarget) {
|
||||
const arrow = ['>'];
|
||||
const isNewTarget = originalTarget !== newTarget; // router
|
||||
const isNewPath = originalPath !== newPath; // pathRewrite
|
||||
if (isNewPath && !isNewTarget) {
|
||||
arrow.unshift('~');
|
||||
}
|
||||
else if (!isNewPath && isNewTarget) {
|
||||
arrow.unshift('=');
|
||||
}
|
||||
else if (isNewPath && isNewTarget) {
|
||||
arrow.unshift('≈');
|
||||
}
|
||||
else {
|
||||
arrow.unshift('-');
|
||||
}
|
||||
return arrow.join('');
|
||||
}
|
||||
exports.getArrow = getArrow;
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
/**
|
||||
* Create rewrite function, to cache parsed rewrite rules.
|
||||
*
|
||||
* @param {Object} rewriteConfig
|
||||
* @return {Function} Function to rewrite paths; This function should accept `path` (request.url) as parameter
|
||||
*/
|
||||
export declare function createPathRewriter(rewriteConfig: any): (...args: any[]) => any;
|
||||
+68
@@ -0,0 +1,68 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.createPathRewriter = void 0;
|
||||
const _ = require("lodash");
|
||||
const errors_1 = require("./errors");
|
||||
const logger_1 = require("./logger");
|
||||
const logger = logger_1.getInstance();
|
||||
/**
|
||||
* Create rewrite function, to cache parsed rewrite rules.
|
||||
*
|
||||
* @param {Object} rewriteConfig
|
||||
* @return {Function} Function to rewrite paths; This function should accept `path` (request.url) as parameter
|
||||
*/
|
||||
function createPathRewriter(rewriteConfig) {
|
||||
let rulesCache;
|
||||
if (!isValidRewriteConfig(rewriteConfig)) {
|
||||
return;
|
||||
}
|
||||
if (_.isFunction(rewriteConfig)) {
|
||||
const customRewriteFn = rewriteConfig;
|
||||
return customRewriteFn;
|
||||
}
|
||||
else {
|
||||
rulesCache = parsePathRewriteRules(rewriteConfig);
|
||||
return rewritePath;
|
||||
}
|
||||
function rewritePath(path) {
|
||||
let result = path;
|
||||
_.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);
|
||||
return false;
|
||||
}
|
||||
});
|
||||
return result;
|
||||
}
|
||||
}
|
||||
exports.createPathRewriter = createPathRewriter;
|
||||
function isValidRewriteConfig(rewriteConfig) {
|
||||
if (_.isFunction(rewriteConfig)) {
|
||||
return true;
|
||||
}
|
||||
else if (!_.isEmpty(rewriteConfig) && _.isPlainObject(rewriteConfig)) {
|
||||
return true;
|
||||
}
|
||||
else if (_.isUndefined(rewriteConfig) ||
|
||||
_.isNull(rewriteConfig) ||
|
||||
_.isEqual(rewriteConfig, {})) {
|
||||
return false;
|
||||
}
|
||||
else {
|
||||
throw new Error(errors_1.ERRORS.ERR_PATH_REWRITER_CONFIG);
|
||||
}
|
||||
}
|
||||
function parsePathRewriteRules(rewriteConfig) {
|
||||
const rules = [];
|
||||
if (_.isPlainObject(rewriteConfig)) {
|
||||
_.forIn(rewriteConfig, (value, key) => {
|
||||
rules.push({
|
||||
regex: new RegExp(key),
|
||||
value: rewriteConfig[key],
|
||||
});
|
||||
logger.info('[HPM] Proxy rewrite rule created: "%s" ~> "%s"', key, rewriteConfig[key]);
|
||||
});
|
||||
}
|
||||
return rules;
|
||||
}
|
||||
+1
@@ -0,0 +1 @@
|
||||
export declare function getTarget(req: any, config: any): Promise<any>;
|
||||
+57
@@ -0,0 +1,57 @@
|
||||
"use strict";
|
||||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.getTarget = void 0;
|
||||
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 (_.isPlainObject(router)) {
|
||||
newTarget = getTargetFromProxyTable(req, router);
|
||||
}
|
||||
else if (_.isFunction(router)) {
|
||||
newTarget = yield router(req);
|
||||
}
|
||||
return newTarget;
|
||||
});
|
||||
}
|
||||
exports.getTarget = getTarget;
|
||||
function getTargetFromProxyTable(req, table) {
|
||||
let result;
|
||||
const host = req.headers.host;
|
||||
const path = req.url;
|
||||
const hostAndPath = host + path;
|
||||
_.forIn(table, (value, key) => {
|
||||
if (containsPath(key)) {
|
||||
if (hostAndPath.indexOf(key) > -1) {
|
||||
// match 'localhost:3000/api'
|
||||
result = table[key];
|
||||
logger.debug('[HPM] Router table match: "%s"', key);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (key === host) {
|
||||
// match 'localhost:3000'
|
||||
result = table[key];
|
||||
logger.debug('[HPM] Router table match: "%s"', host);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
});
|
||||
return result;
|
||||
}
|
||||
function containsPath(v) {
|
||||
return v.indexOf('/') > -1;
|
||||
}
|
||||
+38
@@ -0,0 +1,38 @@
|
||||
/// <reference types="node" />
|
||||
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 Response extends express.Response {
|
||||
}
|
||||
export interface RequestHandler extends express.RequestHandler {
|
||||
upgrade?: (req: Request, socket: net.Socket, head: any) => void;
|
||||
}
|
||||
export declare type Filter = string | string[] | ((pathname: string, req: Request) => boolean);
|
||||
export interface Options extends httpProxy.ServerOptions {
|
||||
pathRewrite?: {
|
||||
[regexp: string]: string;
|
||||
} | ((path: string, req: Request) => string) | ((path: string, req: Request) => Promise<string>);
|
||||
router?: {
|
||||
[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: 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: Response, socket: net.Socket, head: any): void;
|
||||
}
|
||||
interface LogProvider {
|
||||
log: Logger;
|
||||
debug?: Logger;
|
||||
info?: Logger;
|
||||
warn?: Logger;
|
||||
error?: Logger;
|
||||
}
|
||||
declare type Logger = (...args: any[]) => void;
|
||||
export {};
|
||||
+2
@@ -0,0 +1,2 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
+95
@@ -0,0 +1,95 @@
|
||||
{
|
||||
"name": "http-proxy-middleware",
|
||||
"version": "1.0.6",
|
||||
"description": "The one-liner node.js proxy middleware for connect, express and browser-sync",
|
||||
"main": "dist/index.js",
|
||||
"types": "dist/index.d.ts",
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"scripts": {
|
||||
"clean": "rm -rf dist && rm -rf coverage",
|
||||
"lint": "yarn lint:prettier && yarn lint:tslint",
|
||||
"lint:prettier": "prettier --check \"**/*.{js,ts,md}\"",
|
||||
"lint:tslint": "yarn tslint -c tslint.json '{lib,test}/**/*.ts'",
|
||||
"lint:fix": "prettier --write \"**/*.{js,ts,md}\"",
|
||||
"build": "tsc",
|
||||
"pretest": "yarn build",
|
||||
"test": "jest",
|
||||
"coverage": "jest --coverage --coverageReporters=lcov",
|
||||
"prepare": "yarn clean && yarn build && rm dist/tsconfig.tsbuildinfo"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/chimurai/http-proxy-middleware.git"
|
||||
},
|
||||
"keywords": [
|
||||
"reverse",
|
||||
"proxy",
|
||||
"middleware",
|
||||
"http",
|
||||
"https",
|
||||
"connect",
|
||||
"express",
|
||||
"polka",
|
||||
"browser-sync",
|
||||
"gulp",
|
||||
"grunt-contrib-connect",
|
||||
"websocket",
|
||||
"ws",
|
||||
"cors"
|
||||
],
|
||||
"author": "Steven Chim",
|
||||
"license": "MIT",
|
||||
"bugs": {
|
||||
"url": "https://github.com/chimurai/http-proxy-middleware/issues"
|
||||
},
|
||||
"homepage": "https://github.com/chimurai/http-proxy-middleware#readme",
|
||||
"devDependencies": {
|
||||
"@commitlint/cli": "^11.0.0",
|
||||
"@commitlint/config-conventional": "^11.0.0",
|
||||
"@types/express": "^4.17.3",
|
||||
"@types/is-glob": "^4.0.1",
|
||||
"@types/jest": "^26.0.14",
|
||||
"@types/lodash": "^4.14.162",
|
||||
"@types/micromatch": "^4.0.1",
|
||||
"@types/node": "^14.11.8",
|
||||
"@types/supertest": "^2.0.10",
|
||||
"browser-sync": "^2.26.12",
|
||||
"connect": "^3.7.0",
|
||||
"express": "^4.17.1",
|
||||
"husky": "^4.3.0",
|
||||
"jest": "^26.5.3",
|
||||
"lint-staged": "^10.4.0",
|
||||
"mockttp": "^1.0.2",
|
||||
"open": "^7.3.0",
|
||||
"prettier": "^2.1.2",
|
||||
"supertest": "^5.0.0",
|
||||
"ts-jest": "^26.4.1",
|
||||
"tslint": "^6.1.3",
|
||||
"tslint-config-prettier": "^1.18.0",
|
||||
"typescript": "^4.0.3",
|
||||
"ws": "^7.3.1"
|
||||
},
|
||||
"dependencies": {
|
||||
"@types/http-proxy": "^1.17.4",
|
||||
"http-proxy": "^1.18.1",
|
||||
"is-glob": "^4.0.1",
|
||||
"lodash": "^4.17.20",
|
||||
"micromatch": "^4.0.2"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=8.0.0"
|
||||
},
|
||||
"husky": {
|
||||
"hooks": {
|
||||
"commit-msg": "commitlint -E HUSKY_GIT_PARAMS",
|
||||
"pre-commit": "lint-staged"
|
||||
}
|
||||
},
|
||||
"commitlint": {
|
||||
"extends": [
|
||||
"@commitlint/config-conventional"
|
||||
]
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user