Merge branch 'sapphi-red-refacotr/enable-ts-strict-checks'

Author: williamstein

lib/http-proxy/common.ts

@@ -1,4 +1,4 @@
-import type { ProxyTargetDetailed, ServerOptions } from "./index";
+import type { NormalizedServerOptions, ProxyTargetDetailed, ServerOptions } from "./index";
 import { type IncomingMessage as Request } from "http";
 import { TLSSocket } from "tls";
 import type { Socket } from "net";
@@ -12,7 +12,6 @@ export const isSSL = /^https|wss/;
 type Outgoing0 = ProxyTargetDetailed & ServerOptions;
 
 export interface Outgoing extends Outgoing0 {
-  method?: any;
   rejectUnauthorized?: boolean;
   path?: string;
   headers: { [header: string]: string | string[] | undefined } & {
@@ -36,15 +35,17 @@ export function setupOutgoing(
   // Base object to be filled with required properties
   outgoing: Outgoing,
   // Config object passed to the proxy
-  options,
+  options: NormalizedServerOptions,
   // Request Object
   req: Request,
   // String to select forward or target
-  forward?: string,
+  forward?: "forward",
 ) {
+  // the final path is target path + relative path requested by user:
+  const target = options[forward || "target"]!;
+
   outgoing.port =
-    options[forward || "target"].port ??
-    (isSSL.test(options[forward || "target"].protocol) ? 443 : 80);
+    +(target.port ?? (target.protocol !== undefined && isSSL.test(target.protocol) ? 443 : 80));
 
   for (const e of [
     "host",
@@ -57,8 +58,9 @@ export function setupOutgoing(
     "ca",
     "ciphers",
     "secureProtocol",
-  ]) {
-    outgoing[e] = options[forward || "target"][e];
+  ] as const) {
+    // @ts-expect-error -- this mapping is valid
+    outgoing[e] = target[e];
   }
 
   outgoing.method = options.method || req.method;
@@ -87,7 +89,7 @@ export function setupOutgoing(
     outgoing.ca = options.ca;
   }
 
-  if (isSSL.test(options[forward || "target"].protocol)) {
+  if (target.protocol !== undefined && isSSL.test(target.protocol)) {
     outgoing.rejectUnauthorized =
       typeof options.secure === "undefined" ? true : options.secure;
   }
@@ -107,11 +109,9 @@ export function setupOutgoing(
     }
   }
 
-  // the final path is target path + relative path requested by user:
-  const target = options[forward || "target"];
   // target if defined is a URL object so has attribute "pathname", not "path".
   const targetPath =
-    target && options.prependPath !== false ? getPath(target.pathname) : "/";
+    target && options.prependPath !== false && 'pathname' in target ? getPath(target.pathname) : "/";
 
   let outgoingPath = options.toProxy ? req.url : getPath(req.url);
 
@@ -124,7 +124,8 @@ export function setupOutgoing(
 
   if (options.changeOrigin) {
     outgoing.headers.host =
-      required(outgoing.port, options[forward || "target"].protocol) &&
+      target.protocol !== undefined &&
+      required(outgoing.port, target.protocol) &&
       !hasPort(outgoing.host)
         ? outgoing.host + ":" + outgoing.port
         : outgoing.host;
@@ -216,12 +217,22 @@ export function urlJoin(...args: string[]): string {
 
 // Rewrites or removes the domain of a cookie header
 export function rewriteCookieProperty(
-  header: string | any[],
+  header: string,
+  config: Record<string, string>,
+  property: string,
+): string;
+export function rewriteCookieProperty(
+  header: string | string[],
+  config: Record<string, string>,
+  property: string,
+): string | string[];
+export function rewriteCookieProperty(
+  header: string | string[],
   // config = mapping of domain to rewritten domain.
   //         '*' key to match any domain, null value to remove the domain.
-  config: object,
+  config: Record<string, string>,
   property: string,
-) {
+): string | string[] {
   if (Array.isArray(header)) {
     return header.map((headerElement) => {
       return rewriteCookieProperty(headerElement, config, property);
@@ -260,10 +271,10 @@ function getPath(url?: string): string {
   return `${u.pathname ?? ""}${u.search ?? ""}`;
 }
 
-export function toURL(url: URL | urllib.Url | string | undefined): URL {
+export function toURL(url: URL | urllib.Url | ProxyTargetDetailed | string | undefined): URL {
   if (url instanceof URL) {
     return url;
-  } else if (typeof url === "object" && typeof url.href === "string") {
+  } else if (typeof url === "object" && 'href' in url && typeof url.href === "string") {
     url = url.href;
   }
   if (!url) {
@@ -275,7 +286,7 @@ export function toURL(url: URL | urllib.Url | string | undefined): URL {
   }
   if (url.startsWith("//")) {
     // special case -- this would be viewed as a this is a "network-path reference",
-    // so we explicitly prefix with our http schema.  See 
+    // so we explicitly prefix with our http schema.  See
     url = `http://dummy.org${url}`;
   }
   // urllib.Url is deprecated but we support it by converting to URL

lib/http-proxy/index.ts

@@ -26,7 +26,9 @@ export interface ProxyTargetDetailed {
 }
 export type ProxyType = "ws" | "web";
 export type ProxyTarget = ProxyTargetUrl | ProxyTargetDetailed;
-export type ProxyTargetUrl = URL | string | { port: number; host: string };
+export type ProxyTargetUrl = URL | string | { port: number; host: string; protocol?: string };
+
+export type NormalizeProxyTarget<T extends ProxyTargetUrl> = Exclude<T, string> | URL;
 
 export interface ServerOptions {
   // NOTE: `options.target and `options.forward` cannot be both missing when the
@@ -83,6 +85,18 @@ export interface ServerOptions {
   selfHandleResponse?: boolean;
   /** Buffer */
   buffer?: Stream;
+  /** Explicitly set the method type of the ProxyReq */
+  method?: string;
+  /**
+   * Optionally override the trusted CA certificates.
+   * This is passed to https.request.
+   */
+  ca?: string;
+}
+
+export interface NormalizedServerOptions extends ServerOptions {
+  target?: NormalizeProxyTarget<ProxyTarget>;
+  forward?: NormalizeProxyTarget<ProxyTargetUrl>;
 }
 
 export type ErrorCallback =
@@ -106,6 +120,7 @@ type ProxyServerEventMap = {
     req: http.IncomingMessage,
     res: http.ServerResponse,
     options: ServerOptions,
+    socket: net.Socket,
   ];
   proxyRes: [
     proxyRes: http.IncomingMessage,
@@ -137,56 +152,75 @@ type ProxyServerEventMap = {
   ];
 }
 
-export class ProxyServer extends EventEmitter<ProxyServerEventMap> {
-  /**
-   * Used for proxying WS(S) requests
-   * @param req - Client request.
-   * @param socket - Client socket.
-   * @param head - Client head.
-   * @param options - Additional options.
-   */
-  public readonly ws: (
+type ProxyMethodArgs = {
+  ws: [
+    req: http.IncomingMessage,
+    socket: any,
+    head: any,
     ...args:
       [
-        req: http.IncomingMessage,
-        socket: any,
-        head: any,
         options?: ServerOptions,
         callback?: ErrorCallback,
       ]
     | [
-        req: http.IncomingMessage,
-        socket: any,
-        head: any,
         callback?: ErrorCallback,
       ]
-  ) => void;
+  ]
+  web: [
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    ...args:
+        [
+          options: ServerOptions,
+          callback?: ErrorCallback,
+        ]
+      | [
+          callback?: ErrorCallback
+        ]
+  ]
+}
+
+type PassFunctions = {
+  ws: (
+    req: http.IncomingMessage,
+    socket: net.Socket,
+    options: NormalizedServerOptions,
+    head: Buffer | undefined,
+    server: ProxyServer,
+    cb?: ErrorCallback
+  ) => unknown
+  web: (
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    options: NormalizedServerOptions,
+    head: Buffer | undefined,
+    server: ProxyServer,
+    cb?: ErrorCallback
+  ) => unknown
+}
+
+export class ProxyServer extends EventEmitter<ProxyServerEventMap> {
+  /**
+   * Used for proxying WS(S) requests
+   * @param req - Client request.
+   * @param socket - Client socket.
+   * @param head - Client head.
+   * @param options - Additional options.
+   */
+  public readonly ws: (...args: ProxyMethodArgs["ws"]) => void;
 
   /**
    * Used for proxying regular HTTP(S) requests
    * @param req - Client request.
    * @param res - Client response.
    * @param options - Additional options.
    */
-  public readonly web: (
-    ...args:
-      [
-        req: http.IncomingMessage,
-        res: http.ServerResponse,
-        options: ServerOptions,
-        callback?: ErrorCallback,
-      ]
-    | [
-        req: http.IncomingMessage,
-        res: http.ServerResponse,
-        callback?: ErrorCallback
-      ]
-  ) => void;
+  public readonly web: (...args: ProxyMethodArgs["web"]) => void;
 
   private options: ServerOptions;
-  private webPasses;
-  private wsPasses;
-  private _server?;
+  private webPasses: Array<PassFunctions['web']>;
+  private wsPasses: Array<PassFunctions['ws']>;
+  private _server?: http.Server | https.Server | null;
 
   /**
    * Creates the proxy server with specified options.
@@ -233,10 +267,10 @@ export class ProxyServer extends EventEmitter<ProxyServerEventMap> {
 
   // createRightProxy - Returns a function that when called creates the loader for
   // either `ws` or `web`'s passes.
-  createRightProxy = (type: ProxyType): Function => {
+  createRightProxy = <PT extends ProxyType>(type: PT): Function => {
     log("createRightProxy", { type });
-    return (options) => {
-      return (...args: any[] /* req, res, [head], [opts] */) => {
+    return (options: ServerOptions) => {
+      return (...args: ProxyMethodArgs[PT] /* req, res, [head], [opts] */) => {
         const req = args[0];
         log("proxy: ", { type, path: req.url });
         const res = args[1];
@@ -255,16 +289,16 @@ export class ProxyServer extends EventEmitter<ProxyServerEventMap> {
           });
         }
         let counter = args.length - 1;
-        let head;
-        let cb;
+        let head: Buffer | undefined;
+        let cb: ErrorCallback | undefined;
 
         // optional args parse begin
         if (typeof args[counter] === "function") {
           cb = args[counter];
           counter--;
         }
 
-        let requestOptions;
+        let requestOptions: ServerOptions;
         if (!(args[counter] instanceof Buffer) && args[counter] !== res) {
           // Copy global options, and overwrite with request options
           requestOptions = { ...options, ...args[counter] };
@@ -277,7 +311,7 @@ export class ProxyServer extends EventEmitter<ProxyServerEventMap> {
           head = args[counter];
         }
 
-        for (const e of ["target", "forward"]) {
+        for (const e of ["target", "forward"] as const) {
           if (typeof requestOptions[e] === "string") {
             requestOptions[e] = toURL(requestOptions[e]);
           }
@@ -297,7 +331,7 @@ export class ProxyServer extends EventEmitter<ProxyServerEventMap> {
            * refer to the connection socket
            *    pass(req, socket, options, head)
            */
-          if (pass(req, res, requestOptions, head, this, cb)) {
+          if (pass(req, res, requestOptions as NormalizedServerOptions, head, this, cb)) {
             // passes can return a truthy value to halt the loop
             break;
           }
@@ -356,12 +390,12 @@ export class ProxyServer extends EventEmitter<ProxyServerEventMap> {
     });
   };
 
-  before = (type: ProxyType, passName: string, cb: Function) => {
+  before = <PT extends ProxyType>(type: PT, passName: string, cb: PassFunctions[PT]) => {
     if (type !== "ws" && type !== "web") {
       throw new Error("type must be `web` or `ws`");
     }
-    const passes = type === "ws" ? this.wsPasses : this.webPasses;
-    let i = false;
+    const passes = (type === "ws" ? this.wsPasses : this.webPasses) as PassFunctions[PT][];
+    let i: false | number = false;
 
     passes.forEach((v, idx) => {
       if (v.name === passName) {
@@ -376,12 +410,12 @@ export class ProxyServer extends EventEmitter<ProxyServerEventMap> {
     passes.splice(i, 0, cb);
   };
 
-  after = (type: ProxyType, passName: string, cb: Function) => {
+  after = <PT extends ProxyType>(type: PT, passName: string, cb: PassFunctions[PT]) => {
     if (type !== "ws" && type !== "web") {
       throw new Error("type must be `web` or `ws`");
     }
-    const passes = type === "ws" ? this.wsPasses : this.webPasses;
-    let i = false;
+    const passes = (type === "ws" ? this.wsPasses : this.webPasses) as PassFunctions[PT][];
+    let i: false | number = false;
 
     passes.forEach((v, idx) => {
       if (v.name === passName) {