feat: remove bypass option from proxy configuration

Author: bjohansebas

examples/general/proxy-advanced/README.md

@@ -15,5 +15,3 @@ npx webpack serve --open
 2. You should see the text on the page itself change to read `Success!`.
 3. Navigate to `http://localhost:8080/api/users`.
 4. The page should display several JSON objects.
-5. Navigate to `http://localhost:8080/api/nope`.
-6. The page should display `Bypassed proxy!``.

examples/general/proxy-advanced/bypass.html

@@ -8,19 +8,16 @@ module.exports = setup({
   context: __dirname,
   entry: "./app.js",
   devServer: {
-    proxy: {
-      "/api": {
-        target: "http://jsonplaceholder.typicode.com/",
-        changeOrigin: true,
-        pathRewrite: {
-          "^/api": "",
-        },
-        bypass(req) {
-          if (req.url === "/api/nope") {
-            return "/bypass.html";
-          }
+    proxy: [
+      {
+        "/api": {
+          target: "http://jsonplaceholder.typicode.com/",
+          changeOrigin: true,
+          pathRewrite: {
+            "^/api": "",
+          },
         },
       },
-    },
+    ],
   },
 });

examples/general/proxy-advanced/webpack.config.js

@@ -3,7 +3,6 @@
 const os = require("node:os");
 const path = require("node:path");
 const url = require("node:url");
-const util = require("node:util");
 const fs = require("graceful-fs");
 const ipaddr = require("ipaddr.js");
 const { validate } = require("schema-utils");
@@ -138,14 +137,7 @@ const schema = require("./options.json");
  */
 
 /**
- * @callback ByPass
- * @param {Request} req
- * @param {Response} res
- * @param {ProxyConfigArrayItem} proxyConfig
- */
-
-/**
- * @typedef {{ path?: HttpProxyMiddlewareOptionsFilter | undefined, context?: HttpProxyMiddlewareOptionsFilter | undefined } & { bypass?: ByPass } & HttpProxyMiddlewareOptions } ProxyConfigArrayItem
+ * @typedef {{ path?: HttpProxyMiddlewareOptionsFilter | undefined, context?: HttpProxyMiddlewareOptionsFilter | undefined } & HttpProxyMiddlewareOptions } ProxyConfigArrayItem
  */
 
 /**
@@ -2131,8 +2123,6 @@ class Server {
        * @returns {RequestHandler | undefined} request handler
        */
       const getProxyMiddleware = (proxyConfig) => {
-        // It is possible to use the `bypass` method without a `target` or `router`.
-        // However, the proxy middleware has no use in this case, and will fail to instantiate.
         if (proxyConfig.target) {
           const context = proxyConfig.context || proxyConfig.path;
 
@@ -2145,15 +2135,6 @@ class Server {
         if (proxyConfig.router) {
           return createProxyMiddleware(proxyConfig);
         }
-
-        // TODO improve me after drop `bypass` to always generate error when configuration is bad
-        if (!proxyConfig.bypass) {
-          util.deprecate(
-            () => {},
-            `Invalid proxy configuration:\n\n${JSON.stringify(proxyConfig, null, 2)}\n\nThe use of proxy object notation as proxy routes has been removed.\nPlease use the 'router' or 'context' options. Read more at https://github.com/chimurai/http-proxy-middleware/tree/v2.0.6#http-proxy-middleware-options`,
-            "DEP_WEBPACK_DEV_SERVER_PROXY_ROUTES_ARGUMENT",
-          )();
-        }
       };
 
       /**
@@ -2205,7 +2186,7 @@ class Server {
             if (newProxyConfig !== proxyConfig) {
               proxyConfig = newProxyConfig;
 
-              const socket = req.socket || req.connection;
+              const socket = req.socket;
               // @ts-expect-error
               const server = socket ? socket.server : null;
 
@@ -2219,40 +2200,11 @@ class Server {
             }
           }
 
-          // - Check if we have a bypass function defined
-          // - In case the bypass function is defined we'll retrieve the
-          // bypassUrl from it otherwise bypassUrl would be null
-          // TODO remove in the next major in favor `context` and `router` options
-          const isByPassFuncDefined = typeof proxyConfig.bypass === "function";
-          if (isByPassFuncDefined) {
-            util.deprecate(
-              () => {},
-              "Using the 'bypass' option is deprecated. Please use the 'router' or 'context' options. Read more at https://github.com/chimurai/http-proxy-middleware/tree/v2.0.6#http-proxy-middleware-options",
-              "DEP_WEBPACK_DEV_SERVER_PROXY_BYPASS_ARGUMENT",
-            )();
-          }
-          const bypassUrl = isByPassFuncDefined
-            ? await /** @type {ByPass} */ (proxyConfig.bypass)(
-                req,
-                res,
-                proxyConfig,
-              )
-            : null;
-
-          if (typeof bypassUrl === "boolean") {
-            // skip the proxy
-            res.statusCode = 404;
-            req.url = "";
-            next();
-          } else if (typeof bypassUrl === "string") {
-            // byPass to that url
-            req.url = bypassUrl;
-            next();
-          } else if (proxyMiddleware) {
+          if (proxyMiddleware) {
             return proxyMiddleware(req, res, next);
-          } else {
-            next();
           }
+
+          next();
         };
 
         middlewares.push({

lib/Server.js

@@ -1,7 +1,6 @@
 "use strict";
 
 const path = require("node:path");
-const util = require("node:util");
 const express = require("express");
 const request = require("supertest");
 const webpack = require("webpack");
@@ -23,48 +22,6 @@ const proxyOptionPathsAsProperties = [
     target: `http://localhost:${port2}`,
     pathRewrite: { "^/api": "" },
   },
-  {
-    context: "/foo",
-    bypass(req) {
-      if (/\.html$/.test(req.path || req.url)) {
-        return "/index.html";
-      }
-
-      return null;
-    },
-  },
-  {
-    context: "proxyfalse",
-    bypass(req) {
-      if (/\/proxyfalse$/.test(req.path || req.url)) {
-        return false;
-      }
-    },
-  },
-  {
-    context: "/proxy/async",
-    bypass(req, res) {
-      if (/\/proxy\/async$/.test(req.path || req.url)) {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            res.end("proxy async response");
-            resolve(true);
-          }, 10);
-        });
-      }
-    },
-  },
-  {
-    context: "/bypass-with-target",
-    target: `http://localhost:${port1}`,
-    changeOrigin: true,
-    secure: false,
-    bypass(req) {
-      if (/\.(html)$/i.test(req.path || req.url)) {
-        return req.url;
-      }
-    },
-  },
 ];
 
 const proxyOption = [
@@ -77,7 +34,7 @@ const proxyOption = [
 let maxServerListeners = 0;
 const proxyOptionOfArray = [
   { context: "/proxy1", target: `http://localhost:${port1}` },
-  function proxy(req, res, next) {
+  function proxy(req) {
     if (req) {
       const socket = req.socket || req.connection;
       const server = socket ? socket.server : null;
@@ -92,19 +49,6 @@ const proxyOptionOfArray = [
       context: "/api/proxy2",
       target: `http://localhost:${port2}`,
       pathRewrite: { "^/api": "" },
-      bypass: () => {
-        if (req) {
-          const resolveUrl = new URL(req.url, `http://${req.headers.host}`);
-          const params = new URLSearchParams(resolveUrl.search);
-          const foo = params.get("foo");
-
-          if (foo) {
-            res.end(`foo+${next.name}+${typeof next}`);
-
-            return false;
-          }
-        }
-      },
     };
   },
 ];
@@ -246,75 +190,6 @@ describe("proxy option", () => {
         expect(response.text).toContain("from proxy2");
       });
     });
-
-    describe("bypass", () => {
-      it("should log deprecation warning when bypass is used", async () => {
-        const utilSpy = jest.spyOn(util, "deprecate");
-
-        const response = await req.get("/foo/bar.html");
-
-        expect(response.status).toBe(200);
-        expect(response.text).toContain("Hello");
-
-        const lastCall = utilSpy.mock.calls[utilSpy.mock.calls.length - 1];
-
-        expect(lastCall[1]).toBe(
-          "Using the 'bypass' option is deprecated. Please use the 'router' or 'context' options. Read more at https://github.com/chimurai/http-proxy-middleware/tree/v2.0.6#http-proxy-middleware-options",
-        );
-        expect(lastCall[2]).toBe(
-          "DEP_WEBPACK_DEV_SERVER_PROXY_BYPASS_ARGUMENT",
-        );
-
-        utilSpy.mockRestore();
-      });
-
-      it("can rewrite a request path", async () => {
-        const response = await req.get("/foo/bar.html");
-
-        expect(response.status).toBe(200);
-        expect(response.text).toContain("Hello");
-      });
-
-      it("can rewrite a request path regardless of the target defined a bypass option", async () => {
-        const response = await req.get("/baz/hoge.html");
-
-        expect(response.status).toBe(200);
-        expect(response.text).toContain("Hello");
-      });
-
-      it("should pass through a proxy when a bypass function returns null", async () => {
-        const response = await req.get("/foo.js");
-
-        expect(response.status).toBe(200);
-        expect(response.text).toContain("Hey");
-      });
-
-      it("should not pass through a proxy when a bypass function returns false", async () => {
-        const response = await req.get("/proxyfalse");
-
-        expect(response.status).toBe(404);
-      });
-
-      it("should wait if bypass returns promise", async () => {
-        const response = await req.get("/proxy/async");
-
-        expect(response.status).toBe(200);
-        expect(response.text).toContain("proxy async response");
-      });
-
-      it("should work with the 'target' option", async () => {
-        const response = await req.get("/bypass-with-target/foo.js");
-
-        expect(response.status).toBe(404);
-      });
-
-      it("should work with the 'target' option #2", async () => {
-        const response = await req.get("/bypass-with-target/index.html");
-
-        expect(response.status).toBe(200);
-        expect(response.text).toContain("Hello");
-      });
-    });
   });
 
   describe("as an option is an object with the `context` option", () => {
@@ -502,7 +377,7 @@ describe("proxy option", () => {
       const response = await req.get("/api/proxy2?foo=true");
 
       expect(response.statusCode).toBe(200);
-      expect(response.text).toBe("foo+next+function");
+      expect(response.text).toBe("from proxy2");
     });
 
     it("should not exist multiple close events registered", async () => {

test/server/proxy-option.test.js

@@ -1465,7 +1465,6 @@ declare namespace Server {
     ClientConnection,
     WebSocketServer,
     WebSocketServerImplementation,
-    ByPass,
     ProxyConfigArrayItem,
     ProxyConfigArray,
     OpenApp,
@@ -1655,16 +1654,9 @@ type WebSocketServerImplementation = {
   implementation: WebSocketServer;
   clients: ClientConnection[];
 };
-type ByPass = (
-  req: Request,
-  res: Response,
-  proxyConfig: ProxyConfigArrayItem,
-) => any;
 type ProxyConfigArrayItem = {
   path?: HttpProxyMiddlewareOptionsFilter | undefined;
   context?: HttpProxyMiddlewareOptionsFilter | undefined;
-} & {
-  bypass?: ByPass;
 } & HttpProxyMiddlewareOptions;
 type ProxyConfigArray = (
   | ProxyConfigArrayItem