@vercel/backends 0.8.17 → 0.8.18

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as _vercel_build_utils0 from "@vercel/build-utils";
-import { BuildOptions, BuildV2, DetectEntrypointFn, Files, PrepareCache, Span } from "@vercel/build-utils";
+import { BuildOptions, BuildV2, DetectEntrypointFn, Files, PrepareCache, ShouldServe, Span, StartDevServer } from "@vercel/build-utils";
 import { ParseArgsConfig } from "node:util";
 
 //#region src/find-entrypoint.d.ts
@@ -105,9 +105,13 @@ declare const introspectApp: (args: {
 //#region src/diagnostics.d.ts
 declare const diagnostics: _vercel_build_utils0.Diagnostics;
 //#endregion
+//#region src/start-dev-server.d.ts
+declare const shouldServe: ShouldServe;
+declare const startDevServer: StartDevServer;
+//#endregion
 //#region src/index.d.ts
 declare const version = 2;
 declare const build: BuildV2;
 declare const prepareCache: PrepareCache;
 //#endregion
-export { type CervelBuildOptions, type CervelServeOptions, type PathOptions, build, build$1 as cervelBuild, serve as cervelServe, detectEntrypoint, diagnostics, findEntrypoint, findEntrypointOrThrow, getBuildSummary, introspectApp, nodeFileTrace, prepareCache, srvxOptions, version };
+export { type CervelBuildOptions, type CervelServeOptions, type PathOptions, build, build$1 as cervelBuild, serve as cervelServe, detectEntrypoint, diagnostics, findEntrypoint, findEntrypointOrThrow, getBuildSummary, introspectApp, nodeFileTrace, prepareCache, shouldServe, srvxOptions, startDevServer, version };

package/dist/index.mjs

@@ -1,10 +1,10 @@
 import { builtinModules, createRequire } from "node:module";
 import { basename, delimiter, dirname, extname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { delimiter as delimiter$1, dirname as dirname$1, join as join$1 } from "path";
-import { FileBlob, FileFsRef, NodejsLambda, Span, createDiagnostics, debug, defaultCachePathGlob, download, execCommand, generateProjectManifest, getEnvForPackageManager, getInternalServiceCronPath, getLambdaOptionsFromFunction, getNodeBinPaths, getNodeVersion, getReportedServiceType, glob, isBackendFramework, isBunVersion, isExperimentalBackendsWithoutIntrospectionEnabled, isScheduleTriggeredService, runNpmInstall, runPackageJsonScript, scanParentDirs } from "@vercel/build-utils";
+import { FileBlob, FileFsRef, NodejsLambda, Span, cloneEnv, createDiagnostics, debug, defaultCachePathGlob, download, execCommand, generateProjectManifest, getEnvForPackageManager, getInternalServiceCronPath, getLambdaOptionsFromFunction, getNodeBinPaths, getNodeVersion, getReportedServiceType, glob, isBackendFramework, isBunVersion, isExperimentalBackendsWithoutIntrospectionEnabled, isScheduleTriggeredService, runNpmInstall, runPackageJsonScript, scanParentDirs } from "@vercel/build-utils";
 import { createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { lstat, readFile, readlink, rm, stat } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { build as build$2 } from "rolldown";
 import { exports } from "resolve.exports";
 import { isNativeError } from "node:util/types";
@@ -12,9 +12,11 @@ import { nodeFileTrace as nodeFileTrace$1, resolve as resolve$1 } from "@vercel/
 import { transform } from "oxc-transform";
 import execa from "execa";
 import { readFile as readFile$1, writeFile } from "fs/promises";
-import { spawn } from "node:child_process";
+import { fork, spawn } from "node:child_process";
 import { tmpdir } from "node:os";
 import { z } from "zod";
+import { createConnection } from "node:net";
+import getPort from "get-port";
 
 //#region src/utils.ts
 async function downloadInstallAndBundle(args) {
@@ -818,7 +820,7 @@ const Colors = {
 *
 * The `typescript` package is resolved with `require` from the user's app (peer dependency), not bundled.
 */
-const require_ = createRequire(import.meta.url);
+const require_$1 = createRequire(import.meta.url);
 const typescript = (args) => {
 	const { span } = args;
 	return span.child("vc.builder.backends.tsCompile").trace(async () => {
@@ -888,7 +890,7 @@ async function doTypeCheck(args, ts) {
 }
 function resolveTypeScriptModule(workPath) {
 	try {
-		return require_(require_.resolve("typescript", { paths: [workPath] }));
+		return require_$1(require_$1.resolve("typescript", { paths: [workPath] }));
 	} catch (_e) {
 		return null;
 	}
@@ -1806,6 +1808,298 @@ const getFramework = (args) => {
 	}
 };
 
+//#endregion
+//#region src/dev/spawn-srvx.ts
+const require_ = createRequire(import.meta.url);
+const srvxBinPath = resolve(dirname(require_.resolve("srvx/cli")), "../bin/srvx.mjs");
+const tsxPath = pathToFileURL(require_.resolve("tsx")).href;
+const STARTUP_TIMEOUT = 5 * 6e4;
+const SHUTDOWN_TIMEOUT = 5e3;
+function forwardOutput(callback, stream) {
+	return (data) => {
+		if (callback) callback(data);
+		else stream.write(data.toString());
+	};
+}
+function canConnect(port) {
+	return new Promise((resolve$2) => {
+		const socket = createConnection({
+			host: "127.0.0.1",
+			port
+		});
+		let settled = false;
+		const finish = (connected) => {
+			if (settled) return;
+			settled = true;
+			socket.destroy();
+			resolve$2(connected);
+		};
+		socket.once("connect", () => finish(true));
+		socket.once("error", () => finish(false));
+		socket.setTimeout(100, () => finish(false));
+	});
+}
+function waitUntilReady(child, port, entrypoint, signal) {
+	return new Promise((resolve$2, reject) => {
+		const deadline = Date.now() + STARTUP_TIMEOUT;
+		let retryTimer;
+		let settled = false;
+		const cleanup = () => {
+			if (retryTimer) clearTimeout(retryTimer);
+			child.off("error", onError);
+			child.off("exit", onExit);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		const succeed = () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve$2();
+		};
+		const fail = (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		};
+		const onError = (error) => fail(error);
+		const onExit = (code, signal$1) => {
+			const reason = signal$1 ? `signal ${signal$1}` : `exit code ${code}`;
+			fail(/* @__PURE__ */ new Error(`Server \`${entrypoint}\` exited with ${reason}`));
+		};
+		const onAbort = () => {
+			child.kill("SIGTERM");
+			fail(/* @__PURE__ */ new Error(`Server \`${entrypoint}\` cancelled`));
+		};
+		const probe = async () => {
+			if (settled) return;
+			if (await canConnect(port)) succeed();
+			else if (Date.now() >= deadline) fail(/* @__PURE__ */ new Error(`Server \`${entrypoint}\` did not listen on port ${port} within ${STARTUP_TIMEOUT}ms`));
+			else retryTimer = setTimeout(probe, 50);
+		};
+		child.once("error", onError);
+		child.once("exit", onExit);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		if (signal?.aborted) {
+			onAbort();
+			return;
+		}
+		probe();
+	});
+}
+function waitForExit(child, timeout) {
+	if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve(true);
+	return new Promise((resolve$2) => {
+		const onExit = () => {
+			clearTimeout(timer);
+			resolve$2(true);
+		};
+		const timer = setTimeout(() => {
+			child.off("exit", onExit);
+			resolve$2(false);
+		}, timeout);
+		child.once("exit", onExit);
+	});
+}
+async function stopChild(child) {
+	if (child.exitCode !== null || child.signalCode !== null) return;
+	child.kill("SIGTERM");
+	if (await waitForExit(child, SHUTDOWN_TIMEOUT)) return;
+	child.kill("SIGKILL");
+	await waitForExit(child, 1e3);
+}
+async function spawnSrvx(opts) {
+	const port = await getPort({ host: "127.0.0.1" });
+	const env = cloneEnv(process.env, opts.env, {
+		HOST: "127.0.0.1",
+		PORT: String(port)
+	});
+	if (!env.NODE_ENV) env.NODE_ENV = "development";
+	const child = fork(srvxBinPath, [
+		`--port=${port}`,
+		"--host=127.0.0.1",
+		`--static=${resolve(opts.workPath, opts.publicDir)}`,
+		opts.entrypoint
+	], {
+		cwd: opts.workPath,
+		env,
+		execArgv: ["--import", tsxPath],
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe",
+			"ipc"
+		]
+	});
+	child.stdout?.on("data", forwardOutput(opts.onStdout, process.stdout));
+	child.stderr?.on("data", forwardOutput(opts.onStderr, process.stderr));
+	if (!child.pid) throw new Error("srvx child failed to spawn");
+	try {
+		await waitUntilReady(child, port, opts.entrypoint, opts.signal);
+	} catch (error) {
+		await stopChild(child);
+		throw error;
+	}
+	return {
+		pid: child.pid,
+		port,
+		shutdown: () => stopChild(child)
+	};
+}
+
+//#endregion
+//#region src/start-dev-server.ts
+const persistentDevServers = /* @__PURE__ */ new Map();
+const pendingDevServers = /* @__PURE__ */ new Map();
+let cleanupHandlersInstalled = false;
+let shuttingDown = false;
+function snapshotFiles(files) {
+	return { ...files };
+}
+function filesAreEqual(previous, current) {
+	const previousNames = Object.keys(previous);
+	const currentNames = Object.keys(current);
+	return previousNames.length === currentNames.length && previousNames.every((name) => previous[name] === current[name]);
+}
+function envsAreEqual(previous, current) {
+	const previousNames = Object.keys(previous);
+	const currentNames = Object.keys(current);
+	return previousNames.length === currentNames.length && previousNames.every((name) => previous[name] === current[name]);
+}
+function stateMatches(state, files, env) {
+	return filesAreEqual(state.files, files) && envsAreEqual(state.env, env);
+}
+function isProcessRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function terminateProcess(pid) {
+	try {
+		process.kill(pid, "SIGTERM");
+	} catch {}
+}
+function stopPersistentDevServer(key, server) {
+	if (!server.stopPromise) server.stopPromise = (async () => {
+		try {
+			if (server.result.shutdown) await server.result.shutdown();
+			else terminateProcess(server.result.pid);
+		} catch {
+			terminateProcess(server.result.pid);
+		} finally {
+			if (persistentDevServers.get(key) === server) persistentDevServers.delete(key);
+		}
+	})();
+	return server.stopPromise;
+}
+function persistentResult(key, server) {
+	const { pid } = server.result;
+	return {
+		...server.result,
+		persistent: true,
+		shutdown: () => {
+			const current = persistentDevServers.get(key);
+			return current?.result.pid === pid ? stopPersistentDevServer(key, current) : Promise.resolve();
+		}
+	};
+}
+function installCleanupHandlers() {
+	if (cleanupHandlersInstalled) return;
+	cleanupHandlersInstalled = true;
+	const stopAll = () => {
+		shuttingDown = true;
+		for (const pending of pendingDevServers.values()) pending.controller.abort();
+		for (const [key, server] of persistentDevServers) stopPersistentDevServer(key, server);
+	};
+	const killAll = () => {
+		for (const pending of pendingDevServers.values()) pending.controller.abort();
+		for (const server of persistentDevServers.values()) terminateProcess(server.result.pid);
+	};
+	process.on("SIGINT", stopAll);
+	process.on("SIGTERM", stopAll);
+	process.on("exit", killAll);
+}
+const shouldServe = (opts) => {
+	if (opts.requestPath.replace(/\/$/, "").startsWith("api") && opts.hasMatched) return false;
+	return true;
+};
+const startDevServer = async (opts) => {
+	if (opts.service) return null;
+	const key = `${opts.workPath}::${opts.entrypoint ?? "<detect>"}`;
+	const entrypoint = await findEntrypointWithHintOrThrow(opts.workPath, opts.entrypoint);
+	const env = { ...opts.meta?.env };
+	installCleanupHandlers();
+	while (!shuttingDown) {
+		const existing = persistentDevServers.get(key);
+		if (existing) {
+			if (!existing.stopPromise && stateMatches(existing, opts.files, env) && isProcessRunning(existing.result.pid)) return persistentResult(key, existing);
+			await stopPersistentDevServer(key, existing);
+			continue;
+		}
+		const pending = pendingDevServers.get(key);
+		if (pending) {
+			if (!stateMatches(pending, opts.files, env)) pending.controller.abort();
+			let server;
+			try {
+				server = await pending.promise;
+			} catch (error) {
+				if (stateMatches(pending, opts.files, env)) throw error;
+				continue;
+			}
+			if (stateMatches(pending, opts.files, env)) {
+				if (!server) return null;
+				if (isProcessRunning(server.result.pid)) return persistentResult(key, server);
+			}
+			if (server) await stopPersistentDevServer(key, server);
+			continue;
+		}
+		const files = snapshotFiles(opts.files);
+		const controller = new AbortController();
+		const promise = spawnSrvx({
+			workPath: opts.workPath,
+			entrypoint,
+			publicDir: opts.publicDir ?? "public",
+			env,
+			signal: controller.signal,
+			onStdout: opts.onStdout,
+			onStderr: opts.onStderr
+		}).then(async (result) => {
+			const server = {
+				files,
+				env,
+				result
+			};
+			if (shuttingDown) {
+				await stopPersistentDevServer(key, server);
+				return null;
+			}
+			persistentDevServers.set(key, server);
+			return server;
+		});
+		const pendingServer = {
+			files,
+			env,
+			controller,
+			promise
+		};
+		pendingDevServers.set(key, pendingServer);
+		try {
+			const server = await promise;
+			if (!stateMatches(pendingServer, opts.files, env)) {
+				if (server) await stopPersistentDevServer(key, server);
+				continue;
+			}
+			return server ? persistentResult(key, server) : null;
+		} finally {
+			if (pendingDevServers.get(key) === pendingServer) pendingDevServers.delete(key);
+		}
+	}
+	return null;
+};
+
 //#endregion
 //#region src/index.ts
 const version = 2;
@@ -2024,4 +2318,4 @@ const escapeForRegex = (value) => value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
 const toRegexSource = (value) => escapeForRegex(value).replaceAll("/", "\\/");
 
 //#endregion
-export { build, build$1 as cervelBuild, serve as cervelServe, detectEntrypoint, diagnostics, findEntrypoint, findEntrypointOrThrow, getBuildSummary, introspectApp, nodeFileTrace, prepareCache, srvxOptions, version };
+export { build, build$1 as cervelBuild, serve as cervelServe, detectEntrypoint, diagnostics, findEntrypoint, findEntrypointOrThrow, getBuildSummary, introspectApp, nodeFileTrace, prepareCache, shouldServe, srvxOptions, startDevServer, version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/backends",
-  "version": "0.8.17",
+  "version": "0.8.18",
   "license": "Apache-2.0",
   "main": "./dist/index.mjs",
   "homepage": "https://vercel.com/docs",
@@ -33,10 +33,10 @@
     "path-to-regexp": "8.3.0",
     "resolve.exports": "2.0.3",
     "rolldown": "1.0.0-rc.1",
-    "srvx": "0.8.9",
+    "srvx": "0.11.16",
     "tsx": "4.21.0",
     "zod": "3.22.4",
-    "@vercel/build-utils": "13.32.0"
+    "@vercel/build-utils": "13.32.1"
   },
   "devDependencies": {
     "@types/express": "5.0.3",