http-proxy-middleware 1.1.2-alpha.1 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [v1.2.0](https://github.com/chimurai/http-proxy-middleware/releases/tag/v1.2.0)
+
+- feat(handler): response interceptor ([#520](https://github.com/chimurai/http-proxy-middleware/pull/520))
+- fix(log error): handle undefined target when websocket errors ([#527](https://github.com/chimurai/http-proxy-middleware/pull/527))
+
+## [v1.1.2](https://github.com/chimurai/http-proxy-middleware/releases/tag/v1.1.2)
+
+- fix(log error): handle optional target ([#523](https://github.com/chimurai/http-proxy-middleware/pull/523))
+
 ## [v1.1.1](https://github.com/chimurai/http-proxy-middleware/releases/tag/v1.1.1)
 
 - fix(error handler): re-throw http-proxy missing target error ([#517](https://github.com/chimurai/http-proxy-middleware/pull/517))

package/README.md

@@ -1,10 +1,10 @@
 # http-proxy-middleware
 
-[![Build Status](https://img.shields.io/travis/chimurai/http-proxy-middleware/master.svg?style=flat-square)](https://travis-ci.org/chimurai/http-proxy-middleware)
+[![GitHub Workflow Status (branch)](https://img.shields.io/github/workflow/status/chimurai/http-proxy-middleware/Test/master?style=flat-square)](https://github.com/chimurai/http-proxy-middleware/actions?query=branch%3Amaster)
 [![Coveralls](https://img.shields.io/coveralls/chimurai/http-proxy-middleware.svg?style=flat-square)](https://coveralls.io/r/chimurai/http-proxy-middleware)
 [![dependency Status](https://img.shields.io/david/chimurai/http-proxy-middleware.svg?style=flat-square)](https://david-dm.org/chimurai/http-proxy-middleware#info=dependencies)
 [![dependency Status](https://snyk.io/test/npm/http-proxy-middleware/badge.svg?style=flat-square)](https://snyk.io/test/npm/http-proxy-middleware)
-[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![npm](https://img.shields.io/npm/v/http-proxy-middleware?color=%23CC3534&style=flat-square)](https://www.npmjs.com/package/http-proxy-middleware)
 
 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).
 
@@ -69,6 +69,7 @@ _All_ `http-proxy` [options](https://github.com/nodejitsu/node-http-proxy#option
   - [app.use\(path, proxy\)](#appusepath-proxy)
 - [WebSocket](#websocket)
   - [External WebSocket upgrade](#external-websocket-upgrade)
+- [Intercept and manipulate responses](#intercept-and-manipulate-responses)
 - [Working examples](#working-examples)
 - [Recipes](#recipes)
 - [Compatible servers](#compatible-servers)
@@ -298,7 +299,7 @@ Subscribe to [http-proxy events](https://github.com/nodejitsu/node-http-proxy#li
 - **option.onError**: function, subscribe to http-proxy's `error` event for custom error handling.
 
   ```javascript
-  function onError(err, req, res) {
+  function onError(err, req, res, target) {
     res.writeHead(500, {
       'Content-Type': 'text/plain',
     });
@@ -481,6 +482,39 @@ const server = app.listen(3000);
 server.on('upgrade', wsProxy.upgrade); // <-- subscribe to http 'upgrade'
 ```
 
+## Intercept and manipulate responses
+
+Intercept responses from upstream with `responseInterceptor`. (Make sure to set `selfHandleResponse: true`)
+
+Responses which are compressed with `brotli`, `gzip` and `deflate` will be decompressed automatically. The response will be returned as `buffer` ([docs](https://nodejs.org/api/buffer.html)) which you can manipulate.
+
+With `buffer`, response manipulation is not limited to text responses (html/css/js, etc...); image manipulation will be possible too. ([example](https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/response-interceptor.md#manipulate-image-response))
+
+NOTE: `responseInterceptor` disables streaming of target's response.
+
+Example:
+
+```javascript
+const { createProxyMiddleware, responseInterceptor } = require('http-proxy-middleware');
+
+const proxy = createProxyMiddleware({
+  /**
+   * IMPORTANT: avoid res.end being called automatically
+   **/
+  selfHandleResponse: true, // res.end() will be called internally by responseInterceptor()
+
+  /**
+   * Intercept response and replace 'Hello' with 'Goodbye'
+   **/
+  onProxyRes: responseInterceptor(async (responseBuffer, proxyRes, req, res) => {
+    const response = responseBuffer.toString('utf-8'); // convert buffer to string
+    return response.replace('Hello', 'Goodbye'); // manipulate response and return the result
+  }),
+});
+```
+
+Check out [interception recipes](https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/response-interceptor.md#readme) for more examples.
+
 ## Working examples
 
 View and play around with [working examples](https://github.com/chimurai/http-proxy-middleware/tree/master/examples).
@@ -489,6 +523,7 @@ View and play around with [working examples](https://github.com/chimurai/http-pr
 - 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))
+- Response Manipulation ([example source](https://github.com/chimurai/http-proxy-middleware/blob/master/examples/response-interceptor/index.js))
 
 ## Recipes
 

package/dist/handlers/index.d.ts

@@ -0,0 +1 @@
+export * from './public';

package/dist/handlers/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./public"), exports);

package/dist/handlers/public.d.ts

@@ -0,0 +1 @@
+export { responseInterceptor } from './response-interceptor';

package/dist/handlers/public.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseInterceptor = void 0;
+var response_interceptor_1 = require("./response-interceptor");
+Object.defineProperty(exports, "responseInterceptor", { enumerable: true, get: function () { return response_interceptor_1.responseInterceptor; } });

package/dist/handlers/response-interceptor.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import type * as http from 'http';
+declare type Interceptor = (buffer: Buffer, proxyRes: http.IncomingMessage, req: http.IncomingMessage, res: http.ServerResponse) => Promise<Buffer | string>;
+/**
+ * Intercept responses from upstream.
+ * Automatically decompress (deflate, gzip, brotli).
+ * Give developer the opportunity to modify intercepted Buffer and http.ServerResponse
+ *
+ * NOTE: must set options.selfHandleResponse=true (prevent automatic call of res.end())
+ */
+export declare function responseInterceptor(interceptor: Interceptor): (proxyRes: http.IncomingMessage, req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
+export {};

package/dist/handlers/response-interceptor.js

@@ -0,0 +1,72 @@
+"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.responseInterceptor = void 0;
+const zlib = require("zlib");
+/**
+ * Intercept responses from upstream.
+ * Automatically decompress (deflate, gzip, brotli).
+ * Give developer the opportunity to modify intercepted Buffer and http.ServerResponse
+ *
+ * NOTE: must set options.selfHandleResponse=true (prevent automatic call of res.end())
+ */
+function responseInterceptor(interceptor) {
+    return function proxyRes(proxyRes, req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const originalProxyRes = proxyRes;
+            let buffer = Buffer.from('', 'utf8');
+            // decompress proxy response
+            const _proxyRes = decompress(proxyRes, proxyRes.headers['content-encoding']);
+            // concat data stream
+            _proxyRes.on('data', (chunk) => (buffer = Buffer.concat([buffer, chunk])));
+            _proxyRes.on('end', () => __awaiter(this, void 0, void 0, function* () {
+                // set original content type from upstream
+                res.setHeader('content-type', originalProxyRes.headers['content-type'] || '');
+                // call interceptor with intercepted response (buffer)
+                const interceptedBuffer = Buffer.from(yield interceptor(buffer, originalProxyRes, req, res));
+                // set correct content-length (with double byte character support)
+                res.setHeader('content-length', Buffer.byteLength(interceptedBuffer, 'utf8'));
+                res.write(interceptedBuffer);
+                res.end();
+            }));
+            _proxyRes.on('error', (error) => {
+                res.end(`Error fetching proxied request: ${error.message}`);
+            });
+        });
+    };
+}
+exports.responseInterceptor = responseInterceptor;
+/**
+ * Streaming decompression of proxy response
+ * source: https://github.com/apache/superset/blob/9773aba522e957ed9423045ca153219638a85d2f/superset-frontend/webpack.proxy-config.js#L116
+ */
+function decompress(proxyRes, contentEncoding) {
+    let _proxyRes = proxyRes;
+    let decompress;
+    switch (contentEncoding) {
+        case 'gzip':
+            decompress = zlib.createGunzip();
+            break;
+        case 'br':
+            decompress = zlib.createBrotliDecompress();
+            break;
+        case 'deflate':
+            decompress = zlib.createInflate();
+            break;
+        default:
+            break;
+    }
+    if (decompress) {
+        _proxyRes.pipe(decompress);
+        _proxyRes = decompress;
+    }
+    return _proxyRes;
+}

package/dist/http-proxy-middleware.js

@@ -13,7 +13,7 @@ exports.HttpProxyMiddleware = void 0;
 const httpProxy = require("http-proxy");
 const config_factory_1 = require("./config-factory");
 const contextMatcher = require("./context-matcher");
-const handlers = require("./handlers");
+const handlers = require("./_handlers");
 const logger_1 = require("./logger");
 const PathRewriter = require("./path-rewriter");
 const Router = require("./router");
@@ -135,14 +135,15 @@ class HttpProxyMiddleware {
                 }
             }
         });
-        this.logError = (err, req, res) => __awaiter(this, void 0, void 0, function* () {
-            const hostname = (req.headers && req.headers.host) || req.hostname || req.host; // (websocket) || (node0.10 || node 4/5)
-            const routerTarget = yield Router.getTarget(req, this.proxyOptions);
-            const target = routerTarget || this.proxyOptions.target.host || this.proxyOptions.target;
-            const errorMessage = '[HPM] Error occurred while trying to proxy request %s from %s to %s (%s) (%s)';
+        this.logError = (err, req, res, target) => {
+            var _a;
+            const hostname = ((_a = req.headers) === null || _a === void 0 ? void 0 : _a.host) || req.hostname || req.host; // (websocket) || (node0.10 || node 4/5)
+            const requestHref = `${hostname}${req.url}`;
+            const targetHref = `${target === null || target === void 0 ? void 0 : target.href}`; // target is undefined when websocket errors
+            const errorMessage = '[HPM] Error occurred while proxying request %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.logger.error(errorMessage, requestHref, targetHref, err.code || err, errReference);
+        };
         this.config = config_factory_1.createConfig(context, opts);
         this.proxyOptions = this.config.options;
         // create proxy

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,4 +1,14 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createProxyMiddleware = void 0;
 const http_proxy_middleware_1 = require("./http-proxy-middleware");
@@ -7,3 +17,4 @@ function createProxyMiddleware(context, options) {
     return middleware;
 }
 exports.createProxyMiddleware = createProxyMiddleware;
+__exportStar(require("./handlers"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "http-proxy-middleware",
-  "version": "1.1.2-alpha.1",
+  "version": "1.2.0",
   "description": "The one-liner node.js proxy middleware for connect, express and browser-sync",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",