@vercel/node 3.0.5 → 3.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "3.0.5",
+  "version": "3.0.7",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -17,13 +17,14 @@
     "@edge-runtime/primitives": "3.1.1",
     "@edge-runtime/vm": "3.1.1",
     "@types/node": "14.18.33",
-    "@vercel/build-utils": "7.2.0",
+    "@vercel/build-utils": "7.2.2",
     "@vercel/error-utils": "2.0.1",
+    "@vercel/nft": "0.24.2",
     "@vercel/static-config": "3.0.0",
     "async-listen": "3.0.0",
-    "content-type": "1.0.5",
     "edge-runtime": "2.5.1",
     "esbuild": "0.14.47",
+    "etag": "1.8.1",
     "exit-hook": "2.2.1",
     "node-fetch": "2.6.9",
     "path-to-regexp": "6.2.1",
@@ -41,20 +42,16 @@
     "@types/cookie": "0.3.3",
     "@types/etag": "1.8.0",
     "@types/jest": "29.5.0",
-    "@types/test-listen": "1.1.0",
-    "@vercel/ncc": "0.24.0",
-    "@vercel/nft": "0.22.5",
+    "content-type": "1.0.5",
     "cookie": "0.4.0",
     "cross-env": "7.0.3",
-    "etag": "1.8.1",
     "execa": "3.2.0",
     "fs-extra": "11.1.0",
     "jest-junit": "16.0.0",
-    "source-map-support": "0.5.12",
-    "test-listen": "1.1.0"
+    "source-map-support": "0.5.12"
   },
   "scripts": {
-    "build": "node build",
+    "build": "node build.mjs",
     "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"

package/dist/babel.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compile = void 0;
-const babel = require('@babel/core'); // eslint-disable-line @typescript-eslint/no-var-requires
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const pluginTransformModulesCommonJs = require('@babel/plugin-transform-modules-commonjs');
-function compile(filename, source) {
-    return babel.transform(source, {
-        filename,
-        configFile: false,
-        babelrc: false,
-        highlightCode: false,
-        compact: false,
-        sourceType: 'module',
-        sourceMaps: true,
-        parserOpts: {
-            plugins: [
-                'asyncGenerators',
-                'classProperties',
-                'classPrivateProperties',
-                'classPrivateMethods',
-                'optionalCatchBinding',
-                'objectRestSpread',
-                'numericSeparator',
-                'dynamicImport',
-                'importMeta',
-            ],
-        },
-        plugins: [pluginTransformModulesCommonJs],
-    });
-}
-exports.compile = compile;

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

@@ -1,175 +0,0 @@
-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 'undici';
-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 __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 } = createEdgeWasmPlugin();
-    const nodeCompatPlugin = createNodeCompatPlugin();
-    try {
-        const result = await esbuild.build({
-            // bundling behavior: use globals (like "browser") instead
-            // of "require" statements for core libraries (like "node")
-            platform: 'browser',
-            conditions: ['edge-light', 'development'],
-            // target syntax: only use syntax available on the current
-            // version of node
-            target: NODE_VERSION_IDENTIFIER,
-            sourcemap: 'inline',
-            legalComments: 'none',
-            bundle: true,
-            plugins: [
-                edgeWasmPlugin,
-                nodeCompatPlugin.plugin,
-                {
-                    name: 'import.meta.url',
-                    setup({ onLoad }) {
-                        onLoad({ filter: /\.[cm]?js$/, namespace: 'file' }, args => {
-                            let code = readFileSync(args.path, 'utf8');
-                            code = code.replace(/\bimport\.meta\.url\b/g, JSON.stringify(import.meta.url));
-                            return { contents: code };
-                        });
-                    },
-                },
-            ],
-            entryPoints: [entrypointFullPath],
-            write: false,
-            format: 'cjs',
-        });
-        const compiledFile = result.outputFiles?.[0];
-        if (!compiledFile) {
-            throw new Error(`Compilation of ${entrypointRelativePath} produced no output files.`);
-        }
-        const userCode = `
-      // strict mode
-      "use strict";var regeneratorRuntime;
-
-      // user code
-      (() => {
-        ${compiledFile.text};
-      })();
-
-      const userModule = module.exports;
-
-      // request metadata
-      const isMiddleware = ${isMiddleware};
-      const entrypointLabel = '${entrypointRelativePath}';
-
-      // edge handler
-      ${edgeHandlerTemplate};
-      const dependencies = { Request, Response };
-      const options = { isMiddleware, entrypointLabel };
-      registerFetchListener(userModule, options, dependencies);
-    `;
-        return {
-            userCode,
-            wasmAssets,
-            nodeCompatBindings: nodeCompatPlugin.bindings,
-        };
-    }
-    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 compile user code for edge runtime.`);
-        if (isError(error))
-            logError(error);
-        return undefined;
-    }
-}
-async function createEdgeRuntimeServer(params) {
-    try {
-        if (!params) {
-            return undefined;
-        }
-        const wasmBindings = await params.wasmAssets.getContext();
-        const nodeCompatBindings = params.nodeCompatBindings.getContext();
-        const runtime = new EdgeRuntime({
-            initialCode: params.userCode,
-            extend: context => {
-                Object.assign(context, {
-                    // This is required for esbuild wrapping logic to resolve
-                    module: {},
-                    // 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.
-                    process: {
-                        env: process.env,
-                    },
-                    // These are the global bindings for Node.js compatibility
-                    ...nodeCompatBindings,
-                    // These are the global bindings for WebAssembly module
-                    ...wasmBindings,
-                });
-                return context;
-            },
-        });
-        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.');
-        logError(error);
-        return undefined;
-    }
-}
-export async function createEdgeEventHandler(entrypointFullPath, entrypointRelativePath, isMiddleware, isZeroConfig) {
-    const userCode = await compileUserCode(entrypointFullPath, entrypointRelativePath, isMiddleware);
-    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
-            // this matches the serverless function bridge launcher's behavior when
-            // an error is thrown in the function
-            process.exit(1);
-        }
-        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 fetch(url, {
-            body,
-            headers,
-            method: request.method,
-            redirect: 'manual',
-        });
-        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})`;
-            const requestPath = entrypointToRequestPath(entrypointRelativePath, isZeroConfig);
-            console.log(`Error from API Route ${requestPath}: ${body}\n${fakeStackTrace}`);
-            // this matches the serverless function bridge launcher's behavior when
-            // an error is thrown in the function
-            process.exit(1);
-        }
-        return {
-            status: response.status,
-            headers: response.headers,
-            body: response.body,
-            encoding: 'utf8',
-        };
-    };
-}
-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 '/' + entrypointToOutputPath(entrypointRelativePath, isZeroConfig);
-}

