@ohos-ports/http-proxy-middleware 0.0.0-stage → 4.2.0-beta.1

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

@@ -0,0 +1,31 @@
+import type * as http from 'node:http';
+import type { Options, RequestHandler } from './types.js';
+export declare class HttpProxyMiddleware<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> {
+    #private;
+    private wsInternalSubscribedServers;
+    private activeServers;
+    private proxyOptions;
+    private proxy;
+    private pathRewriter;
+    private logger;
+    constructor(options: Options<TReq, TRes>);
+    middleware: RequestHandler<TReq, TRes>;
+    private registerPlugins;
+    private catchUpgradeRequest;
+    private handleUpgrade;
+    /**
+     * Determine whether request should be proxied.
+     */
+    private shouldProxy;
+    /**
+     * Apply option.router and option.pathRewrite
+     * Order matters:
+     *    Router uses original path for routing;
+     *    NOT the modified path, after it has been rewritten by pathRewrite
+     * @param {Object} req
+     * @return {Object} proxy options
+     */
+    private prepareProxyRequest;
+    private applyRouter;
+    private applyPathRewrite;
+}

package/dist/http-proxy-middleware.js

@@ -0,0 +1,183 @@
+import { createProxyServer } from 'httpxy';
+import { verifyConfig } from './configuration.js';
+import { Debug as debug } from './debug.js';
+import { getPlugins } from './get-plugins.js';
+import { getLogger } from './logger.js';
+import { matchPathFilter } from './path-filter.js';
+import { createPathRewriter } from './path-rewriter.js';
+import { getTarget } from './router.js';
+import { getFunctionName } from './utils/function.js';
+import { normalizeIPv6LiteralTargets } from './utils/ipv6.js';
+export class HttpProxyMiddleware {
+    wsInternalSubscribedServers = new WeakSet();
+    activeServers = new Set();
+    proxyOptions;
+    proxy;
+    pathRewriter;
+    logger;
+    constructor(options) {
+        verifyConfig(options);
+        this.proxyOptions = options;
+        this.logger = getLogger(options);
+        debug(`create proxy server`);
+        this.proxy = createProxyServer({});
+        this.registerPlugins(this.proxy, this.proxyOptions);
+        this.pathRewriter = createPathRewriter(this.proxyOptions.pathRewrite); // returns undefined when "pathRewrite" is not provided
+        // https://github.com/chimurai/http-proxy-middleware/issues/19
+        // expose function to upgrade externally
+        this.middleware.upgrade = (req, socket, head) => {
+            const server = this.#getServer(req);
+            if (server && !this.wsInternalSubscribedServers.has(server)) {
+                this.handleUpgrade(req, socket, head);
+            }
+        };
+    }
+    #getServer(req) {
+        return req.socket?.server;
+    }
+    // https://github.com/Microsoft/TypeScript/wiki/'this'-in-TypeScript#red-flags-for-this
+    middleware = (async (req, res, next) => {
+        if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
+            let activeProxyOptions;
+            try {
+                // Preparation Phase: Apply router and path rewriter.
+                activeProxyOptions = await this.prepareProxyRequest(req, res);
+                // [Smoking Gun] httpxy is inconsistent with error handling:
+                // 1. If target is missing (here), it emits 'error' but returns a boolean (bypassing our catch/next).
+                // 2. If a network error occurs (in proxy.web), it rejects the promise but SKIPS emitting 'error'.
+                // We manually throw here to force Case 1 into the catch block so next(err) is called for Express.
+                if (!activeProxyOptions.target && !activeProxyOptions.forward) {
+                    throw new Error('Must provide a proper URL as target');
+                }
+            }
+            catch (err) {
+                next?.(err);
+                return;
+            }
+            try {
+                // Proxying Phase: Handle the actual web request.
+                debug(`proxy request to target: %O`, activeProxyOptions.target);
+                await this.proxy.web(req, res, activeProxyOptions);
+            }
+            catch (err) {
+                // Manually emit 'error' event because httpxy's promise-based API does not emit it automatically.
+                // This is crucial for backward compatibility with HPM plugins (like error-response-plugin)
+                // and custom listeners registered via the 'on: { error: ... }' option.
+                this.proxy.emit('error', err, req, res, activeProxyOptions.target);
+                next?.(err);
+            }
+        }
+        else {
+            next?.();
+        }
+        /**
+         * Get the server object to subscribe to server events;
+         * 'upgrade' for websocket and 'close' for graceful shutdown
+         */
+        const server = this.#getServer(req);
+        if (server && !this.activeServers.has(server)) {
+            debug('registering server close listener');
+            this.activeServers.add(server);
+            server.on('close', () => {
+                debug('server close signal received.');
+                this.activeServers.delete(server);
+                if (this.activeServers.size > 0) {
+                    debug(`proxy server not closed: ${this.activeServers.size} server(s) still active`);
+                    return;
+                }
+                else {
+                    debug('closing proxy server');
+                    this.proxy.close(() => debug('proxy server closed'));
+                }
+            });
+        }
+        if (this.proxyOptions.ws === true && server) {
+            // use initial request to access the server object to subscribe to http upgrade event
+            this.catchUpgradeRequest(server);
+        }
+    });
+    registerPlugins(proxy, options) {
+        const plugins = getPlugins(options);
+        plugins.forEach((plugin) => {
+            debug(`register plugin: "${getFunctionName(plugin)}"`);
+            plugin(proxy, options);
+        });
+    }
+    catchUpgradeRequest = (server) => {
+        if (!this.wsInternalSubscribedServers.has(server)) {
+            debug('subscribing to server upgrade event');
+            server.on('upgrade', this.handleUpgrade);
+            this.wsInternalSubscribedServers.add(server);
+        }
+    };
+    handleUpgrade = async (req, socket, head) => {
+        try {
+            if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
+                // No HTTP response object exists during WebSocket upgrades, so pass undefined.
+                const activeProxyOptions = await this.prepareProxyRequest(req, undefined);
+                await this.proxy.ws(req, socket, activeProxyOptions, head);
+                debug('server upgrade event received. Proxying WebSocket');
+            }
+        }
+        catch (err) {
+            // This error does not include the URL as the fourth argument as we won't
+            // have the URL if `this.prepareProxyRequest` throws an error.
+            this.proxy.emit('error', err, req, socket);
+        }
+    };
+    /**
+     * Determine whether request should be proxied.
+     */
+    shouldProxy = (pathFilter, req) => {
+        try {
+            return matchPathFilter(pathFilter, req.url, req);
+        }
+        catch (err) {
+            debug('Error: matchPathFilter() called with request url: ', `"${req.url}"`);
+            this.logger.error(err);
+            return false;
+        }
+    };
+    /**
+     * Apply option.router and option.pathRewrite
+     * Order matters:
+     *    Router uses original path for routing;
+     *    NOT the modified path, after it has been rewritten by pathRewrite
+     * @param {Object} req
+     * @return {Object} proxy options
+     */
+    prepareProxyRequest = async (req, res) => {
+        const newProxyOptions = Object.assign({}, this.proxyOptions);
+        // Apply in order:
+        // 1. option.router
+        // 2. option.pathRewrite
+        await this.applyRouter(req, res, newProxyOptions);
+        normalizeIPv6LiteralTargets(newProxyOptions);
+        await this.applyPathRewrite(req, res, this.pathRewriter, newProxyOptions);
+        return newProxyOptions;
+    };
+    // Modify option.target when router present.
+    applyRouter = async (req, res, options) => {
+        let newTarget;
+        if (options.router) {
+            newTarget = await getTarget(req, res, options);
+            if (newTarget) {
+                debug('router new target: "%s"', newTarget);
+                options.target = newTarget;
+            }
+        }
+    };
+    // rewrite path
+    applyPathRewrite = async (req, res, pathRewriter, options) => {
+        if (req.url && pathRewriter) {
+            const path = await pathRewriter(req.url, req, res, options);
+            if (typeof path === 'string') {
+                debug('pathRewrite new path: %s', path);
+                req.url = path;
+            }
+            else {
+                debug('pathRewrite: no rewritten path found: %s', req.url);
+            }
+        }
+    };
+}

