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

package/dist/configuration.d.ts

@@ -0,0 +1,2 @@
+import { Options } from './types';
+export declare function verifyConfig(options: Options): void;

package/dist/configuration.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyConfig = void 0;
+const errors_1 = require("./errors");
+function verifyConfig(options) {
+    if (!options.target && !options.router) {
+        throw new Error(errors_1.ERRORS.ERR_CONFIG_FACTORY_TARGET_MISSING);
+    }
+}
+exports.verifyConfig = verifyConfig;

package/dist/debug.d.ts

@@ -0,0 +1,5 @@
+import * as createDebug from 'debug';
+/**
+ * Debug instance with the given namespace: http-proxy-middleware
+ */
+export declare const Debug: createDebug.Debugger;

package/dist/debug.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Debug = void 0;
+const createDebug = require("debug");
+/**
+ * Debug instance with the given namespace: http-proxy-middleware
+ */
+exports.Debug = createDebug('http-proxy-middleware');

package/dist/errors.d.ts

@@ -1,6 +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_CONTEXT_MATCHER_INVALID_ARRAY = "[HPM] Invalid pathFilter. 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"
 }

package/dist/errors.js

@@ -5,6 +5,6 @@ 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_CONTEXT_MATCHER_INVALID_ARRAY"] = "[HPM] Invalid pathFilter. 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 = {}));

package/dist/get-plugins.d.ts

@@ -0,0 +1,2 @@
+import type { Options, Plugin } from './types';
+export declare function getPlugins(options: Options): Plugin[];

package/dist/get-plugins.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlugins = void 0;
+const default_1 = require("./plugins/default");
+function getPlugins(options) {
+    var _a, _b;
+    // don't load default errorResponsePlugin if user has specified their own
+    const maybeErrorResponsePlugin = !!((_a = options.on) === null || _a === void 0 ? void 0 : _a.error) ? [] : [default_1.errorResponsePlugin];
+    const defaultPlugins = !!options.ejectPlugins
+        ? [] // no default plugins when ejecting
+        : [default_1.debugProxyErrorsPlugin, default_1.proxyEventsPlugin, default_1.loggerPlugin, ...maybeErrorResponsePlugin];
+    const userPlugins = (_b = options.plugins) !== null && _b !== void 0 ? _b : [];
+    return [...defaultPlugins, ...userPlugins];
+}
+exports.getPlugins = getPlugins;

package/dist/handlers/fix-request-body.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import type * as http from 'http';
+import type { Request } from '../types';
 /**
  * Fix proxied body if bodyParser is involved.
  */
-export declare function fixRequestBody(proxyReq: http.ClientRequest, req: http.IncomingMessage): void;
+export declare function fixRequestBody(proxyReq: http.ClientRequest, req: Request): void;

package/dist/handlers/index.js

@@ -1,7 +1,11 @@
 "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]; } });
+    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];

package/dist/handlers/response-interceptor.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.responseInterceptor = void 0;
 const zlib = require("zlib");
