fix: bypass the request when the server.proxy is specified

packages/plugin-vite/src/plugins/dev_server.ts

@@ -1,4 +1,4 @@
-import type { DevEnvironment, Plugin } from "vite";
+import type { DevEnvironment, Plugin, ResolvedServerOptions } from "vite";
 import * as path from "@std/path";
 import { contentType as getStdContentType } from "@std/media-types/content-type";
 import { ASSET_CACHE_BUST_KEY } from "fresh/internal";
@@ -10,6 +10,39 @@ function getContentType(ext: string): string {
   return getStdContentType(ext) ?? "application/octet-stream";
 }
 
+/**
+ * Handling the user config of proxy
+ * https://vite.dev/config/server-options#server-proxy
+ *
+ * Note: per-entry `bypass(req, res, options)` callbacks are not supported here.
+ * Requests matched by a proxy key are always short-circuited to Vite's proxy
+ * handler; a `bypass` that returns `false` would still skip Fresh but then
+ * fall through the proxy without being proxied, resulting in a 404.
+ */
+function createProxyUrlMatcher(
+  proxy: ResolvedServerOptions["proxy"],
+): ((url: string) => boolean) | undefined {
+  if (proxy === undefined) return undefined;
+
+  const matchers = Object.keys(proxy).map((context) => {
+    // with RegExp
+    if (context[0] === "^") {
+      const regex = new RegExp(context);
+      return (url: string) => regex.test(url);
+    }
+    // string shorthand
+    return (url: string) => url.startsWith(context);
+  });
+
+  return (url: string) => {
+    for (const matches of matchers) {
+      if (matches(url)) return true;
+    }
+
+    return false;
+  };
+}
+
 export function devServer(freshConfig: ResolvedFreshViteConfig): Plugin[] {
   let publicDir = "";
   return [
@@ -27,15 +60,25 @@ export function devServer(freshConfig: ResolvedFreshViteConfig): Plugin[] {
         const IGNORE_URLS = new RegExp(
           `^(${base})?/(@(vite|fs|id)|\\.vite)/`,
         );
+        // Precompute the proxy URL matcher; proxy config is fixed at server start.
+        const matchesProxyUrl = createProxyUrlMatcher(
+          server.config.server.proxy,
+        );
 
         server.middlewares.use(async (nodeReq, nodeRes, next) => {
           const serverCfg = server.config.server;
+          const rawUrl = nodeReq.url ?? "/";
+
+          // bypass the request when the proxy specified
+          if (matchesProxyUrl?.(rawUrl)) {
+            return next();
+          }
 
           const protocol = serverCfg.https ? "https" : "http";
           const host = serverCfg.host ? serverCfg.host : "localhost";
           const port = serverCfg.port;
           const url = new URL(
-            `${protocol}://${host}:${port}${nodeReq.url ?? "/"}`,
+            `${protocol}://${host}:${port}${rawUrl}`,
           );
 
           // Don't cache in dev

packages/plugin-vite/tests/dev_server_test.ts

@@ -1,5 +1,6 @@
 import * as path from "@std/path";
 import { expect } from "@std/expect";
+import { withTmpDir, writeFiles } from "../../fresh/src/test_utils.ts";
 import {
   waitFor,
   waitForText,
@@ -465,6 +466,91 @@ integrationTest(
   },
 );
 
+// https://github.com/denoland/fresh/issues/3814
+integrationTest("vite dev - server.proxy bypasses Fresh routes", async () => {
+  const api = new URLPattern({ pathname: "/api/*" });
+  const api2 = new URLPattern({ pathname: "/api2/*" });
+  const api3 = new URLPattern({ pathname: "/api3/*" });
+  await using proxy = Deno.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+  }, (req) => {
+    const url = new URL(req.url);
+    if (api.test({ pathname: url.pathname })) {
+      return new Response("api");
+    }
+    if (api2.test({ pathname: url.pathname })) {
+      return new Response("api2");
+    }
+    if (api3.test({ pathname: url.pathname })) {
+      return new Response("api3");
+    }
+    throw new Error("unreachable");
+  });
+
+  await using tmp = await withTmpDir({
+    dir: path.join(import.meta.dirname!, ".."),
+    prefix: "tmp_vite_",
+  });
+
+  await writeFiles(tmp.dir, {
+    "main.ts": `import { App } from "@fresh/core";
+export const app = new App()
+.get("/", () => new Response("ok"));
+`,
+    "vite.config.ts": `import { defineConfig } from "vite";
+import { fresh } from "@fresh/plugin-vite";
+
+export default defineConfig({
+plugins: [fresh()],
+server: {
+  proxy: {
+    "/api": Deno.env.get("FRESH_TEST_PROXY_TARGET")!,
+    "/api2": {
+      target: Deno.env.get("FRESH_TEST_PROXY_TARGET")!,
+      rewrite: (path) => path.replace(/^\\/api2\\/ping/, "/api2/pong"),
+    },
+    '^/api3/.*': {
+      target: Deno.env.get("FRESH_TEST_PROXY_TARGET")!,
+      changeOrigin: true,
+    },
+  },
+},
+});
+`,
+  });
+
+  await launchDevServer(
+    tmp.dir,
+    async (address) => {
+      {
+        const res = await fetch(`${address}/api/ping?x=1`);
+        expect(res.status).toEqual(200);
+        expect(await res.text()).toEqual("api");
+      }
+      {
+        const res = await fetch(`${address}/api2/pong?y=2`);
+        expect(res.status).toEqual(200);
+        expect(await res.text()).toEqual("api2");
+      }
+      {
+        const res = await fetch(`${address}/api3/pong?z=3`);
+        expect(res.status).toEqual(200);
+        expect(await res.text()).toEqual("api3");
+      }
+      {
+        // Ensure the bypass is selective — non-proxied routes still hit Fresh.
+        const res = await fetch(`${address}/`);
+        expect(res.status).toEqual(200);
+        expect(await res.text()).toEqual("ok");
+      }
+    },
+    {
+      FRESH_TEST_PROXY_TARGET: `http://127.0.0.1:${proxy.addr.port}`,
+    },
+  );
+});
+
 integrationTest("vite dev - source mapped stack traces", async () => {
   const res = await fetch(`${demoServer.address()}/tests/throw`);
   const text = await res.text();