Merge branch 'master' into docs-response-interceptor-utf8

Author: chimurai

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [v1.2.1](https://github.com/chimurai/http-proxy-middleware/releases/tag/v1.2.1)
+
+- fix(response interceptor): proxy original response headers ([#563](https://github.com/chimurai/http-proxy-middleware/pull/563))
+
 ## [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))

README.md

@@ -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 requests](#intercept-and-manipulate-requests)
 - [Intercept and manipulate responses](#intercept-and-manipulate-responses)
 - [Working examples](#working-examples)
 - [Recipes](#recipes)
@@ -482,6 +483,25 @@ const server = app.listen(3000);
 server.on('upgrade', wsProxy.upgrade); // <-- subscribe to http 'upgrade'
 ```
 
+## Intercept and manipulate requests
+
+Intercept requests from downstream by defining `onProxyReq` in `createProxyMiddleware`.
+
+Currently the only pre-provided request interceptor is `fixRequestBody`, which is used to fix proxied POST requests when `bodyParser` is applied before this middleware.
+
+Example:
+
+```javascript
+const { createProxyMiddleware, fixRequestBody } = require('http-proxy-middleware');
+
+const proxy = createProxyMiddleware({
+  /**
+   * Fix bodyParser
+   **/
+  onProxyReq: fixRequestBody,
+});
+```
+
 ## Intercept and manipulate responses
 
 Intercept responses from upstream with `responseInterceptor`. (Make sure to set `selfHandleResponse: true`)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "http-proxy-middleware",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "The one-liner node.js proxy middleware for connect, express and browser-sync",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -60,6 +60,7 @@
     "@types/ws": "^7.4.0",
     "@typescript-eslint/eslint-plugin": "^4.19.0",
     "@typescript-eslint/parser": "^4.19.0",
+    "body-parser": "^1.19.0",
     "browser-sync": "^2.26.14",
     "connect": "^3.7.0",
     "eslint": "^7.23.0",

src/handlers/fix-request-body.ts

@@ -0,0 +1,27 @@
+import { ClientRequest } from 'http';
+import type { Request } from '../types';
+import * as querystring from 'querystring';
+
+/**
+ * Fix proxied body if bodyParser is involved.
+ */
+export function fixRequestBody(proxyReq: ClientRequest, req: Request): void {
+  if (!req.body || !Object.keys(req.body).length) {
+    return;
+  }
+
+  const contentType = proxyReq.getHeader('Content-Type') as string;
+  const writeBody = (bodyData: string) => {
+    // deepcode ignore ContentLengthInCode: bodyParser fix
+    proxyReq.setHeader('Content-Length', Buffer.byteLength(bodyData));
+    proxyReq.write(bodyData);
+  };
+
+  if (contentType.includes('application/json')) {
+    writeBody(JSON.stringify(req.body));
+  }
+
+  if (contentType === 'application/x-www-form-urlencoded') {
+    writeBody(querystring.stringify(req.body));
+  }
+}

src/handlers/public.ts

@@ -1 +1,2 @@
 export { responseInterceptor } from './response-interceptor';
+export { fixRequestBody } from './fix-request-body';

src/handlers/response-interceptor.ts

@@ -31,8 +31,8 @@ export function responseInterceptor(interceptor: Interceptor) {
     _proxyRes.on('data', (chunk) => (buffer = Buffer.concat([buffer, chunk])));
 
     _proxyRes.on('end', async () => {
-      // set original content type from upstream
-      res.setHeader('content-type', originalProxyRes.headers['content-type'] || '');
+      // copy original headers
+      copyHeaders(proxyRes, res);
 
       // call interceptor with intercepted response (buffer)
       const interceptedBuffer = Buffer.from(await interceptor(buffer, originalProxyRes, req, res));
@@ -79,3 +79,33 @@ function decompress(proxyRes: http.IncomingMessage, contentEncoding: string) {
 
   return _proxyRes;
 }
+
+/**
+ * Copy original headers
+ * https://github.com/apache/superset/blob/9773aba522e957ed9423045ca153219638a85d2f/superset-frontend/webpack.proxy-config.js#L78
+ */
+function copyHeaders(originalResponse, response) {
+  response.statusCode = originalResponse.statusCode;
+  response.statusMessage = originalResponse.statusMessage;
+
+  if (response.setHeader) {
+    let keys = Object.keys(originalResponse.headers);
+
+    // ignore chunked, brotli, gzip, deflate headers
+    keys = keys.filter((key) => !['content-encoding', 'transfer-encoding'].includes(key));
+
+    keys.forEach((key) => {
+      let value = originalResponse.headers[key];
+
+      if (key === 'set-cookie') {
+        // remove cookie domain
+        value = Array.isArray(value) ? value : [value];
+        value = value.map((x) => x.replace(/Domain=[^;]+?/i, ''));
+      }
+
+      response.setHeader(key, value);
+    });
+  } else {
+    response.headers = originalResponse.headers;
+  }
+}

test/e2e/express-router.spec.ts

@@ -1,6 +1,6 @@
 import * as express from 'express';
 import * as http from 'http';
-import { createProxyMiddleware } from './_utils';
+import { createProxyMiddleware } from './test-kit';
 import { Options } from '../../src/index';
 
 describe('Usage in Express', () => {

test/e2e/http-proxy-middleware.spec.ts

@@ -1,8 +1,9 @@
-import { createProxyMiddleware, createApp, createAppWithPath } from './_utils';
+import { createProxyMiddleware, createApp, createAppWithPath, fixRequestBody } from './test-kit';
 import * as request from 'supertest';
 import { Mockttp, getLocal, CompletedRequest } from 'mockttp';
 import { Request, Response } from '../../src/types';
 import { NextFunction } from 'express';
+import * as bodyParser from 'body-parser';
 
 describe('E2E http-proxy-middleware', () => {
   describe('http-proxy-middleware creation', () => {
@@ -78,6 +79,44 @@ describe('E2E http-proxy-middleware', () => {
       });
     });
 
+    describe('basic setup with configured body-parser', () => {
+      it('should proxy request body from form', async () => {
+        agent = request(
+          createApp(
+            bodyParser.urlencoded({ extended: false }),
+            createProxyMiddleware('/api', {
+              target: `http://localhost:${mockTargetServer.port}`,
+              onProxyReq: fixRequestBody,
+            })
+          )
+        );
+
+        await mockTargetServer.post('/api').thenCallback((req) => {
+          expect(req.body.text).toBe('foo=bar&bar=baz');
+          return { status: 200 };
+        });
+        await agent.post('/api').send('foo=bar').send('bar=baz').expect(200);
+      });
+
+      it('should proxy request body from json', async () => {
+        agent = request(
+          createApp(
+            bodyParser.json(),
+            createProxyMiddleware('/api', {
+              target: `http://localhost:${mockTargetServer.port}`,
+              onProxyReq: fixRequestBody,
+            })
+          )
+        );
+
+        await mockTargetServer.post('/api').thenCallback((req) => {
+          expect(req.body.json).toEqual({ foo: 'bar', bar: 'baz', doubleByte: '文' });
+          return { status: 200 };
+        });
+        await agent.post('/api').send({ foo: 'bar', bar: 'baz', doubleByte: '文' }).expect(200);
+      });
+    });
+
     describe('custom context matcher/filter', () => {
       it('should have response body: "HELLO WEB"', async () => {
         const filter = (path, req) => {

test/e2e/path-rewriter.spec.ts

@@ -1,4 +1,4 @@
-import { createProxyMiddleware, createApp } from './_utils';
+import { createProxyMiddleware, createApp } from './test-kit';
 import * as request from 'supertest';
 import { getLocal, Mockttp } from 'mockttp';
 

test/e2e/response-interceptor.spec.ts

@@ -1,5 +1,5 @@
 import { createProxyMiddleware, responseInterceptor } from '../../src';
-import { createApp } from './_utils';
+import { createApp } from './test-kit';
 import * as request from 'supertest';
 
 describe('responseInterceptor()', () => {
@@ -41,6 +41,32 @@ describe('responseInterceptor()', () => {
     });
   });
 
+  describe('intercept responses with original headers', () => {
+    beforeEach(() => {
+      agent = request(
+        createApp(
+          createProxyMiddleware({
+            target: `http://httpbin.org`,
+            changeOrigin: true, // for vhosted sites, changes host header to match to target's host
+            selfHandleResponse: true,
+            onProxyRes: responseInterceptor(async (responseBuffer, proxyRes, req, res) => {
+              return responseBuffer;
+            }),
+          })
+        )
+      );
+    });
+
+    it('should proxy and return original headers from http://httpbin.org/cookies/set/cookie/monster', async () => {
+      return agent
+        .get(`/cookies/set/cookie/monster`)
+        .expect('Access-Control-Allow-Origin', '*')
+        .expect('Date', /.+/)
+        .expect('set-cookie', /.*cookie=monster.*/)
+        .expect(302);
+    });
+  });
+
   describe('intercept compressed responses', () => {
     beforeEach(() => {
       agent = request(