package/dist/index-hono.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hono-specific API entrypoint.
+ *
+ * This is intentionally published as a dedicated subpath (`http-proxy-middleware/hono`)
+ * so the root package types do not import `hono` / `@hono/node-server`.
+ *
+ * Keeping these exports out of the root entrypoint prevents non-Hono consumers from
+ * getting TypeScript module-resolution errors for optional Hono dependencies.
+ */
+export { createHonoProxyMiddleware } from './factory-hono.js';

package/dist/index-hono.js

@@ -0,0 +1,10 @@
+/**
+ * Hono-specific API entrypoint.
+ *
+ * This is intentionally published as a dedicated subpath (`http-proxy-middleware/hono`)
+ * so the root package types do not import `hono` / `@hono/node-server`.
+ *
+ * Keeping these exports out of the root entrypoint prevents non-Hono consumers from
+ * getting TypeScript module-resolution errors for optional Hono dependencies.
+ */
+export { createHonoProxyMiddleware } from './factory-hono.js';

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './factory.js';
+export * from './handlers/index.js';
+export type { Plugin, Filter, Options, RequestHandler, OnProxyEvent } from './types.js';
+export * from './plugins/index.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './factory.js';
+export * from './handlers/index.js';
+export * from './plugins/index.js';

package/dist/logger.d.ts

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

