@vercel/node 2.9.6 → 2.9.8

package/dist/fork-dev-server.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import { Config, Meta } from '@vercel/build-utils';
+import { ChildProcess } from 'child_process';
+export declare function forkDevServer(options: {
+    tsConfig: any;
+    config: Config;
+    maybeTranspile: boolean;
+    workPath: string | undefined;
+    isTypeScript: boolean;
+    isEsm: boolean;
+    require_: NodeRequire;
+    entrypoint: string;
+    meta: Meta;
+    /**
+     * A path to the dev-server path. This is used in tests.
+     */
+    devServerPath?: string;
+}): ChildProcess & {
+    pid: number;
+};
+/**
+ * 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.
+ */
+export declare function readMessage(child: ChildProcess): Promise<{
+    state: 'message';
+    value: {
+        port: number;
+    };
+} | {
+    state: 'exit';
+    value: [number, string | null];
+}>;

package/dist/fork-dev-server.js

@@ -0,0 +1,81 @@
+"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;
+    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');
+    if (options.maybeTranspile) {
+        if (options.isTypeScript) {
+            if (options.isEsm) {
+                nodeOptions = `--loader ${esmLoader} ${nodeOptions || ''}`;
+            }
+            else {
+                nodeOptions = `--require ${cjsLoader} ${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: 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',
+            TS_NODE_COMPILER_OPTIONS: options.tsConfig?.compilerOptions
+                ? JSON.stringify(options.tsConfig.compilerOptions)
+                : undefined,
+            NODE_OPTIONS: nodeOptions,
+        }),
+    };
+    const child = 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 = 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/index.js

@@ -300955,6 +300955,95 @@ function compile(filename, source) {
 exports.M = compile;
 
 
+/***/ }),
+
+/***/ 31158:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"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(__webpack_require__(51));
+const build_utils_1 = __webpack_require__(63445);
+const child_process_1 = __webpack_require__(63129);
+const url_1 = __webpack_require__(78835);
+const path_1 = __webpack_require__(85622);
+function forkDevServer(options) {
+    let nodeOptions = process.env.NODE_OPTIONS;
+    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');
+    if (options.maybeTranspile) {
+        if (options.isTypeScript) {
+            if (options.isEsm) {
+                nodeOptions = `--loader ${esmLoader} ${nodeOptions || ''}`;
+            }
+            else {
+                nodeOptions = `--require ${cjsLoader} ${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: 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',
+            TS_NODE_COMPILER_OPTIONS: options.tsConfig?.compilerOptions
+                ? JSON.stringify(options.tsConfig.compilerOptions)
+                : undefined,
+            NODE_OPTIONS: nodeOptions,
+        }),
+    };
+    const child = 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 = 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;
+
+
 /***/ }),
 
 /***/ 39037:
@@ -300990,9 +301079,7 @@ Object.defineProperty(exports, "shouldServe", ({ enumerable: true, get: function
 const static_config_1 = __webpack_require__(16199);
 const typescript_1 = __webpack_require__(39677);
 const utils_1 = __webpack_require__(76136);
-function isPortInfo(v) {
-    return v && typeof v.port === 'number';
-}
+const fork_dev_server_1 = __webpack_require__(31158);
 const ALLOWED_RUNTIMES = ['nodejs', ...Object.values(utils_1.EdgeRuntimes)];
 const require_ = eval('require');
 const tscPath = path_1.resolve(path_1.dirname(require_.resolve('typescript')), '../bin/tsc');
@@ -301330,16 +301417,11 @@ const startDevServer = async (opts) => {
         filename: 'package.json',
     });
     const pkg = pathToPkg ? require_(pathToPkg) : {};
-    const tsNodePath = require_.resolve('ts-node');
-    const esmLoader = path_1.join(tsNodePath, '..', '..', 'esm.mjs');
-    const cjsLoader = path_1.join(tsNodePath, '..', '..', 'register', 'index.js');
     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));
