@vercel/backends 0.0.27 → 0.0.28

package/dist/rolldown/index.mjs

@@ -0,0 +1,301 @@
+import { builtinModules } from "node:module";
+import { FileBlob, FileFsRef, Span, isBackendFramework } from "@vercel/build-utils";
+import { dirname, extname, join, relative } from "node:path";
+import { existsSync } from "node:fs";
+import { lstat, readFile } from "node:fs/promises";
+import { build } from "rolldown";
+import { nodeFileTrace } from "@vercel/nft";
+import { isNativeError } from "node:util/types";
+import { transform } from "oxc-transform";
+import { exports } from "resolve.exports";
+
+//#region src/rolldown/resolve-format.ts
+const resolveEntrypointAndFormat = async (args) => {
+	const extension = extname(args.entrypoint);
+	const extensionMap = {
+		".ts": {
+			format: "auto",
+			extension: "js"
+		},
+		".mts": {
+			format: "esm",
+			extension: "mjs"
+		},
+		".cts": {
+			format: "cjs",
+			extension: "cjs"
+		},
+		".cjs": {
+			format: "cjs",
+			extension: "cjs"
+		},
+		".js": {
+			format: "auto",
+			extension: "js"
+		},
+		".mjs": {
+			format: "esm",
+			extension: "mjs"
+		}
+	};
+	const extensionInfo = extensionMap[extension] || extensionMap[".js"];
+	let resolvedFormat = extensionInfo.format === "auto" ? void 0 : extensionInfo.format;
+	const packageJsonPath = join(args.workPath, "package.json");
+	let pkg = {};
+	if (existsSync(packageJsonPath)) {
+		const source = await readFile(packageJsonPath, "utf8");
+		try {
+			pkg = JSON.parse(source.toString());
+		} catch (_e) {
+			pkg = {};
+		}
+		if (extensionInfo.format === "auto") if (pkg.type === "module") resolvedFormat = "esm";
+		else resolvedFormat = "cjs";
+	}
+	if (!resolvedFormat) throw new Error(`Unable to resolve format for ${args.entrypoint}`);
+	return {
+		format: resolvedFormat,
+		extension: resolvedFormat === "esm" ? "mjs" : "cjs"
+	};
+};
+
+//#endregion
+//#region src/rolldown/nft.ts
+const nft = async (args) => {
+	const nftSpan = args.span.child("vc.builder.backends.nft");
+	const runNft = async () => {
+		const nftResult = await nodeFileTrace(Array.from(args.localBuildFiles), {
+			base: args.repoRootPath,
+			processCwd: args.workPath,
+			ts: true,
+			mixedModules: true,
+			ignore: args.ignoreNodeModules ? (path) => path.includes("node_modules") : void 0,
+			async readFile(fsPath) {
+				try {
+					let source = await readFile(fsPath);
+					if (isTypeScriptFile(fsPath)) source = (await transform(fsPath, source.toString())).code;
+					return source;
+				} catch (error) {
+					if (isNativeError(error) && "code" in error && (error.code === "ENOENT" || error.code === "EISDIR")) return null;
+					throw error;
+				}
+			}
+		});
+		for (const file of nftResult.fileList) {
+			const absolutePath = join(args.repoRootPath, file);
+			const stats = await lstat(absolutePath);
+			const outputPath = file;
+			if (args.localBuildFiles.has(join(args.repoRootPath, outputPath))) continue;
+			if (stats.isSymbolicLink() || stats.isFile()) if (args.ignoreNodeModules) {
+				const content = await readFile(absolutePath, "utf-8");
+				args.files[outputPath] = new FileBlob({
+					data: content,
+					mode: stats.mode
+				});
+			} else args.files[outputPath] = new FileFsRef({
+				fsPath: absolutePath,
+				mode: stats.mode
+			});
+		}
+	};
+	await nftSpan.trace(runNft);
+};
+const isTypeScriptFile = (fsPath) => {
+	return fsPath.endsWith(".ts") || fsPath.endsWith(".tsx") || fsPath.endsWith(".mts") || fsPath.endsWith(".cts");
+};
+
+//#endregion
+//#region src/rolldown/index.ts
+const PLUGIN_NAME = "vercel:backends";
+const CJS_SHIM_PREFIX = "\0cjs-shim:";
+const rolldown = async (args) => {
+	const files = {};
+	const { format, extension } = await resolveEntrypointAndFormat(args);
+	const localBuildFiles = /* @__PURE__ */ new Set();
+	let handler = null;
+	const packageJsonCache = /* @__PURE__ */ new Map();
+	const shimMeta = /* @__PURE__ */ new Map();
+	const framework = {
+		slug: "",
+		version: ""
+	};
+	const getPackageJson = async (pkgPath) => {
+		if (packageJsonCache.has(pkgPath)) return packageJsonCache.get(pkgPath);
+		try {
+			const contents = await readFile(pkgPath, "utf-8");
+			const parsed = JSON.parse(contents);
+			packageJsonCache.set(pkgPath, parsed);
+			return parsed;
+		} catch {
+			packageJsonCache.set(pkgPath, null);
+			return null;
+		}
+	};
+	const isCommonJS = async (bareImport, resolvedPath, resolvedInfo) => {
+		const ext = extname(resolvedPath);
+		if (ext === ".cjs") return true;
+		if (ext === ".mjs") return false;
+		if (ext === ".js" || ext === ".ts") {
+			const pkgJsonPath = resolvedInfo.packageJsonPath;
+			if (!pkgJsonPath) return true;
+			const pkgJson = await getPackageJson(pkgJsonPath);
+			if (!pkgJson) return true;
+			const pkgDir = dirname(pkgJsonPath);
+			const relativePath = resolvedPath.slice(pkgDir.length + 1).replace(/\\/g, "/");
+			const pkgName = pkgJson.name || "";
+			const subpath = bareImport.startsWith(pkgName) ? `.${bareImport.slice(pkgName.length)}` || "." : ".";
+			try {
+				if (exports(pkgJson, subpath, {
+					require: false,
+					conditions: ["node", "import"]
+				})?.some((p) => p === relativePath || p === `./${relativePath}`)) return false;
+				if (exports(pkgJson, subpath, {
+					require: true,
+					conditions: ["node", "require"]
+				})?.some((p) => p === relativePath || p === `./${relativePath}`)) return true;
+			} catch {}
+			if (pkgJson.module) return false;
+			return pkgJson.type !== "module";
+		}
+		return true;
+	};
+	const isBareImport = (id) => {
+		return !id.startsWith(".") && !id.startsWith("/") && !/^[a-z][a-z0-9+.-]*:/i.test(id);
+	};
+	const isNodeModule = (resolved) => {
+		return resolved?.id?.includes("node_modules") ?? false;
+	};
+	const isNodeBuiltin = (id) => {
+		const normalizedId = id.includes(":") ? id.split(":")[1] : id;
+		return builtinModules.includes(normalizedId);
+	};
+	const isLocalImport = (id) => {
+		return !id.startsWith("node:") && !id.includes("node_modules");
+	};
+	const plugin = () => {
+		return {
+			name: PLUGIN_NAME,
+			resolveId: {
+				order: "pre",
+				async handler(id, importer, rOpts) {
+					if (id.startsWith(CJS_SHIM_PREFIX)) return {
+						id,
+						external: false
+					};
+					const resolved = await this.resolve(id, importer, rOpts);
+					if (isNodeBuiltin(id)) return {
+						id: id.startsWith("node:") ? id : `node:${id}`,
+						external: true
+					};
+					if (resolved?.id && isLocalImport(resolved.id)) localBuildFiles.add(resolved.id);
+					else if (!resolved) localBuildFiles.add(join(args.workPath, id));
+					if (importer?.startsWith(CJS_SHIM_PREFIX) && isBareImport(id)) return {
+						id,
+						external: true
+					};
+					if (importer && isBareImport(id) && isNodeModule(resolved)) {
+						if (isBackendFramework(id) && resolved?.packageJsonPath) try {
+							const pkg = await readFile(resolved.packageJsonPath, "utf8");
+							const pkgJson = JSON.parse(pkg);
+							framework.slug = pkgJson.name;
+							framework.version = pkgJson.version;
+						} catch {}
+						if (resolved ? await isCommonJS(id, resolved.id, resolved) : false) {
+							const importerPkgJsonPath = (await this.resolve(importer))?.packageJsonPath;
+							if (importerPkgJsonPath) {
+								const importerPkgDir = relative(args.repoRootPath, dirname(importerPkgJsonPath));
+								const shimId$1 = `${CJS_SHIM_PREFIX}${importerPkgDir.replace(/\//g, "_")}_${id.replace(/\//g, "_")}`;
+								shimMeta.set(shimId$1, {
+									pkgDir: importerPkgDir,
+									pkgName: id
+								});
+								return {
+									id: shimId$1,
+									external: false
+								};
+							}
+							const shimId = `${CJS_SHIM_PREFIX}${id.replace(/\//g, "_")}`;
+							shimMeta.set(shimId, {
+								pkgDir: "",
+								pkgName: id
+							});
+							return {
+								id: shimId,
+								external: false
+							};
+						}
+						return {
+							id,
+							external: true
+						};
+					}
+					if (importer && isBareImport(id)) return resolved;
+					if (resolved && !isNodeModule(resolved)) return resolved;
+					return resolved;
+				}
+			},
+			load: { async handler(id) {
+				if (id.startsWith(CJS_SHIM_PREFIX)) {
+					const meta = shimMeta.get(id);
+					if (!meta) return { code: `module.exports = require('${id.slice(10)}');` };
+					const { pkgDir, pkgName } = meta;
+					return { code: `
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const requireFromContext = createRequire(join(dirname(fileURLToPath(import.meta.url)), '${pkgDir ? join("..", pkgDir, "package.json") : "../package.json"}'));
+module.exports = requireFromContext('${pkgName}');
+`.trim() };
+				}
+				return null;
+			} }
+		};
+	};
+	const runRolldown = () => build({
+		input: args.entrypoint,
+		write: false,
+		cwd: args.workPath,
+		platform: "node",
+		transform: { define: format === "esm" ? {
+			__dirname: "import.meta.dirname",
+			__filename: "import.meta.filename"
+		} : void 0 },
+		tsconfig: true,
+		plugins: [plugin()],
+		output: {
+			cleanDir: true,
+			format,
+			entryFileNames: `[name].${extension}`,
+			preserveModules: true,
+			preserveModulesRoot: args.repoRootPath,
+			sourcemap: false
+		}
+	});
+	const rolldownSpan = args.span?.child("vc.builder.backends.rolldown");
+	const out = await rolldownSpan?.trace(runRolldown) || await runRolldown();
+	for (const file of out.output) if (file.type === "chunk") {
+		if (file.isEntry) handler = file.fileName;
+		files[file.fileName] = new FileBlob({
+			data: file.code,
+			mode: 420
+		});
+	}
+	await nft({
+		...args,
+		localBuildFiles,
+		files,
+		span: rolldownSpan ?? new Span({ name: "vc.builder.backends.nft" }),
+		ignoreNodeModules: true
+	});
+	if (!handler) throw new Error(`Unable to resolve build handler for entrypoint: ${args.entrypoint}`);
+	return {
+		files,
+		handler,
+		framework,
+		localBuildFiles
+	};
+};
+
+//#endregion
+export { rolldown };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/backends",
-  "version": "0.0.27",
+  "version": "0.0.28",
   "license": "Apache-2.0",
   "main": "./dist/index.mjs",
   "homepage": "https://vercel.com/docs",
