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

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

@@ -0,0 +1,42 @@
+import { Debug } from '../../debug.js';
+import { getFunctionName } from '../../utils/function.js';
+import { definePlugin } from '../define-plugin.js';
+const debug = Debug.extend('proxy-events-plugin');
+/**
+ * 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 const proxyEventsPlugin = definePlugin((proxyServer, options) => {
+    if (!options.on) {
+        return;
+    }
+    // hoist variable here for better typing
+    let eventName;
+    // for in provide better typing than Object.entries()
+    for (eventName in options.on) {
+        if (Object.prototype.hasOwnProperty.call(options.on, eventName)) {
+            const handler = options.on[eventName];
+            if (!handler) {
+                continue;
+            }
+            debug(`register event handler: "${eventName}" -> "${getFunctionName(handler)}"`);
+            proxyServer.on(eventName, handler);
+        }
+    }
+});

package/dist/plugins/define-plugin.d.ts

@@ -0,0 +1,25 @@
+import type * as http from 'node:http';
+import type { Plugin } from '../types.js';
+/**
+ * Helper function to define a http-proxy-middleware plugin
+ * @see proxyServer {@link ProxyServer} - proxy server instance to which the plugin is being applied
+ * @see options {@link Options} - options object passed to `createProxyMiddleware`
+ *
+ * @example defining a plugin
+ * ```js
+ * export const myPlugin = definePlugin((proxyServer, options) => {
+ *   // plugin implementation
+ * });
+ * ```
+ *
+ * @example using a plugin
+ * ```js
+ * createProxyMiddleware({
+ *   target: 'http://example.com',
+ *   plugins: [myPlugin],
+ * });
+ * ```
+ *
+ * @since 4.1.0
+ */
+export declare function definePlugin<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse>(fn: Plugin<TReq, TRes>): Plugin<TReq, TRes>;

package/dist/plugins/define-plugin.js

@@ -0,0 +1,25 @@
+/**
+ * Helper function to define a http-proxy-middleware plugin
+ * @see proxyServer {@link ProxyServer} - proxy server instance to which the plugin is being applied
+ * @see options {@link Options} - options object passed to `createProxyMiddleware`
+ *
+ * @example defining a plugin
+ * ```js
+ * export const myPlugin = definePlugin((proxyServer, options) => {
+ *   // plugin implementation
+ * });
+ * ```
+ *
+ * @example using a plugin
+ * ```js
+ * createProxyMiddleware({
+ *   target: 'http://example.com',
+ *   plugins: [myPlugin],
+ * });
+ * ```
+ *
+ * @since 4.1.0
+ */
+export function definePlugin(fn) {
+    return fn;
+}

package/dist/plugins/index.d.ts

@@ -0,0 +1,2 @@
+export * from './define-plugin.js';
+export * from './default/index.js';

package/dist/plugins/index.js

@@ -0,0 +1,4 @@
+// definePlugin()
+export * from './define-plugin.js';
+// default plugins
+export * from './default/index.js';

package/dist/router.d.ts

@@ -0,0 +1,3 @@
+import type * as http from 'node:http';
+import type { Options } from './index.js';
+export declare function getTarget<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse>(req: TReq, res: TRes | undefined, config: Options<TReq, TRes>): Promise<import("httpxy").ProxyTarget | undefined>;

package/dist/router.js