+const debug_1 = require("../debug");
+const function_1 = require("../utils/function");
+const debug = debug_1.Debug.extend('response-interceptor');
 /**
  * Intercept responses from upstream.
  * Automatically decompress (deflate, gzip, brotli).
@@ -10,7 +13,8 @@ const zlib = require("zlib");
  * NOTE: must set options.selfHandleResponse=true (prevent automatic call of res.end())
  */
 function responseInterceptor(interceptor) {
-    return async function proxyRes(proxyRes, req, res) {
+    return async function proxyResResponseInterceptor(proxyRes, req, res) {
+        debug('intercept proxy response');
         const originalProxyRes = proxyRes;
         let buffer = Buffer.from('', 'utf8');
         // decompress proxy response
@@ -21,9 +25,12 @@ function responseInterceptor(interceptor) {
             // copy original headers
             copyHeaders(proxyRes, res);
             // call interceptor with intercepted response (buffer)
+            debug('call interceptor function: %s', (0, function_1.getFunctionName)(interceptor));
             const interceptedBuffer = Buffer.from(await interceptor(buffer, originalProxyRes, req, res));
             // set correct content-length (with double byte character support)
+            debug('set content-length: %s', Buffer.byteLength(interceptedBuffer, 'utf8'));
             res.setHeader('content-length', Buffer.byteLength(interceptedBuffer, 'utf8'));
+            debug('write intercepted response');
             res.write(interceptedBuffer);
             res.end();
         });
@@ -54,6 +61,7 @@ function decompress(proxyRes, contentEncoding) {
             break;
     }
     if (decompress) {
+        debug(`decompress proxy response with 'content-encoding': %s`, contentEncoding);
         _proxyRes.pipe(decompress);
         _proxyRes = decompress;
     }
@@ -64,6 +72,7 @@ function decompress(proxyRes, contentEncoding) {
  * https://github.com/apache/superset/blob/9773aba522e957ed9423045ca153219638a85d2f/superset-frontend/webpack.proxy-config.js#L78
  */
 function copyHeaders(originalResponse, response) {
+    debug('copy original response headers');
     response.statusCode = originalResponse.statusCode;
     response.statusMessage = originalResponse.statusMessage;
     if (response.setHeader) {

package/dist/http-proxy-middleware.d.ts

@@ -1,23 +1,17 @@
-import type { Filter, RequestHandler, Options } from './types';
+import type { RequestHandler, Options } from './types';
 export declare class HttpProxyMiddleware {
-    private logger;
-    private config;
     private wsInternalSubscribed;
     private serverOnCloseSubscribed;
     private proxyOptions;
     private proxy;
     private pathRewriter;
-    constructor(context: Filter | Options, opts?: Options);
+    constructor(options: Options);
     middleware: RequestHandler;
+    private registerPlugins;
     private catchUpgradeRequest;
     private handleUpgrade;
     /**
      * Determine whether request should be proxied.
-     *
-     * @private
-     * @param  {String} context [description]
-     * @param  {Object} req     [description]
-     * @return {Boolean}
      */
     private shouldProxy;
     /**
@@ -31,5 +25,4 @@ export declare class HttpProxyMiddleware {
     private prepareProxyRequest;
     private applyRouter;
     private applyPathRewrite;
-    private logError;
 }

package/dist/http-proxy-middleware.js

@@ -2,31 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 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 logger_1 = require("./logger");
+const configuration_1 = require("./configuration");
+const get_plugins_1 = require("./get-plugins");
+const path_filter_1 = require("./path-filter");
 const PathRewriter = require("./path-rewriter");
 const Router = require("./router");
+const debug_1 = require("./debug");
+const function_1 = require("./utils/function");
 class HttpProxyMiddleware {
-    constructor(context, opts) {
-        this.logger = (0, logger_1.getInstance)();
+    constructor(options) {
         this.wsInternalSubscribed = false;
         this.serverOnCloseSubscribed = false;
         // https://github.com/Microsoft/TypeScript/wiki/'this'-in-TypeScript#red-flags-for-this
         this.middleware = async (req, res, next) => {
             var _a, _b;
-            if (this.shouldProxy(this.config.context, req)) {
+            if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
                 try {
                     const activeProxyOptions = await this.prepareProxyRequest(req);
+                    (0, debug_1.Debug)(`proxy request to target: %O`, activeProxyOptions.target);
                     this.proxy.web(req, res, activeProxyOptions);
                 }
                 catch (err) {
-                    next(err);
+                    next && next(err);
                 }
             }
             else {
-                next();
+                next && next();
             }
             /**
              * Get the server object to subscribe to server events;
@@ -36,10 +37,10 @@ class HttpProxyMiddleware {
              * req.socket: node >= 13
              * req.connection: node < 13 (Remove this when node 12/13 support is dropped)
              */
-            const server = (_b = ((_a = req.socket) !== null && _a !== void 0 ? _a : req.connection)) === null || _b === void 0 ? void 0 : _b.server;
+            const server = (_b = (((_a = req.socket) !== null && _a !== void 0 ? _a : req.connection))) === null || _b === void 0 ? void 0 : _b.server;
             if (server && !this.serverOnCloseSubscribed) {
                 server.on('close', () => {
-                    this.logger.info('[HPM] server close signal received: closing proxy server');
+                    (0, debug_1.Debug)('server close signal received: closing proxy server');
                     this.proxy.close();
                 });
                 this.serverOnCloseSubscribed = true;
@@ -51,6 +52,7 @@ class HttpProxyMiddleware {
         };
         this.catchUpgradeRequest = (server) => {
             if (!this.wsInternalSubscribed) {
+                (0, debug_1.Debug)('subscribing to server upgrade event');
                 server.on('upgrade', this.handleUpgrade);
                 // prevent duplicate upgrade handling;
                 // in case external upgrade is also configured
@@ -58,23 +60,17 @@ class HttpProxyMiddleware {
             }
         };
         this.handleUpgrade = async (req, socket, head) => {
-            if (this.shouldProxy(this.config.context, req)) {
+            if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
                 const activeProxyOptions = await this.prepareProxyRequest(req);
                 this.proxy.ws(req, socket, head, activeProxyOptions);
-                this.logger.info('[HPM] Upgrading to WebSocket');
+                (0, debug_1.Debug)('server upgrade event received. Proxying 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);
+        this.shouldProxy = (pathFilter, req) => {
+            return (0, path_filter_1.matchPathFilter)(pathFilter, req.url, req);
         };
         /**
          * Apply option.router and option.pathRewrite
@@ -85,22 +81,20 @@ class HttpProxyMiddleware {
          * @return {Object} proxy options
          */
         this.prepareProxyRequest = async (req) => {
-            // 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;
+            /**
+             * Incorrect usage confirmed: https://github.com/expressjs/express/issues/4854#issuecomment-1066171160
+             * Temporary restore req.url patch for {@link src/legacy/create-proxy-middleware.ts legacyCreateProxyMiddleware()}
+             * FIXME: remove this patch in future release
+             */
+            if (this.middleware.__LEGACY_HTTP_PROXY_MIDDLEWARE__) {
+                req.url = req.originalUrl || req.url;
+            }
             const newProxyOptions = Object.assign({}, this.proxyOptions);
             // Apply in order:
             // 1. option.router
             // 2. option.pathRewrite
             await this.applyRouter(req, newProxyOptions);
             await this.applyPathRewrite(req, this.pathRewriter);
-            // debug logging for both http(s) and websockets
-            if (this.proxyOptions.logLevel === 'debug') {
-                const arrow = (0, 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.
@@ -109,7 +103,7 @@ class HttpProxyMiddleware {
             if (options.router) {
                 newTarget = await Router.getTarget(req, options);
                 if (newTarget) {
-                    this.logger.debug('[HPM] Router new target: %s -> "%s"', options.target, newTarget);
+                    (0, debug_1.Debug)('router new target: "%s"', newTarget);
                     options.target = newTarget;
                 }
             }
@@ -119,32 +113,20 @@ class HttpProxyMiddleware {
             if (pathRewriter) {
                 const path = await pathRewriter(req.url, req);
                 if (typeof path === 'string') {
+                    (0, debug_1.Debug)('pathRewrite new path: %s', req.url);
                     req.url = path;
                 }
                 else {
-                    this.logger.info('[HPM] pathRewrite: No rewritten path found. (%s)', req.url);
+                    (0, debug_1.Debug)('pathRewrite: no rewritten path found: %s', req.url);
                 }
             }
         };
-        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, requestHref, targetHref, err.code || err, errReference);
-        };
-        this.config = (0, config_factory_1.createConfig)(context, opts);
-        this.proxyOptions = this.config.options;
-        // create proxy
+        (0, configuration_1.verifyConfig)(options);
+        this.proxyOptions = options;
+        (0, debug_1.Debug)(`create proxy server`);
         this.proxy = httpProxy.createProxyServer({});
-        this.logger.info(`[HPM] Proxy created: ${this.config.context}  -> ${this.proxyOptions.target}`);
+        this.registerPlugins(this.proxy, this.proxyOptions);
         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) => {
@@ -153,5 +135,12 @@ class HttpProxyMiddleware {
             }
         };
     }
+    registerPlugins(proxy, options) {
+        const plugins = (0, get_plugins_1.getPlugins)(options);
+        plugins.forEach((plugin) => {
+            (0, debug_1.Debug)(`register plugin: "${(0, function_1.getFunctionName)(plugin)}"`);
+            plugin(proxy, options);
+        });
+    }
 }
 exports.HttpProxyMiddleware = HttpProxyMiddleware;

package/dist/index.d.ts

@@ -1,4 +1,12 @@
-import { Filter, Options } from './types';
-export declare function createProxyMiddleware(context: Filter | Options, options?: Options): import("./types").RequestHandler;
+import type { Options, RequestHandler } from './types';
+export declare function createProxyMiddleware(options: Options): RequestHandler;
 export * from './handlers';
-export { Filter, Options, RequestHandler } from './types';
+export type { Filter, Options, RequestHandler } from './types';
+/**
+ * Default plugins
+ */
+export * from './plugins/default';
+/**
+ * Legacy exports
+ */
+export * from './legacy';

package/dist/index.js

@@ -1,7 +1,11 @@
 "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]; } });
+    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];
@@ -12,9 +16,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 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);
+function createProxyMiddleware(options) {
+    const { middleware } = new http_proxy_middleware_1.HttpProxyMiddleware(options);
     return middleware;
 }
 exports.createProxyMiddleware = createProxyMiddleware;
 __exportStar(require("./handlers"), exports);
+/**
+ * Default plugins
+ */
+__exportStar(require("./plugins/default"), exports);
+/**
+ * Legacy exports
+ */
+__exportStar(require("./legacy"), exports);

package/dist/legacy/create-proxy-middleware.d.ts

@@ -0,0 +1,11 @@
+import { Filter, RequestHandler } from '../types';
+import { LegacyOptions } from './types';
+/**
+ * @deprecated
+ * This function is deprecated and will be removed in a future version.
+ *
+ * Use {@link createProxyMiddleware} instead.
+ */
+export declare function legacyCreateProxyMiddleware(shortHand: string): RequestHandler;
+export declare function legacyCreateProxyMiddleware(legacyOptions: LegacyOptions): RequestHandler;
+export declare function legacyCreateProxyMiddleware(legacyContext: Filter, legacyOptions: LegacyOptions): RequestHandler;

package/dist/legacy/create-proxy-middleware.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyCreateProxyMiddleware = void 0;
+const __1 = require("..");
+const debug_1 = require("../debug");
+const options_adapter_1 = require("./options-adapter");
+const debug = debug_1.Debug.extend('legacy-create-proxy-middleware');
+function legacyCreateProxyMiddleware(legacyContext, legacyOptions) {
+    debug('init');
+    const options = (0, options_adapter_1.legacyOptionsAdapter)(legacyContext, legacyOptions);
+    const proxyMiddleware = (0, __1.createProxyMiddleware)(options);
+    // https://github.com/chimurai/http-proxy-middleware/pull/731/files#diff-07e6ad10bda0df091b737caed42767657cd0bd74a01246a1a0b7ab59c0f6e977L118
+    debug('add marker for patching req.url (old behavior)');
+    proxyMiddleware.__LEGACY_HTTP_PROXY_MIDDLEWARE__ = true;
+    return proxyMiddleware;
+}
+exports.legacyCreateProxyMiddleware = legacyCreateProxyMiddleware;

package/dist/legacy/index.d.ts

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

package/dist/legacy/index.js

@@ -0,0 +1,17 @@
+"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("./public"), exports);

package/dist/legacy/options-adapter.d.ts

@@ -0,0 +1,6 @@
+import { Filter, Options } from '..';
+import { LegacyOptions } from './types';
+/**
+ * Convert {@link LegacyOptions legacy Options} to new {@link Options}
+ */
+export declare function legacyOptionsAdapter(legacyContext: Filter | LegacyOptions, legacyOptions: LegacyOptions): Options;

package/dist/legacy/options-adapter.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyOptionsAdapter = void 0;
+const url = require("url");
+const debug_1 = require("../debug");
+const logger_1 = require("../logger");
+const debug = debug_1.Debug.extend('legacy-options-adapter');
+// https://github.com/chimurai/http-proxy-middleware/blob/7341704d0aa9d1606dfd37ebfdffddd34c894784/src/_handlers.ts#L20-L27
+const proxyEventMap = {
+    onError: 'error',
+    onProxyReq: 'proxyReq',
+    onProxyRes: 'proxyRes',
+    onProxyReqWs: 'proxyReqWs',
+    onOpen: 'open',
+    onClose: 'close',
+};
+/**
+ * Convert {@link LegacyOptions legacy Options} to new {@link Options}
+ */
+function legacyOptionsAdapter(legacyContext, legacyOptions) {
+    let options;
+    let logger;
+    // https://github.com/chimurai/http-proxy-middleware/pull/716
+    if (typeof legacyContext === 'string' && !!url.parse(legacyContext).host) {
+        throw new Error(`Shorthand syntax is removed from legacyCreateProxyMiddleware().
+      Please use "legacyCreateProxyMiddleware({ target: 'http://www.example.org' })" instead.`);
+    }
+    // detect old "context" argument and convert to "options.pathFilter"
+    // https://github.com/chimurai/http-proxy-middleware/pull/722/files#diff-a2a171449d862fe29692ce031981047d7ab755ae7f84c707aef80701b3ea0c80L4
+    if (legacyContext && legacyOptions) {
+        debug('map legacy context/filter to options.pathFilter');
+        options = { ...legacyOptions, pathFilter: legacyContext };
+        logger = getLegacyLogger(options);
+        logger.warn(`[http-proxy-middleware] Legacy "context" argument is deprecated. Migrate your "context" to "options.pathFilter":
+
+      const options = {
+        pathFilter: '${legacyContext}',
+      }
+
+      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md
+      `);
+    }
+    else if (legacyContext && !legacyOptions) {
+        options = { ...legacyContext };
+        logger = getLegacyLogger(options);
+    }
+    // map old event names to new event names
+    // https://github.com/chimurai/http-proxy-middleware/pull/745/files#diff-c54113cf61ec99691748a3890bfbeb00e10efb3f0a76f03a0fd9ec49072e410aL48-L53
+    Object.entries(proxyEventMap).forEach(([legacyEventName, proxyEventName]) => {
+        if (options[legacyEventName]) {
+            options.on = { ...options.on };
+            options.on[proxyEventName] = options[legacyEventName];
+            debug('map legacy event "%s" to "on.%s"', legacyEventName, proxyEventName);
+            logger.warn(`[http-proxy-middleware] Legacy "${legacyEventName}" is deprecated. Migrate to "options.on.${proxyEventName}":
+
+        const options = {
+          on: {
+            ${proxyEventName}: () => {},
+          },
+        }
+
+        More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md
+        `);
+        }
+    });
+    // map old logProvider to new logger
+    // https://github.com/chimurai/http-proxy-middleware/pull/749
+    const logProvider = options.logProvider && options.logProvider();
+    const logLevel = options.logLevel;
+    debug('legacy logLevel', logLevel);
+    debug('legacy logProvider: %O', logProvider);
+    if (typeof logLevel === 'string' && logLevel !== 'silent') {
+        debug('map "logProvider" to "logger"');
+        logger.warn(`[http-proxy-middleware] Legacy "logLevel" and "logProvider" are deprecated. Migrate to "options.logger":
+
+      const options = {
+        logger: console,
+      }
+
+      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md
+      `);
+    }
+    return options;
+}
+exports.legacyOptionsAdapter = legacyOptionsAdapter;
+function getLegacyLogger(options) {
+    const legacyLogger = options.logProvider && options.logProvider();
+    if (legacyLogger) {
+        options.logger = legacyLogger;
+    }
+    return (0, logger_1.getLogger)(options);
+}

package/dist/legacy/public.d.ts

@@ -0,0 +1,2 @@
+export { legacyCreateProxyMiddleware } from './create-proxy-middleware';
+export { LegacyOptions } from './types';

package/dist/legacy/public.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyCreateProxyMiddleware = void 0;
+var create_proxy_middleware_1 = require("./create-proxy-middleware");
+Object.defineProperty(exports, "legacyCreateProxyMiddleware", { enumerable: true, get: function () { return create_proxy_middleware_1.legacyCreateProxyMiddleware; } });