@rsbuild/core 2.0.0-alpha.4 → 2.0.0-beta.1

package/compiled/http-proxy-middleware/index.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-
 import * as http from 'http';
 import events from 'events';
 import * as net from 'net';
@@ -253,52 +252,125 @@ declare namespace Server {
  * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/6f529c6c67a447190f86bfbf894d1061e41e07b7/types/http-proxy-middleware/index.d.ts
  */
 
-interface Request extends http.IncomingMessage {
+type NextFunction<T = (err?: any) => void> = T;
+interface RequestHandler<TReq = http.IncomingMessage, TRes = http.ServerResponse, TNext = NextFunction> {
+    (req: TReq, res: TRes, next?: TNext): Promise<void>;
+    upgrade: (req: http.IncomingMessage, socket: net.Socket, head: Buffer) => void;
 }
-interface Response extends http.ServerResponse {
+type Filter<TReq = http.IncomingMessage> = string | string[] | ((pathname: string, req: TReq) => boolean);
+interface Plugin<TReq = http.IncomingMessage, TRes = http.ServerResponse> {
+    (proxyServer: Server<TReq, TRes>, options: Options<TReq, TRes>): void;
 }
-interface RequestHandler {
-  (req: Request, res: Response, next?: (err?: any) => void): void | Promise<void>;
-    upgrade?: (req: Request, socket: net.Socket, head: any) => void;
+interface OnProxyEvent<TReq = http.IncomingMessage, TRes = http.ServerResponse> {
+    error?: Server.ErrorCallback<Error, TReq, TRes>;
+    proxyReq?: Server.ProxyReqCallback<http.ClientRequest, TReq, TRes>;
+    proxyReqWs?: Server.ProxyReqWsCallback<http.ClientRequest, TReq>;
+    proxyRes?: Server.ProxyResCallback<TReq, TRes>;
+    open?: Server.OpenCallback;
+    close?: Server.CloseCallback<TReq>;
+    start?: Server.StartCallback<TReq, TRes>;
+    end?: Server.EndCallback<TReq, TRes>;
+    econnreset?: Server.EconnresetCallback<Error, TReq, TRes>;
 }
-declare type Filter = string | string[] | ((pathname: string, req: Request) => boolean);
-interface Options extends Server.ServerOptions {
+type Logger = Pick<Console, 'info' | 'warn' | 'error'>;
+interface Options<TReq = http.IncomingMessage, TRes = http.ServerResponse> extends Server.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 | undefined) | ((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]: Server.ServerOptions['target'];
-    } | ((req: Request) => Server.ServerOptions['target']) | ((req: Request) => Promise<Server.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) => Server.ServerOptions['target']) | ((req: TReq) => Promise<Server.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;
-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
- */
-declare type OnErrorCallback = (err: Error, req: Request, res: Response, target?: string | Partial<url.Url>) => void;
-declare type OnProxyResCallback = (proxyRes: http.IncomingMessage, req: Request, res: Response) => void;
-declare type OnProxyReqCallback = (proxyReq: http.ClientRequest, req: Request, res: Response, options: Server.ServerOptions) => void;
-declare type OnProxyReqWsCallback = (proxyReq: http.ClientRequest, req: Request, socket: net.Socket, options: Server.ServerOptions, head: any) => void;
-declare type OnCloseCallback = (proxyRes: Response, proxySocket: net.Socket, proxyHead: any) => void;
-declare type OnOpenCallback = (proxySocket: net.Socket) => void;
 
-declare type Interceptor = (buffer: Buffer, proxyRes: http.IncomingMessage, req: http.IncomingMessage, res: http.ServerResponse) => Promise<Buffer | string>;
+declare function createProxyMiddleware<TReq = http.IncomingMessage, TRes = http.ServerResponse, TNext = NextFunction>(options: Options<TReq, TRes>): RequestHandler<TReq, TRes, TNext>;
+
+type Interceptor<TReq = http.IncomingMessage, TRes = http.ServerResponse> = (buffer: Buffer, proxyRes: TReq, req: TReq, res: TRes) => Promise<Buffer | string>;
 /**
  * Intercept responses from upstream.
  * Automatically decompress (deflate, gzip, brotli).
@@ -306,14 +378,167 @@ declare type Interceptor = (buffer: Buffer, proxyRes: http.IncomingMessage, req:
  *
  * NOTE: must set options.selfHandleResponse=true (prevent automatic call of res.end())
  */
-declare function responseInterceptor(interceptor: Interceptor): (proxyRes: http.IncomingMessage, req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
+declare function responseInterceptor<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse>(interceptor: Interceptor<TReq, TRes>): (proxyRes: TReq, req: TReq, res: TRes) => Promise<void>;
 
+type BodyParserLikeRequest = http.IncomingMessage & {
+    body?: any;
+};
 /**
  * Fix proxied body if bodyParser is involved.
  */
-declare function fixRequestBody(proxyReq: http.ClientRequest, req: http.IncomingMessage): void;
+declare function fixRequestBody<TReq extends BodyParserLikeRequest = BodyParserLikeRequest>(proxyReq: http.ClientRequest, req: TReq): void;
+
+/**
+ * Subscribe to {@link https://www.npmjs.com/package/http-proxy#listening-for-proxy-events http-proxy error events} to prevent server from crashing.
+ * Errors are logged with {@link https://www.npmjs.com/package/debug debug} library.
+ */
+declare const debugProxyErrorsPlugin: Plugin;
+
+declare const errorResponsePlugin: Plugin;
+
+declare const loggerPlugin: Plugin;
+
+/**
+ * Implements option.on object to subscribe to http-proxy events.
+ *
+ * @example
+ * ```js
+ * createProxyMiddleware({
+ *  on: {
+ *    error: (error, req, res, target) => {},
+ *    proxyReq: (proxyReq, req, res, options) => {},
+ *    proxyReqWs: (proxyReq, req, socket, options) => {},
+ *    proxyRes: (proxyRes, req, res) => {},
+ *    open: (proxySocket) => {},
+ *    close: (proxyRes, proxySocket, proxyHead) => {},
+ *    start: (req, res, target) => {},
+ *    end: (req, res, proxyRes) => {},
+ *    econnreset: (error, req, res, target) => {},
+ *  }
+ * });
+ * ```
+ */
+declare const proxyEventsPlugin: Plugin;
+
+/**
+ * @deprecated
+ *
+ * Will be removed in a future version.
+ */
+interface LegacyOptions<TReq = http.IncomingMessage, TRes = http.ServerResponse> extends Options<TReq, TRes> {
+    /**
+     * @deprecated
+     * Use `on.error` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    error: () => {}
+     * }
+     * ```
+     */
+    onError?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.proxyRes` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    proxyRes: () => {}
+     * }
+     * ```
+     */
+    onProxyRes?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.proxyReq` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    proxyReq: () => {}
+     * }
+     * ```
+     */
+    onProxyReq?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.proxyReqWs` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    proxyReqWs: () => {}
+     * }
+     * ```
+     */
+    onProxyReqWs?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.open` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    open: () => {}
+     * }
+     * ```
+     */
+    onOpen?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `on.close` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *   on: {
+     *    close: () => {}
+     * }
+     * ```
+     */
+    onClose?: (...args: any[]) => void;
+    /**
+     * @deprecated
+     * Use `logger` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *  logger: console
+     * }
+     * ```
+     */
+    logProvider?: any;
+    /**
+     * @deprecated
+     * Use `logger` instead.
+     *
+     * @example
+     * ```js
+     * {
+     *  logger: console
+     * }
+     * ```
+     */
+    logLevel?: any;
+}
 
-declare function createProxyMiddleware(context: Filter | Options, options?: Options): RequestHandler;
+/**
+ * @deprecated
+ * This function is deprecated and will be removed in a future version.
+ *
+ * Use {@link createProxyMiddleware} instead.
+ */
+declare function legacyCreateProxyMiddleware<TReq = http.IncomingMessage, TRes = http.ServerResponse>(shortHand: string): RequestHandler<TReq, TRes>;
+declare function legacyCreateProxyMiddleware<TReq = http.IncomingMessage, TRes = http.ServerResponse>(legacyOptions: LegacyOptions<TReq, TRes>): RequestHandler<TReq, TRes>;
+declare function legacyCreateProxyMiddleware<TReq = http.IncomingMessage, TRes = http.ServerResponse>(legacyContext: Filter<TReq>, legacyOptions: LegacyOptions<TReq, TRes>): RequestHandler<TReq, TRes>;
 
-export { createProxyMiddleware, fixRequestBody, responseInterceptor };
-export type { Filter, Options, RequestHandler };
+export { createProxyMiddleware, debugProxyErrorsPlugin, errorResponsePlugin, fixRequestBody, legacyCreateProxyMiddleware, loggerPlugin, proxyEventsPlugin, responseInterceptor };
+export type { Filter, LegacyOptions, Options, Plugin, RequestHandler };