@vercel/node 2.11.0 → 2.12.0

package/dist/dev-server.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onDevRequest = void 0;
 const entrypoint = process.env.VERCEL_DEV_ENTRYPOINT;
@@ -6,27 +9,17 @@ delete process.env.VERCEL_DEV_ENTRYPOINT;
 if (!entrypoint) {
     throw new Error('`VERCEL_DEV_ENTRYPOINT` must be defined');
 }
-delete process.env.TS_NODE_TRANSPILE_ONLY;
-delete process.env.TS_NODE_COMPILER_OPTIONS;
 const path_1 = require("path");
 const useRequire = process.env.VERCEL_DEV_IS_ESM !== '1';
+const edge_handler_1 = require("./edge-functions/edge-handler");
 const http_1 = require("http");
+const serverless_handler_1 = require("./serverless-functions/serverless-handler");
+const utils_1 = require("./utils");
 const static_config_1 = require("@vercel/static-config");
 const ts_morph_1 = require("ts-morph");
-const utils_1 = require("./utils");
-const edge_handler_1 = require("./edge-functions/edge-handler");
-const serverless_handler_1 = require("./serverless-functions/serverless-handler");
-function listen(server, port, host) {
-    return new Promise(resolve => {
-        server.listen(port, host, () => {
-            resolve();
-        });
-    });
-}
-function parseRuntime(entrypoint, entryPointPath) {
-    const project = new ts_morph_1.Project();
-    const staticConfig = static_config_1.getConfig(project, entryPointPath);
-    const runtime = staticConfig?.runtime;
+const async_listen_1 = __importDefault(require("async-listen"));
+const parseConfig = (entryPointPath) => static_config_1.getConfig(new ts_morph_1.Project(), entryPointPath);
+function getRuntime(runtime, entrypoint) {
     if (runtime && !utils_1.isEdgeRuntime(runtime)) {
         throw new Error(`Invalid function runtime "${runtime}" for "${entrypoint}". Valid runtimes are: ${JSON.stringify(Object.values(utils_1.EdgeRuntimes))}. Learn more: https://vercel.link/creating-edge-functions`);
     }
@@ -34,7 +27,8 @@ function parseRuntime(entrypoint, entryPointPath) {
 }
 async function createEventHandler(entrypoint, config, options) {
     const entrypointPath = path_1.join(process.cwd(), entrypoint);
-    const runtime = parseRuntime(entrypoint, entrypointPath);
+    const staticConfig = parseConfig(entrypointPath);
+    const runtime = getRuntime(staticConfig?.runtime, entrypoint);
     // `middleware.js`/`middleware.ts` file is always run as
     // an Edge Function, otherwise needs to be opted-in via
     // `export const config = { runtime: 'edge' }`
@@ -42,6 +36,7 @@ async function createEventHandler(entrypoint, config, options) {
         return edge_handler_1.createEdgeEventHandler(entrypointPath, entrypoint, config.middleware || false, config.zeroConfig);
     }
     return serverless_handler_1.createServerlessEventHandler(entrypointPath, {
+        mode: staticConfig?.supportsResponseStreaming ? 'streaming' : 'buffer',
         shouldAddHelpers: options.shouldAddHelpers,
         useRequire,
     });
@@ -55,7 +50,7 @@ async function main() {
     delete process.env.VERCEL_DEV_BUILD_ENV;
     const shouldAddHelpers = !(config.helpers === false || buildEnv.NODEJS_HELPERS === '0');
     const proxyServer = http_1.createServer(onDevRequest);
-    await listen(proxyServer, 0, '127.0.0.1');
+    await async_listen_1.default(proxyServer, { host: '127.0.0.1', port: 0 });
     try {
         handleEvent = await createEventHandler(entrypoint, config, {
             shouldAddHelpers,
@@ -86,14 +81,19 @@ async function onDevRequest(req, res) {
         return;
     }
     try {
-        const result = await handleEvent(req);
-        res.statusCode = result.statusCode;
-        for (const [key, value] of Object.entries(result.headers)) {
-            if (typeof value !== 'undefined') {
+        const { headers, body, status } = await handleEvent(req);
+        res.statusCode = status;
+        for (const [key, value] of headers) {
+            if (value !== undefined) {
                 res.setHeader(key, value);
             }
         }
-        res.end(Buffer.from(result.body, result.encoding));
+        if (body instanceof Buffer) {
+            res.end(body);
+        }
+        else {
+            body.pipe(res);
+        }
     }
     catch (error) {
         res.statusCode = 500;

package/dist/edge-functions/edge-handler-template.js

@@ -1,49 +1,29 @@
 // provided by the edge runtime:
 /* global addEventListener */
 
-function buildUrl(requestDetails) {
-  const host = requestDetails.headers['x-forwarded-host'] || '127.0.0.1';
-  const path = requestDetails.url || '/';
-
-  const allProtocols = requestDetails.headers['x-forwarded-proto'];
-  let proto;
-  if (allProtocols) {
-    // handle multi-protocol like: https,http://...
-    proto = allProtocols.split(/\b/).shift();
-  } else {
-    proto = 'http';
-  }
-
-  return `${proto}://${host}${path}`;
+function getUrl(url, headers) {
+  const urlObj = new URL(url);
+  const protocol = headers.get('x-forwarded-proto');
+  if (protocol) urlObj.protocol = protocol.split(/\b/).shift();
+  urlObj.host = headers.get('x-forwarded-host');
+  urlObj.port = headers.get('x-forwarded-port');
+  return urlObj.toString();
 }
 
-async function respond(
-  userEdgeHandler,
-  requestDetails,
-  event,
-  options,
-  dependencies
-) {
+async function respond(userEdgeHandler, event, options, dependencies) {
   const { Request, Response } = dependencies;
   const { isMiddleware } = options;
-
-  let body;
-
-  if (requestDetails.method !== 'GET' && requestDetails.method !== 'HEAD') {
-    if (requestDetails.body) {
-      body = Uint8Array.from(atob(requestDetails.body), c => c.charCodeAt(0));
-    }
-  }
-
-  const request = new Request(buildUrl(requestDetails), {
-    headers: requestDetails.headers,
-    method: requestDetails.method,
-    body: body,
-  });
-
-  event.request = request;
-
-  let response = await userEdgeHandler(event.request, event);
+  event.request.headers.set(
+    'host',
+    event.request.headers.get('x-forwarded-host')
+  );
+  let response = await userEdgeHandler(
+    new Request(
+      getUrl(event.request.url, event.request.headers),
+      event.request
+    ),
+    event
+  );
 
   if (!response) {
     if (isMiddleware) {
@@ -85,10 +65,8 @@ async function parseRequestEvent(event) {
 function registerFetchListener(userEdgeHandler, options, dependencies) {
   addEventListener('fetch', async event => {
     try {
-      const requestDetails = await parseRequestEvent(event);
       const response = await respond(
         userEdgeHandler,
-        requestDetails,
         event,
         options,
         dependencies
@@ -100,11 +78,10 @@ function registerFetchListener(userEdgeHandler, options, dependencies) {
   });
 }
 
-// for testing:
 module.exports = {
-  buildUrl,
-  respond,
-  toResponseError,
+  getUrl,
   parseRequestEvent,
   registerFetchListener,
+  respond,
+  toResponseError,
 };

package/dist/edge-functions/edge-handler.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="node" />
-import { IncomingMessage } from 'http';
-import { VercelProxyResponse } from '@vercel/node-bridge/types';
+import type { VercelProxyResponse } from '../types';
+import type { IncomingMessage } from 'http';
 export declare function createEdgeEventHandler(entrypointFullPath: string, entrypointRelativePath: string, isMiddleware: boolean, isZeroConfig?: boolean): Promise<(request: IncomingMessage) => Promise<VercelProxyResponse>>;

package/dist/edge-functions/edge-handler.js

@@ -1,34 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEdgeEventHandler = void 0;
-const build_utils_1 = require("@vercel/build-utils");
-const exit_hook_1 = __importDefault(require("exit-hook"));
-const edge_runtime_1 = require("edge-runtime");
-const esbuild_1 = __importDefault(require("esbuild"));
-const node_fetch_1 = __importDefault(require("node-fetch"));
 const edge_wasm_plugin_1 = require("./edge-wasm-plugin");
-const utils_1 = require("../utils");
-const fs_1 = require("fs");
 const edge_node_compat_plugin_1 = require("./edge-node-compat-plugin");
+const edge_runtime_1 = require("edge-runtime");
+const node_fetch_1 = __importStar(require("node-fetch"));
+const error_utils_1 = require("@vercel/error-utils");
+const fs_1 = require("fs");
+const utils_1 = require("../utils");
+const esbuild_1 = __importDefault(require("esbuild"));
+const exit_hook_1 = __importDefault(require("exit-hook"));
+const url_1 = require("url");
 const NODE_VERSION_MAJOR = process.version.match(/^v(\d+)\.\d+/)?.[1];
 const NODE_VERSION_IDENTIFIER = `node${NODE_VERSION_MAJOR}`;
 if (!NODE_VERSION_MAJOR) {
     throw new Error(`Unable to determine current node version: process.version=${process.version}`);
 }
 const edgeHandlerTemplate = fs_1.readFileSync(`${__dirname}/edge-handler-template.js`);
-async function serializeRequest(message) {
-    const bodyBuffer = await build_utils_1.streamToBuffer(message);
-    const body = bodyBuffer.toString('base64');
-    return JSON.stringify({
-        url: message.url,
-        method: message.method,
-        headers: message.headers,
-        body,
-    });
-}
 async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMiddleware) {
     const { wasmAssets, plugin: edgeWasmPlugin } = edge_wasm_plugin_1.createEdgeWasmPlugin();
     const nodeCompatPlugin = edge_node_compat_plugin_1.createNodeCompatPlugin();
@@ -43,7 +53,20 @@ async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMid
             sourcemap: 'inline',
             legalComments: 'none',
             bundle: true,
-            plugins: [edgeWasmPlugin, nodeCompatPlugin.plugin],
+            plugins: [
+                edgeWasmPlugin,
+                nodeCompatPlugin.plugin,
+                {
+                    name: 'import.meta.url',
+                    setup({ onLoad }) {
+                        onLoad({ filter: /\.[cm]?js$/, namespace: 'file' }, args => {
+                            let code = fs_1.readFileSync(args.path, 'utf8');
+                            code = code.replace(/\bimport\.meta\.url\b/g, JSON.stringify(url_1.pathToFileURL(__filename)));
+                            return { contents: code };
+                        });
+                    },
+                },
+            ],
             entryPoints: [entrypointFullPath],
             write: false,
             format: 'cjs',
@@ -71,14 +94,8 @@ async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMid
 
       // edge handler
       ${edgeHandlerTemplate};
-      const dependencies = {
-        Request,
-        Response
-      };
-      const options = {
-        isMiddleware,
-        entrypointLabel
-      };
+      const dependencies = { Request, Response };
+      const options = { isMiddleware, entrypointLabel };
       registerFetchListener(userEdgeHandler, options, dependencies);
     `;
         return {
@@ -91,20 +108,21 @@ async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMid
         // We can't easily show a meaningful stack trace from ncc -> edge-runtime.
         // So, stick with just the message for now.
         console.error(`Failed to compile user code for edge runtime.`);
-        utils_1.logError(error);
+        if (error_utils_1.isError(error))
+            utils_1.logError(error);
         return undefined;
     }
 }
-async function createEdgeRuntime(params) {
+async function createEdgeRuntimeServer(params) {
     try {
         if (!params) {
             return undefined;
         }
         const wasmBindings = await params.wasmAssets.getContext();
         const nodeCompatBindings = params.nodeCompatBindings.getContext();
-        const edgeRuntime = new edge_runtime_1.EdgeRuntime({
+        const runtime = new edge_runtime_1.EdgeRuntime({
             initialCode: params.userCode,
-            extend: (context) => {
+            extend: context => {
                 Object.assign(context, {
                     // This is required for esbuild wrapping logic to resolve
                     module: {},
@@ -122,8 +140,8 @@ async function createEdgeRuntime(params) {
                 return context;
             },
         });
-        const server = await edge_runtime_1.runServer({ runtime: edgeRuntime });
-        exit_hook_1.default(server.close);
+        const server = await edge_runtime_1.runServer({ runtime });
+        exit_hook_1.default(() => server.close());
         return server;
     }
     catch (error) {
@@ -136,7 +154,7 @@ async function createEdgeRuntime(params) {
 }
 async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath, isMiddleware, isZeroConfig) {
     const userCode = await compileUserCode(entrypointFullPath, entrypointRelativePath, isMiddleware);
-    const server = await createEdgeRuntime(userCode);
+    const server = await createEdgeRuntimeServer(userCode);
     return async function (request) {
         if (!server) {
             // this error state is already logged, but we have to wait until here to exit the process
@@ -144,14 +162,20 @@ async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath
             // an error is thrown in the function
             process.exit(1);
         }
-        const response = await node_fetch_1.default(server.url, {
+        const headers = new node_fetch_1.Headers(request.headers);
+        const body = await utils_1.serializeBody(request);
+        if (body !== undefined)
+            headers.set('content-length', String(body.length));
+        const url = new URL(request.url ?? '/', server.url);
+        const response = await node_fetch_1.default(url, {
+            body,
+            headers,
+            method: request.method,
             redirect: 'manual',
-            method: 'post',
-            body: await serializeRequest(request),
         });
-        const body = await response.text();
         const isUserError = response.headers.get('x-vercel-failed') === 'edge-wrapper';
         if (isUserError && response.status >= 500) {
+            const body = await response.text();
             // We can't currently get a real stack trace from the Edge Function error,
             // but we can fake a basic one that is still usefult to the user.
             const fakeStackTrace = `    at (${entrypointRelativePath})`;
@@ -162,9 +186,9 @@ async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath
             process.exit(1);
         }
         return {
-            statusCode: response.status,
-            headers: response.headers.raw(),
-            body,
+            status: response.status,
+            headers: response.headers,
+            body: response.body,
             encoding: 'utf8',
         };
     };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { ServerResponse, IncomingMessage } from 'http';
+import type { Headers } from 'node-fetch';
 export declare type VercelRequestCookies = {
     [key: string]: string;
 };
@@ -31,3 +32,9 @@ export declare type NowRequest = VercelRequest;
 export declare type NowResponse = VercelResponse;
 /** @deprecated Use VercelApiHandler instead. */
 export declare type NowApiHandler = VercelApiHandler;
+export interface VercelProxyResponse {
+    status: number;
+    headers: Headers;
+    body: Buffer | NodeJS.ReadableStream;
+    encoding: BufferEncoding;
+}

package/dist/index.js

@@ -140129,6 +140129,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.startDevServer = exports.prepareCache = exports.build = exports.version = exports.shouldServe = void 0;
+const error_utils_1 = __webpack_require__(27915);
 const url_1 = __importDefault(__webpack_require__(78835));
 const child_process_1 = __webpack_require__(63129);
 const fs_1 = __webpack_require__(35747);
@@ -140264,13 +140265,14 @@ async function compile(workPath, baseDir, entrypointPath, config, nodeVersion, i
                 sourceCache.set(relPath, source);
                 return source;
             }
-            catch (e) {
-                if (e.code === 'ENOENT' || e.code === 'EISDIR') {
+            catch (error) {
+                if (error_utils_1.isErrnoException(error) &&
+                    (error.code === 'ENOENT' || error.code === 'EISDIR')) {
                     // `null` represents a not found
                     sourceCache.set(relPath, null);
                     return null;
                 }
-                throw e;
+                throw error;
             }
         },
     });
@@ -140495,8 +140497,8 @@ const startDevServer = async (opts) => {
         filename: 'package.json',
     });
     const pkg = pathToPkg ? require_(pathToPkg) : {};
-    const isTypescript = ['.ts', '.tsx', '.mts', '.cts'].includes(ext);
-    const maybeTranspile = isTypescript || !['.cjs', '.mjs'].includes(ext);
+    const isTypeScript = ['.ts', '.tsx', '.mts', '.cts'].includes(ext);
+    const maybeTranspile = isTypeScript || !['.cjs', '.mjs'].includes(ext);
     const isEsm = ext === '.mjs' ||
         ext === '.mts' ||
         (pkg.type === 'module' && ['.js', '.ts', '.tsx'].includes(ext));
@@ -140528,10 +140530,10 @@ const startDevServer = async (opts) => {
             try {
                 tsConfig = ts.readConfigFile(pathToTsConfig, ts.sys.readFile).config;
             }
-            catch (err) {
-                if (err.code !== 'ENOENT') {
+            catch (error) {
+                if (error_utils_1.isErrnoException(error) && error.code !== 'ENOENT') {
                     console.error(`Error while parsing "${pathToTsConfig}"`);
-                    throw err;
+                    throw error;
                 }
             }
         }
@@ -140552,7 +140554,7 @@ const startDevServer = async (opts) => {
         entrypoint,
         require_,
         isEsm,
-        isTypeScript: isTypescript,
+        isTypeScript,
         maybeTranspile,
         meta,
         tsConfig,
@@ -140561,7 +140563,7 @@ const startDevServer = async (opts) => {
     const message = await fork_dev_server_1.readMessage(child);
     if (message.state === 'message') {
         // "message" event
-        if (isTypescript) {
+        if (isTypeScript) {
             // Invoke `tsc --noEmit` asynchronously in the background, so
             // that the HTTP request is not blocked by the type checking.
             doTypeCheck(opts, pathToTsConfig).catch((err) => {
@@ -140601,11 +140603,9 @@ async function doTypeCheck({ entrypoint, workPath, meta = {} }, projectTsConfig)
         await fs_1.promises.mkdir(entrypointCacheDir, { recursive: true });
         await fs_1.promises.writeFile(tsconfigPath, json, { flag: 'wx' });
     }
-    catch (err) {
-        // Don't throw if the file already exists
-        if (err.code !== 'EEXIST') {
-            throw err;
-        }
+    catch (error) {
+        if (error_utils_1.isErrnoException(error) && error.code !== 'EEXIST')
+            throw error;
     }
     const child = child_process_1.spawn(process.execPath, [
         tscPath,
@@ -141016,10 +141016,10 @@ function filterDiagnostics(diagnostics, ignore) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.isEdgeRuntime = exports.EdgeRuntimes = exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
-const path_1 = __webpack_require__(85622);
-const path_to_regexp_1 = __webpack_require__(91344);
+exports.serializeBody = exports.isEdgeRuntime = exports.EdgeRuntimes = exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
 const build_utils_1 = __webpack_require__(63445);
+const path_to_regexp_1 = __webpack_require__(91344);
+const path_1 = __webpack_require__(85622);
 function getRegExpFromMatchers(matcherOrMatchers) {
     if (!matcherOrMatchers) {
         return '^/.*$';
@@ -141082,6 +141082,12 @@ function isEdgeRuntime(runtime) {
         Object.values(EdgeRuntimes).includes(runtime));
 }
 exports.isEdgeRuntime = isEdgeRuntime;
+async function serializeBody(request) {
+    return request.method !== 'GET' && request.method !== 'HEAD'
+        ? await build_utils_1.streamToBuffer(request)
+        : undefined;
+}
+exports.serializeBody = serializeBody;
 
 
 /***/ }),
@@ -141157,6 +141163,14 @@ module.exports = require("@vercel/build-utils");
 
 /***/ }),
 
+/***/ 27915:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("@vercel/error-utils");
+
+/***/ }),
+
 /***/ 27167:
 /***/ ((module) => {
 

package/dist/serverless-functions/dynamic-import.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const { pathToFileURL } = require('url');
+const { isAbsolute } = require('path');
+
+function dynamicImport(filepath) {
+  const id = isAbsolute(filepath) ? pathToFileURL(filepath).href : filepath;
+  return import(id);
+}
+
+module.exports = {
+  dynamicImport,
+};

package/dist/serverless-functions/helpers.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import type { ServerResponse, IncomingMessage } from 'http';
+declare type VercelRequestCookies = {
+    [key: string]: string;
+};
+declare type VercelRequestQuery = {
+    [key: string]: string | string[];
+};
+declare type VercelRequestBody = any;
+export declare type VercelRequest = IncomingMessage & {
+    query: VercelRequestQuery;
+    cookies: VercelRequestCookies;
+    body: VercelRequestBody;
+};
+export declare type VercelResponse = ServerResponse & {
+    send: (body: any) => VercelResponse;
+    json: (jsonBody: any) => VercelResponse;
+    status: (statusCode: number) => VercelResponse;
+    redirect: (statusOrUrl: string | number, url?: string) => VercelResponse;
+};
+export declare function addHelpers(_req: IncomingMessage, _res: ServerResponse): Promise<void>;
+export {};

package/dist/serverless-functions/helpers.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addHelpers = void 0;
+const utils_1 = require("../utils");
+const stream_1 = require("stream");
+class ApiError extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+function getBodyParser(body, contentType) {
+    return function parseBody() {
+        const { parse: parseContentType } = require('content-type');
+        const { type } = parseContentType(contentType);
+        if (type === 'application/json') {
+            try {
+                const str = body.toString();
+                return str ? JSON.parse(str) : {};
+            }
+            catch (error) {
+                throw new ApiError(400, 'Invalid JSON');
+            }
+        }
+        if (type === 'application/octet-stream')
+            return body;
+        if (type === 'application/x-www-form-urlencoded') {
+            const { parse: parseQS } = require('querystring');
+            // note: querystring.parse does not produce an iterable object
+            // https://nodejs.org/api/querystring.html#querystring_querystring_parse_str_sep_eq_options
+            return parseQS(body.toString());
+        }
+        if (type === 'text/plain')
+            return body.toString();
+        return undefined;
+    };
+}
+function getQueryParser({ url = '/' }) {
+    return function parseQuery() {
+        const { parse: parseURL } = require('url');
+        return parseURL(url, true).query;
+    };
+}
+function getCookieParser(req) {
+    return function parseCookie() {
+        const header = req.headers.cookie;
+        if (!header)
+            return {};
+        const { parse } = require('cookie');
+        return parse(Array.isArray(header) ? header.join(';') : header);
+    };
+}
+function status(res, statusCode) {
+    res.statusCode = statusCode;
+    return res;
+}
+function setCharset(type, charset) {
+    const { parse, format } = require('content-type');
+    const parsed = parse(type);
+    parsed.parameters.charset = charset;
+    return format(parsed);
+}
+function redirect(res, statusOrUrl, url) {
+    if (typeof statusOrUrl === 'string') {
+        url = statusOrUrl;
+        statusOrUrl = 307;
+    }
+    if (typeof statusOrUrl !== 'number' || typeof url !== 'string') {
+        throw new Error(`Invalid redirect arguments. Please use a single argument URL, e.g. res.redirect('/destination') or use a status code and URL, e.g. res.redirect(307, '/destination').`);
+    }
+    res.writeHead(statusOrUrl, { Location: url }).end();
+    return res;
+}
+function setLazyProp(req, prop, getter) {
+    const opts = { configurable: true, enumerable: true };
+    const optsReset = { ...opts, writable: true };
+    Object.defineProperty(req, prop, {
+        ...opts,
+        get: () => {
+            const value = getter();
+            // we set the property on the object to avoid recalculating it
+            Object.defineProperty(req, prop, { ...optsReset, value });
+            return value;
+        },
+        set: value => {
+            Object.defineProperty(req, prop, { ...optsReset, value });
+        },
+    });
+}
+function createETag(body, encoding) {
+    const etag = require('etag');
+    const buf = !Buffer.isBuffer(body) ? Buffer.from(body, encoding) : body;
+    return etag(buf, { weak: true });
+}
+function json(req, res, jsonBody) {
+    const body = JSON.stringify(jsonBody);
+    if (!res.getHeader('content-type')) {
+        res.setHeader('content-type', 'application/json; charset=utf-8');
+    }
+    return send(req, res, body);
+}
+function send(req, res, body) {
+    let chunk = body;
+    let encoding;
+    switch (typeof chunk) {
+        // string defaulting to html
+        case 'string':
+            if (!res.getHeader('content-type')) {
+                res.setHeader('content-type', 'text/html');
+            }
+            break;
+        case 'boolean':
+        case 'number':
+        case 'object':
+            if (chunk === null) {
+                chunk = '';
+            }
+            else if (Buffer.isBuffer(chunk)) {
+                if (!res.getHeader('content-type')) {
+                    res.setHeader('content-type', 'application/octet-stream');
+                }
+            }
+            else {
+                return json(req, res, chunk);
+            }
+            break;
+    }
+    // write strings in utf-8
+    if (typeof chunk === 'string') {
+        encoding = 'utf8';
+        // reflect this in content-type
+        const type = res.getHeader('content-type');
+        if (typeof type === 'string') {
+            res.setHeader('content-type', setCharset(type, 'utf-8'));
+        }
+    }
+    // populate Content-Length
+    let len;
+    if (chunk !== undefined) {
+        if (Buffer.isBuffer(chunk)) {
+            // get length of Buffer
+            len = chunk.length;
+        }
+        else if (typeof chunk === 'string') {
+            if (chunk.length < 1000) {
+                // just calculate length small chunk
+                len = Buffer.byteLength(chunk, encoding);
+            }
+            else {
+                // convert chunk to Buffer and calculate
+                const buf = Buffer.from(chunk, encoding);
+                len = buf.length;
+                chunk = buf;
+                encoding = undefined;
+            }
+        }
+        else {
+            throw new Error('`body` is not a valid string, object, boolean, number, Stream, or Buffer');
+        }
+        if (len !== undefined) {
+            res.setHeader('content-length', len);
+        }
+    }
+    // populate ETag
+    let etag;
+    if (!res.getHeader('etag') &&
+        len !== undefined &&
+        (etag = createETag(chunk, encoding))) {
+        res.setHeader('etag', etag);
+    }
+    // strip irrelevant headers
+    if (204 === res.statusCode || 304 === res.statusCode) {
+        res.removeHeader('Content-Type');
+        res.removeHeader('Content-Length');
+        res.removeHeader('Transfer-Encoding');
+        chunk = '';
+    }
+    if (req.method === 'HEAD') {
+        // skip body for HEAD
+        res.end();
+    }
+    else if (encoding) {
+        // respond with encoding
+        res.end(chunk, encoding);
+    }
+    else {
+        // respond without encoding
+        res.end(chunk);
+    }
+    return res;
+}
+function restoreBody(req, body) {
+    const replicateBody = new stream_1.PassThrough();
+    const on = replicateBody.on.bind(replicateBody);
+    const originalOn = req.on.bind(req);
+    req.read = replicateBody.read.bind(replicateBody);
+    req.on = req.addListener = (name, cb) => 
+    // @ts-expect-error
+    name === 'data' || name === 'end' ? on(name, cb) : originalOn(name, cb);
+    replicateBody.write(body);
+    replicateBody.end();
+}
+async function readBody(req) {
+    const body = (await utils_1.serializeBody(req)) || Buffer.from('');
+    restoreBody(req, body);
+    return body;
+}
+async function addHelpers(_req, _res) {
+    const req = _req;
+    const res = _res;
+    setLazyProp(req, 'cookies', getCookieParser(req));
+    setLazyProp(req, 'query', getQueryParser(req));
+    const contentType = req.headers['content-type'];
+    const body = contentType === undefined ? Buffer.from('') : await readBody(req);
+    setLazyProp(req, 'body', getBodyParser(body, contentType));
+    res.status = statusCode => status(res, statusCode);
+    res.redirect = (statusOrUrl, url) => redirect(res, statusOrUrl, url);
+    res.send = body => send(req, res, body);
+    res.json = jsonBody => json(req, res, jsonBody);
+}
+exports.addHelpers = addHelpers;

package/dist/serverless-functions/serverless-handler.d.ts

@@ -1,7 +1,10 @@
 /// <reference types="node" />
-import { IncomingMessage } from 'http';
-import { VercelProxyResponse } from '@vercel/node-bridge/types';
-export declare function createServerlessEventHandler(entrypoint: string, options: {
+import type { IncomingMessage } from 'http';
+import type { VercelProxyResponse } from '../types';
+declare type ServerlessServerOptions = {
     shouldAddHelpers: boolean;
     useRequire: boolean;
-}): Promise<(request: IncomingMessage) => Promise<VercelProxyResponse>>;
+    mode: 'streaming' | 'buffer';
+};
+export declare function createServerlessEventHandler(entrypointPath: string, options: ServerlessServerOptions): Promise<(request: IncomingMessage) => Promise<VercelProxyResponse>>;
+export {};

package/dist/serverless-functions/serverless-handler.js

@@ -1,47 +1,70 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createServerlessEventHandler = void 0;
-const launcher_js_1 = require("@vercel/node-bridge/launcher.js");
-function rawBody(readable) {
-    return new Promise((resolve, reject) => {
-        let bytes = 0;
-        const chunks = [];
-        readable.on('error', reject);
-        readable.on('data', chunk => {
-            chunks.push(chunk);
-            bytes += chunk.length;
-        });
-        readable.on('end', () => {
-            resolve(Buffer.concat(chunks, bytes));
-        });
+const helpers_1 = require("./helpers");
+const http_1 = require("http");
+// @ts-expect-error
+const dynamic_import_js_1 = require("./dynamic-import.js");
+const utils_1 = require("../utils");
+const build_utils_1 = require("@vercel/build-utils");
+const exit_hook_1 = __importDefault(require("exit-hook"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const async_listen_1 = __importDefault(require("async-listen"));
+async function createServerlessServer(userCode, options) {
+    const server = http_1.createServer(async (req, res) => {
+        if (options.shouldAddHelpers)
+            await helpers_1.addHelpers(req, res);
+        return userCode(req, res);
     });
+    exit_hook_1.default(() => server.close());
+    return { url: await async_listen_1.default(server) };
 }
-async function createServerlessEventHandler(entrypoint, options) {
-    const launcher = launcher_js_1.getVercelLauncher({
-        entrypointPath: entrypoint,
-        helpersPath: './helpers.js',
-        shouldAddHelpers: options.shouldAddHelpers,
-        useRequire: options.useRequire,
-        // not used
-        bridgePath: '',
-        sourcemapSupportPath: '',
-    });
-    const bridge = launcher();
+async function compileUserCode(entrypointPath, options) {
+    let fn = options.useRequire
+        ? require(entrypointPath)
+        : await dynamic_import_js_1.dynamicImport(entrypointPath);
+    /**
+     * In some cases we might have nested default props due to TS => JS
+     */
+    for (let i = 0; i < 5; i++) {
+        if (fn.default)
+            fn = fn.default;
+    }
+    return fn;
+}
+async function createServerlessEventHandler(entrypointPath, options) {
+    const userCode = await compileUserCode(entrypointPath, options);
+    const server = await createServerlessServer(userCode, options);
     return async function (request) {
-        const body = await rawBody(request);
-        const event = {
-            Action: 'Invoke',
-            body: JSON.stringify({
-                method: request.method,
-                path: request.url,
-                headers: request.headers,
-                encoding: 'base64',
-                body: body.toString('base64'),
-            }),
-        };
-        return bridge.launcher(event, {
-            callbackWaitsForEmptyEventLoop: false,
+        const url = new URL(request.url ?? '/', server.url);
+        const response = await node_fetch_1.default(url, {
+            body: await utils_1.serializeBody(request),
+            headers: {
+                ...request.headers,
+                host: request.headers['x-forwarded-host'],
+            },
+            method: request.method,
+            redirect: 'manual',
         });
+        let body;
+        if (options.mode === 'streaming') {
+            body = response.body;
+        }
+        else {
+            body = await build_utils_1.streamToBuffer(response.body);
+            response.headers.delete('transfer-encoding');
+            //@ts-expect-error
+            response.headers.set('content-length', body.length);
+        }
+        return {
+            status: response.status,
+            headers: response.headers,
+            body,
+            encoding: 'utf8',
+        };
     };
 }
 exports.createServerlessEventHandler = createServerlessEventHandler;

package/dist/utils.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEdgeRuntime = exports.EdgeRuntimes = exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
-const path_1 = require("path");
-const path_to_regexp_1 = require("path-to-regexp");
+exports.serializeBody = exports.isEdgeRuntime = exports.EdgeRuntimes = exports.logError = exports.entrypointToOutputPath = exports.getRegExpFromMatchers = void 0;
 const build_utils_1 = require("@vercel/build-utils");
+const path_to_regexp_1 = require("path-to-regexp");
+const path_1 = require("path");
 function getRegExpFromMatchers(matcherOrMatchers) {
     if (!matcherOrMatchers) {
         return '^/.*$';
@@ -66,3 +66,9 @@ function isEdgeRuntime(runtime) {
         Object.values(EdgeRuntimes).includes(runtime));
 }
 exports.isEdgeRuntime = isEdgeRuntime;
+async function serializeBody(request) {
+    return request.method !== 'GET' && request.method !== 'HEAD'
+        ? await build_utils_1.streamToBuffer(request)
+        : undefined;
+}
+exports.serializeBody = serializeBody;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "build": "node build",
-    "test": "jest --env node --verbose --bail --runInBand",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --env node --verbose --bail --runInBand",
     "test-unit": "pnpm test test/unit",
     "test-e2e": "pnpm test test/integration"
   },
@@ -22,9 +22,11 @@
     "@edge-runtime/vm": "2.0.0",
     "@types/node": "14.18.33",
     "@vercel/build-utils": "6.7.1",
+    "@vercel/error-utils": "1.0.8",
     "@vercel/node-bridge": "4.0.1",
     "@vercel/static-config": "2.0.16",
-    "edge-runtime": "2.0.0",
+    "async-listen": "1.2.0",
+    "edge-runtime": "2.1.4",
     "esbuild": "0.14.47",
     "exit-hook": "2.2.1",
     "node-fetch": "2.6.7",
@@ -48,11 +50,12 @@
     "@vercel/nft": "0.22.5",
     "content-type": "1.0.4",
     "cookie": "0.4.0",
+    "cross-env": "7.0.3",
     "etag": "1.8.1",
     "execa": "3.2.0",
     "fs-extra": "11.1.0",
     "source-map-support": "0.5.12",
     "test-listen": "1.1.0"
   },
-  "gitHead": "a63b9d960bec291e152308c30074843aab802c8d"
+  "gitHead": "7082da84511740ea0304b5f93b0073bbb3f3a9ed"
 }