-    const devServerPath = path_1.join(__dirname, 'dev-server.js');
-    let nodeOptions = process.env.NODE_OPTIONS;
     let tsConfig = {};
     if (maybeTranspile) {
         const resolveTypescript = (p) => {
@@ -301385,48 +301467,21 @@ const startDevServer = async (opts) => {
         // In prod, we emit outputs to the filesystem.
         // In dev, we don't emit because we use ts-node.
         tsConfig.compilerOptions.noEmit = true;
-        if (isTypescript) {
-            if (isEsm) {
-                nodeOptions = `--loader ${esmLoader} ${nodeOptions || ''}`;
-            }
-            else {
-                nodeOptions = `--require ${cjsLoader} ${nodeOptions || ''}`;
-            }
-        }
-        else {
-            if (isEsm) {
-                // no transform needed because Node.js supports ESM natively
-            }
-            else {
-                nodeOptions = `--require ${cjsLoader} ${nodeOptions || ''}`;
-            }
-        }
     }
-    const child = child_process_1.fork(devServerPath, [], {
-        cwd: workPath,
-        execArgv: [],
-        env: build_utils_1.cloneEnv(process.env, meta.env, {
-            VERCEL_DEV_ENTRYPOINT: entrypoint,
-            VERCEL_DEV_IS_ESM: isEsm ? '1' : undefined,
-            VERCEL_DEV_CONFIG: JSON.stringify(config),
-            VERCEL_DEV_BUILD_ENV: JSON.stringify(meta.buildEnv || {}),
-            TS_NODE_TRANSPILE_ONLY: '1',
-            TS_NODE_COMPILER_OPTIONS: tsConfig?.compilerOptions
-                ? JSON.stringify(tsConfig.compilerOptions)
-                : undefined,
-            NODE_OPTIONS: nodeOptions,
-        }),
+    const child = fork_dev_server_1.forkDevServer({
+        workPath,
+        config,
+        entrypoint,
+        require_,
+        isEsm,
+        isTypeScript: isTypescript,
+        maybeTranspile,
+        meta,
+        tsConfig,
     });
     const { pid } = child;
-    if (!pid) {
-        throw new Error(`Child Process has no "pid" when forking: "${devServerPath}"`);
-    }
-    const onMessage = once_1.default(child, 'message');
-    const onExit = once_1.default.spread(child, 'close');
-    const result = await Promise.race([onMessage, onExit]);
-    onExit.cancel();
-    onMessage.cancel();
-    if (isPortInfo(result)) {
+    const message = await fork_dev_server_1.readMessage(child);
+    if (message.state === 'message') {
         // "message" event
         if (isTypescript) {
             // Invoke `tsc --noEmit` asynchronously in the background, so
@@ -301435,11 +301490,11 @@ const startDevServer = async (opts) => {
                 console.error('Type check for %j failed:', entrypoint, err);
             });
         }
-        return { port: result.port, pid };
+        return { port: message.value.port, pid };
     }
     else {
         // Got "exit" event from child process
-        const [exitCode, signal] = result;
+        const [exitCode, signal] = message.value;
         const reason = signal ? `"${signal}" signal` : `exit code ${exitCode}`;
         throw new Error(`Function \`${entrypoint}\` failed with ${reason}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.9.6",
+  "version": "2.9.8",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -12,7 +12,7 @@
   "scripts": {
     "build": "node build",
     "test": "jest --env node --verbose --bail --runInBand",
-    "test-unit": "pnpm test test/prepare-cache.test.ts test/utils.test.ts",
+    "test-unit": "pnpm test test/prepare-cache.test.ts test/utils.test.ts test/dev.test.ts",
     "test-e2e": "pnpm test test/integration-*.test.js"
   },
   "files": [
@@ -31,8 +31,8 @@
   "dependencies": {
     "@edge-runtime/vm": "2.0.0",
     "@types/node": "14.18.33",
-    "@vercel/build-utils": "6.3.0",
-    "@vercel/node-bridge": "3.1.11",
+    "@vercel/build-utils": "6.3.1",
+    "@vercel/node-bridge": "3.1.12",
     "@vercel/static-config": "2.0.13",
     "edge-runtime": "2.0.0",
     "esbuild": "0.14.47",
@@ -64,5 +64,5 @@
     "test-listen": "1.1.0",
     "ts-morph": "12.0.0"
   },
-  "gitHead": "3d98d1cdea151b7125deb082c2c8469c865027d0"
+  "gitHead": "7845bef8268b191f422f493fca6e2772bee7ac86"
 }