package/dist/edge-functions/edge-node-compat-plugin.mjs

@@ -1,140 +0,0 @@
-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',
-    'assert',
-    'util',
-    'async_hooks',
-];
-const getSupportedNodeModuleRegex = () => new RegExp(`^(?:node:)?(?:${SUPPORTED_NODE_MODULES.join('|')})$`);
-function pick(obj, keys) {
-    const res = {};
-    for (const key of keys) {
-        res[key] = obj[key];
-    }
-    return res;
-}
-const NativeModuleMap = () => {
-    const mods = {
-        buffer: pick(BufferImplementation, [
-            'constants',
-            'kMaxLength',
-            'kStringMaxLength',
-            'Buffer',
-            'SlowBuffer',
-        ]),
-        events: pick(EventsImplementation, [
-            'EventEmitter',
-            'captureRejectionSymbol',
-            'defaultMaxListeners',
-            'errorMonitor',
-            'listenerCount',
-            'on',
-            'once',
-        ]),
-        async_hooks: pick(AsyncHooksImplementation, [
-            'AsyncLocalStorage',
-            'AsyncResource',
-        ]),
-        assert: pick(AssertImplementation, [
-            'AssertionError',
-            'deepEqual',
-            'deepStrictEqual',
-            'doesNotMatch',
-            'doesNotReject',
-            'doesNotThrow',
-            'equal',
-            'fail',
-            'ifError',
-            'match',
-            'notDeepEqual',
-            'notDeepStrictEqual',
-            'notEqual',
-            'notStrictEqual',
-            'ok',
-            'rejects',
-            'strict',
-            'strictEqual',
-            'throws',
-        ]),
-        util: pick(UtilImplementation, [
-            '_extend',
-            'callbackify',
-            'format',
-            'inherits',
-            'promisify',
-            'types',
-        ]),
-    };
-    return new Map(Object.entries(mods));
-};
-const NODE_COMPAT_NAMESPACE = 'vercel-node-compat';
-export class NodeCompatBindings {
-    constructor() {
-        this.bindings = new Map();
-    }
-    use(modulePath) {
-        const stripped = modulePath.replace(/^node:/, '');
-        const name = `__vc_node_${stripped}__`;
-        if (!this.bindings.has(modulePath)) {
-            const value = NativeModuleMap().get(stripped);
-            if (value === undefined) {
-                throw new Error(`Could not find module ${modulePath}`);
-            }
-            this.bindings.set(modulePath, {
-                modulePath: modulePath,
-                name,
-                value,
-            });
-        }
-        return name;
-    }
-    getContext() {
-        const context = {};
-        for (const binding of this.bindings.values()) {
-            context[binding.name] = binding.value;
-        }
-        return context;
-    }
-}
-/**
- * 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.
- */
-export function createNodeCompatPlugin() {
-    const bindings = new NodeCompatBindings();
-    const plugin = {
-        name: 'vc-node-compat',
-        setup(b) {
-            b.onResolve({ filter: getSupportedNodeModuleRegex() }, async (args) => {
-                const importee = args.path.replace('node:', '');
-                if (!SUPPORTED_NODE_MODULES.includes(importee)) {
-                    return;
-                }
-                return {
-                    namespace: NODE_COMPAT_NAMESPACE,
-                    path: args.path,
-                };
-            });
-            b.onLoad({ filter: /.+/, namespace: NODE_COMPAT_NAMESPACE }, async (args) => {
-                const fullName = args.path.startsWith('node:')
-                    ? args.path
-                    : `node:${args.path}`;
-                const globalName = bindings.use(fullName);
-                return {
-                    contents: `module.exports = ${globalName};`,
-                    loader: 'js',
-                };
-            });
-        },
-    };
-    return {
-        plugin,
-        bindings,
-    };
-}