package/dist/logger.js

@@ -0,0 +1,21 @@
+/**
+ * Compatibility matrix
+ *
+  | 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
+ */
+const noopLogger = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export function getLogger(options) {
+    return options.logger || noopLogger;
+}

package/dist/path-filter.d.ts

@@ -0,0 +1,3 @@
+import type * as http from 'node:http';
+import type { Filter } from './types.js';
+export declare function matchPathFilter<TReq extends http.IncomingMessage = http.IncomingMessage>(pathFilter: Filter<TReq> | undefined, uri: string | undefined, req: http.IncomingMessage): boolean;

package/dist/path-filter.js

@@ -0,0 +1,76 @@
+import isGlob from 'is-glob';
+import micromatch from 'micromatch';
+import { HttpProxyMiddlewareError } from './errors.js';
+export function matchPathFilter(pathFilter = '/', uri, req) {
+    // single path
+    if (isStringPath(pathFilter)) {
+        return matchSingleStringPath(pathFilter, uri);
+    }
+    // single glob path
+    if (isGlobPath(pathFilter)) {
+        return matchSingleGlobPath(pathFilter, uri);
+    }
+    // multi path
+    if (Array.isArray(pathFilter)) {
+        if (pathFilter.every(isStringPath)) {
+            return matchMultiPath(pathFilter, uri);
+        }
+        if (pathFilter.every(isGlobPath)) {
+            return matchMultiGlobPath(pathFilter, uri);
+        }
+        throw new HttpProxyMiddlewareError('[HPM] Invalid pathFilter. Plain paths (e.g. "/api") can not be mixed with globs (e.g. "/api/**"). Expecting something like: ["/api", "/ajax"] or ["/api/**", "!**.html"].', 'HPM_INVALID_PATH_FILTER_ARRAY_CONFIG');
+    }
+    // custom matching
+    if (typeof pathFilter === 'function') {
+        const pathname = getUrlPathName(uri);
+        return Boolean(pathFilter(pathname, req));
+    }
+    throw new HttpProxyMiddlewareError('[HPM] Invalid pathFilter. Expecting something like: "/api" or ["/api", "/ajax"]', 'HPM_INVALID_PATH_FILTER_CONFIG');
+}
+/**
+ * @param  {String} pathFilter '/api'
+ * @param  {String} uri     'http://example.org/api/b/c/d.html'
+ * @return {Boolean}
+ */
+function matchSingleStringPath(pathFilter, uri) {
+    const pathname = getUrlPathName(uri);
+    return pathname?.indexOf(pathFilter) === 0;
+}
+function matchSingleGlobPath(pattern, uri) {
+    const pathname = getUrlPathName(uri);
+    const matches = micromatch([pathname], pattern);
+    return matches && matches.length > 0;
+}
+function matchMultiGlobPath(patternList, uri) {
+    return matchSingleGlobPath(patternList, uri);
+}
+/**
+ * @param  {String} pathFilterList ['/api', '/ajax']
+ * @param  {String} uri     'http://example.org/api/b/c/d.html'
+ * @return {Boolean}
+ */
+function matchMultiPath(pathFilterList, uri) {
+    let isMultiPath = false;
+    for (const context of pathFilterList) {
+        if (matchSingleStringPath(context, uri)) {
+            isMultiPath = true;
+            break;
+        }
+    }
+    return isMultiPath;
+}
+/**
+ * Parses URI and returns RFC 3986 path
+ *
+ * @param  {String} uri from req.url
+ * @return {String}     RFC 3986 path
+ */
+function getUrlPathName(uri) {
+    return uri && new URL(uri, 'http://0.0.0.0').pathname;
+}
+function isStringPath(pathFilter) {
+    return typeof pathFilter === 'string' && !isGlob(pathFilter);
+}
+function isGlobPath(pathFilter) {
+    return isGlob(pathFilter);
+}