@@ -11,11 +11,9 @@
   "exports": {
     ".": "./dist/index.mjs",
     "./package.json": "./package.json",
-    "./introspection/loaders/cjs": "./dist/introspection/loaders/cjs.cjs",
-    "./introspection/loaders/esm": "./dist/introspection/loaders/esm.mjs",
-    "./introspection/loaders/hooks": "./dist/introspection/loaders/hooks.mjs",
-    "./introspection/loaders/rolldown-esm": "./dist/introspection/loaders/rolldown-esm.mjs",
-    "./introspection/loaders/rolldown-hooks": "./dist/introspection/loaders/rolldown-hooks.mjs"
+    "./rolldown/esm": "./dist/rolldown/esm.mjs",
+    "./rolldown/hooks": "./dist/rolldown/hooks.mjs",
+    "./rolldown/cjs-hooks": "./dist/rolldown/cjs-hooks.cjs"
   },
   "repository": {
     "type": "git",
@@ -36,7 +34,7 @@
     "srvx": "0.8.9",
     "tsx": "4.21.0",
     "zod": "3.22.4",
-    "@vercel/build-utils": "13.3.0"
+    "@vercel/build-utils": "13.3.1"
   },
   "peerDependencies": {
     "typescript": "^4.0.0 || ^5.0.0"