package/dist/edge-functions/edge-wasm-plugin.mjs

@@ -1,77 +0,0 @@
-// copied from `edge-functions-bridge`:
-// https://github.com/vercel/runtimes/blob/c076db9e3ce5635f7c2690396e3d9f791a0fd808/packages/edge-functions-bridge/src/get-edge-function-source.ts#L282-L317
-import { createHash } from 'crypto';
-import { promises as fs } from 'fs';
-export class WasmAssets {
-    constructor() {
-        this.assets = new Map();
-    }
-    /**
-     * Declare a WebAssembly binding
-     */
-    async declare(filePath) {
-        const hash = sha1(await fs.readFile(filePath));
-        const name = `wasm_${hash}`;
-        this.assets.set(name, filePath);
-        return name;
-    }
-    /**
-     * Get an object with the context needed to execute the code
-     * built with the plugin
-     */
-    async getContext() {
-        const promises = [];
-        const context = {};
-        for (const [name, filePath] of this.assets) {
-            promises.push((async () => {
-                const bytes = await fs.readFile(filePath);
-                context[name] = await WebAssembly.compile(bytes);
-            })());
-        }
-        await Promise.all(promises);
-        return context;
-    }
-    /**
-     * Allow to iterate easily
-     */
-    [Symbol.iterator]() {
-        return this.assets[Symbol.iterator]();
-    }
-}
-export function createEdgeWasmPlugin() {
-    const wasmAssets = new WasmAssets();
-    const plugin = {
-        name: 'vercel-wasm',
-        setup(b) {
-            b.onResolve({ filter: /\.wasm\?module/i }, async (data) => {
-                const wasmFile = data.path.replace(/\?module$/, '');
-                const resolvedPath = await b.resolve(wasmFile, {
-                    importer: data.importer,
-                    resolveDir: data.resolveDir,
-                });
-                if (!resolvedPath.path) {
-                    return {
-                        errors: [
-                            { text: `WebAssembly file could not be located: ${wasmFile}` },
-                        ],
-                    };
-                }
-                const name = await wasmAssets.declare(resolvedPath.path);
-                return {
-                    path: name,
-                    namespace: 'vercel-wasm',
-                };
-            });
-            b.onLoad({ namespace: 'vercel-wasm', filter: /.+/ }, args => {
-                return {
-                    loader: 'js',
-                    contents: `export default globalThis[${JSON.stringify(args.path)}]`,
-                };
-            });
-        },
-    };
-    return { plugin, wasmAssets };
-}
-function sha1(data) {
-    return createHash('sha1').update(data).digest('hex');
-}

package/dist/fork-dev-server.js

