@vercel/node 3.0.7 → 3.0.9

package/dist/dev-server.mjs

@@ -528,7 +528,7 @@ function createNodeCompatPlugin() {
 
 // src/edge-functions/edge-handler.mts
 import { EdgeRuntime, runServer } from "edge-runtime";
-import { fetch, Headers as Headers2 } from "undici";
+import { Headers as Headers2, request as undiciRequest } from "undici";
 import { isError } from "@vercel/error-utils";
 import { readFileSync } from "fs";
 
@@ -589,6 +589,7 @@ async function serializeBody(request) {
 // src/edge-functions/edge-handler.mts
 import esbuild from "esbuild";
 import exitHook from "exit-hook";
+import { buildToHeaders } from "@edge-runtime/node-utils";
 import { fileURLToPath } from "url";
 var NODE_VERSION_MAJOR = process.version.match(/^v(\d+)\.\d+/)?.[1];
 var NODE_VERSION_IDENTIFIER = `node${NODE_VERSION_MAJOR}`;
@@ -597,6 +598,7 @@ if (!NODE_VERSION_MAJOR) {
     `Unable to determine current node version: process.version=${process.version}`
   );
 }
+var toHeaders = buildToHeaders({ Headers: Headers2 });
 var __dirname = fileURLToPath(new URL(".", import.meta.url));
 var edgeHandlerTemplate = readFileSync(
   `${__dirname}/edge-handler-template.js`
@@ -724,20 +726,19 @@ async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath
     if (!server) {
       process.exit(1);
     }
-    const headers = new Headers2(request.headers);
     const body = await serializeBody(request);
     if (body !== void 0)
-      headers.set("content-length", String(body.length));
+      request.headers["content-length"] = String(body.length);
     const url = new URL(request.url ?? "/", server.url);
-    const response = await fetch(url, {
+    const response = await undiciRequest(url, {
       body,
-      headers,
-      method: request.method,
-      redirect: "manual"
+      headers: request.headers,
+      method: request.method || "GET"
     });
-    const isUserError = response.headers.get("x-vercel-failed") === "edge-wrapper";
-    if (isUserError && response.status >= 500) {
-      const body2 = await response.text();
+    const resHeaders = toHeaders(response.headers);
+    const isUserError = resHeaders.get("x-vercel-failed") === "edge-wrapper";
+    if (isUserError && response.statusCode >= 500) {
+      const body2 = await response.body.text();
       const fakeStackTrace = `    at (${entrypointRelativePath})`;
       const requestPath = entrypointToRequestPath(
         entrypointRelativePath,
@@ -750,8 +751,8 @@ ${fakeStackTrace}`
       process.exit(1);
     }
     return {
-      status: response.status,
-      headers: response.headers,
+      status: response.statusCode,
+      headers: resHeaders,
       body: response.body,
       encoding: "utf8"
     };
@@ -972,11 +973,12 @@ async function addHelpers(_req, _res) {
 // src/serverless-functions/serverless-handler.mts
 import { createServer } from "http";
 import exitHook2 from "exit-hook";
-import { Headers as Headers3, fetch as fetch2 } from "undici";
+import { Headers as Headers3, request as undiciRequest2 } from "undici";
 import { listen } from "async-listen";
 import { isAbsolute } from "path";
 import { pathToFileURL } from "url";
-import zlib from "zlib";
+import { buildToHeaders as buildToHeaders2 } from "@edge-runtime/node-utils";
+var toHeaders2 = buildToHeaders2({ Headers: Headers3 });
 var [NODE_MAJOR] = process.versions.node.split(".").map((v) => Number(v));
 var HTTP_METHODS = [
   "GET",
@@ -987,26 +989,6 @@ var HTTP_METHODS = [
   "DELETE",
   "PATCH"
 ];
-function compress(body, encoding) {
-  switch (encoding) {
-    case "br":
-      return zlib.brotliCompressSync(body, {
-        params: {
-          [zlib.constants.BROTLI_PARAM_QUALITY]: 0
-        }
-      });
-    case "gzip":
-      return zlib.gzipSync(body, {
-        level: zlib.constants.Z_BEST_SPEED
-      });
-    case "deflate":
-      return zlib.deflateSync(body, {
-        level: zlib.constants.Z_BEST_SPEED
-      });
-    default:
-      throw new Error(`encoding '${encoding}' not supported`);
-  }
-}
 async function createServerlessServer(userCode) {
   const server = createServer(userCode);
   exitHook2(() => server.close());
@@ -1040,38 +1022,23 @@ async function createServerlessEventHandler(entrypointPath, options) {
   const isStreaming = options.mode === "streaming";
   return async function(request) {
     const url = new URL(request.url ?? "/", server.url);
-    const response = await fetch2(url, {
+    const response = await undiciRequest2(url, {
       body: await serializeBody(request),
-      compress: !isStreaming,
-      // @ts-expect-error
       headers: {
         ...request.headers,
         host: request.headers["x-forwarded-host"]
       },
-      method: request.method,
-      redirect: "manual"
+      method: request.method || "GET"
     });
     let body = null;
-    let headers = response.headers;
+    let headers = toHeaders2(response.headers);
     if (isStreaming) {
       body = response.body;
     } else {
-      body = Buffer.from(await response.arrayBuffer());
-      const contentEncoding = response.headers.get("content-encoding");
-      if (contentEncoding) {
-        body = compress(body, contentEncoding);
-        const clonedHeaders = [];
-        for (const [key, value] of response.headers.entries()) {
-          if (key !== "transfer-encoding") {
-            clonedHeaders.push([key, value]);
-          }
-        }
-        clonedHeaders.push(["content-length", String(Buffer.byteLength(body))]);
-        headers = new Headers3(clonedHeaders);
-      }
+      body = Buffer.from(await response.body.arrayBuffer());
     }
     return {
-      status: response.status,
+      status: response.statusCode,
       headers,
       body,
       encoding: "utf8"
@@ -1080,7 +1047,6 @@ async function createServerlessEventHandler(entrypointPath, options) {
 }
 
 // src/dev-server.mts
-import { toToReadable } from "@edge-runtime/node-utils";
 import { getConfig } from "@vercel/static-config";
 import { Project } from "ts-morph";
 import { listen as listen2 } from "async-listen";
@@ -1157,7 +1123,7 @@ async function onDevRequest(req, res) {
     } else if (body instanceof Buffer) {
       res.end(body);
     } else {
-      toToReadable(body).pipe(res);
+      body.pipe(res);
     }
   } catch (error) {
     res.statusCode = 500;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import type { ServerResponse, IncomingMessage } from 'http';
 import type { Headers } from 'undici';
+import type { Readable } from 'stream';
 
 export type VercelRequestCookies = { [key: string]: string };
 export type VercelRequestQuery = { [key: string]: string | string[] };
@@ -44,6 +45,6 @@ export type NowApiHandler = VercelApiHandler;
 export interface VercelProxyResponse {
   status: number;
   headers: Headers;
-  body: ReadableStream<Uint8Array> | Buffer | null;
+  body: Readable | Buffer | null;
   encoding: BufferEncoding;
 }