@vercel/backends 0.8.30 → 0.8.33

package/dist/index.d.mts

@@ -3,8 +3,15 @@ import { BuildOptions, BuildV2, DetectEntrypointFn, Files, PrepareCache, ShouldS
 import { ParseArgsConfig } from "node:util";
 
 //#region src/find-entrypoint.d.ts
-declare const findEntrypoint: (cwd: string) => Promise<string | undefined>;
-declare const findEntrypointOrThrow: (cwd: string) => Promise<string>;
+type FindEntrypointOptions = {
+  /**
+   * Project setting `outputDirectory`. When set, the search is exclusive to
+   * that directory, matching the wrapper builders.
+   */
+  outputDirectory?: string;
+};
+declare const findEntrypoint: (cwd: string, options?: FindEntrypointOptions) => Promise<string | undefined>;
+declare const findEntrypointOrThrow: (cwd: string, options?: FindEntrypointOptions) => Promise<string>;
 /**
  * Normalized entrypoint detector for Node services. Wraps {@link findEntrypoint}
  * and returns the result in the shared {@link DetectedEntrypoint} shape consumed

package/dist/index.mjs

@@ -75,15 +75,64 @@ const diagnostics = createDiagnostics("node");
 
 //#endregion
 //#region src/find-entrypoint.ts
-const frameworks = [
-	"express",
-	"hono",
-	"elysia",
-	"fastify",
-	"@nestjs/core",
-	"h3"
+/**
+* Entrypoint detection modeled on the framework wrapper builders
+* (`@vercel/express`, `@vercel/hono`, ... — see
+* `packages/build-utils/src/generate-node-builder-functions.ts`), but
+* deliberately a *permissive union* with this builder's historical behavior
+* so that neither wrapper migrations nor existing `@vercel/backends` flag
+* users start failing:
+*
+* 1. If `outputDirectory` is configured, search there first (wrapper
+*    preference) — but fall through to the source tree instead of erroring
+*    when nothing is found (historical backends behavior: `outputDirectory`
+*    never blocked detection).
+* 2. Search well-known filenames in the project root, requiring the file to
+*    import the detected framework (wrapper behavior).
+* 3. Fall back to `package.json#main` when it points at an existing file —
+*    without requiring a framework import (historical backends behavior;
+*    the wrappers additionally gate `main` on the import, but relaxing the
+*    gate only accepts more projects, never fewer).
+*
+* When no framework dependency is recognized, the framework-import gate is
+* skipped and the first existing well-known file (or `main`) wins.
+*/
+const entrypointExtensions = [
+	"js",
+	"cjs",
+	"mjs",
+	"ts",
+	"cts",
+	"mts"
+];
+/**
+* Wrapper builders search app/index/server (+src). Historical backends also
+* searched main/src/main for every framework; keep them appended so
+* existing users don't lose their entrypoint.
+*/
+const DEFAULT_FILENAMES = [
+	"app",
+	"index",
+	"server",
+	"src/app",
+	"src/index",
+	"src/server",
+	"main",
+	"src/main"
 ];
-const entrypointFilenames = [
+/** NestJS conventionally uses `src/main.ts`; its wrapper prefers `src/` first. */
+const NESTJS_FILENAMES = [
+	"src/main",
+	"src/app",
+	"src/index",
+	"src/server",
+	"main",
+	"app",
+	"index",
+	"server"
+];
+/** Used when no framework dependency is recognized (historical backends order). */
+const GENERIC_FILENAMES = [
 	"app",
 	"index",
 	"server",
@@ -93,62 +142,129 @@ const entrypointFilenames = [
 	"src/server",
 	"src/main"
 ];
-const entrypointExtensions = [
-	"js",
-	"cjs",
-	"mjs",
-	"ts",
-	"cts",
-	"mts"
+/**
+* `@nestjs/core` is listed first: Nest apps commonly also depend on `express`
+* (via `@nestjs/platform-express`), and their entrypoints import
+* `@nestjs/core`, not `express`.
+*/
+const FRAMEWORKS = [
+	{
+		dependency: "@nestjs/core",
+		name: "nestjs",
+		filenames: NESTJS_FILENAMES
+	},
+	{
+		dependency: "express",
+		name: "express",
+		filenames: DEFAULT_FILENAMES
+	},
+	{
+		dependency: "hono",
+		name: "hono",
+		filenames: DEFAULT_FILENAMES
+	},
+	{
+		dependency: "elysia",
+		name: "elysia",
+		filenames: DEFAULT_FILENAMES
+	},
+	{
+		dependency: "fastify",
+		name: "fastify",
+		filenames: DEFAULT_FILENAMES
+	},
+	{
+		dependency: "koa",
+		name: "koa",
+		filenames: DEFAULT_FILENAMES
+	},
+	{
+		dependency: "h3",
+		name: "h3",
+		filenames: DEFAULT_FILENAMES
+	}
 ];
-const entrypoints = entrypointFilenames.flatMap((filename) => entrypointExtensions.map((extension) => `${filename}.${extension}`));
-const createFrameworkRegex = (framework) => new RegExp(`(?:from|require|import)\\s*(?:\\(\\s*)?["']${framework}["']\\s*(?:\\))?`, "g");
-const findEntrypoint = async (cwd) => {
+const toCandidates = (filenames) => filenames.flatMap((filename) => entrypointExtensions.map((extension) => `${filename}.${extension}`));
+const entrypointsForMessage = (filenames) => filenames.map((filename) => `- ${filename}.{${entrypointExtensions.join(",")}}`).join("\n");
+const createFrameworkRegex = (dependency) => new RegExp(`(?:from|require|import)\\s*(?:\\(\\s*)?["']${dependency}["']\\s*(?:\\))?`, "g");
+const pluralize = (word, count) => count === 1 ? word : `${word}s`;
+/** Returns true/false for readable files, null when unreadable/missing. */
+const matchesFramework = async (absolutePath, spec) => {
+	try {
+		return (await readFile(absolutePath, "utf-8")).match(createFrameworkRegex(spec.dependency)) !== null;
+	} catch {
+		return null;
+	}
+};
+const searchDirectory = async (dir, framework, filenames) => {
+	const existing = toCandidates(filenames).filter((candidate) => existsSync(join(dir, candidate)));
+	if (!framework) return {
+		entrypoint: existing[0],
+		entrypointsNotMatchingRegex: []
+	};
+	const matching = [];
+	const entrypointsNotMatchingRegex = [];
+	for (const candidate of existing) {
+		const matches = await matchesFramework(join(dir, candidate), framework);
+		if (matches === true) matching.push(candidate);
+		else if (matches === false) entrypointsNotMatchingRegex.push(candidate);
+	}
+	const entrypoint = matching[0];
+	if (matching.length > 1) console.warn(`Multiple entrypoints found: ${matching.join(", ")}. Using ${entrypoint}.`);
+	return {
+		entrypoint,
+		entrypointsNotMatchingRegex
+	};
+};
+const findMainEntrypoint = async (cwd, packageJsonObject) => {
+	const main = packageJsonObject && typeof packageJsonObject.main === "string" ? packageJsonObject.main.trim() : "";
+	if (!main) return void 0;
+	const abs = resolve(cwd, main);
+	const rel = relative(cwd, abs);
+	if (rel.startsWith("..") || rel === "") return void 0;
+	if (!existsSync(abs)) return void 0;
+	try {
+		await readFile(abs, "utf-8");
+	} catch {
+		return;
+	}
+	return rel.split(sep).join("/");
+};
+const resolveEntrypoint = async (cwd, options) => {
 	let packageJsonObject = null;
 	try {
 		const packageJson = await readFile(join(cwd, "package.json"), "utf-8");
 		packageJsonObject = JSON.parse(packageJson);
 	} catch (_) {}
-	if (packageJsonObject) {
-		const main = typeof packageJsonObject.main === "string" ? packageJsonObject.main.trim() : "";
-		if (main) {
-			const abs = resolve(cwd, main);
-			const rel = relative(cwd, abs);
-			if (!rel.startsWith("..") && rel !== "") try {
-				await readFile(abs, "utf-8");
-				return rel.split(sep).join("/");
-			} catch {}
-		}
-	}
-	let framework;
-	if (packageJsonObject) framework = frameworks.find((framework$1) => packageJsonObject.dependencies?.[framework$1]);
-	if (!framework) for (const entrypoint of entrypoints) {
-		const entrypointPath = join(cwd, entrypoint);
-		try {
-			await readFile(entrypointPath, "utf-8");
-			return entrypoint;
-		} catch (_) {}
-	}
-	const regex = framework ? createFrameworkRegex(framework) : void 0;
-	for (const entrypoint of entrypoints) {
-		const entrypointPath = join(cwd, entrypoint);
-		try {
-			const content = await readFile(entrypointPath, "utf-8");
-			if (regex) {
-				if (regex.test(content)) return entrypoint;
-			}
-		} catch (_) {}
+	const framework = packageJsonObject ? FRAMEWORKS.find((spec) => packageJsonObject.dependencies?.[spec.dependency]) : void 0;
+	const filenames = framework ? framework.filenames : GENERIC_FILENAMES;
+	const searchedForMessage = entrypointsForMessage(filenames);
+	const noMatchingImportError = (candidates) => /* @__PURE__ */ new Error(`No entrypoint found which imports ${framework.name}. Found possible ${pluralize("entrypoint", candidates.length)}: ${candidates.join(", ")}`);
+	const dir = options?.outputDirectory?.replace(/^\/+|\/+$/g, "");
+	if (dir) {
+		const { entrypoint: outputDirEntrypoint } = await searchDirectory(join(cwd, dir), framework, filenames);
+		if (outputDirEntrypoint) return { entrypoint: join(dir, outputDirEntrypoint).split(sep).join("/") };
 	}
+	const { entrypoint, entrypointsNotMatchingRegex } = await searchDirectory(cwd, framework, filenames);
+	if (entrypoint) return { entrypoint };
+	const mainEntrypoint = await findMainEntrypoint(cwd, packageJsonObject);
+	if (mainEntrypoint) return { entrypoint: mainEntrypoint };
+	if (framework && entrypointsNotMatchingRegex.length > 0) return { error: noMatchingImportError(entrypointsNotMatchingRegex) };
+	if (framework) return { error: /* @__PURE__ */ new Error(`No entrypoint found. Searched for:\n${searchedForMessage}`) };
+	return { error: /* @__PURE__ */ new Error(`No entrypoint found in "${cwd}". Set package.json "main" to a server file, or add one of: ${toCandidates(filenames).join(", ")}`) };
 };
-const findEntrypointOrThrow = async (cwd) => {
-	const entrypoint = await findEntrypoint(cwd);
-	if (!entrypoint) throw new Error(`No entrypoint found in "${cwd}". Set package.json "main" to a server file, or add one of: ${entrypoints.join(", ")}`);
-	return entrypoint;
+const findEntrypoint = async (cwd, options) => {
+	return (await resolveEntrypoint(cwd, options)).entrypoint;
 };
-const findEntrypointWithHintOrThrow = async (workPath, configured) => {
+const findEntrypointOrThrow = async (cwd, options) => {
+	const result = await resolveEntrypoint(cwd, options);
+	if (result.error) throw result.error;
+	return result.entrypoint;
+};
+const findEntrypointWithHintOrThrow = async (workPath, configured, options) => {
 	const explicit = configured && configured !== "package.json" ? configured : null;
 	if (explicit && existsSync(join(workPath, explicit))) return explicit;
-	return findEntrypointOrThrow(workPath);
+	return findEntrypointOrThrow(workPath, options);
 };
 /**
 * Normalized entrypoint detector for Node services. Wraps {@link findEntrypoint}
@@ -807,22 +923,12 @@ const Colors = {
 
 //#endregion
 //#region src/typescript.ts
-/**
-* Typecheck via the TypeScript compiler API (`createProgram`, `getPreEmitDiagnostics`),
-* not by spawning the `tsc` binary.
-*
-* We only want to validate the deployment entrypoint and its import graph, not every
-* file matched by `tsconfig` `include`. The CLI cannot combine `--project` with explicit
-* root files (TS5042), so expressing 'project options + entry-only roots' in one `tsc`
-* call requires a generated tsconfig on disk. Writing beside the user's config is
-* invasive; a temp config elsewhere often breaks `node_modules` / `@types` resolution
-* relative to the real project. The API lets us reuse `parseJsonConfigFileContent` (same
-* options as `-p`) with explicit `rootNames`, no files written, and a compiler host whose
-* current directory stays `workPath`.
-*
-* The `typescript` package is resolved with `require` from the user's app (peer dependency), not bundled.
-*/
 const require_$1 = createRequire(import.meta.url);
+const IGNORED_DIAGNOSTIC_CODES = new Set([
+	6059,
+	18002,
+	18003
+]);
 const typescript = (args) => {
 	const { span } = args;
 	return span.child("vc.builder.backends.tsCompile").trace(async () => {
@@ -832,7 +938,7 @@ const typescript = (args) => {
 			".mts",
 			".cts"
 		].includes(extension)) return;
-		const ts = resolveTypeScriptModule(args.workPath);
+		const ts = resolveTypeScriptModule(dirname(resolve(args.workPath, args.entrypoint)));
 		if (!ts) {
 			console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Typecheck skipped ${Colors.gray("(TypeScript not found)")}`));
 			return null;
@@ -842,66 +948,95 @@ const typescript = (args) => {
 };
 async function doTypeCheck(args, ts) {
 	const entryAbsolute = resolve(args.workPath, args.entrypoint);
-	const tsconfig = await findNearestTsconfig(args.workPath);
+	const tsconfig = findNearestTsconfig(dirname(entryAbsolute));
 	const formatDiagnostics = process.stdout.isTTY ? ts.formatDiagnosticsWithColorAndContext : ts.formatDiagnostics;
 	const diagnosticHost = {
 		getNewLine: () => ts.sys.newLine,
 		getCanonicalFileName: (fileName) => ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
 		getCurrentDirectory: () => args.workPath
 	};
+	const filterIgnored = (diagnostics$1) => diagnostics$1.filter((d) => !IGNORED_DIAGNOSTIC_CODES.has(d.code));
+	const fail = (diagnostics$1) => {
+		const message = formatDiagnostics(diagnostics$1, diagnosticHost);
+		console.error("\nTypeScript type check failed:\n");
+		console.error(message);
+		throw new Error("TypeScript type check failed");
+	};
 	let options;
-	let parseDiagnostics = [];
+	const rootNames = [entryAbsolute];
 	if (tsconfig) {
 		const configRead = ts.readConfigFile(tsconfig, ts.sys.readFile);
-		if (configRead.error) {
-			const message = formatDiagnostics([configRead.error], diagnosticHost);
-			console.error("\nTypeScript type check failed:\n");
-			console.error(message);
-			throw new Error("TypeScript type check failed");
-		}
-		const parsed = ts.parseJsonConfigFileContent(configRead.config, ts.sys, dirname(tsconfig), void 0, tsconfig);
-		parseDiagnostics = parsed.errors;
+		if (configRead.error) fail([configRead.error]);
+		const config = configRead.config ?? {};
+		const parsed = ts.parseJsonConfigFileContent(config, ts.sys, dirname(tsconfig), void 0, tsconfig);
+		const parseErrors = filterIgnored(parsed.errors).filter((d) => d.category === ts.DiagnosticCategory.Error);
+		if (parseErrors.length > 0) if (parsed.options.noEmitOnError) fail(parseErrors);
+		else console.error(formatDiagnostics(parseErrors, diagnosticHost));
 		options = {
 			...parsed.options,
 			noEmit: true,
 			skipLibCheck: true,
-			allowJs: true,
-			esModuleInterop: true
+			allowJs: true
 		};
+		delete options.out;
+		delete options.outFile;
+		delete options.composite;
+		delete options.declarationDir;
+		delete options.declarationMap;
+		delete options.emitDeclarationOnly;
+		delete options.tsBuildInfoFile;
+		delete options.incremental;
+		if (options.target === void 0) options.target = defaultScriptTarget(ts, args.nodeVersionMajor);
+		if (options.esModuleInterop === void 0) options.esModuleInterop = true;
+		if (options.module === void 0 && options.moduleResolution === void 0) {
+			options.module = ts.ModuleKind.NodeNext;
+			options.moduleResolution = ts.ModuleResolutionKind.NodeNext;
+			options.strict = false;
+		}
+		for (const fileName of parsed.fileNames) if (/\.d\.(ts|mts|cts)$/.test(fileName) && fileName !== entryAbsolute) rootNames.push(fileName);
 	} else options = {
 		noEmit: true,
 		skipLibCheck: true,
 		allowJs: true,
 		esModuleInterop: true,
-		target: ts.ScriptTarget.ES2022,
+		target: defaultScriptTarget(ts, args.nodeVersionMajor),
 		module: ts.ModuleKind.NodeNext,
-		moduleResolution: ts.ModuleResolutionKind.NodeNext
+		moduleResolution: ts.ModuleResolutionKind.NodeNext,
+		strict: false
 	};
 	const compilerHost = ts.createCompilerHost(options);
 	compilerHost.getCurrentDirectory = () => args.workPath;
-	const program = ts.createProgram([entryAbsolute], options, compilerHost);
-	const errors = [...parseDiagnostics, ...ts.getPreEmitDiagnostics(program)].filter((d) => d.category === ts.DiagnosticCategory.Error);
+	const program = ts.createProgram(rootNames, options, compilerHost);
+	const errors = filterIgnored(ts.getPreEmitDiagnostics(program)).filter((d) => d.category === ts.DiagnosticCategory.Error);
 	if (errors.length === 0) {
 		console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Typecheck complete`));
 		return;
 	}
-	const output = formatDiagnostics(errors, diagnosticHost);
-	console.error("\nTypeScript type check failed:\n");
-	console.error(output);
-	throw new Error("TypeScript type check failed");
+	fail(errors);
+}
+function defaultScriptTarget(ts, nodeVersionMajor = 16) {
+	if (nodeVersionMajor >= 16) return ts.ScriptTarget.ES2021;
+	if (nodeVersionMajor >= 14) return ts.ScriptTarget.ES2020;
+	return ts.ScriptTarget.ES2019;
 }
-function resolveTypeScriptModule(workPath) {
+function resolveTypeScriptModule(startDir) {
 	try {
-		return require_$1(require_$1.resolve("typescript", { paths: [workPath] }));
+		const ts = require_$1(require_$1.resolve("typescript", { paths: [startDir] }));
+		console.log(`Using TypeScript ${ts.version} (local user-provided)`);
+		return ts;
 	} catch (_e) {
 		return null;
 	}
 }
-const findNearestTsconfig = async (workPath) => {
-	const tsconfigPath = join(workPath, "tsconfig.json");
-	if (existsSync(tsconfigPath)) return tsconfigPath;
-	if (workPath === "/") return;
-	return findNearestTsconfig(join(workPath, ".."));
+const findNearestTsconfig = (startDir) => {
+	let dir = resolve(startDir);
+	for (;;) {
+		const tsconfigPath = join(dir, "tsconfig.json");
+		if (existsSync(tsconfigPath)) return tsconfigPath;
+		const parent = dirname(dir);
+		if (parent === dir) return;
+		dir = parent;
+	}
 };
 
 //#endregion
@@ -2136,7 +2271,8 @@ const build = async (args) => {
 	span.setAttributes({ "builder.name": builderName });
 	const buildSpan = span.child("vc.builder.backends.build");
 	return buildSpan.trace(async () => {
-		const entrypoint = await findEntrypointWithHintOrThrow(args.workPath, args.entrypoint);
+		const userBuildResult = await maybeDoBuildCommand(args, downloadResult);
+		const entrypoint = await findEntrypointWithHintOrThrow(args.workPath, args.entrypoint, { outputDirectory: getOutputDirectorySetting(args.config) });
 		debug("Entrypoint", entrypoint);
 		args.entrypoint = entrypoint;
 		const serviceName = typeof args.config?.serviceName === "string" && args.config.serviceName !== "" ? args.config.serviceName : void 0;
@@ -2152,7 +2288,6 @@ const build = async (args) => {
 			entrypoint
 		});
 		const isCronService = cronEntries !== void 0;
-		const userBuildResult = await maybeDoBuildCommand(args, downloadResult);
 		const preDeployCommand = args.config.preDeployCommand;
 		if (args.registerPreDeploy && typeof preDeployCommand === "string") {
 			const nodeBinPath = getNodeBinPaths({
@@ -2199,7 +2334,8 @@ const build = async (args) => {
 		} else typescriptPromise = typescript({
 			entrypoint,
 			workPath: args.workPath,
-			span: buildSpan
+			span: buildSpan,
+			nodeVersionMajor: nodeVersion.major
 		});
 		const localBuildFiles = userBuildResult?.localBuildFiles.size > 0 ? userBuildResult?.localBuildFiles : rolldownResult.localBuildFiles;
 		const files = userBuildResult?.files || rolldownResult.files;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/backends",
-  "version": "0.8.30",
+  "version": "0.8.33",
   "license": "Apache-2.0",
   "main": "./dist/index.mjs",
   "homepage": "https://vercel.com/docs",
@@ -37,8 +37,8 @@
     "ts-morph": "12.0.0",
     "tsx": "4.21.0",
     "zod": "3.22.4",
-    "@vercel/build-utils": "13.36.3",
-    "@vercel/static-config": "3.4.0"
+    "@vercel/static-config": "3.4.1",
+    "@vercel/build-utils": "14.0.2"
   },
   "devDependencies": {
     "@types/express": "5.0.3",
@@ -56,7 +56,7 @@
     "build": "tsdown",
     "vitest-run": "vitest -c ../../vitest.config.mts",
     "vitest": "tsdown && vitest",
-    "vitest-unit": "glob --absolute 'test/unit.*test.ts'",
+    "vitest-unit": "pnpm vitest-run --run test/unit.",
     "type-check": "tsc --noEmit"
   }
 }