@@ -1,78 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readMessage = exports.forkDevServer = void 0;
-const once_1 = __importDefault(require("@tootallnate/once"));
-const build_utils_1 = require("@vercel/build-utils");
-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 || '';
-    if (!nodeOptions.includes('--no-warnings')) {
-        nodeOptions += ' --no-warnings';
-    }
-    const tsNodePath = options.require_.resolve('ts-node');
-    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) {
-            nodeOptions = `--loader ${esmLoader} ${nodeOptions || ''}`;
-        }
-        else {
-            if (options.isEsm) {
-                // no transform needed because Node.js supports ESM natively
-            }
-            else {
-                nodeOptions = `--require ${cjsLoader} ${nodeOptions || ''}`;
-            }
-        }
-    }
-    const forkOptions = {
-        cwd: options.workPath,
-        execArgv: [],
-        env: (0, build_utils_1.cloneEnv)(process.env, options.meta.env, {
-            VERCEL_DEV_ENTRYPOINT: options.entrypoint,
-            VERCEL_DEV_CONFIG: JSON.stringify(options.config),
-            VERCEL_DEV_BUILD_ENV: JSON.stringify(options.meta.buildEnv || {}),
-            TS_NODE_TRANSPILE_ONLY: '1',
-            TS_NODE_COMPILER_OPTIONS: options.tsConfig?.compilerOptions
-                ? JSON.stringify(options.tsConfig.compilerOptions)
-                : undefined,
-            NODE_OPTIONS: nodeOptions,
-        }),
-    };
-    const child = (0, child_process_1.fork)(devServerPath, [], forkOptions);
-    checkForPid(devServerPath, child);
-    return child;
-}
-exports.forkDevServer = forkDevServer;
-function checkForPid(path, process) {
-    if (!process.pid) {
-        throw new Error(`Child Process has no "pid" when forking: "${path}"`);
-    }
-}
-/**
- * When launching a dev-server, we want to know its state.
- * This function will be used to know whether it was exited (due to some error),
- * or it is listening to new requests, and we can start proxying requests.
- */
-async function readMessage(child) {
-    const onMessage = (0, once_1.default)(child, 'message');
-    const onExit = once_1.default.spread(child, 'close');
-    const result = await Promise.race([
-        onMessage.then(x => {
-            return { state: 'message', value: x };
-        }),
-        onExit.then(v => {
-            return { state: 'exit', value: v };
-        }),
-    ]);
-    onExit.cancel();
-    onMessage.cancel();
-    return result;
-}
-exports.readMessage = readMessage;

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

@@ -1,7 +0,0 @@
-import type { ServerResponse, IncomingMessage } from 'http';
-/**
- * When users export at least one HTTP handler, we will generate
- * a generic handler routing to the right method. If there is no
- * handler function exported returns null.
- */
-export declare function getWebExportsHandler(listener: any, methods: string[]): (req: IncomingMessage, res: ServerResponse) => void;

package/dist/serverless-functions/helpers-web.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWebExportsHandler = void 0;
-const node_utils_1 = require("@edge-runtime/node-utils");
-class FetchEvent {
-    constructor(request) {
-        this.request = request;
-        this.response = null;
-        this.awaiting = new Set();
-    }
-    respondWith(response) {
-        this.response = response;
-    }
-    waitUntil() {
-        throw new Error('waitUntil is not implemented yet for Node.js');
-    }
-}
-const webHandlerToNodeHandler = (0, node_utils_1.buildToNodeHandler)({
-    Headers,
-    ReadableStream,
-    // @ts-expect-error Property 'duplex' is missing in type 'Request'
-    Request: class extends Request {
-        constructor(input, init) {
-            super(input, addDuplexToInit(init));
-        }
-    },
-    Uint8Array: Uint8Array,
-    FetchEvent: FetchEvent,
-}, { defaultOrigin: 'https://vercel.com' });
-/**
- * When users export at least one HTTP handler, we will generate
- * a generic handler routing to the right method. If there is no
- * handler function exported returns null.
- */
-function getWebExportsHandler(listener, methods) {
-    const handlerByMethod = {};
-    for (const key of methods) {
-        handlerByMethod[key] =
-            typeof listener[key] !== 'undefined'
-                ? webHandlerToNodeHandler(listener[key])
-                : defaultHttpHandler;
-    }
-    return (req, res) => {
-        const method = req.method ?? 'GET';
-        handlerByMethod[method](req, res);
-    };
-}
-exports.getWebExportsHandler = getWebExportsHandler;
-/**
- * Add `duplex: 'half'` by default to all requests
- * https://github.com/vercel/edge-runtime/blob/bf167c418247a79d3941bfce4a5d43c37f512502/packages/primitives/src/primitives/fetch.js#L22-L26
- * https://developer.chrome.com/articles/fetch-streaming-requests/#streaming-request-bodies
- */
-function addDuplexToInit(init) {
-    if (typeof init === 'undefined' || typeof init === 'object') {
-        return { duplex: 'half', ...init };
-    }
-    return init;
-}
-function defaultHttpHandler(_, res) {
-    res.statusCode = 405;
-    res.end();
-}