package/dist/path-rewriter.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { PathRewriteConfig } from './types.js';
+/**
+ * Create rewrite function, to cache parsed rewrite rules.
+ */
+export declare function createPathRewriter<TReq extends IncomingMessage = IncomingMessage, TRes extends ServerResponse = ServerResponse>(rewriteConfig: PathRewriteConfig<TReq, TRes> | undefined): ((path: string, req: TReq, res?: TRes | undefined, options?: import("./types.js").Options<TReq, TRes> | undefined) => string | undefined) | ((path: string, req: TReq, res?: TRes | undefined, options?: import("./types.js").Options<TReq, TRes> | undefined) => Promise<string | undefined>) | undefined;

package/dist/path-rewriter.js

@@ -0,0 +1,59 @@
+import isPlainObject from 'is-plain-obj';
+import { Debug } from './debug.js';
+import { HttpProxyMiddlewareError } from './errors.js';
+const debug = Debug.extend('path-rewriter');
+/**
+ * Create rewrite function, to cache parsed rewrite rules.
+ */
+export function createPathRewriter(rewriteConfig) {
+    let rulesCache;
+    if (!isValidRewriteConfig(rewriteConfig)) {
+        return;
+    }
+    if (typeof rewriteConfig === 'function') {
+        const customRewriteFn = rewriteConfig;
+        return customRewriteFn;
+    }
+    else {
+        rulesCache = parsePathRewriteRules(rewriteConfig);
+        return rewritePath;
+    }
+    function rewritePath(path) {
+        let result = path;
+        for (const rule of rulesCache) {
+            if (rule.regex.test(path)) {
+                result = result.replace(rule.regex, rule.value);
+                debug('rewriting path from "%s" to "%s"', path, result);
+                break;
+            }
+        }
+        return result;
+    }
+}
+function isValidRewriteConfig(rewriteConfig) {
+    if (typeof rewriteConfig === 'function') {
+        return true;
+    }
+    else if (isPlainObject(rewriteConfig)) {
+        return Object.keys(rewriteConfig).length !== 0;
+    }
+    else if (rewriteConfig === undefined || rewriteConfig === null) {
+        return false;
+    }
+    else {
+        throw new HttpProxyMiddlewareError('[HPM] Invalid pathRewrite config. Expecting object with pathRewrite config or a rewrite function', 'HPM_INVALID_PATH_REWRITER_CONFIG');
+    }
+}
+function parsePathRewriteRules(rewriteConfig) {
+    const rules = [];
+    if (isPlainObject(rewriteConfig)) {
+        for (const [key, value] of Object.entries(rewriteConfig)) {
+            rules.push({
+                regex: new RegExp(key),
+                value: value,
+            });
+            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 type { Plugin } from '../../types.js';
+/**
+ * Subscribe to {@link https://github.com/unjs/httpxy#events `httpxy` 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,77 @@
+import { styleText } from 'node:util';
+import { Debug } from '../../debug.js';
+import { definePlugin } from '../define-plugin.js';
+const debug = Debug.extend('debug-proxy-errors-plugin');
+const BODY_PARSER_ERROR_MESSAGE = `[HPM] Connection reset (ECONNRESET) detected with non-empty "req.body" [ERR_HPM.GH40].
+
+      This usually means that the POST request body (req.body) was already parsed before reaching the proxy.
+      When bodyParser runs first, it consumes the request stream, leaving the proxy unable to forward the body data to the target server.
+
+      How to fix this issue:
+      - Option 1: Place the proxy middleware before the bodyParser middleware.
+      - Option 2: Use 'fixRequestBody()' helper to fix this issue.
+
+      For more details, see: https://github.com/chimurai/http-proxy-middleware/issues/40\n`;
+function hasParsedBody(req) {
+    return Boolean(req && req.method === 'POST' && 'body' in req && req.body);
+}
+/**
+ * Subscribe to {@link https://github.com/unjs/httpxy#events `httpxy` error events} to prevent server from crashing.
+ * Errors are logged with {@link https://www.npmjs.com/package/debug debug} library.
+ */
+export const debugProxyErrorsPlugin = definePlugin((proxyServer, options) => {
+    /**
+     * The old `http-proxy` doesn't handle any errors by default (https://github.com/http-party/node-http-proxy#listening-for-proxy-events)
+     * > We do not do any error handling of messages passed between client and proxy, and messages passed between proxy and target, so it is recommended that you listen on errors and handle them.
+     * Subscribing to error event to prevent server from crashing
+     */
+    proxyServer.on('error', (error, req, res, target) => {
+        debug(`httpxy error event: \n%O`, error);
+        // detect request body (when bodyParser used) and log an error message to help debugging
+        if (error.code === 'ECONNRESET' && hasParsedBody(req)) {
+            console.error(styleText('red', BODY_PARSER_ERROR_MESSAGE));
+        }
+    });
+    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(`httpxy econnreset event: \n%O`, error);
+    });
+});

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

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

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

@@ -0,0 +1,28 @@
+import { getStatusCode } from '../../status-code.js';
+import { sanitize } from '../../utils/sanitize.js';
+import { definePlugin } from '../define-plugin.js';
+function isResponseLike(obj) {
+    return obj && typeof obj.writeHead === 'function';
+}
+function isSocketLike(obj) {
+    return obj && typeof obj.write === 'function' && !('writeHead' in obj);
+}
+export const errorResponsePlugin = definePlugin((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 (isResponseLike(res)) {
+            if (!res.headersSent) {
+                const statusCode = getStatusCode(err.code);
+                res.writeHead(statusCode);
+            }
+            const host = req.headers && req.headers.host;
+            res.end(`Error occurred while trying to proxy: ${sanitize(host)}${sanitize(req.url)}`);
+        }
+        else if (isSocketLike(res)) {
+            res.destroy();
+        }
+    });
+});

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

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

