1 |
|
2 |
|
3 | import * as events from "events";
|
4 | import * as http from "http";
|
5 | import * as https from "https";
|
6 | import * as net from "net";
|
7 | import * as stream from "stream";
|
8 | import * as url from "url";
|
9 |
|
10 | interface ProxyTargetDetailed {
|
11 | host: string;
|
12 | port: number;
|
13 | protocol?: string | undefined;
|
14 | hostname?: string | undefined;
|
15 | socketPath?: string | undefined;
|
16 | key?: string | undefined;
|
17 | passphrase?: string | undefined;
|
18 | pfx?: Buffer | string | undefined;
|
19 | cert?: string | undefined;
|
20 | ca?: string | undefined;
|
21 | ciphers?: string | undefined;
|
22 | secureProtocol?: string | undefined;
|
23 | }
|
24 |
|
25 | declare class Server<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse>
|
26 | extends events.EventEmitter
|
27 | {
|
28 | |
29 |
|
30 |
|
31 |
|
32 | constructor(options?: Server.ServerOptions);
|
33 |
|
34 | /**
|
35 | * Used for proxying regular HTTP(S) requests
|
36 | * @param req - Client request.
|
37 | * @param res - Client response.
|
38 | * @param options - Additional options.
|
39 | */
|
40 | web(
|
41 | req: http.IncomingMessage,
|
42 | res: http.ServerResponse,
|
43 | options?: Server.ServerOptions,
|
44 | callback?: Server.ErrorCallback,
|
45 | ): void;
|
46 |
|
47 | /**
|
48 | * Used for proxying regular HTTP(S) requests
|
49 | * @param req - Client request.
|
50 | * @param socket - Client socket.
|
51 | * @param head - Client head.
|
52 | * @param options - Additionnal options.
|
53 | */
|
54 | ws(
|
55 | req: http.IncomingMessage,
|
56 | socket: any,
|
57 | head: any,
|
58 | options?: Server.ServerOptions,
|
59 | callback?: Server.ErrorCallback,
|
60 | ): void;
|
61 |
|
62 | /**
|
63 | * A function that wraps the object in a webserver, for your convenience
|
64 | * @param port - Port to listen on
|
65 | * @param hostname - The hostname to listen on
|
66 | */
|
67 | listen(port: number, hostname?: string): Server<TIncomingMessage, TServerResponse>;
|
68 |
|
69 | /**
|
70 | * A function that closes the inner webserver and stops listening on given port
|
71 | */
|
72 | close(callback?: () => void): void;
|
73 |
|
74 | /**
|
75 | * Creates the proxy server with specified options.
|
76 | * @param options Config object passed to the proxy
|
77 | * @returns Proxy object with handlers for `ws` and `web` requests
|
78 | */
|
79 | // tslint:disable:no-unnecessary-generics
|
80 | static createProxyServer<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse>(
|
81 | options?: Server.ServerOptions,
|
82 | ): Server<TIncomingMessage, TServerResponse>;
|
83 |
|
84 | /**
|
85 | * Creates the proxy server with specified options.
|
86 | * @param options Config object passed to the proxy
|
87 | * @returns Proxy object with handlers for `ws` and `web` requests
|
88 | */
|
89 | // tslint:disable:no-unnecessary-generics
|
90 | static createServer<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse>(
|
91 | options?: Server.ServerOptions,
|
92 | ): Server<TIncomingMessage, TServerResponse>;
|
93 |
|
94 | /**
|
95 | * Creates the proxy server with specified options.
|
96 | * @param options Config object passed to the proxy
|
97 | * @returns Proxy object with handlers for `ws` and `web` requests
|
98 | */
|
99 | // tslint:disable:no-unnecessary-generics
|
100 | static createProxy<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse>(
|
101 | options?: Server.ServerOptions,
|
102 | ): Server<TIncomingMessage, TServerResponse>;
|
103 |
|
104 | addListener(event: string, listener: () => void): this;
|
105 | on(event: string, listener: () => void): this;
|
106 | on(event: "error", listener: Server.ErrorCallback<Error, TIncomingMessage, TServerResponse>): this;
|
107 | on(event: "start", listener: Server.StartCallback<TIncomingMessage, TServerResponse>): this;
|
108 | on(
|
109 | event: "proxyReq",
|
110 | listener: Server.ProxyReqCallback<http.ClientRequest, TIncomingMessage, TServerResponse>,
|
111 | ): this;
|
112 | on(event: "proxyRes", listener: Server.ProxyResCallback<TIncomingMessage, TServerResponse>): this;
|
113 | on(event: "proxyReqWs", listener: Server.ProxyReqWsCallback<http.ClientRequest, TIncomingMessage>): this;
|
114 | on(event: "econnreset", listener: Server.EconnresetCallback<Error, TIncomingMessage, TServerResponse>): this;
|
115 | on(event: "end", listener: Server.EndCallback<TIncomingMessage, TServerResponse>): this;
|
116 | on(event: "open", listener: Server.OpenCallback): this;
|
117 | on(event: "close", listener: Server.CloseCallback<TIncomingMessage>): this;
|
118 |
|
119 | once(event: string, listener: () => void): this;
|
120 | once(event: "error", listener: Server.ErrorCallback<Error, TIncomingMessage, TServerResponse>): this;
|
121 | once(event: "start", listener: Server.StartCallback<TIncomingMessage, TServerResponse>): this;
|
122 | once(
|
123 | event: "proxyReq",
|
124 | listener: Server.ProxyReqCallback<http.ClientRequest, TIncomingMessage, TServerResponse>,
|
125 | ): this;
|
126 | once(event: "proxyRes", listener: Server.ProxyResCallback<TIncomingMessage, TServerResponse>): this;
|
127 | once(event: "proxyReqWs", listener: Server.ProxyReqWsCallback<http.ClientRequest, TIncomingMessage>): this;
|
128 | once(event: "econnreset", listener: Server.EconnresetCallback<Error, TIncomingMessage, TServerResponse>): this;
|
129 | once(event: "end", listener: Server.EndCallback<TIncomingMessage, TServerResponse>): this;
|
130 | once(event: "open", listener: Server.OpenCallback): this;
|
131 | once(event: "close", listener: Server.CloseCallback<TIncomingMessage>): this;
|
132 | removeListener(event: string, listener: () => void): this;
|
133 | removeAllListeners(event?: string): this;
|
134 | getMaxListeners(): number;
|
135 | setMaxListeners(n: number): this;
|
136 | listeners(event: string): Array<() => void>;
|
137 | emit(event: string, ...args: any[]): boolean;
|
138 | listenerCount(type: string): number;
|
139 | }
|
140 |
|
141 | declare namespace Server {
|
142 | type ProxyTarget = ProxyTargetUrl | ProxyTargetDetailed;
|
143 | type ProxyTargetUrl = string | Partial<url.Url>;
|
144 |
|
145 | interface ServerOptions {
|
146 |
|
147 | target?: ProxyTarget | undefined;
|
148 |
|
149 | forward?: ProxyTargetUrl | undefined;
|
150 |
|
151 | agent?: any;
|
152 |
|
153 | ssl?: any;
|
154 |
|
155 | ws?: boolean | undefined;
|
156 |
|
157 | xfwd?: boolean | undefined;
|
158 |
|
159 | secure?: boolean | undefined;
|
160 |
|
161 | toProxy?: boolean | undefined;
|
162 |
|
163 | prependPath?: boolean | undefined;
|
164 |
|
165 | ignorePath?: boolean | undefined;
|
166 |
|
167 | localAddress?: string | undefined;
|
168 |
|
169 | changeOrigin?: boolean | undefined;
|
170 |
|
171 | preserveHeaderKeyCase?: boolean | undefined;
|
172 |
|
173 | auth?: string | undefined;
|
174 |
|
175 | hostRewrite?: string | undefined;
|
176 |
|
177 | autoRewrite?: boolean | undefined;
|
178 |
|
179 | protocolRewrite?: string | undefined;
|
180 |
|
181 | cookieDomainRewrite?: false | string | { [oldDomain: string]: string } | undefined;
|
182 |
|
183 | cookiePathRewrite?: false | string | { [oldPath: string]: string } | undefined;
|
184 |
|
185 | headers?: { [header: string]: string } | undefined;
|
186 |
|
187 | proxyTimeout?: number | undefined;
|
188 |
|
189 | timeout?: number | undefined;
|
190 |
|
191 | followRedirects?: boolean | undefined;
|
192 |
|
193 | selfHandleResponse?: boolean | undefined;
|
194 |
|
195 | buffer?: stream.Stream | undefined;
|
196 | }
|
197 |
|
198 | type StartCallback<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse> = (
|
199 | req: TIncomingMessage,
|
200 | res: TServerResponse,
|
201 | target: ProxyTargetUrl,
|
202 | ) => void;
|
203 | type ProxyReqCallback<
|
204 | TClientRequest = http.ClientRequest,
|
205 | TIncomingMessage = http.IncomingMessage,
|
206 | TServerResponse = http.ServerResponse,
|
207 | > = (proxyReq: TClientRequest, req: TIncomingMessage, res: TServerResponse, options: ServerOptions) => void;
|
208 | type ProxyResCallback<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse> = (
|
209 | proxyRes: TIncomingMessage,
|
210 | req: TIncomingMessage,
|
211 | res: TServerResponse,
|
212 | ) => void;
|
213 | type ProxyReqWsCallback<TClientRequest = http.ClientRequest, TIncomingMessage = http.IncomingMessage> = (
|
214 | proxyReq: TClientRequest,
|
215 | req: TIncomingMessage,
|
216 | socket: net.Socket,
|
217 | options: ServerOptions,
|
218 | head: any,
|
219 | ) => void;
|
220 | type EconnresetCallback<
|
221 | TError = Error,
|
222 | TIncomingMessage = http.IncomingMessage,
|
223 | TServerResponse = http.ServerResponse,
|
224 | > = (
|
225 | err: TError,
|
226 | req: TIncomingMessage,
|
227 | res: TServerResponse,
|
228 | target: ProxyTargetUrl,
|
229 | ) => void;
|
230 | type EndCallback<TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse> = (
|
231 | req: TIncomingMessage,
|
232 | res: TServerResponse,
|
233 | proxyRes: TIncomingMessage,
|
234 | ) => void;
|
235 | type OpenCallback = (proxySocket: net.Socket) => void;
|
236 | type CloseCallback<TIncomingMessage = http.IncomingMessage> = (
|
237 | proxyRes: TIncomingMessage,
|
238 | proxySocket: net.Socket,
|
239 | proxyHead: any,
|
240 | ) => void;
|
241 | type ErrorCallback<TError = Error, TIncomingMessage = http.IncomingMessage, TServerResponse = http.ServerResponse> =
|
242 | (
|
243 | err: TError,
|
244 | req: TIncomingMessage,
|
245 | res: TServerResponse | net.Socket,
|
246 | target?: ProxyTargetUrl,
|
247 | ) => void;
|
248 | }
|
249 |
|
250 | export = Server;
|