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

package/dist/router.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTarget = void 0;
 const isPlainObj = require("is-plain-obj");
-const logger_1 = require("./logger");
-const logger = (0, logger_1.getInstance)();
+const debug_1 = require("./debug");
+const debug = debug_1.Debug.extend('router');
 async function getTarget(req, config) {
     let newTarget;
     const router = config.router;
@@ -21,20 +21,20 @@ function getTargetFromProxyTable(req, table) {
     const host = req.headers.host;
     const path = req.url;
     const hostAndPath = host + path;
-    for (const [key] of Object.entries(table)) {
+    for (const [key, value] of Object.entries(table)) {
         if (containsPath(key)) {
             if (hostAndPath.indexOf(key) > -1) {
                 // match 'localhost:3000/api'
-                result = table[key];
-                logger.debug('[HPM] Router table match: "%s"', key);
+                result = value;
+                debug('match: "%s" -> "%s"', key, result);
                 break;
             }
         }
         else {
             if (key === host) {
                 // match 'localhost:3000'
-                result = table[key];
-                logger.debug('[HPM] Router table match: "%s"', host);
+                result = value;
+                debug('match: "%s" -> "%s"', host, result);
                 break;
             }
         }

package/dist/status-code.d.ts

@@ -0,0 +1 @@
+export declare function getStatusCode(errorCode: string): number;

package/dist/status-code.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStatusCode = void 0;
+function getStatusCode(errorCode) {
+    let statusCode;
+    if (/HPE_INVALID/.test(errorCode)) {
+        statusCode = 502;
+    }
+    else {
+        switch (errorCode) {
+            case 'ECONNRESET':
+            case 'ENOTFOUND':
+            case 'ECONNREFUSED':
+            case 'ETIMEDOUT':
+                statusCode = 504;
+                break;
+            default:
+                statusCode = 500;
+                break;
+        }
+    }
+    return statusCode;
+}
+exports.getStatusCode = getStatusCode;

package/dist/types.d.ts

@@ -3,52 +3,123 @@
  * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/6f529c6c67a447190f86bfbf894d1061e41e07b7/types/http-proxy-middleware/index.d.ts
  */
 /// <reference types="node" />
-import type * as express from 'express';
+/// <reference types="node" />
+/// <reference types="node" />
 import type * as http from 'http';
 import type * as httpProxy from 'http-proxy';
 import type * as net from 'net';
-import type * as url from 'url';
-export interface Request extends express.Request {
+export declare type NextFunction<T = (err?: any) => void> = T;
+export interface RequestHandler<TReq = http.IncomingMessage, TRes = http.ServerResponse, TNext = NextFunction> {
+    (req: TReq, res: TRes, next?: TNext): void | Promise<void>;
+    upgrade?: (req: http.IncomingMessage, socket: net.Socket, head: any) => void;
 }
-export interface Response extends express.Response {
+export declare type Filter<TReq = http.IncomingMessage> = string | string[] | ((pathname: string, req: TReq) => boolean);
+export interface Plugin<TReq = http.IncomingMessage, TRes = http.ServerResponse> {
+    (proxyServer: httpProxy<TReq, TRes>, options: Options<TReq, TRes>): void;
 }
-export interface RequestHandler extends express.RequestHandler {
-    upgrade?: (req: Request, socket: net.Socket, head: any) => void;
+export interface OnProxyEvent<TReq = http.IncomingMessage, TRes = http.ServerResponse> {
+    error?: httpProxy.ErrorCallback<Error, TReq, TRes>;
+    proxyReq?: httpProxy.ProxyReqCallback<http.ClientRequest, TReq, TRes>;
+    proxyReqWs?: httpProxy.ProxyReqWsCallback<http.ClientRequest, TReq>;
+    proxyRes?: httpProxy.ProxyResCallback<TReq, TRes>;
+    open?: httpProxy.OpenCallback;
+    close?: httpProxy.CloseCallback<TReq>;
+    start?: httpProxy.StartCallback<TReq, TRes>;
+    end?: httpProxy.EndCallback<TReq, TRes>;
+    econnreset?: httpProxy.EconnresetCallback<Error, TReq, TRes>;
 }
-export declare type Filter = string | string[] | ((pathname: string, req: Request) => boolean);
-export interface Options extends httpProxy.ServerOptions {
+export declare type Logger = Pick<Console, 'info' | 'warn' | 'error'>;
+export interface Options<TReq = http.IncomingMessage, TRes = http.ServerResponse> extends httpProxy.ServerOptions {
+    /**
+     * Narrow down requests to proxy or not.
+     * Filter on {@link http.IncomingMessage.url `pathname`} which is relative to the proxy's "mounting" point in the server.
+     * Or use the {@link http.IncomingMessage `req`}  object for more complex filtering.
+     * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/pathFilter.md
+     * @since v3.0.0
+     */
+    pathFilter?: Filter<TReq>;
+    /**
+     * Modify request paths before requests are send to the target.
+     * @example
+     * ```js
+     * createProxyMiddleware({
+     *   pathRewrite: {
+     *     '^/api/old-path': '/api/new-path', // rewrite path
+     *   }
+     * });
+     * ```
+     * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/pathRewrite.md
+     */
     pathRewrite?: {
         [regexp: string]: string;
-    } | ((path: string, req: Request) => string) | ((path: string, req: Request) => Promise<string>);
+    } | ((path: string, req: TReq) => string) | ((path: string, req: TReq) => Promise<string>);
+    /**
+     * Access the internal http-proxy server instance to customize behavior
+     *
+     * @example
+     * ```js
+     * createProxyMiddleware({
+     *   plugins: [(proxyServer, options) => {
+     *     proxyServer.on('error', (error, req, res) => {
+     *       console.error(error);
+     *     });
+     *   }]
+     * });
+     * ```
+     * @link https://github.com/chimurai/http-proxy-middleware#plugins-array
+     * @since v3.0.0
+     */
+    plugins?: Plugin<TReq, TRes>[];
+    /**
+     * Eject pre-configured plugins.
+     * NOTE: register your own error handlers to prevent server from crashing.
+     *
+     * @link https://github.com/chimurai/http-proxy-middleware#ejectplugins-boolean-default-false
+     * @since v3.0.0
+     */
+    ejectPlugins?: boolean;
+    /**
+     * Listen to http-proxy events
+     * @see {@link OnProxyEvent} for available events
+     * @example
+     * ```js
+     * createProxyMiddleware({
+     *   on: {
+     *     error: (error, req, res, target) => {
+     *       console.error(error);
+     *     }
+     *   }
+     * });
+     * ```
+     * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/proxy-events.md
+     * @since v3.0.0
+     */
+    on?: OnProxyEvent<TReq, TRes>;
+    /**
+     * Dynamically set the {@link Options.target `options.target`}.
+     * @example
+     * ```js
+     * createProxyMiddleware({
+     *   router: async (req) => {
+     *     return 'http://127:0.0.1:3000';
+     *   }
+     * });
+     * ```
+     * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/router.md
+     */
     router?: {
         [hostOrPath: string]: httpProxy.ServerOptions['target'];
-    } | ((req: Request) => httpProxy.ServerOptions['target']) | ((req: Request) => Promise<httpProxy.ServerOptions['target']>);
-    logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent';
-    logProvider?: LogProviderCallback;
-    onError?: OnErrorCallback;
-    onProxyRes?: OnProxyResCallback;
-    onProxyReq?: OnProxyReqCallback;
-    onProxyReqWs?: OnProxyReqWsCallback;
-    onOpen?: OnOpenCallback;
-    onClose?: OnCloseCallback;
-}
-interface LogProvider {
-    log: Logger;
-    debug?: Logger;
-    info?: Logger;
-    warn?: Logger;
-    error?: Logger;
+    } | ((req: TReq) => httpProxy.ServerOptions['target']) | ((req: TReq) => Promise<httpProxy.ServerOptions['target']>);
+    /**
+     * Log information from http-proxy-middleware
+     * @example
+     * ```js
+     * createProxyMiddleware({
+     *  logger: console
+     * });
+     * ```
+     * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/logger.md
+     * @since v3.0.0
+     */
+    logger?: Logger | any;
 }
-declare type Logger = (...args: any[]) => void;
-export declare type LogProviderCallback = (provider: LogProvider) => LogProvider;
-/**
- * Use types based on the events listeners from http-proxy
- * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/51504fd999031b7f025220fab279f1b2155cbaff/types/http-proxy/index.d.ts
- */
-export declare type OnErrorCallback = (err: Error, req: Request, res: Response, target?: string | Partial<url.Url>) => void;
-export declare type OnProxyResCallback = (proxyRes: http.IncomingMessage, req: Request, res: Response) => void;
-export declare type OnProxyReqCallback = (proxyReq: http.ClientRequest, req: Request, res: Response, options: httpProxy.ServerOptions) => void;
-export declare type OnProxyReqWsCallback = (proxyReq: http.ClientRequest, req: Request, socket: net.Socket, options: httpProxy.ServerOptions, head: any) => void;
-export declare type OnCloseCallback = (proxyRes: Response, proxySocket: net.Socket, proxyHead: any) => void;
-export declare type OnOpenCallback = (proxySocket: net.Socket) => void;
-export {};

package/dist/utils/function.d.ts

@@ -0,0 +1 @@
+export declare function getFunctionName(fn: Function): string;

package/dist/utils/function.js

@@ -0,0 +1,8 @@
+"use strict";
+/* eslint-disable @typescript-eslint/ban-types */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionName = void 0;
+function getFunctionName(fn) {
+    return fn.name || '[anonymous Function]';
+}
+exports.getFunctionName = getFunctionName;

package/package.json

@@ -1,28 +1,25 @@
 {
   "name": "http-proxy-middleware",
-  "version": "2.0.6",
-  "description": "The one-liner node.js proxy middleware for connect, express and browser-sync",
+  "version": "3.0.0-beta.1",
+  "description": "The one-liner node.js proxy middleware for connect, express, next.js and more",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
   "scripts": {
-    "clean": "rm -rf dist && rm -rf coverage",
+    "clean": "rm -rf dist coverage tsconfig.tsbuildinfo .eslintcache",
     "lint": "yarn prettier && yarn eslint",
     "lint:fix": "yarn prettier:fix && yarn eslint:fix",
-    "eslint": "eslint '{src,test}/**/*.ts'",
+    "eslint": "eslint '{src,test}/**/*.ts' --cache",
     "eslint:fix": "yarn eslint --fix",
     "prettier": "prettier --list-different \"**/*.{js,ts,md,yml,json,html}\"",
     "prettier:fix": "prettier --write \"**/*.{js,ts,md,yml,json,html}\"",
-    "prebuild": "yarn clean",
-    "build": "tsc",
-    "pretest": "yarn build",
+    "build": "tsc --build",
     "test": "jest",
-    "precoverage": "yarn build",
-    "coverage": "jest --coverage --coverageReporters=lcov",
+    "coverage": "jest --coverage",
     "prepare": "husky install",
-    "prepack": "yarn build && rm dist/tsconfig.tsbuildinfo",
+    "prepack": "yarn clean && yarn test && yarn build",
     "spellcheck": "npx --yes cspell --show-context --show-suggestions '**/*.*'"
   },
   "repository": {
@@ -39,6 +36,7 @@
     "express",
     "fastify",
     "polka",
+    "next.js",
     "browser-sync",
     "gulp",
     "grunt-contrib-connect",
@@ -53,50 +51,44 @@
   },
   "homepage": "https://github.com/chimurai/http-proxy-middleware#readme",
   "devDependencies": {
-    "@commitlint/cli": "16.2.1",
-    "@commitlint/config-conventional": "16.2.1",
-    "@types/express": "4.17.13",
+    "@commitlint/cli": "17.4.4",
+    "@commitlint/config-conventional": "17.4.4",
+    "@types/debug": "4.1.7",
+    "@types/express": "4.17.17",
     "@types/is-glob": "4.0.2",
-    "@types/jest": "27.4.0",
+    "@types/jest": "29.4.0",
     "@types/micromatch": "4.0.2",
-    "@types/node": "17.0.18",
-    "@types/supertest": "2.0.11",
-    "@types/ws": "8.2.2",
-    "@typescript-eslint/eslint-plugin": "5.12.0",
-    "@typescript-eslint/parser": "5.12.0",
-    "body-parser": "1.19.2",
-    "browser-sync": "2.27.7",
+    "@types/node": "18.14.5",
+    "@types/supertest": "2.0.12",
+    "@types/ws": "8.5.4",
+    "@typescript-eslint/eslint-plugin": "5.54.0",
+    "@typescript-eslint/parser": "5.54.0",
+    "body-parser": "1.20.2",
+    "browser-sync": "2.28.1",
     "connect": "3.7.0",
-    "eslint": "8.9.0",
-    "eslint-config-prettier": "8.3.0",
-    "eslint-plugin-prettier": "4.0.0",
-    "express": "4.17.3",
+    "eslint": "8.35.0",
+    "eslint-config-prettier": "8.6.0",
+    "eslint-plugin-prettier": "4.2.1",
+    "express": "4.18.2",
     "get-port": "5.1.1",
-    "husky": "7.0.4",
-    "jest": "27.5.1",
-    "lint-staged": "12.3.4",
-    "mockttp": "2.6.0",
-    "open": "8.4.0",
-    "prettier": "2.5.1",
-    "supertest": "6.2.2",
-    "ts-jest": "27.1.3",
-    "typescript": "4.5.5",
-    "ws": "8.5.0"
+    "husky": "8.0.3",
+    "jest": "29.4.3",
+    "lint-staged": "13.1.2",
+    "mockttp": "3.7.0",
+    "open": "8.4.2",
+    "prettier": "2.8.4",
+    "supertest": "6.3.3",
+    "ts-jest": "29.0.5",
+    "typescript": "4.9.5",
+    "ws": "8.12.1"
   },
   "dependencies": {
-    "@types/http-proxy": "^1.17.8",
+    "@types/http-proxy": "^1.17.10",
+    "debug": "^4.3.4",
     "http-proxy": "^1.18.1",
     "is-glob": "^4.0.1",
     "is-plain-obj": "^3.0.0",
-    "micromatch": "^4.0.2"
-  },
-  "peerDependencies": {
-    "@types/express": "^4.17.13"
-  },
-  "peerDependenciesMeta": {
-    "@types/express": {
-      "optional": true
-    }
+    "micromatch": "^4.0.5"
   },
   "engines": {
     "node": ">=12.0.0"

package/dist/_handlers.d.ts

@@ -1,4 +0,0 @@
-import type { Options } from './types';
-import type * as httpProxy from 'http-proxy';
-export declare function init(proxy: httpProxy, option: Options): void;
-export declare function getHandlers(options: Options): any;

package/dist/_handlers.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHandlers = exports.init = void 0;
-const logger_1 = require("./logger");
-const logger = (0, logger_1.getInstance)();
-function init(proxy, option) {
-    const handlers = getHandlers(option);
-    for (const eventName of Object.keys(handlers)) {
-        proxy.on(eventName, handlers[eventName]);
-    }
-    // https://github.com/webpack/webpack-dev-server/issues/1642
-    proxy.on('econnreset', (error, req, res, target) => {
-        logger.error(`[HPM] ECONNRESET: %O`, error);
-    });
-    // https://github.com/webpack/webpack-dev-server/issues/1642#issuecomment-1104325120
-    proxy.on('proxyReqWs', (proxyReq, req, socket, options, head) => {
-        socket.on('error', (error) => {
-            logger.error(`[HPM] WebSocket error: %O`, error);
-        });
-    });
-    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 proxyEventsMap = {
-        error: 'onError',
-        proxyReq: 'onProxyReq',
-        proxyReqWs: 'onProxyReqWs',
-        proxyRes: 'onProxyRes',
-        open: 'onOpen',
-        close: 'onClose',
-    };
-    const handlers = {};
-    for (const [eventName, onEventName] of Object.entries(proxyEventsMap)) {
-        // 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 fnHandler = options ? options[onEventName] : null;
-        if (typeof fnHandler === 'function') {
-            handlers[eventName] = fnHandler;
-        }
-    }
-    // add default error handler in absence of error handler
-    if (typeof handlers.error !== 'function') {
-        handlers.error = defaultErrorHandler;
-    }
-    // add default close handler in absence of close handler
-    if (typeof handlers.close !== 'function') {
-        handlers.close = logClose;
-    }
-    return handlers;
-}
-exports.getHandlers = getHandlers;
-function defaultErrorHandler(err, req, res) {
-    // Re-throw error. Not recoverable since req & res are empty.
-    if (!req && !res) {
-        throw err; // "Error: Must provide a proper URL as target"
-    }
-    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':
-                case 'ETIMEDOUT':
-                    res.writeHead(504);
-                    break;
-                default:
-                    res.writeHead(500);
-            }
-        }
-    }
-    res.end(`Error occurred while trying to proxy: ${host}${req.url}`);
-}
-function logClose(req, socket, head) {
-    // view disconnected websocket connections
-    logger.info('[HPM] Client disconnected');
-}

package/dist/config-factory.d.ts

@@ -1,6 +0,0 @@
-import { Filter, Options } from './types';
-export declare type Config = {
-    context: Filter;
-    options: Options;
-};
-export declare function createConfig(context: any, opts?: Options): Config;

package/dist/config-factory.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConfig = void 0;
-const isPlainObj = require("is-plain-obj");
-const url = require("url");
-const errors_1 = require("./errors");
-const logger_1 = require("./logger");
-const logger = (0, 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 = Object.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 = Object.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 = Object.assign(config.options, opts);
-    }
-    configureLogger(config.options);
-    if (!config.options.target && !config.options.router) {
-        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 (typeof context === 'string') {
-        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 isPlainObj(context) && (opts == null || Object.keys(opts).length === 0);
-}
-function configureLogger(options) {
-    if (options.logLevel) {
-        logger.setLevel(options.logLevel);
-    }
-    if (options.logProvider) {
-        logger.setProvider(options.logProvider);
-    }
-}

package/dist/context-matcher.d.ts

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