@vercel/backends 0.0.63 → 0.1.0

package/dist/index.d.mts

@@ -97,9 +97,12 @@ declare const introspectApp: (args: {
   additionalDeps: string[];
 }>;
 //#endregion
+//#region src/diagnostics.d.ts
+declare const diagnostics: _vercel_build_utils0.Diagnostics;
+//#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, findEntrypoint, findEntrypointOrThrow, getBuildSummary, introspectApp, nodeFileTrace, prepareCache, srvxOptions, version };
+export { type CervelBuildOptions, type CervelServeOptions, type PathOptions, build, build$1 as cervelBuild, serve as cervelServe, diagnostics, findEntrypoint, findEntrypointOrThrow, getBuildSummary, introspectApp, nodeFileTrace, prepareCache, srvxOptions, version };

package/dist/index.mjs

@@ -1,6 +1,9 @@
 import { builtinModules, createRequire } from "node:module";
-import { delimiter, dirname, join } from "path";
-import { FileBlob, FileFsRef, NodejsLambda, Span, debug, defaultCachePathGlob, download, execCommand, getEnvForPackageManager, getLambdaOptionsFromFunction, getNodeBinPaths, getNodeVersion, glob, isBackendFramework, isBunVersion, isExperimentalBackendsWithoutIntrospectionEnabled, runNpmInstall, runPackageJsonScript, scanParentDirs } from "@vercel/build-utils";
+import path, { delimiter, dirname, join } from "path";
+import { FileBlob, FileFsRef, MANIFEST_VERSION, NodejsLambda, Span, createDiagnostics, debug, defaultCachePathGlob, download, execCommand, getEnvForPackageManager, getLambdaOptionsFromFunction, getNodeBinPaths, getNodeVersion, glob, isBackendFramework, isBunVersion, isExperimentalBackendsWithoutIntrospectionEnabled, runNpmInstall, runPackageJsonScript, scanParentDirs, writeProjectManifest } from "@vercel/build-utils";
+import fs from "fs";
+import yaml from "js-yaml";
+import { parseSyml } from "@yarnpkg/parsers";
 import { createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { lstat, readFile, rm, stat } from "node:fs/promises";
 import { basename, dirname as dirname$1, extname, isAbsolute, join as join$1, relative, resolve, sep } from "node:path";
@@ -20,7 +23,7 @@ async function downloadInstallAndBundle(args) {
 	const { entrypoint, files, workPath, meta, config, repoRootPath } = args;
 	await download(files, workPath, meta);
 	const entrypointFsDirname = join(workPath, dirname(entrypoint));
-	const { cliType, lockfileVersion, packageJsonPackageManager, turboSupportsCorepackHome } = await scanParentDirs(entrypointFsDirname, true, repoRootPath);
+	const { cliType, lockfilePath, lockfileVersion, packageJsonPackageManager, turboSupportsCorepackHome } = await scanParentDirs(entrypointFsDirname, true, repoRootPath);
 	const spawnEnv = getEnvForPackageManager({
 		cliType,
 		lockfileVersion,
@@ -40,7 +43,10 @@ async function downloadInstallAndBundle(args) {
 	else await runNpmInstall(entrypointFsDirname, [], { env: spawnEnv }, meta, config.projectSettings?.createdAt);
 	return {
 		entrypointFsDirname,
-		spawnEnv
+		spawnEnv,
+		cliType,
+		lockfilePath,
+		lockfileVersion
 	};
 }
 async function maybeExecBuildCommand(args, { spawnEnv }) {
@@ -61,6 +67,349 @@ async function maybeExecBuildCommand(args, { spawnEnv }) {
 	return runPackageJsonScript(args.workPath, ["build"], { env: spawnEnv }, args.config.projectSettings?.createdAt);
 }
 
+//#endregion
+//#region src/diagnostics.ts
+function classifySource(resolvedUrl) {
+	if (!resolvedUrl) return {};
+	if (resolvedUrl.startsWith("file:")) return {
+		source: "file",
+		sourceUrl: resolvedUrl.slice(5)
+	};
+	if (resolvedUrl.startsWith("git+") || resolvedUrl.startsWith("git://")) return {
+		source: "git",
+		sourceUrl: resolvedUrl.replace(/^git\+/, "")
+	};
+	try {
+		return {
+			source: "registry",
+			sourceUrl: new URL(resolvedUrl).origin
+		};
+	} catch {
+		return {};
+	}
+}
+function npmEntryScopes(entry) {
+	const scopes = [];
+	if (entry.dev) scopes.push("dev");
+	if (entry.peer) scopes.push("peer");
+	if (entry.optional) scopes.push("optional");
+	if (scopes.length === 0) scopes.push("prod");
+	return scopes;
+}
+function parseNpmLock(content, lockfileVersion) {
+	const lockMap = /* @__PURE__ */ new Map();
+	const parsed = JSON.parse(content);
+	if ((lockfileVersion ?? parsed.lockfileVersion ?? 1) >= 2) {
+		const packages = parsed.packages;
+		if (!packages) return lockMap;
+		for (const [key, entry] of Object.entries(packages)) {
+			if (key === "") continue;
+			if (!key.startsWith("node_modules/")) continue;
+			if (entry.link === true) continue;
+			const rest = key.slice(13);
+			const isScoped = rest.startsWith("@");
+			const slashCount = (rest.match(/\//g) ?? []).length;
+			if (isScoped ? slashCount !== 1 : slashCount !== 0) continue;
+			const resolved = entry.resolved;
+			if (resolved?.startsWith("file:")) continue;
+			const version$1 = entry.version ?? "";
+			const existing = lockMap.get(rest);
+			if (existing && !isHigherVersion(version$1, existing.resolved)) continue;
+			const { source, sourceUrl } = classifySource(resolved);
+			const lockEntry = {
+				resolved: version$1,
+				scopes: npmEntryScopes(entry)
+			};
+			if (source) lockEntry.source = source;
+			if (sourceUrl) lockEntry.sourceUrl = sourceUrl;
+			lockMap.set(rest, lockEntry);
+		}
+	} else {
+		const dependencies = parsed.dependencies;
+		if (!dependencies) return lockMap;
+		const walk = (deps) => {
+			for (const [name, entry] of Object.entries(deps)) {
+				const resolved = entry.resolved;
+				if (!resolved?.startsWith("file:")) {
+					const version$1 = entry.version ?? "";
+					const existing = lockMap.get(name);
+					if (!existing || isHigherVersion(version$1, existing.resolved)) {
+						const { source, sourceUrl } = classifySource(resolved);
+						const lockEntry = {
+							resolved: version$1,
+							scopes: npmEntryScopes(entry)
+						};
+						if (source) lockEntry.source = source;
+						if (sourceUrl) lockEntry.sourceUrl = sourceUrl;
+						lockMap.set(name, lockEntry);
+					}
+				}
+				const nested = entry.dependencies;
+				if (nested) walk(nested);
+			}
+		};
+		walk(dependencies);
+	}
+	return lockMap;
+}
+function isHigherVersion(a, b) {
+	const seg = (v) => v.split(/[.\-+]/).map((s) => parseInt(s, 10) || 0);
+	const pa = seg(a);
+	const pb = seg(b);
+	for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+		if ((pa[i] ?? 0) > (pb[i] ?? 0)) return true;
+		if ((pa[i] ?? 0) < (pb[i] ?? 0)) return false;
+	}
+	return false;
+}
+function extractPackageName(spec) {
+	const s = spec.replace(/\(.*\)$/, "");
+	if (s.startsWith("@")) {
+		const i$1 = s.indexOf("@", 1);
+		return i$1 === -1 ? null : s.slice(0, i$1);
+	}
+	const i = s.lastIndexOf("@");
+	return i <= 0 ? null : s.slice(0, i);
+}
+function parsePnpmV9Key(key) {
+	const name = extractPackageName(key);
+	if (!name) return null;
+	return {
+		name,
+		version: key.replace(/\(.*\)$/, "").slice(name.length + 1)
+	};
+}
+function parsePnpmV5Key(key) {
+	if (!key.startsWith("/")) return null;
+	const rest = key.slice(1);
+	if (rest.startsWith("@")) {
+		const firstSlash = rest.indexOf("/");
+		if (firstSlash === -1) return null;
+		const secondSlash = rest.indexOf("/", firstSlash + 1);
+		if (secondSlash === -1) return null;
+		return {
+			name: rest.slice(0, secondSlash),
+			version: rest.slice(secondSlash + 1).split("_")[0]
+		};
+	}
+	const slashIndex = rest.indexOf("/");
+	if (slashIndex === -1) return null;
+	return {
+		name: rest.slice(0, slashIndex),
+		version: rest.slice(slashIndex + 1).split("_")[0]
+	};
+}
+function parsePnpmV6Key(key) {
+	if (!key.startsWith("/")) return null;
+	const rest = key.slice(1);
+	let atIdx;
+	if (rest.startsWith("@")) atIdx = rest.indexOf("@", 1);
+	else atIdx = rest.indexOf("@");
+	if (atIdx === -1) return null;
+	return {
+		name: rest.slice(0, atIdx),
+		version: rest.slice(atIdx + 1).split("_")[0].replace(/\(.*\)$/, "")
+	};
+}
+function classifyPnpmResolution(resolution) {
+	if (!resolution) return {};
+	if (resolution.type === "directory" || resolution.directory) return { local: true };
+	if (typeof resolution.tarball === "string") return classifySource(resolution.tarball);
+	if (resolution.type === "git" || typeof resolution.repo === "string") return {
+		source: "git",
+		sourceUrl: resolution.repo ?? void 0
+	};
+	return {};
+}
+function parsePnpmLock(content, lockfileVersion) {
+	const lockMap = /* @__PURE__ */ new Map();
+	const docs = [];
+	yaml.safeLoadAll(content, (doc) => docs.push(doc));
+	const parsedYaml = docs[0];
+	if (!parsedYaml) return lockMap;
+	const lv = lockfileVersion ?? Number(parsedYaml.lockfileVersion ?? "0");
+	const packages = parsedYaml.packages;
+	if (!packages) return lockMap;
+	const parseKey = lv >= 9 ? parsePnpmV9Key : lv >= 6 ? parsePnpmV6Key : parsePnpmV5Key;
+	for (const [key, entry] of Object.entries(packages)) {
+		const keyParsed = parseKey(key);
+		if (!keyParsed) continue;
+		const { name, version: version$1 } = keyParsed;
+		const resolution = entry.resolution;
+		const { local, source, sourceUrl } = classifyPnpmResolution(resolution);
+		if (local) continue;
+		const existing = lockMap.get(name);
+		if (existing && !isHigherVersion(version$1, existing.resolved)) continue;
+		const lockEntry = {
+			resolved: version$1,
+			scopes: ["prod"]
+		};
+		if (source) lockEntry.source = source;
+		if (sourceUrl) lockEntry.sourceUrl = sourceUrl;
+		lockMap.set(name, lockEntry);
+	}
+	return lockMap;
+}
+function parseYarnLock(content, lockfileVersion) {
+	const lockMap = /* @__PURE__ */ new Map();
+	const isBerry = (lockfileVersion ?? 1) >= 2;
+	const parsed = parseSyml(content);
+	for (const [key, entry] of Object.entries(parsed)) {
+		if (key === "__metadata" || !entry) continue;
+		if (isBerry && entry.linkType === "soft") continue;
+		const version$1 = entry.version;
+		if (!version$1) continue;
+		let source;
+		let sourceUrl;
+		if (!isBerry && entry.resolved) {
+			if (entry.resolved.startsWith("file:")) continue;
+			const classified = classifySource(entry.resolved);
+			source = classified.source;
+			sourceUrl = classified.sourceUrl;
+		}
+		const specifiers = key.split(",").map((s) => s.trim().replace(/^"|"$/g, ""));
+		let name = null;
+		for (const spec of specifiers) {
+			name = extractPackageName(spec);
+			if (name) break;
+		}
+		if (!name) continue;
+		const existing = lockMap.get(name);
+		if (existing && !isHigherVersion(version$1, existing.resolved)) continue;
+		const lockEntry = {
+			resolved: version$1,
+			scopes: ["prod"]
+		};
+		if (source) lockEntry.source = source;
+		if (sourceUrl) lockEntry.sourceUrl = sourceUrl;
+		lockMap.set(name, lockEntry);
+	}
+	return lockMap;
+}
+function parseBunLock(content) {
+	const lockMap = /* @__PURE__ */ new Map();
+	const json = content.replace(/,(\s*[}\]])/g, "$1");
+	const packages = JSON.parse(json).packages;
+	if (!packages) return lockMap;
+	for (const [name, value] of Object.entries(packages)) {
+		if (!Array.isArray(value)) continue;
+		const ref = value[0];
+		if (!ref || typeof ref !== "string") continue;
+		const pkgName = extractPackageName(ref);
+		if (!pkgName) continue;
+		const version$1 = ref.slice(pkgName.length + 1);
+		if (!version$1) continue;
+		if (version$1.startsWith("file:") || version$1.startsWith("workspace:")) continue;
+		const existingBun = lockMap.get(name);
+		if (existingBun && !isHigherVersion(version$1, existingBun.resolved)) continue;
+		lockMap.set(name, {
+			resolved: version$1,
+			scopes: ["prod"]
+		});
+	}
+	return lockMap;
+}
+async function parseLockfile(cliType, lockfilePath, lockfileVersion) {
+	if (cliType === "bun" && lockfileVersion === 0) return /* @__PURE__ */ new Map();
+	if (cliType === "vlt") return /* @__PURE__ */ new Map();
+	const content = await fs.promises.readFile(lockfilePath, "utf-8");
+	switch (cliType) {
+		case "npm": return parseNpmLock(content, lockfileVersion);
+		case "pnpm": return parsePnpmLock(content, lockfileVersion);
+		case "yarn": return parseYarnLock(content, lockfileVersion);
+		case "bun": return parseBunLock(content);
+		default: return /* @__PURE__ */ new Map();
+	}
+}
+async function readPackageJson(startDir) {
+	let current = startDir;
+	for (;;) try {
+		const content = await fs.promises.readFile(path.join(current, "package.json"), "utf-8");
+		return JSON.parse(content);
+	} catch {
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function buildDirectMaps(pkgJson) {
+	const directScopes = /* @__PURE__ */ new Map();
+	const directRequested = /* @__PURE__ */ new Map();
+	const add = (deps, scope) => {
+		if (!deps || typeof deps !== "object") return;
+		for (const [name, specifier] of Object.entries(deps)) {
+			if (!directScopes.has(name)) directScopes.set(name, /* @__PURE__ */ new Set());
+			directScopes.get(name).add(scope);
+			if (!directRequested.has(name)) directRequested.set(name, specifier);
+		}
+	};
+	add(pkgJson.dependencies, "prod");
+	add(pkgJson.devDependencies, "dev");
+	add(pkgJson.peerDependencies, "peer");
+	add(pkgJson.optionalDependencies, "optional");
+	return {
+		directScopes,
+		directRequested
+	};
+}
+async function generateProjectManifest({ workPath, nodeVersion, cliType, lockfilePath, lockfileVersion }) {
+	try {
+		const pkgJson = await readPackageJson(workPath);
+		if (!pkgJson) return;
+		const { directScopes, directRequested } = buildDirectMaps(pkgJson);
+		const lockMap = lockfilePath ? await parseLockfile(cliType, lockfilePath, lockfileVersion) : /* @__PURE__ */ new Map();
+		const directDeps = [];
+		const transitiveDeps = [];
+		for (const [name, scopes] of directScopes) {
+			const lock = lockMap.get(name);
+			const dep = {
+				name,
+				type: "direct",
+				scopes: [...scopes].sort(),
+				requested: directRequested.get(name),
+				resolved: lock?.resolved ?? ""
+			};
+			if (lock?.source) dep.source = lock.source;
+			if (lock?.sourceUrl) dep.sourceUrl = lock.sourceUrl;
+			directDeps.push(dep);
+		}
+		for (const [name, lock] of lockMap) {
+			if (directScopes.has(name)) continue;
+			const dep = {
+				name,
+				type: "transitive",
+				scopes: lock.scopes,
+				resolved: lock.resolved
+			};
+			if (lock.source) dep.source = lock.source;
+			if (lock.sourceUrl) dep.sourceUrl = lock.sourceUrl;
+			transitiveDeps.push(dep);
+		}
+		const runtimeVersion = { resolved: String(nodeVersion.major) };
+		const enginesNode = pkgJson.engines?.node;
+		if (enginesNode) {
+			runtimeVersion.requested = enginesNode;
+			runtimeVersion.requestedSource = "package.json";
+		} else for (const filename of [".node-version", ".nvmrc"]) try {
+			const trimmed = (await fs.promises.readFile(path.join(workPath, filename), "utf-8")).trim();
+			if (trimmed) {
+				runtimeVersion.requested = trimmed;
+				runtimeVersion.requestedSource = filename;
+				break;
+			}
+		} catch {}
+		await writeProjectManifest({
+			version: MANIFEST_VERSION,
+			runtime: "node",
+			runtimeVersion,
+			dependencies: [...directDeps.sort((a, b) => a.name.localeCompare(b.name)), ...transitiveDeps.sort((a, b) => a.name.localeCompare(b.name))]
+		}, workPath, "node");
+	} catch (err) {
+		debug(`generateProjectManifest: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+const diagnostics = createDiagnostics("node");
+
 //#endregion
 //#region src/cervel/plugin.ts
 const CJS_SHIM_PREFIX$1 = "\0cjs-shim:";
@@ -1607,6 +1956,17 @@ const build = async (args) => {
 			conditions: isBun ? ["bun"] : void 0,
 			span: buildSpan
 		});
+		try {
+			await generateProjectManifest({
+				workPath: args.workPath,
+				nodeVersion,
+				cliType: downloadResult.cliType,
+				lockfilePath: downloadResult.lockfilePath,
+				lockfileVersion: downloadResult.lockfileVersion
+			});
+		} catch (err) {
+			debug(`Failed to write node manifest: ${err instanceof Error ? err.message : String(err)}`);
+		}
 		const baseDir = args.repoRootPath || args.workPath;
 		const includeResults = await Promise.all(normalizeArray(args.config.includeFiles).map((pattern) => glob(pattern, baseDir)));
 		for (const matched of includeResults) for (const [relPath, entry] of Object.entries(matched)) files[relPath] = entry;
@@ -1709,4 +2069,4 @@ const escapeForRegex = (value) => value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
 const toRegexSource = (value) => escapeForRegex(value).replaceAll("/", "\\/");
 
 //#endregion
-export { build, build$1 as cervelBuild, serve as cervelServe, findEntrypoint, findEntrypointOrThrow, getBuildSummary, introspectApp, nodeFileTrace, prepareCache, srvxOptions, version };
+export { build, build$1 as cervelBuild, serve as cervelServe, diagnostics, findEntrypoint, findEntrypointOrThrow, getBuildSummary, introspectApp, nodeFileTrace, prepareCache, srvxOptions, version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/backends",
-  "version": "0.0.63",
+  "version": "0.1.0",
   "license": "Apache-2.0",
   "main": "./dist/index.mjs",
   "homepage": "https://vercel.com/docs",
@@ -24,6 +24,8 @@
     "dist"
   ],
   "dependencies": {
+    "@yarnpkg/parsers": "^3.0.0",
+    "js-yaml": "^3.13.1",
     "@vercel/nft": "1.5.0",
     "execa": "3.2.0",
     "fs-extra": "11.1.0",
@@ -34,13 +36,14 @@
     "srvx": "0.8.9",
     "tsx": "4.21.0",
     "zod": "3.22.4",
-    "@vercel/build-utils": "13.17.1"
+    "@vercel/build-utils": "13.18.0"
   },
   "peerDependencies": {
     "typescript": "^4.0.0 || ^5.0.0"
   },
   "devDependencies": {
     "@types/express": "5.0.3",
+    "@types/js-yaml": "3.12.1",
     "@types/fs-extra": "11",
     "@types/jest": "27.5.1",
     "@types/node": "20.11.0",