http-proxy-middleware 2.0.6 → 3.0.0-beta.0

package/dist/legacy/types.d.ts

@@ -0,0 +1,110 @@
+import { Options } from '..';
+/**
+ * @deprecated
+ *
+ * Will be removed in a future version.
+ */
+export interface LegacyOptions extends Options {
+    /**
+     * @deprecated
+     * Use `on.error` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    error: () => {}
+     * }
+     * ```
+     */
+    onError?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.proxyRes` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    proxyRes: () => {}
+     * }
+     * ```
+     */
+    onProxyRes?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.proxyReq` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    proxyReq: () => {}
+     * }
+     * ```
+     */
+    onProxyReq?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.proxyReqWs` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    proxyReqWs: () => {}
+     * }
+     * ```
+     */
+    onProxyReqWs?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.open` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    open: () => {}
+     * }
+     * ```
+     */
+    onOpen?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.close` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    close: () => {}
+     * }
+     * ```
+     */
+    onClose?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `logger` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *  logger: console
+     * }
+     * ```
+     */
+    logProvider?: any;
+    /**
+     * @deprecated
+     * Use `logger` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *  logger: console
+     * }
+     * ```
+     */
+    logLevel?: any;
+}

package/dist/legacy/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/logger.d.ts

@@ -1,14 +1,2 @@
-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;
+import { Logger, Options } from './types';
+export declare function getLogger(options: Options): Logger;

package/dist/logger.js

@@ -1,135 +1,26 @@
 "use strict";
-/* eslint-disable prefer-rest-params */
+/* eslint-disable @typescript-eslint/no-empty-function */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getArrow = exports.getInstance = void 0;
-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 && typeof fnProvider !== 'function') {
-            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(format, ...args) {
-        const result = util.format(format, ...args);
-        return result;
-    }
-}
+exports.getLogger = void 0;
 /**
- * -> normal proxy
- * => router
- * ~> pathRewrite
- * ≈> router + pathRewrite
+ * Compatibility matrix
  *
- * @param  {String} originalPath
- * @param  {String} newPath
- * @param  {String} originalTarget
- * @param  {String} newTarget
- * @return {String}
+  | Library  |  log  |  info  | warn  |  error  | \<interpolation\> |
+  |----------|:------|:-------|:------|:--------|:------------------|
+  | console  |   ✅   |  ✅   |   ✅   |   ✅    |   ✅ (%s %o %O)   |
+  | bunyan   |   ❌   |  ✅   |   ✅   |   ✅    |   ✅ (%s %o %O)   |
+  | pino     |   ❌   |  ✅   |   ✅   |   ✅    |   ✅ (%s %o %O)   |
+  | winston  |   ❌   |  ✅   |   ✅   |   ✅    |   ✅ (%s %o %O)^1 |
+  | log4js   |   ❌   |  ✅   |   ✅   |   ✅    |   ✅ (%s %o %O)   |
+ *
+ * ^1: https://github.com/winstonjs/winston#string-interpolation
  */
-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('');
+const noopLogger = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+function getLogger(options) {
+    return options.logger || noopLogger;
 }
-exports.getArrow = getArrow;
+exports.getLogger = getLogger;

package/dist/path-filter.d.ts

@@ -0,0 +1,2 @@
+import type { Filter, Request } from './types';
+export declare function matchPathFilter(pathFilter: Filter, uri: string, req: Request): boolean;

package/dist/{context-matcher.js → path-filter.js}

@@ -1,45 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.match = void 0;
+exports.matchPathFilter = void 0;
 const isGlob = require("is-glob");
 const micromatch = require("micromatch");
 const url = require("url");
 const errors_1 = require("./errors");
