@vercel/rust 1.1.1 → 1.3.0

package/dist/index.js

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   build: () => build,
+  diagnostics: () => diagnostics,
   prepareCache: () => prepareCache,
   shouldServe: () => shouldServe,
   startDevServer: () => startDevServer2,
@@ -38,7 +39,7 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_node_path4 = __toESM(require("path"));
-var import_build_utils6 = require("@vercel/build-utils");
+var import_build_utils7 = require("@vercel/build-utils");
 var import_execa4 = __toESM(require("execa"));
 
 // src/lib/rust-toolchain.ts
@@ -74,12 +75,11 @@ var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"));
 var import_smol_toml = require("smol-toml");
 var import_execa2 = __toESM(require("execa"));
-async function getCargoMetadata(options) {
-  const { stdout: cargoMetaData } = await (0, import_execa2.default)(
-    "cargo",
-    ["metadata", "--format-version", "1"],
-    options
-  );
+async function getCargoMetadata(options, filterPlatform) {
+  const args = ["metadata", "--format-version", "1"];
+  if (filterPlatform)
+    args.push("--filter-platform", filterPlatform);
+  const { stdout: cargoMetaData } = await (0, import_execa2.default)("cargo", args, options);
   return JSON.parse(cargoMetaData);
 }
 async function findCargoWorkspace(config) {
@@ -316,11 +316,111 @@ var startDevServer = async (opts) => {
   }
 };
 
+// src/diagnostics.ts
+var import_build_utils6 = require("@vercel/build-utils");
+function parseSource(source) {
+  if (!source)
+    return { include: false };
+  if (source.startsWith("path+file:"))
+    return { include: false };
+  if (source.startsWith("registry+https://github.com/rust-lang/crates.io-index")) {
+    return {
+      include: true,
+      source: "registry",
+      sourceUrl: "https://crates.io"
+    };
+  }
+  if (source.startsWith("registry+")) {
+    const url = source.slice("registry+".length).split(/[?#]/)[0];
+    return { include: true, source: "registry", sourceUrl: url };
+  }
+  if (source.startsWith("git+")) {
+    const url = source.slice("git+".length).split(/[?#]/)[0];
+    return { include: true, source: "git", sourceUrl: url };
+  }
+  return { include: true };
+}
+async function generateProjectManifest({
+  workPath,
+  cargoMetadata,
+  framework,
+  serviceType,
+  runtimeVersion
+}) {
+  try {
+    const { packages, resolve } = cargoMetadata;
+    const pkgById = new Map(packages.map((p) => [p.id, p]));
+    const rootId = resolve.root;
+    const rootNode = resolve.nodes.find((n) => n.id === rootId);
+    if (!rootNode)
+      return;
+    const rootPkg = pkgById.get(rootId);
+    const directMap = /* @__PURE__ */ new Map();
+    for (const dep of rootNode.deps) {
+      const scopes = dep.dep_kinds.map(
+        (dk) => dk.kind === "dev" ? "dev" : dk.kind === "build" ? "build" : "prod"
+      );
+      const depPkg = pkgById.get(dep.pkg);
+      const req = rootPkg?.dependencies.find((d) => d.name === depPkg?.name)?.req;
+      directMap.set(dep.pkg, {
+        scopes: [...new Set(scopes)].sort(),
+        requested: req
+      });
+    }
+    const directEntries = [];
+    const transitiveEntries = [];
+    for (const node of resolve.nodes) {
+      if (node.id === rootId)
+        continue;
+      const pkg = pkgById.get(node.id);
+      if (!pkg)
+        continue;
+      const sourceInfo = parseSource(pkg.source);
+      if (!sourceInfo.include)
+        continue;
+      const directInfo = directMap.get(node.id);
+      const entry = {
+        name: pkg.name,
+        type: directInfo ? "direct" : "transitive",
+        // Transitive scope would require full graph traversal to trace which
+        // root-level scope pulled this in. 'prod' is a safe default — accurate
+        // scope propagation for transitives is left to future work.
+        scopes: directInfo ? directInfo.scopes : ["prod"],
+        resolved: pkg.version
+      };
+      if (directInfo?.requested)
+        entry.requested = directInfo.requested;
+      if (sourceInfo.source)
+        entry.source = sourceInfo.source;
+      if (sourceInfo.sourceUrl)
+        entry.sourceUrl = sourceInfo.sourceUrl;
+      if (directInfo)
+        directEntries.push(entry);
+      else
+        transitiveEntries.push(entry);
+    }
+    const manifest = {
+      version: import_build_utils6.MANIFEST_VERSION,
+      runtime: "rust",
+      ...framework ? { framework } : {},
+      ...serviceType ? { serviceType } : {},
+      ...runtimeVersion ? { runtimeVersion } : {},
+      dependencies: [
+        ...directEntries.sort((a, b) => a.name.localeCompare(b.name)),
+        ...transitiveEntries.sort((a, b) => a.name.localeCompare(b.name))
+      ]
+    };
+    await (0, import_build_utils6.writeProjectManifest)(manifest, workPath, "rust");
+  } catch {
+  }
+}
+var diagnostics = (0, import_build_utils6.createDiagnostics)("rust");
+
 // src/index.ts
 async function buildHandler(options) {
   const BUILDER_DEBUG = Boolean(process.env.VERCEL_BUILDER_DEBUG ?? false);
   const isVercelBuild = Boolean(process.env.VERCEL_BUILD_IMAGE ?? false);
-  const { files, entrypoint, workPath, config, meta } = options;
+  const { files, entrypoint, workPath, config, meta, service } = options;
   const crossCompilationEnabled = !isVercelBuild && !meta?.isDev;
   if (crossCompilationEnabled && process.platform === "win32") {
     throw new Error(
@@ -328,8 +428,8 @@ async function buildHandler(options) {
     );
   }
   await installRustToolchain();
-  (0, import_build_utils6.debug)("Creating file system");
-  const downloadedFiles = await (0, import_build_utils6.download)(files, workPath, meta);
+  (0, import_build_utils7.debug)("Creating file system");
+  const downloadedFiles = await (0, import_build_utils7.download)(files, workPath, meta);
   const entryPath = downloadedFiles[entrypoint].fsPath;
   const HOME = process.platform === "win32" ? assertEnv("USERPROFILE") : assertEnv("HOME");
   const PATH = assertEnv("PATH");
@@ -345,25 +445,23 @@ async function buildHandler(options) {
   const cargoBuildConfiguration = await findCargoBuildConfiguration(cargoWorkspace);
   await runUserScripts(workPath);
   const extraFiles = await gatherExtraFiles(config.includeFiles, workPath);
-  const lambdaOptions = await (0, import_build_utils6.getLambdaOptionsFromFunction)({
+  const lambdaOptions = await (0, import_build_utils7.getLambdaOptionsFromFunction)({
     sourceFile: entrypoint,
     config
   });
   const architecture = lambdaOptions?.architecture || "x86_64";
   const buildVariant = meta?.isDev ? "debug" : "release";
   const buildTarget = cargoBuildConfiguration?.build.target ?? "";
+  const targetTriple = architecture === "x86_64" ? "x86_64-unknown-linux-gnu" : "aarch64-unknown-linux-gnu";
   try {
-    const args = crossCompilationEnabled ? [
-      "zigbuild",
-      "--target",
-      architecture === "x86_64" ? "x86_64-unknown-linux-gnu" : "aarch64-unknown-linux-gnu",
-      "--bin",
-      binaryName
-    ].concat(BUILDER_DEBUG ? ["--verbose"] : ["--quiet"], ["--release"]) : ["build", "--bin", binaryName].concat(
+    const args = crossCompilationEnabled ? ["zigbuild", "--target", targetTriple, "--bin", binaryName].concat(
+      BUILDER_DEBUG ? ["--verbose"] : ["--quiet"],
+      ["--release"]
+    ) : ["build", "--bin", binaryName].concat(
       BUILDER_DEBUG ? ["--verbose"] : ["--quiet"],
       meta?.isDev ? [] : ["--release"]
     );
-    (0, import_build_utils6.debug)(
+    (0, import_build_utils7.debug)(
       `Running \`cargo build\` for \`${binaryName}\` (\`${architecture}\`)`
     );
     await (0, import_execa4.default)("cargo", args, {
@@ -371,21 +469,19 @@ async function buildHandler(options) {
       env: rustEnv
     });
   } catch (err) {
-    (0, import_build_utils6.debug)(`Running \`cargo build\` for \`${binaryName}\` failed`);
+    (0, import_build_utils7.debug)(`Running \`cargo build\` for \`${binaryName}\` failed`);
     throw err;
   }
-  (0, import_build_utils6.debug)(
+  (0, import_build_utils7.debug)(
     `Building \`${binaryName}\` for \`${process.platform}\` (\`${architecture}\`) completed`
   );
-  let { target_directory: targetDirectory } = await getCargoMetadata({
-    cwd: workPath,
-    env: rustEnv
-  });
+  const cargoMetadata = await getCargoMetadata(
+    { cwd: workPath, env: rustEnv },
+    targetTriple
+  );
+  let { target_directory: targetDirectory } = cargoMetadata;
   if (crossCompilationEnabled) {
-    targetDirectory = import_node_path4.default.join(
-      targetDirectory,
-      architecture === "x86_64" ? "x86_64-unknown-linux-gnu" : "aarch64-unknown-linux-gnu"
-    );
+    targetDirectory = import_node_path4.default.join(targetDirectory, targetTriple);
   }
   targetDirectory = import_node_path4.default.join(targetDirectory, buildTarget);
   const bin = import_node_path4.default.join(
@@ -394,8 +490,8 @@ async function buildHandler(options) {
     getExecutableName(binaryName)
   );
   const handler = getExecutableName("executable");
-  const executableFile = new import_build_utils6.FileFsRef({ mode: 493, fsPath: bin });
-  const lambda = new import_build_utils6.Lambda({
+  const executableFile = new import_build_utils7.FileFsRef({ mode: 493, fsPath: bin });
+  const lambda = new import_build_utils7.Lambda({
     ...lambdaOptions,
     files: {
       ...extraFiles,
@@ -408,7 +504,31 @@ async function buildHandler(options) {
     runtimeLanguage: "rust"
   });
   lambda.zipBuffer = await lambda.createZip();
-  (0, import_build_utils6.debug)(`generating function for \`${entrypoint}\``);
+  let resolvedRustVersion;
+  try {
+    const { stdout: rustcOut } = await (0, import_execa4.default)("rustc", ["--version"], {
+      env: rustEnv,
+      cwd: workPath
+    });
+    resolvedRustVersion = rustcOut.split(" ")[1];
+  } catch {
+    (0, import_build_utils7.debug)("Failed to determine rustc version");
+  }
+  const rootPkg = cargoMetadata.packages.find(
+    (p) => p.id === cargoMetadata.resolve.root
+  );
+  const requestedRustVersion = rootPkg?.rust_version || void 0;
+  await generateProjectManifest({
+    workPath,
+    cargoMetadata,
+    framework: config?.framework ?? void 0,
+    serviceType: service ? (0, import_build_utils7.getReportedServiceType)(service) : void 0,
+    runtimeVersion: resolvedRustVersion ? {
+      ...requestedRustVersion ? { requested: requestedRustVersion } : {},
+      resolved: resolvedRustVersion
+    } : void 0
+  });
+  (0, import_build_utils7.debug)(`generating function for \`${entrypoint}\``);
   return {
     output: lambda
   };
@@ -417,8 +537,8 @@ var runtime = {
   version: 3,
   build: buildHandler,
   prepareCache: async ({ workPath }) => {
-    (0, import_build_utils6.debug)(`Caching \`${workPath}\``);
-    const cacheFiles = await (0, import_build_utils6.glob)("target/**", workPath);
+    (0, import_build_utils7.debug)(`Caching \`${workPath}\``);
+    const cacheFiles = await (0, import_build_utils7.glob)("target/**", workPath);
     for (const f of Object.keys(cacheFiles)) {
       const accept = /(?:^|\/)target\/release\/\.fingerprint\//.test(f) || /(?:^|\/)target\/release\/build\//.test(f) || /(?:^|\/)target\/release\/deps\//.test(f) || /(?:^|\/)target\/debug\/\.fingerprint\//.test(f) || /(?:^|\/)target\/debug\/build\//.test(f) || /(?:^|\/)target\/debug\/deps\//.test(f);
       if (!accept) {
@@ -429,10 +549,10 @@ var runtime = {
   },
   startDevServer,
   shouldServe: async (options) => {
-    (0, import_build_utils6.debug)(`Requested ${options.requestPath} for ${options.entrypoint}`);
+    (0, import_build_utils7.debug)(`Requested ${options.requestPath} for ${options.entrypoint}`);
     const entrypointWithoutExt = options.entrypoint.replace(/\.rs$/, "");
     const matches = options.requestPath === options.entrypoint || options.requestPath === entrypointWithoutExt;
-    (0, import_build_utils6.debug)(
+    (0, import_build_utils7.debug)(
       `shouldServe: ${matches} (entrypointWithoutExt: ${entrypointWithoutExt})`
     );
     return Promise.resolve(matches);
@@ -442,6 +562,7 @@ var { version, build, prepareCache, startDevServer: startDevServer2, shouldServe
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,
+  diagnostics,
   prepareCache,
   shouldServe,
   startDevServer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/rust",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/rust",
@@ -17,25 +17,24 @@
     "execa": "5"
   },
   "devDependencies": {
-    "@types/jest": "^29.4.0",
     "@types/ms": "^0.7.31",
     "@types/node": "20.11.0",
     "@vercel/style-guide": "^4.0.2",
     "eslint": "^8.35.0",
     "husky": "^8.0.3",
-    "jest": "^29.5.0",
     "ms": "^2.1.3",
     "prettier": "^2.8.4",
     "rimraf": "^4.1.1",
-    "ts-jest": "^29.0.5",
-    "typescript": "^4.9.4",
-    "@vercel/build-utils": "13.17.0",
-    "@vercel/routing-utils": "6.1.1"
+    "vitest": "2.0.3",
+    "@vercel/build-utils": "13.26.2",
+    "@vercel/routing-utils": "6.2.0"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",
-    "test": "jest --reporters=default --reporters=jest-junit --env node --verbose --runInBand --bail",
+    "test": "vitest run --config ../../vitest.config.mts",
     "test-e2e": "pnpm test",
-    "type-check": "tsc --noEmit"
+    "type-check": "tsc --noEmit",
+    "vitest-run": "vitest -c ../../vitest.config.mts",
+    "vitest-e2e": "glob --absolute 'test/**/*.test.js' 'test/**/*.test.ts' 'tests/**/*.test.js' 'tests/**/*.test.ts'"
   }
 }