package/dist/plugins/default/index.js

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

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

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

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

@@ -0,0 +1,57 @@
+import { URL } from 'node:url';
+import { getLogger } from '../../logger.js';
+import { createUrl } from '../../utils/create-url.js';
+import { getPort } from '../../utils/logger-plugin.js';
+import { definePlugin } from '../define-plugin.js';
+export const loggerPlugin = definePlugin((proxyServer, options) => {
+    const logger = getLogger(options);
+    proxyServer.on('error', (err, req, res, target) => {
+        const hostname = req?.headers?.host;
+        const requestHref = `${hostname}${req?.url}`;
+        const targetHref = `${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) => {
+        // BrowserSync uses req.originalUrl
+        // Next.js doesn't have req.baseUrl
+        const originalUrl = req.originalUrl ?? `${req.baseUrl || ''}${req.url}`;
+        // construct targetUrl
+        let target;
+        try {
+            const port = getPort(proxyRes.req?.agent?.sockets);
+            const { protocol, host, path } = proxyRes.req;
+            target = createUrl({ protocol, host, port, path });
+        }
+        catch (err) {
+            // should not error. keeping fallback just in case
+            console.error('[HPM] Unexpected error while creating target URL', err);
+            // fallback to old implementation (less correct - without port)
+            target = new URL(options.target);
+            target.pathname = proxyRes.req.path;
+        }
+        const targetUrl = target.toString();
+        const exchange = `[HPM] ${req.method} ${originalUrl} -> ${targetUrl} [${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());
+    });
+});

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

@@ -0,0 +1,22 @@
+import type { Plugin } from '../../types.js';
+/**
+ * Implements option.on object to subscribe to `httpxy` 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;