@@ -0,0 +1,60 @@
+import isPlainObject from 'is-plain-obj';
+import { Debug } from './debug.js';
+const debug = Debug.extend('router');
+export async function getTarget(req, res, config) {
+    let newTarget;
+    const router = config.router;
+    if (isPlainObject(router)) {
+        newTarget = getTargetFromProxyTable(req, router);
+    }
+    else if (typeof router === 'function') {
+        newTarget = await router(req, res, config);
+    }
+    return newTarget;
+}
+function getTargetFromProxyTable(req, table) {
+    let result;
+    const host = req.headers.host ?? '';
+    const path = req.url ?? '';
+    for (const [key, value] of Object.entries(table)) {
+        if (containsPath(key)) {
+            if (isHostAndPathKey(key)) {
+                const [keyHost, keyPath] = splitHostAndPathKey(key);
+                // SECURITY: host+path keys must match exact host + path prefix.
+                if (host === keyHost && path.startsWith(keyPath)) {
+                    // match 'localhost:3000/api'
+                    result = value;
+                    debug('match: "%s" -> "%s"', key, result);
+                    break;
+                }
+            }
+            else {
+                if (path.startsWith(key)) {
+                    // match '/api'
+                    result = value;
+                    debug('match: "%s" -> "%s"', key, result);
+                    break;
+                }
+            }
+        }
+        else {
+            if (key === host) {
+                // match 'localhost:3000'
+                result = value;
+                debug('match: "%s" -> "%s"', host, result);
+                break;
+            }
+        }
+    }
+    return result;
+}
+function containsPath(v) {
+    return v.indexOf('/') > -1;
+}
+function isHostAndPathKey(v) {
+    return containsPath(v) && !v.startsWith('/');
+}
+function splitHostAndPathKey(v) {
+    const firstSlash = v.indexOf('/');
+    return [v.slice(0, firstSlash), v.slice(firstSlash)];
+}

package/dist/status-code.d.ts

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

package/dist/status-code.js

@@ -0,0 +1,23 @@
+export function getStatusCode(errorCode) {
+    let statusCode;
+    if (/HPE_INVALID/.test(errorCode)) {
+        statusCode = 502;
+        return statusCode;
+    }
+    if (/HPM_ERR_INVALID_MULTIPART_/.test(errorCode)) {
+        statusCode = 400;
+        return statusCode;
+    }
+    switch (errorCode) {
+        case 'ECONNRESET':
+        case 'ENOTFOUND':
+        case 'ECONNREFUSED':
+        case 'ETIMEDOUT':
+            statusCode = 504;
+            break;
+        default:
+            statusCode = 500;
+            break;
+    }
+    return statusCode;
+}

