@vercel/node 2.12.0 → 2.14.0

package/dist/{dev-server.js → dev-server.mjs}

@@ -1,44 +1,32 @@
-"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;
 delete process.env.VERCEL_DEV_ENTRYPOINT;
 if (!entrypoint) {
     throw new Error('`VERCEL_DEV_ENTRYPOINT` must be defined');
 }
-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 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`);
-    }
-    return runtime;
-}
+import { join } from 'path';
+import { createEdgeEventHandler } from './edge-functions/edge-handler.mjs';
+import { createServer } from 'http';
+import { createServerlessEventHandler } from './serverless-functions/serverless-handler.mjs';
+import { isEdgeRuntime, logError, validateConfiguredRuntime } from './utils.js';
+import { getConfig } from '@vercel/static-config';
+import { Project } from 'ts-morph';
+import asyncListen from 'async-listen';
+const { default: listen } = asyncListen;
+const parseConfig = (entryPointPath) => getConfig(new Project(), entryPointPath);
 async function createEventHandler(entrypoint, config, options) {
-    const entrypointPath = path_1.join(process.cwd(), entrypoint);
+    const entrypointPath = join(process.cwd(), entrypoint);
     const staticConfig = parseConfig(entrypointPath);
-    const runtime = getRuntime(staticConfig?.runtime, entrypoint);
+    const runtime = staticConfig?.runtime;
+    validateConfiguredRuntime(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' }`
-    if (config.middleware === true || utils_1.isEdgeRuntime(runtime)) {
-        return edge_handler_1.createEdgeEventHandler(entrypointPath, entrypoint, config.middleware || false, config.zeroConfig);
+    if (config.middleware === true || isEdgeRuntime(runtime)) {
+        return createEdgeEventHandler(entrypointPath, entrypoint, config.middleware || false, config.zeroConfig);
     }
-    return serverless_handler_1.createServerlessEventHandler(entrypointPath, {
+    return createServerlessEventHandler(entrypointPath, {
         mode: staticConfig?.supportsResponseStreaming ? 'streaming' : 'buffer',
         shouldAddHelpers: options.shouldAddHelpers,
-        useRequire,
     });
 }
 let handleEvent;
@@ -49,15 +37,15 @@ async function main() {
     const buildEnv = JSON.parse(process.env.VERCEL_DEV_BUILD_ENV || '{}');
     delete process.env.VERCEL_DEV_BUILD_ENV;
     const shouldAddHelpers = !(config.helpers === false || buildEnv.NODEJS_HELPERS === '0');
-    const proxyServer = http_1.createServer(onDevRequest);
-    await async_listen_1.default(proxyServer, { host: '127.0.0.1', port: 0 });
+    const proxyServer = createServer(onDevRequest);
+    await listen(proxyServer, { host: '127.0.0.1', port: 0 });
     try {
         handleEvent = await createEventHandler(entrypoint, config, {
             shouldAddHelpers,
         });
     }
     catch (error) {
-        utils_1.logError(error);
+        logError(error);
         handlerEventError = error;
     }
     const address = proxyServer.address();
@@ -100,8 +88,7 @@ async function onDevRequest(req, res) {
         res.end(error.stack);
     }
 }
-exports.onDevRequest = onDevRequest;
 main().catch(err => {
-    utils_1.logError(err);
+    logError(err);
     process.exit(1);
 });

package/dist/edge-functions/{edge-handler.js → edge-handler.mjs}

@@ -1,49 +1,25 @@
-"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 edge_wasm_plugin_1 = require("./edge-wasm-plugin");
-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");
+import { createEdgeWasmPlugin } from './edge-wasm-plugin.mjs';
+import { createNodeCompatPlugin, } from './edge-node-compat-plugin.mjs';
+import { EdgeRuntime, runServer } from 'edge-runtime';
+import fetch, { Headers } from 'node-fetch';
+import { isError } from '@vercel/error-utils';
+import { readFileSync } from 'fs';
+import { serializeBody, entrypointToOutputPath, logError } from '../utils.js';
+import esbuild from 'esbuild';
+import exitHook from 'exit-hook';
+import { fileURLToPath } from '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`);
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const edgeHandlerTemplate = readFileSync(`${__dirname}/edge-handler-template.js`);
 async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMiddleware) {
-    const { wasmAssets, plugin: edgeWasmPlugin } = edge_wasm_plugin_1.createEdgeWasmPlugin();
-    const nodeCompatPlugin = edge_node_compat_plugin_1.createNodeCompatPlugin();
+    const { wasmAssets, plugin: edgeWasmPlugin } = createEdgeWasmPlugin();
+    const nodeCompatPlugin = createNodeCompatPlugin();
     try {
-        const result = await esbuild_1.default.build({
+        const result = await esbuild.build({
             // bundling behavior: use globals (like "browser") instead
             // of "require" statements for core libraries (like "node")
             platform: 'browser',
@@ -60,8 +36,8 @@ async function compileUserCode(entrypointFullPath, entrypointRelativePath, isMid
                     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)));
+                            let code = readFileSync(args.path, 'utf8');
+                            code = code.replace(/\bimport\.meta\.url\b/g, JSON.stringify(import.meta.url));
                             return { contents: code };
                         });
                     },
@@ -108,8 +84,8 @@ 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.`);
-        if (error_utils_1.isError(error))
-            utils_1.logError(error);
+        if (isError(error))
+            logError(error);
         return undefined;
     }
 }
@@ -120,12 +96,23 @@ async function createEdgeRuntimeServer(params) {
         }
         const wasmBindings = await params.wasmAssets.getContext();
         const nodeCompatBindings = params.nodeCompatBindings.getContext();
-        const runtime = new edge_runtime_1.EdgeRuntime({
+        let WebSocket;
+        // undici's WebSocket handling is only available in Node.js >= 18
+        // so fallback to using ws for v16
+        if (Number(process.version.split('.')[0].substring(1)) < 18) {
+            // @ts-ignore
+            WebSocket = (await import('ws')).WebSocket;
+        }
+        else {
+            WebSocket = (await import('undici')).WebSocket;
+        }
+        const runtime = new EdgeRuntime({
             initialCode: params.userCode,
             extend: context => {
                 Object.assign(context, {
                     // This is required for esbuild wrapping logic to resolve
                     module: {},
+                    WebSocket,
                     // This is required for environment variable access.
                     // In production, env var access is provided by static analysis
                     // so that only the used values are available.
@@ -140,19 +127,19 @@ async function createEdgeRuntimeServer(params) {
                 return context;
             },
         });
-        const server = await edge_runtime_1.runServer({ runtime });
-        exit_hook_1.default(() => server.close());
+        const server = await runServer({ runtime });
+        exitHook(() => server.close());
         return server;
     }
     catch (error) {
         // 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 instantiate edge runtime.');
-        utils_1.logError(error);
+        logError(error);
         return undefined;
     }
 }
-async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath, isMiddleware, isZeroConfig) {
+export async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath, isMiddleware, isZeroConfig) {
     const userCode = await compileUserCode(entrypointFullPath, entrypointRelativePath, isMiddleware);
     const server = await createEdgeRuntimeServer(userCode);
     return async function (request) {
@@ -162,12 +149,13 @@ async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath
             // an error is thrown in the function
             process.exit(1);
         }
-        const headers = new node_fetch_1.Headers(request.headers);
-        const body = await utils_1.serializeBody(request);
+        const headers = new Headers(request.headers);
+        const body = await 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, {
+        // @ts-expect-error
+        const response = await fetch(url, {
             body,
             headers,
             method: request.method,
@@ -193,9 +181,8 @@ async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath
         };
     };
 }
-exports.createEdgeEventHandler = createEdgeEventHandler;
 function entrypointToRequestPath(entrypointRelativePath, isZeroConfig) {
     // ensure the path starts with a slash to match conventions used elsewhere,
     // notably when rendering serverless function paths in error messages
-    return '/' + utils_1.entrypointToOutputPath(entrypointRelativePath, isZeroConfig);
+    return '/' + entrypointToOutputPath(entrypointRelativePath, isZeroConfig);
 }

package/dist/edge-functions/{edge-node-compat-plugin.js → edge-node-compat-plugin.mjs}

@@ -1,14 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodeCompatPlugin = exports.NodeCompatBindings = void 0;
-const buffer_1 = __importDefault(require("buffer"));
-const events_1 = __importDefault(require("events"));
-const async_hooks_1 = __importDefault(require("async_hooks"));
-const assert_1 = __importDefault(require("assert"));
-const util_1 = __importDefault(require("util"));
+import BufferImplementation from 'buffer';
+import EventsImplementation from 'events';
+import AsyncHooksImplementation from 'async_hooks';
+import AssertImplementation from 'assert';
+import UtilImplementation from 'util';
 const SUPPORTED_NODE_MODULES = [
     'buffer',
     'events',
@@ -26,14 +20,14 @@ function pick(obj, keys) {
 }
 const NativeModuleMap = () => {
     const mods = {
-        buffer: pick(buffer_1.default, [
+        buffer: pick(BufferImplementation, [
             'constants',
             'kMaxLength',
             'kStringMaxLength',
             'Buffer',
             'SlowBuffer',
         ]),
-        events: pick(events_1.default, [
+        events: pick(EventsImplementation, [
             'EventEmitter',
             'captureRejectionSymbol',
             'defaultMaxListeners',
@@ -42,11 +36,11 @@ const NativeModuleMap = () => {
             'on',
             'once',
         ]),
-        async_hooks: pick(async_hooks_1.default, [
+        async_hooks: pick(AsyncHooksImplementation, [
             'AsyncLocalStorage',
             'AsyncResource',
         ]),
-        assert: pick(assert_1.default, [
+        assert: pick(AssertImplementation, [
             'AssertionError',
             'deepEqual',
             'deepStrictEqual',
@@ -67,7 +61,7 @@ const NativeModuleMap = () => {
             'strictEqual',
             'throws',
         ]),
-        util: pick(util_1.default, [
+        util: pick(UtilImplementation, [
             '_extend',
             'callbackify',
             'format',
@@ -79,7 +73,7 @@ const NativeModuleMap = () => {
     return new Map(Object.entries(mods));
 };
 const NODE_COMPAT_NAMESPACE = 'vercel-node-compat';
-class NodeCompatBindings {
+export class NodeCompatBindings {
     constructor() {
         this.bindings = new Map();
     }
@@ -107,13 +101,12 @@ class NodeCompatBindings {
         return context;
     }
 }
-exports.NodeCompatBindings = NodeCompatBindings;
 /**
  * Allows to enable Node.js compatibility by detecting namespaced `node:`
  * imports and producing metadata to bind global variables for each.
  * It requires from the consumer to add the imports.
  */
-function createNodeCompatPlugin() {
+export function createNodeCompatPlugin() {
     const bindings = new NodeCompatBindings();
     const plugin = {
         name: 'vc-node-compat',
@@ -145,4 +138,3 @@ function createNodeCompatPlugin() {
         bindings,
     };
 }
-exports.createNodeCompatPlugin = createNodeCompatPlugin;

package/dist/edge-functions/{edge-wasm-plugin.js → edge-wasm-plugin.mjs}

@@ -1,11 +1,8 @@
-"use strict";
 // copied from `edge-functions-bridge`:
 // https://github.com/vercel/runtimes/blob/c076db9e3ce5635f7c2690396e3d9f791a0fd808/packages/edge-functions-bridge/src/get-edge-function-source.ts#L282-L317
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEdgeWasmPlugin = exports.WasmAssets = void 0;
-const crypto_1 = require("crypto");
-const fs_1 = require("fs");
-class WasmAssets {
+import { createHash } from 'crypto';
+import { promises as fs } from 'fs';
+export class WasmAssets {
     constructor() {
         this.assets = new Map();
     }
@@ -13,7 +10,7 @@ class WasmAssets {
      * Declare a WebAssembly binding
      */
     async declare(filePath) {
-        const hash = sha1(await fs_1.promises.readFile(filePath));
+        const hash = sha1(await fs.readFile(filePath));
         const name = `wasm_${hash}`;
         this.assets.set(name, filePath);
         return name;
@@ -27,7 +24,7 @@ class WasmAssets {
         const context = {};
         for (const [name, filePath] of this.assets) {
             promises.push((async () => {
-                const bytes = await fs_1.promises.readFile(filePath);
+                const bytes = await fs.readFile(filePath);
                 context[name] = await WebAssembly.compile(bytes);
             })());
         }
@@ -41,8 +38,7 @@ class WasmAssets {
         return this.assets[Symbol.iterator]();
     }
 }
-exports.WasmAssets = WasmAssets;
-function createEdgeWasmPlugin() {
+export function createEdgeWasmPlugin() {
     const wasmAssets = new WasmAssets();
     const plugin = {
         name: 'vercel-wasm',
@@ -76,7 +72,6 @@ function createEdgeWasmPlugin() {
     };
     return { plugin, wasmAssets };
 }
-exports.createEdgeWasmPlugin = createEdgeWasmPlugin;
 function sha1(data) {
-    return crypto_1.createHash('sha1').update(data).digest('hex');
+    return createHash('sha1').update(data).digest('hex');
 }

package/dist/fork-dev-server.js

@@ -10,19 +10,17 @@ const child_process_1 = require("child_process");
 const url_1 = require("url");
 const path_1 = require("path");
 function forkDevServer(options) {
-    let nodeOptions = process.env.NODE_OPTIONS;
+    let nodeOptions = process.env.NODE_OPTIONS || '';
+    if (!nodeOptions.includes('--no-warnings')) {
+        nodeOptions += ' --no-warnings';
+    }
     const tsNodePath = options.require_.resolve('ts-node');
-    const esmLoader = url_1.pathToFileURL(path_1.join(tsNodePath, '..', '..', 'esm.mjs'));
-    const cjsLoader = path_1.join(tsNodePath, '..', '..', 'register', 'index.js');
-    const devServerPath = options.devServerPath || path_1.join(__dirname, 'dev-server.js');
+    const esmLoader = (0, url_1.pathToFileURL)((0, path_1.join)(tsNodePath, '..', '..', 'esm.mjs'));
+    const cjsLoader = (0, path_1.join)(tsNodePath, '..', '..', 'register', 'index.js');
+    const devServerPath = options.devServerPath || (0, path_1.join)(__dirname, 'dev-server.mjs');
     if (options.maybeTranspile) {
         if (options.isTypeScript) {
-            if (options.isEsm) {
-                nodeOptions = `--loader ${esmLoader} ${nodeOptions || ''}`;
-            }
-            else {
-                nodeOptions = `--require ${cjsLoader} ${nodeOptions || ''}`;
-            }
+            nodeOptions = `--loader ${esmLoader} ${nodeOptions || ''}`;
         }
         else {
             if (options.isEsm) {
@@ -36,9 +34,8 @@ function forkDevServer(options) {
     const forkOptions = {
         cwd: options.workPath,
         execArgv: [],
-        env: build_utils_1.cloneEnv(process.env, options.meta.env, {
+        env: (0, build_utils_1.cloneEnv)(process.env, options.meta.env, {
             VERCEL_DEV_ENTRYPOINT: options.entrypoint,
-            VERCEL_DEV_IS_ESM: options.isEsm ? '1' : undefined,
             VERCEL_DEV_CONFIG: JSON.stringify(options.config),
             VERCEL_DEV_BUILD_ENV: JSON.stringify(options.meta.buildEnv || {}),
             TS_NODE_TRANSPILE_ONLY: '1',
@@ -48,7 +45,7 @@ function forkDevServer(options) {
             NODE_OPTIONS: nodeOptions,
         }),
     };
-    const child = child_process_1.fork(devServerPath, [], forkOptions);
+    const child = (0, child_process_1.fork)(devServerPath, [], forkOptions);
     checkForPid(devServerPath, child);
     return child;
 }
@@ -64,7 +61,7 @@ function checkForPid(path, process) {
  * or it is listening to new requests, and we can start proxying requests.
  */
 async function readMessage(child) {
-    const onMessage = once_1.default(child, 'message');
+    const onMessage = (0, once_1.default)(child, 'message');
     const onExit = once_1.default.spread(child, 'close');
     const result = await Promise.race([
         onMessage.then(x => {

package/dist/index.d.ts

@@ -1,37 +1,38 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { ServerResponse, IncomingMessage } from 'http';
 import type { Headers } from 'node-fetch';
-export declare type VercelRequestCookies = {
+export type VercelRequestCookies = {
     [key: string]: string;
 };
-export declare type VercelRequestQuery = {
+export type VercelRequestQuery = {
     [key: string]: string | string[];
 };
-export declare type VercelRequestBody = any;
-export declare type VercelRequest = IncomingMessage & {
+export type VercelRequestBody = any;
+export type VercelRequest = IncomingMessage & {
     query: VercelRequestQuery;
     cookies: VercelRequestCookies;
     body: VercelRequestBody;
 };
-export declare type VercelResponse = ServerResponse & {
+export type VercelResponse = ServerResponse & {
     send: (body: any) => VercelResponse;
     json: (jsonBody: any) => VercelResponse;
     status: (statusCode: number) => VercelResponse;
     redirect: (statusOrUrl: string | number, url?: string) => VercelResponse;
 };
-export declare type VercelApiHandler = (req: VercelRequest, res: VercelResponse) => void | Promise<void>;
+export type VercelApiHandler = (req: VercelRequest, res: VercelResponse) => void | Promise<void>;
 /** @deprecated Use VercelRequestCookies instead. */
-export declare type NowRequestCookies = VercelRequestCookies;
+export type NowRequestCookies = VercelRequestCookies;
 /** @deprecated Use VercelRequestQuery instead. */
-export declare type NowRequestQuery = VercelRequestQuery;
+export type NowRequestQuery = VercelRequestQuery;
 /** @deprecated Use VercelRequestBody instead. */
-export declare type NowRequestBody = any;
+export type NowRequestBody = any;
 /** @deprecated Use VercelRequest instead. */
-export declare type NowRequest = VercelRequest;
+export type NowRequest = VercelRequest;
 /** @deprecated Use VercelResponse instead. */
-export declare type NowResponse = VercelResponse;
+export type NowResponse = VercelResponse;
 /** @deprecated Use VercelApiHandler instead. */
-export declare type NowApiHandler = VercelApiHandler;
+export type NowApiHandler = VercelApiHandler;
 export interface VercelProxyResponse {
     status: number;
     headers: Headers;