-function match(context, uri, req) {
+function matchPathFilter(pathFilter = '/', uri, req) {
     // single path
-    if (isStringPath(context)) {
-        return matchSingleStringPath(context, uri);
+    if (isStringPath(pathFilter)) {
+        return matchSingleStringPath(pathFilter, uri);
     }
     // single glob path
-    if (isGlobPath(context)) {
-        return matchSingleGlobPath(context, uri);
+    if (isGlobPath(pathFilter)) {
+        return matchSingleGlobPath(pathFilter, uri);
     }
     // multi path
-    if (Array.isArray(context)) {
-        if (context.every(isStringPath)) {
-            return matchMultiPath(context, uri);
+    if (Array.isArray(pathFilter)) {
+        if (pathFilter.every(isStringPath)) {
+            return matchMultiPath(pathFilter, uri);
         }
-        if (context.every(isGlobPath)) {
-            return matchMultiGlobPath(context, uri);
+        if (pathFilter.every(isGlobPath)) {
+            return matchMultiGlobPath(pathFilter, uri);
         }
         throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_INVALID_ARRAY);
     }
     // custom matching
-    if (typeof context === 'function') {
+    if (typeof pathFilter === 'function') {
         const pathname = getUrlPathName(uri);
-        return context(pathname, req);
+        return pathFilter(pathname, req);
     }
     throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_GENERIC);
 }
-exports.match = match;
+exports.matchPathFilter = matchPathFilter;
 /**
- * @param  {String} context '/api'
+ * @param  {String} pathFilter '/api'
  * @param  {String} uri     'http://example.org/api/b/c/d.html'
  * @return {Boolean}
  */
-function matchSingleStringPath(context, uri) {
+function matchSingleStringPath(pathFilter, uri) {
     const pathname = getUrlPathName(uri);
-    return pathname.indexOf(context) === 0;
+    return pathname.indexOf(pathFilter) === 0;
 }
 function matchSingleGlobPath(pattern, uri) {
     const pathname = getUrlPathName(uri);
@@ -50,13 +50,13 @@ function matchMultiGlobPath(patternList, uri) {
     return matchSingleGlobPath(patternList, uri);
 }
 /**
- * @param  {String} contextList ['/api', '/ajax']
+ * @param  {String} pathFilterList ['/api', '/ajax']
  * @param  {String} uri     'http://example.org/api/b/c/d.html'
  * @return {Boolean}
  */
-function matchMultiPath(contextList, uri) {
+function matchMultiPath(pathFilterList, uri) {
     let isMultiPath = false;
-    for (const context of contextList) {
+    for (const context of pathFilterList) {
         if (matchSingleStringPath(context, uri)) {
             isMultiPath = true;
             break;
@@ -73,9 +73,9 @@ function matchMultiPath(contextList, uri) {
 function getUrlPathName(uri) {
     return uri && url.parse(uri).pathname;
 }
-function isStringPath(context) {
-    return typeof context === 'string' && !isGlob(context);
+function isStringPath(pathFilter) {
+    return typeof pathFilter === 'string' && !isGlob(pathFilter);
 }
-function isGlobPath(context) {
-    return isGlob(context);
+function isGlobPath(pathFilter) {
+    return isGlob(pathFilter);
 }

package/dist/path-rewriter.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPathRewriter = void 0;
 const isPlainObj = require("is-plain-obj");
 const errors_1 = require("./errors");
-const logger_1 = require("./logger");
-const logger = (0, logger_1.getInstance)();
+const debug_1 = require("./debug");
+const debug = debug_1.Debug.extend('path-rewriter');
 /**
  * Create rewrite function, to cache parsed rewrite rules.
  *
@@ -29,7 +29,7 @@ function createPathRewriter(rewriteConfig) {
         for (const rule of rulesCache) {
             if (rule.regex.test(path)) {
                 result = result.replace(rule.regex, rule.value);
-                logger.debug('[HPM] Rewriting path from "%s" to "%s"', path, result);
+                debug('rewriting path from "%s" to "%s"', path, result);
                 break;
             }
         }
@@ -54,12 +54,12 @@ function isValidRewriteConfig(rewriteConfig) {
 function parsePathRewriteRules(rewriteConfig) {
     const rules = [];
     if (isPlainObj(rewriteConfig)) {
-        for (const [key] of Object.entries(rewriteConfig)) {
+        for (const [key, value] of Object.entries(rewriteConfig)) {
             rules.push({
                 regex: new RegExp(key),
-                value: rewriteConfig[key],
+                value: value,
             });
-            logger.info('[HPM] Proxy rewrite rule created: "%s" ~> "%s"', key, rewriteConfig[key]);
+            debug('rewrite rule created: "%s" ~> "%s"', key, value);
         }
     }
     return rules;

package/dist/plugins/default/debug-proxy-errors-plugin.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from '../../types';
+/**
+ * Subscribe to {@link https://www.npmjs.com/package/http-proxy#listening-for-proxy-events http-proxy error events} to prevent server from crashing.
+ * Errors are logged with {@link https://www.npmjs.com/package/debug debug} library.
+ */
+export declare const debugProxyErrorsPlugin: Plugin;

package/dist/plugins/default/debug-proxy-errors-plugin.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugProxyErrorsPlugin = void 0;
+const debug_1 = require("../../debug");
+const debug = debug_1.Debug.extend('debug-proxy-errors-plugin');
+/**
+ * Subscribe to {@link https://www.npmjs.com/package/http-proxy#listening-for-proxy-events http-proxy error events} to prevent server from crashing.
+ * Errors are logged with {@link https://www.npmjs.com/package/debug debug} library.
+ */
+const debugProxyErrorsPlugin = (proxyServer) => {
+    /**
+     * http-proxy doesn't handle any errors by default (https://github.com/http-party/node-http-proxy#listening-for-proxy-events)
+     * Prevent server from crashing when http-proxy errors (uncaught errors)
+     */
+    proxyServer.on('error', (error, req, res, target) => {
+        debug(`http-proxy error event: \n%O`, error);
+    });
+    proxyServer.on('proxyReq', (proxyReq, req, socket) => {
+        socket.on('error', (error) => {
+            debug('Socket error in proxyReq event: \n%O', error);
+        });
+    });
+    /**
+     * Fix SSE close events
+     * @link https://github.com/chimurai/http-proxy-middleware/issues/678
+     * @link https://github.com/http-party/node-http-proxy/issues/1520#issue-877626125
+     */
+    proxyServer.on('proxyRes', (proxyRes, req, res) => {
+        res.on('close', () => {
+            if (!res.writableEnded) {
+                debug('Destroying proxyRes in proxyRes close event');
+                proxyRes.destroy();
+            }
+        });
+    });
+    /**
+     * Fix crash when target server restarts
+     * https://github.com/chimurai/http-proxy-middleware/issues/476#issuecomment-746329030
+     * https://github.com/webpack/webpack-dev-server/issues/1642#issuecomment-790602225
+     */
+    proxyServer.on('proxyReqWs', (proxyReq, req, socket) => {
+        socket.on('error', (error) => {
+            debug('Socket error in proxyReqWs event: \n%O', error);
+        });
+    });
+    proxyServer.on('open', (proxySocket) => {
+        proxySocket.on('error', (error) => {
+            debug('Socket error in open event: \n%O', error);
+        });
+    });
+    proxyServer.on('close', (req, socket, head) => {
+        socket.on('error', (error) => {
+            debug('Socket error in close event: \n%O', error);
+        });
+    });
+    // https://github.com/webpack/webpack-dev-server/issues/1642#issuecomment-1103136590
+    proxyServer.on('econnreset', (error, req, res, target) => {
+        debug(`http-proxy econnreset event: \n%O`, error);
+    });
+};
+exports.debugProxyErrorsPlugin = debugProxyErrorsPlugin;

package/dist/plugins/default/error-response-plugin.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '../../types';
+export declare const errorResponsePlugin: Plugin;

package/dist/plugins/default/error-response-plugin.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorResponsePlugin = void 0;
+const status_code_1 = require("../../status-code");
+const errorResponsePlugin = (proxyServer, options) => {
+    proxyServer.on('error', (err, req, res, target) => {
+        // Re-throw error. Not recoverable since req & res are empty.
+        if (!req && !res) {
+            throw err; // "Error: Must provide a proper URL as target"
+        }
+        if (res.writeHead && !res.headersSent) {
+            const statusCode = (0, status_code_1.getStatusCode)(err.code);
+            res.writeHead(statusCode);
+        }
+        const host = req.headers && req.headers.host;
+        res.end(`Error occurred while trying to proxy: ${host}${req.url}`);
+    });
+};
+exports.errorResponsePlugin = errorResponsePlugin;

package/dist/plugins/default/index.d.ts

@@ -0,0 +1,4 @@
+export * from './debug-proxy-errors-plugin';
+export * from './error-response-plugin';
+export * from './logger-plugin';
+export * from './proxy-events';

package/dist/plugins/default/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./debug-proxy-errors-plugin"), exports);
+__exportStar(require("./error-response-plugin"), exports);
+__exportStar(require("./logger-plugin"), exports);
+__exportStar(require("./proxy-events"), exports);

package/dist/plugins/default/logger-plugin.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '../../types';
+export declare const loggerPlugin: Plugin;

package/dist/plugins/default/logger-plugin.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerPlugin = void 0;
+const logger_1 = require("../../logger");
+const loggerPlugin = (proxyServer, options) => {
+    const logger = (0, logger_1.getLogger)(options);
+    proxyServer.on('error', (err, req, res, target) => {
+        var _a;
+        const hostname = (_a = req === null || req === void 0 ? void 0 : req.headers) === null || _a === void 0 ? void 0 : _a.host;
+        const requestHref = `${hostname}${req === null || req === void 0 ? void 0 : 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
+        logger.error(errorMessage, requestHref, targetHref, err.code || err, errReference);
+    });
+    /**
+     * Log request and response
+     * @example
+     * ```shell
+     * [HPM] GET /users/ -> http://jsonplaceholder.typicode.com/users/ [304]
+     * ```
+     */
+    proxyServer.on('proxyRes', (proxyRes, req, res) => {
+        var _a;
+        // BrowserSync uses req.originalUrl
+        const originalUrl = (_a = req.originalUrl) !== null && _a !== void 0 ? _a : `${req.baseUrl}${req.path}`;
+        const exchange = `[HPM] ${req.method} ${originalUrl} -> ${proxyRes.req.protocol}//${proxyRes.req.host}${proxyRes.req.path} [${proxyRes.statusCode}]`;
+        logger.info(exchange);
+    });
+    /**
+     * When client opens WebSocket connection
+     */
+    proxyServer.on('open', (socket) => {
+        logger.info('[HPM] Client connected: %o', socket.address());
+    });
+    /**
+     * When client closes WebSocket connection
+     */
+    proxyServer.on('close', (req, proxySocket, proxyHead) => {
+        logger.info('[HPM] Client disconnected: %o', proxySocket.address());
+    });
+};
+exports.loggerPlugin = loggerPlugin;

package/dist/plugins/default/proxy-events.d.ts

@@ -0,0 +1,22 @@
+import { Plugin } from '../../types';
+/**
+ * Implements option.on object to subscribe to http-proxy events.
+ *
+ * @example
+ * ```js
+ * createProxyMiddleware({
+ *  on: {
+ *    error: (error, req, res, target) => {},
+ *    proxyReq: (proxyReq, req, res, options) => {},
+ *    proxyReqWs: (proxyReq, req, socket, options) => {},
+ *    proxyRes: (proxyRes, req, res) => {},
+ *    open: (proxySocket) => {},
+ *    close: (proxyRes, proxySocket, proxyHead) => {},
+ *    start: (req, res, target) => {},
+ *    end: (req, res, proxyRes) => {},
+ *    econnreset: (error, req, res, target) => {},
+ *  }
+ * });
+ * ```
+ */
+export declare const proxyEventsPlugin: Plugin;

package/dist/plugins/default/proxy-events.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyEventsPlugin = void 0;
+const debug_1 = require("../../debug");
+const function_1 = require("../../utils/function");
+const debug = debug_1.Debug.extend('proxy-events-plugin');
+/**
+ * Implements option.on object to subscribe to http-proxy events.
+ *
+ * @example
+ * ```js
+ * createProxyMiddleware({
+ *  on: {
+ *    error: (error, req, res, target) => {},
+ *    proxyReq: (proxyReq, req, res, options) => {},
+ *    proxyReqWs: (proxyReq, req, socket, options) => {},
+ *    proxyRes: (proxyRes, req, res) => {},
+ *    open: (proxySocket) => {},
+ *    close: (proxyRes, proxySocket, proxyHead) => {},
+ *    start: (req, res, target) => {},
+ *    end: (req, res, proxyRes) => {},
+ *    econnreset: (error, req, res, target) => {},
+ *  }
+ * });
+ * ```
+ */
+const proxyEventsPlugin = (proxyServer, options) => {
+    Object.entries(options.on || {}).forEach(([eventName, handler]) => {
+        debug(`register event handler: "${eventName}" -> "${(0, function_1.getFunctionName)(handler)}"`);
+        proxyServer.on(eventName, handler);
+    });
+};
+exports.proxyEventsPlugin = proxyEventsPlugin;