package/dist/types.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Based on definition by DefinitelyTyped:
+ * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/6f529c6c67a447190f86bfbf894d1061e41e07b7/types/http-proxy-middleware/index.d.ts
+ */
+import type * as http from 'node:http';
+import type * as net from 'node:net';
+import type { ProxyServer, ProxyServerOptions } from 'httpxy';
+export type NextFunction<T = (err?: any) => void> = T;
+export interface RequestHandler<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse, TNext = NextFunction> {
+    (req: TReq, res: TRes, next?: TNext): Promise<void>;
+    upgrade: (req: TReq, socket: net.Socket, head: Buffer) => void;
+}
+export type Filter<TReq extends http.IncomingMessage = http.IncomingMessage> = string | string[] | ((pathname: string, req: TReq) => boolean | string | RegExpMatchArray | null);
+/**
+ * @see {@link https://github.com/chimurai/http-proxy-middleware/tree/master#defineplugin-helper `definePlugin()`} to define a http-proxy-middleware plugin.
+ */
+export interface Plugin<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> {
+    (proxyServer: ProxyServer<TReq, TRes>, options: Options<TReq, TRes>): void;
+}
+export interface OnProxyEvent<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> {
+    error?: (err: Error, req: TReq, res: TRes | net.Socket, target?: string | Partial<URL>) => void;
+    proxyReq?: (proxyReq: http.ClientRequest, req: TReq, res: TRes, options: ProxyServerOptions) => void;
+    proxyReqWs?: (proxyReq: http.ClientRequest, req: TReq, socket: net.Socket, options: ProxyServerOptions, head: any) => void;
+    proxyRes?: (proxyRes: TReq, req: TReq, res: TRes) => void | Promise<void>;
+    open?: (proxySocket: net.Socket) => void;
+    close?: (proxyRes: TReq, proxySocket: net.Socket, proxyHead: any) => void;
+    start?: (req: TReq, res: TRes, target: string | Partial<URL>) => void;
+    end?: (req: TReq, res: TRes, proxyRes: TReq) => void;
+    econnreset?: (err: Error, req: TReq, res: TRes, target: string | Partial<URL>) => void;
+}
+export type Logger = Pick<Console, 'info' | 'warn' | 'error'>;
+export type PathRewriteConfig<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> = {
+    [regexp: string]: string;
+} | ((path: string, req: TReq, 
+/** `res` is undefined in WebSocket upgrade flows. */
+res?: TRes | undefined, options?: Options<TReq, TRes>) => string | undefined) | ((path: string, req: TReq, 
+/** `res` is undefined in WebSocket upgrade flows. */
+res?: TRes | undefined, options?: Options<TReq, TRes>) => Promise<string | undefined>);
+export interface Options<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> extends ProxyServerOptions {
+    /**
+     * 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
+     *   }
+     * });
+     * ```
+     * @since v0.15.0
+     * @since v0.21.0 - support `async` function
+     * @since v4.1.0 - `res` and `options` parameters added to custom function
+     *
+     * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/pathRewrite.md
+     */
+    pathRewrite?: PathRewriteConfig<TReq, TRes>;
+    /**
+     * Access the internal `httpxy` 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 `httpxy` 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, res, options) => {
+     *     return 'http://127:0.0.1:3000';
+     *   }
+     * });
+     * ```
+     *
+     * @since v0.16.0
+     * @since v4.1.0 - `res` and `options` parameters added to router function signature
+     *
+     * NOTE: `res` is undefined in WebSocket upgrade flows.
+     *
+     * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/router.md
+     */
+    router?: Record<string, ProxyServerOptions['target']> | ((req: TReq, res: TRes | undefined, options: Options<TReq, TRes>) => ProxyServerOptions['target']) | ((req: TReq, res: TRes | undefined, options: Options<TReq, TRes>) => Promise<ProxyServerOptions['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;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/create-url.d.ts

@@ -0,0 +1,9 @@
+import { URL } from 'url';
+type CreateUrlParams = {
+    protocol?: string;
+    host?: string;
+    port?: string;
+    path?: string;
+};
+export declare function createUrl({ protocol, host, port, path }: CreateUrlParams): URL;
+export {};

package/dist/utils/create-url.js

@@ -0,0 +1,17 @@
+import { URL } from 'url';
+export function createUrl({ protocol, host, port, path }) {
+    // wrap IPv6 host in brackets
+    const ipv6Host = host?.includes(':') ? `[${host}]` : host;
+    // use fallback values to create a valid URL (protocol: 'undefined:', host: '[::]')
+    // nock v13 issue: protocol and host are undefined (https://github.com/chimurai/http-proxy-middleware/issues/1035)
+    // nock v14+ seems to return protocol and host correctly
+    const base = `${protocol || 'undefined:'}//${ipv6Host || '[::]'}`;
+    const url = new URL(base);
+    if (port) {
+        url.port = port;
+    }
+    if (path) {
+        url.pathname = path;
+    }
+    return url;
+}

package/dist/utils/function.d.ts

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

package/dist/utils/function.js

@@ -0,0 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+export function getFunctionName(fn) {
+    return fn.name || '[anonymous Function]';
+}

package/dist/utils/ipv6.d.ts

@@ -0,0 +1,20 @@
+import type * as http from 'node:http';
+import type { Options } from '../types.js';
+/**
+ * Normalize bracketed IPv6 URL targets into unbracketed host options.
+ *
+ * RFC 2732 defines the URL syntax for literal IPv6 addresses as bracketed
+ * host references (for example `http://[::1]:8080/path` where host is
+ * `[::1]`).
+ *
+ * `httpxy` resolves bracketed hostnames (for example `[::1]`) via DNS,
+ * which can fail for IPv6 literals. This converts string/URL `target` and
+ * `forward` values into object form with `hostname: ::1` (brackets removed)
+ * so the address can be connected directly.
+ *
+ * Reference: RFC 2732, Section 2 (Literal IPv6 Address Format in URL's)
+ * https://www.ietf.org/rfc/rfc2732.txt
+ *
+ * The provided options object is mutated in place.
+ */
+export declare function normalizeIPv6LiteralTargets<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse>(options: Options<TReq, TRes>): void;

package/dist/utils/ipv6.js

@@ -0,0 +1,66 @@
+import { Debug } from '../debug.js';
+const debug = Debug.extend('ipv6');
+/**
+ * Normalize bracketed IPv6 URL targets into unbracketed host options.
+ *
+ * RFC 2732 defines the URL syntax for literal IPv6 addresses as bracketed
+ * host references (for example `http://[::1]:8080/path` where host is
+ * `[::1]`).
+ *
+ * `httpxy` resolves bracketed hostnames (for example `[::1]`) via DNS,
+ * which can fail for IPv6 literals. This converts string/URL `target` and
+ * `forward` values into object form with `hostname: ::1` (brackets removed)
+ * so the address can be connected directly.
+ *
+ * Reference: RFC 2732, Section 2 (Literal IPv6 Address Format in URL's)
+ * https://www.ietf.org/rfc/rfc2732.txt
+ *
+ * The provided options object is mutated in place.
+ */
+export function normalizeIPv6LiteralTargets(options) {
+    options.target = normalizeIPv6ProxyTarget(options.target, 'target');
+    options.forward = normalizeIPv6ProxyTarget(options.forward, 'forward');
+}
+function normalizeIPv6ProxyTarget(target, optionName) {
+    const targetUrl = toTargetUrl(target);
+    if (targetUrl && isBracketedIPv6Hostname(targetUrl.hostname)) {
+        const normalizedHostname = normalizeIPv6DestinationHostname(stripBrackets(targetUrl.hostname));
+        debug('normalized IPv6 "%s" %s', optionName, target);
+        const auth = targetUrl.username || targetUrl.password
+            ? `${targetUrl.username}:${targetUrl.password}`
+            : undefined;
+        return {
+            hostname: normalizedHostname,
+            auth,
+            pathname: targetUrl.pathname,
+            port: targetUrl.port,
+            protocol: targetUrl.protocol,
+            search: targetUrl.search,
+        };
+    }
+    return target;
+}
+function toTargetUrl(target) {
+    if (typeof target === 'string') {
+        return new URL(target);
+    }
+    if (target instanceof URL) {
+        return target;
+    }
+    return undefined;
+}
+function isBracketedIPv6Hostname(hostname) {
+    return hostname.startsWith('[') && hostname.endsWith(']');
+}
+function stripBrackets(hostname) {
+    return hostname.replace(/^\[|\]$/g, '');
+}
+function normalizeIPv6DestinationHostname(hostname) {
+    // The unspecified address (::) is not a routable destination for outbound client requests.
+    // Treat it as loopback so a target like http://[::]:port reaches local IPv6 listeners.
+    if (hostname === '::') {
+        debug('normalizing hostname unspecified IPv6 address (::) to loopback (::1)');
+        return '::1';
+    }
+    return hostname;
+}

package/dist/utils/logger-plugin.d.ts

@@ -0,0 +1,7 @@
+import type { Agent } from 'node:http';
+export type Sockets = Pick<Agent, 'sockets'>;
+/**
+ * Get port from target
+ * Using proxyRes.req.agent.sockets to determine the target port
+ */
+export declare function getPort(sockets?: Sockets): string | undefined;

package/dist/utils/logger-plugin.js

@@ -0,0 +1,7 @@
+/**
+ * Get port from target
+ * Using proxyRes.req.agent.sockets to determine the target port
+ */
+export function getPort(sockets) {
+    return Object.keys(sockets || {})?.[0]?.split(':')[1];
+}

package/dist/utils/sanitize.d.ts

@@ -0,0 +1 @@
+export declare function sanitize(input: string | undefined): string;

package/dist/utils/sanitize.js

@@ -0,0 +1,3 @@
+export function sanitize(input) {
+    return input?.replace(/[<>]/g, (i) => encodeURIComponent(i)) ?? '';
+}

package/package.json

@@ -1,6 +1,122 @@
 {
   "name": "@ohos-ports/http-proxy-middleware",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "4.2.0-beta.1",
+  "description": "The one-liner node.js proxy middleware for connect, express, next.js and more",
+  "keywords": [
+    "browser-sync",
+    "connect",
+    "cors",
+    "express",
+    "fastify",
+    "grunt-contrib-connect",
+    "gulp",
+    "hono",
+    "http",
+    "https",
+    "middleware",
+    "next.js",
+    "polka",
+    "proxy",
+    "reverse",
+    "websocket",
+    "ws"
+  ],
+  "homepage": "https://github.com/chimurai/http-proxy-middleware#readme",
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "license": "MIT",
+  "author": "Steven Chim",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/http-proxy-middleware/4.2.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./hono": {
+      "types": "./dist/index-hono.d.ts",
+      "import": "./dist/index-hono.js",
+      "default": "./dist/index-hono.js"
+    }
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "scripts": {
+    "clean": "rm -rf dist coverage tsconfig.tsbuildinfo .eslintcache",
+    "install:all": "yarn && (cd examples && yarn)",
+    "lint": "yarn format && yarn eslint",
+    "lint:fix": "yarn format:fix && yarn eslint:fix",
+    "eslint": "eslint --cache '**/*.{js,ts,mjs,mts}'",
+    "eslint:fix": "yarn eslint --fix",
+    "format": "oxfmt --list-different \"**/*.{js,ts,mjs,mts,md,yml,json,html}\"",
+    "format:fix": "oxfmt --write \"**/*.{js,ts,mjs,mts,md,yml,json,html}\"",
+    "build": "tsc --build",
+    "test": "vitest run",
+    "test:types": "tsc --project tsconfig.test.json --noEmit",
+    "coverage": "vitest run --coverage",
+    "prepare": "husky",
+    "prepack": "yarn clean && yarn test && yarn build",
+    "spellcheck": "npx --yes cspell --show-context --show-suggestions '**/*.*'"
+  },
+  "dependencies": {
+    "debug": "^4.4.3",
+    "httpxy": "^0.5.4",
+    "is-glob": "^4.0.3",
+    "is-plain-obj": "^4.1.0",
+    "micromatch": "^4.0.8"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "21.2.0",
+    "@commitlint/config-conventional": "21.2.0",
+    "@eslint/js": "10.0.1",
+    "@hono/node-server": "2.0.8",
+    "@types/debug": "4.1.13",
+    "@types/eslint": "9.6.1",
+    "@types/express": "5.0.6",
+    "@types/is-glob": "4.0.4",
+    "@types/micromatch": "4.0.10",
+    "@types/node": "26.1.0",
+    "@types/supertest": "7.2.0",
+    "@types/ws": "8.18.1",
+    "@vitest/coverage-v8": "4.1.9",
+    "body-parser": "2.3.0",
+    "eslint": "10.6.0",
+    "express": "5.2.1",
+    "get-port": "7.2.0",
+    "globals": "17.7.0",
+    "hono": "4.12.27",
+    "husky": "9.1.7",
+    "lint-staged": "17.0.8",
+    "mockttp": "4.4.2",
+    "msw": "2.14.6",
+    "nock": "14.0.16",
+    "open": "11.0.0",
+    "oxfmt": "0.57.0",
+    "pkg-pr-new": "0.0.75",
+    "supertest": "7.2.2",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.62.1",
+    "vitest": "4.1.9",
+    "ws": "8.21.0"
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "engines": {
+    "node": "^22.15.0 || ^24.0.0 || >=26.0.0"
+  }
+}