feat(proxy): use native fetch + event.app.fetch (#1141)

Author: pi0

docs/2.utils/5.proxy.md

@@ -8,7 +8,7 @@ icon: arcticons:super-proxy
 
 <!-- automd:jsdocs src="../../src/utils/proxy.ts" -->
 
-### `fetchWithEvent(event, req, init?, options?: { fetch: F })`
+### `fetchWithEvent(event, req, init?)`
 
 Make a fetch request with the event's context and headers.
 

src/utils/internal/proxy.ts

@@ -15,18 +15,6 @@ export const ignoredHeaders: Set<string> = new Set([
   "accept",
 ]);
 
-export function getFetch<T = typeof fetch>(_fetch?: T): T {
-  if (_fetch) {
-    return _fetch;
-  }
-  if (globalThis.fetch) {
-    return globalThis.fetch as T;
-  }
-  throw new Error(
-    "fetch is not available. Try importing `node-fetch-native/polyfill` for Node.js.",
-  );
-}
-
 export function rewriteCookieProperty(
   header: string,
   map: string | Record<string, string>,

src/utils/proxy.ts

@@ -1,12 +1,10 @@
-import type { H3EventContext } from "../types/context.ts";
 import type { H3Event } from "../event.ts";
 
 import { splitSetCookieString } from "cookie-es";
-import { sanitizeStatusMessage, sanitizeStatusCode } from "./sanitize.ts";
+import { sanitizeStatusMessage } from "./sanitize.ts";
 import { HTTPError } from "../error.ts";
 import {
   PayloadMethods,
-  getFetch,
   ignoredHeaders,
   mergeHeaders,
   rewriteCookieProperty,
@@ -17,12 +15,7 @@ export interface ProxyOptions {
   headers?: HeadersInit;
   forwardHeaders?: string[];
   filterHeaders?: string[];
-  fetchOptions?: RequestInit & { duplex?: "half" | "full" } & {
-    ignoreResponseError?: boolean;
-  };
-  fetch?: typeof fetch;
-  sendStream?: boolean;
-  streamRequest?: boolean;
+  fetchOptions?: RequestInit & { duplex?: "half" | "full" };
   cookieDomainRewrite?: string | Record<string, string>;
   cookiePathRewrite?: string | Record<string, string>;
   onResponse?: (event: H3Event, response: Response) => void;
@@ -37,16 +30,9 @@ export async function proxyRequest(
   opts: ProxyOptions = {},
 ): Promise<BodyInit | undefined | null> {
   // Request Body
-  let body;
-  let duplex: "half" | "full" | undefined;
-  if (PayloadMethods.has(event.req.method)) {
-    if (opts.streamRequest) {
-      body = event.req.body;
-      duplex = "half";
-    } else {
-      body = await event.req.arrayBuffer();
-    }
-  }
+  const requestBody = PayloadMethods.has(event.req.method)
+    ? event.req.body
+    : undefined;
 
   // Method
   const method = opts.fetchOptions?.method || event.req.method;
@@ -66,8 +52,8 @@ export async function proxyRequest(
     ...opts,
     fetchOptions: {
       method,
-      body,
-      duplex,
+      body: requestBody,
+      duplex: requestBody ? "half" : undefined,
       ...opts.fetchOptions,
       headers: fetchHeaders,
     },
@@ -82,17 +68,20 @@ export async function proxy(
   target: string,
   opts: ProxyOptions = {},
 ): Promise<BodyInit | undefined | null> {
+  const fetchOptions: RequestInit = {
+    headers: opts.headers as HeadersInit,
+    ...opts.fetchOptions,
+  };
+
   let response: Response | undefined;
   try {
-    response = await getFetch(opts.fetch)(target, {
-      headers: opts.headers as HeadersInit,
-      ignoreResponseError: true, // make $ofetch.raw transparent
-      ...opts.fetchOptions,
-    });
+    response =
+      target[0] === "/" && event.app?.fetch
+        ? await event.app._fetch(target, fetchOptions, { ...event.context })
+        : await fetch(target, fetchOptions);
   } catch (error) {
     throw new HTTPError({ status: 502, cause: error });
   }
-  event.res.status = sanitizeStatusCode(response.status, event.res.status);
   event.res.statusText = sanitizeStatusMessage(response.statusText);
 
   const cookies: string[] = [];
@@ -134,17 +123,6 @@ export async function proxy(
     await opts.onResponse(event, response);
   }
 
-  // Directly send consumed _data
-  if ((response as any)._data !== undefined) {
-    return (response as any)._data;
-  }
-
-  // Send at once
-  if (opts.sendStream === false) {
-    return new Uint8Array(await response.arrayBuffer());
-  }
-
-  // Send as stream
   return response.body;
 }
 
@@ -176,26 +154,26 @@ export function getProxyRequestHeaders(
 /**
  * Make a fetch request with the event's context and headers.
  */
-export function fetchWithEvent<
-  T = unknown,
-  _R = unknown,
-  F extends (req: RequestInfo | URL, opts?: any) => any = typeof fetch,
->(
+export async function fetchWithEvent(
   event: H3Event,
   req: RequestInfo | URL,
-  init?: RequestInit & { context?: H3EventContext },
-  options?: { fetch: F },
-): unknown extends T ? ReturnType<F> : T {
-  return getFetch(options?.fetch)(req, {
-    ...init,
-    context: init?.context || event.context,
-    headers: mergeHeaders(
-      getProxyRequestHeaders(event, {
-        host: typeof req === "string" && req.startsWith("/"),
-      }),
-      init?.headers,
-    ),
-  } satisfies RequestInit & {
-    context?: H3EventContext;
-  });
+  init?: RequestInit,
+): Promise<Response> {
+  if (typeof req !== "string" || req[0] !== "/" || !event.app) {
+    return fetch(req, init);
+  }
+
+  return await event.app!._fetch(
+    req,
+    {
+      ...init,
+      headers: mergeHeaders(
+        getProxyRequestHeaders(event, {
+          host: typeof req === "string" && req.startsWith("/"),
+        }),
+        init?.headers,
+      ),
+    },
+    { ...event.context },
+  );
 }