@vercel/rust 0.0.0-canary.0

package/dist/index.js

@@ -0,0 +1,428 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  build: () => build,
+  prepareCache: () => prepareCache,
+  shouldServe: () => shouldServe,
+  startDevServer: () => startDevServer2,
+  version: () => version
+});
+module.exports = __toCommonJS(src_exports);
+var import_node_path4 = __toESM(require("path"));
+var import_build_utils6 = require("@vercel/build-utils");
+var import_execa4 = __toESM(require("execa"));
+
+// src/lib/rust-toolchain.ts
+var import_build_utils = require("@vercel/build-utils");
+var import_execa = __toESM(require("execa"));
+async function downloadRustToolchain() {
+  try {
+    await (0, import_execa.default)(
+      `curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y`,
+      [],
+      { shell: true, stdio: "inherit" }
+    );
+  } catch (err) {
+    let message = "Unknown Error";
+    if (err instanceof Error) {
+      message = err.message;
+    }
+    throw new Error(`Installing Rust Toolchain via rustup failed: ${message}`);
+  }
+}
+var installRustToolchain = async () => {
+  try {
+    await (0, import_execa.default)(`rustup -V`, [], { shell: true, stdio: "ignore" });
+    (0, import_build_utils.debug)("Rust Toolchain is already installed, skipping download");
+  } catch (err) {
+    await downloadRustToolchain();
+  }
+};
+
+// src/lib/cargo.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var import_toml = __toESM(require("@iarna/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
+  );
+  return JSON.parse(cargoMetaData);
+}
+async function findCargoWorkspace(config) {
+  const { stdout: projectDescriptionStr } = await (0, import_execa2.default)(
+    "cargo",
+    ["locate-project"],
+    config
+  );
+  const projectDescription = JSON.parse(projectDescriptionStr);
+  return {
+    toml: await import_toml.default.parse.stream(import_node_fs.default.createReadStream(projectDescription.root)),
+    root: projectDescription.root
+  };
+}
+async function findCargoBuildConfiguration(workspace) {
+  const configPath = import_node_path.default.join(
+    import_node_path.default.dirname(workspace.root),
+    ".cargo/config.toml"
+  );
+  if (!import_node_fs.default.existsSync(configPath)) {
+    return null;
+  }
+  const config = await import_toml.default.parse.stream(import_node_fs.default.createReadStream(configPath));
+  return config;
+}
+function findBinaryName(workspace, entryPath) {
+  const { bin } = workspace.toml;
+  if (bin) {
+    const relativePath = import_node_path.default.relative(import_node_path.default.dirname(workspace.root), entryPath);
+    const entry = bin.find((binEntry) => binEntry.path === relativePath);
+    if (entry?.name) {
+      return entry.name;
+    }
+  }
+  return import_node_path.default.basename(entryPath, ".rs").replace("[", "_").replace("]", "_");
+}
+
+// src/lib/utils.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var import_build_utils2 = require("@vercel/build-utils");
+function getExecutableName(binName) {
+  return process.platform === "win32" ? `${binName}.exe` : binName;
+}
+function assertEnv(name) {
+  if (!process.env[name]) {
+    throw new Error(`Missing ENV variable process.env.${name}`);
+  }
+  return process.env[name];
+}
+async function runUserScripts(dir) {
+  const buildScriptPath = import_node_path2.default.join(dir, "build.sh");
+  const buildScriptExists = import_node_fs2.default.existsSync(buildScriptPath);
+  if (buildScriptExists) {
+    (0, import_build_utils2.debug)("Running `build.sh`");
+    await (0, import_build_utils2.runShellScript)(buildScriptPath);
+  }
+}
+async function gatherExtraFiles(globMatcher, workPath) {
+  if (!globMatcher)
+    return {};
+  (0, import_build_utils2.debug)(
+    `Gathering extra files for glob \`${JSON.stringify(
+      globMatcher
+    )}\` in ${workPath}`
+  );
+  if (Array.isArray(globMatcher)) {
+    const allMatches = await Promise.all(
+      globMatcher.map((pattern) => (0, import_build_utils2.glob)(pattern, workPath))
+    );
+    return allMatches.reduce((acc, matches) => ({ ...acc, ...matches }), {});
+  }
+  return (0, import_build_utils2.glob)(globMatcher, workPath);
+}
+
+// src/lib/start-dev-server.ts
+var import_child_process = require("child_process");
+var import_events = require("events");
+var import_build_utils5 = require("@vercel/build-utils");
+
+// src/lib/dev-build.ts
+var import_node_path3 = __toESM(require("path"));
+var import_execa3 = __toESM(require("execa"));
+var import_build_utils3 = require("@vercel/build-utils");
+async function buildExecutableForDev(workPath, entrypoint) {
+  (0, import_build_utils3.debug)(`Building executable for development: ${entrypoint}`);
+  const HOME = process.platform === "win32" ? assertEnv("USERPROFILE") : assertEnv("HOME");
+  const PATH = assertEnv("PATH");
+  const rustEnv = {
+    PATH: `${import_node_path3.default.join(HOME, ".cargo/bin")}${import_node_path3.default.delimiter}${PATH}`,
+    RUSTFLAGS: [process.env.RUSTFLAGS].filter(Boolean).join(" ")
+  };
+  const entryPath = import_node_path3.default.join(workPath, entrypoint);
+  const cargoWorkspace = await findCargoWorkspace({
+    env: rustEnv,
+    cwd: import_node_path3.default.dirname(entryPath)
+  });
+  const binaryName = findBinaryName(cargoWorkspace, entryPath);
+  (0, import_build_utils3.debug)(`Building binary "${binaryName}" in debug mode for dev server`);
+  try {
+    await (0, import_execa3.default)(
+      "cargo",
+      [
+        "build",
+        "--bin",
+        binaryName,
+        "--message-format=json-diagnostic-rendered-ansi"
+      ],
+      {
+        cwd: workPath,
+        env: rustEnv,
+        stdio: "pipe"
+      }
+    );
+  } catch (err) {
+    (0, import_build_utils3.debug)(`Cargo build failed for ${binaryName}`);
+    throw new Error(`Failed to build Rust binary for development: ${err}`);
+  }
+  const { target_directory: targetDirectory } = await getCargoMetadata({
+    cwd: workPath,
+    env: rustEnv
+  });
+  const executablePath = import_node_path3.default.join(
+    targetDirectory,
+    "debug",
+    getExecutableName(binaryName)
+  );
+  (0, import_build_utils3.debug)(`Built executable at: ${executablePath}`);
+  return executablePath;
+}
+
+// src/lib/dev-server.ts
+var import_build_utils4 = require("@vercel/build-utils");
+function createDevServerEnv(baseEnv, meta = {}) {
+  const devEnv = {
+    // Base environment
+    ...Object.fromEntries(
+      Object.entries(baseEnv).filter(([, value]) => value !== void 0)
+    ),
+    // Development-specific variables
+    VERCEL_DEV: "1",
+    RUST_LOG: process.env.RUST_LOG || "info",
+    // Runtime environment from meta
+    ...meta.env || {}
+  };
+  Object.keys(devEnv).forEach((key) => {
+    if (devEnv[key] === void 0) {
+      delete devEnv[key];
+    }
+  });
+  (0, import_build_utils4.debug)(`Dev server environment: ${Object.keys(devEnv).join(", ")}`);
+  return devEnv;
+}
+
+// src/lib/start-dev-server.ts
+var startDevServer = async (opts) => {
+  const { entrypoint, workPath, meta = {} } = opts;
+  try {
+    await installRustToolchain();
+    const executablePath = await buildExecutableForDev(workPath, entrypoint);
+    (0, import_build_utils5.debug)(`Starting Rust dev server: ${executablePath}`);
+    const devEnv = createDevServerEnv(process.env, meta);
+    const child = (0, import_child_process.spawn)(executablePath, [], {
+      cwd: workPath,
+      env: devEnv,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (!child.pid) {
+      throw new Error("Failed to start dev server process");
+    }
+    (0, import_build_utils5.debug)(`Dev server process started with PID: ${child.pid}`);
+    let buffer = "";
+    let portEmitted = false;
+    child.stdout?.on("data", (data) => {
+      const output = data.toString();
+      buffer += output;
+      if (!portEmitted && buffer.includes("Dev server listening:")) {
+        const portMatch = buffer.match(/Dev server listening: (\d+)/);
+        if (portMatch) {
+          const port = parseInt(portMatch[1], 10);
+          (0, import_build_utils5.debug)(
+            `Rust dev server detected port ${port}, emitting message event`
+          );
+          child.emit("message", { port }, null);
+          portEmitted = true;
+        }
+        buffer = "";
+      }
+      console.log(output);
+    });
+    child.stderr?.on("data", (data) => {
+      console.error(data.toString());
+    });
+    child.on("error", (err) => {
+      (0, import_build_utils5.debug)(`Dev server error: ${err}`);
+    });
+    child.on("exit", (code, signal) => {
+      (0, import_build_utils5.debug)(`Dev server exited with code ${code}, signal ${signal}`);
+    });
+    const onMessage = (0, import_events.once)(child, "message");
+    const onExit = (0, import_events.once)(child, "close");
+    const result = await Promise.race([
+      onMessage.then((args) => {
+        const [messageData] = args;
+        return { state: "message", value: messageData };
+      }),
+      onExit.then((args) => {
+        const [code, signal] = args;
+        return { state: "exit", value: [code, signal] };
+      })
+    ]);
+    if (result.state === "message") {
+      const { port } = result.value;
+      (0, import_build_utils5.debug)(`Rust dev server ready on port ${port}`);
+      if (!child.pid) {
+        throw new Error("Child process has no PID");
+      }
+      const shutdown = async () => {
+        try {
+          process.kill(child.pid, "SIGTERM");
+        } catch (err) {
+          (0, import_build_utils5.debug)(`Error terminating Rust dev server: ${err}`);
+        }
+      };
+      return { port, pid: child.pid, shutdown };
+    } else {
+      const [exitCode, signal] = result.value;
+      const reason = signal ? `"${signal}" signal` : `exit code ${exitCode}`;
+      throw new Error(`Rust dev server failed with ${reason}`);
+    }
+  } catch (error) {
+    (0, import_build_utils5.debug)(`Failed to start dev server: ${error}`);
+    return null;
+  }
+};
+
+// 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 crossCompilationEnabled = !isVercelBuild && !meta?.isDev;
+  await installRustToolchain();
+  (0, import_build_utils6.debug)("Creating file system");
+  const downloadedFiles = await (0, import_build_utils6.download)(files, workPath, meta);
+  const entryPath = downloadedFiles[entrypoint].fsPath;
+  const HOME = process.platform === "win32" ? assertEnv("USERPROFILE") : assertEnv("HOME");
+  const PATH = assertEnv("PATH");
+  const rustEnv = {
+    PATH: `${import_node_path4.default.join(HOME, ".cargo/bin")}${import_node_path4.default.delimiter}${PATH}`,
+    RUSTFLAGS: [process.env.RUSTFLAGS].filter(Boolean).join(" ")
+  };
+  const cargoWorkspace = await findCargoWorkspace({
+    env: rustEnv,
+    cwd: import_node_path4.default.dirname(entryPath)
+  });
+  const binaryName = findBinaryName(cargoWorkspace, entryPath);
+  const cargoBuildConfiguration = await findCargoBuildConfiguration(cargoWorkspace);
+  const buildVariant = BUILDER_DEBUG || meta?.isDev ? "debug" : "release";
+  const buildTarget = cargoBuildConfiguration?.build.target ?? "";
+  await runUserScripts(workPath);
+  const extraFiles = await gatherExtraFiles(config.includeFiles, workPath);
+  (0, import_build_utils6.debug)(`Running \`cargo build\` for \`${binaryName}\``);
+  try {
+    const args = crossCompilationEnabled ? [
+      "zigbuild",
+      "--target",
+      "x86_64-unknown-linux-gnu",
+      "--bin",
+      binaryName
+    ].concat(BUILDER_DEBUG ? ["--verbose"] : ["--quiet"], ["--release"]) : ["build", "--bin", binaryName].concat(
+      BUILDER_DEBUG ? ["--verbose"] : ["--quiet"],
+      meta?.isDev ? [] : ["--release"]
+    );
+    await (0, import_execa4.default)("cargo", args, {
+      cwd: workPath,
+      env: rustEnv
+    });
+  } catch (err) {
+    (0, import_build_utils6.debug)(`Running \`cargo build\` for \`${binaryName}\` failed`);
+    throw err;
+  }
+  (0, import_build_utils6.debug)(`Building \`${binaryName}\` for \`${process.platform}\` completed`);
+  let { target_directory: targetDirectory } = await getCargoMetadata({
+    cwd: workPath,
+    env: rustEnv
+  });
+  if (crossCompilationEnabled) {
+    targetDirectory = import_node_path4.default.join(targetDirectory, "x86_64-unknown-linux-gnu");
+  }
+  targetDirectory = import_node_path4.default.join(targetDirectory, buildTarget);
+  const bin = import_node_path4.default.join(
+    targetDirectory,
+    buildVariant,
+    getExecutableName(binaryName)
+  );
+  const lambdaOptions = await (0, import_build_utils6.getLambdaOptionsFromFunction)({
+    sourceFile: entrypoint,
+    config
+  });
+  const handler = getExecutableName("executable");
+  const executableFile = new import_build_utils6.FileFsRef({ mode: 493, fsPath: bin });
+  const lambda = new import_build_utils6.Lambda({
+    files: {
+      ...extraFiles,
+      [handler]: executableFile
+    },
+    handler,
+    runtime: "executable",
+    supportsResponseStreaming: true,
+    ...lambdaOptions
+  });
+  lambda.zipBuffer = await lambda.createZip();
+  (0, import_build_utils6.debug)(`generating function for \`${entrypoint}\``);
+  return {
+    output: lambda
+  };
+}
+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);
+    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) {
+        delete cacheFiles[f];
+      }
+    }
+    return cacheFiles;
+  },
+  startDevServer,
+  shouldServe: async (options) => {
+    (0, import_build_utils6.debug)(`Requested ${options.requestPath} for ${options.entrypoint}`);
+    return Promise.resolve(options.requestPath === options.entrypoint);
+  }
+};
+var { version, build, prepareCache, startDevServer: startDevServer2, shouldServe } = runtime;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  prepareCache,
+  shouldServe,
+  startDevServer,
+  version
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@vercel/rust",
+  "version": "0.0.0-canary.0",
+  "license": "Apache-2.0",
+  "main": "./dist/index",
+  "homepage": "https://vercel.com/docs/runtimes#official-runtimes/rust",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vercel/vercel.git",
+    "directory": "packages/rust"
+  },
+  "scripts": {
+    "build": "node ../../utils/build-builder.mjs",
+    "test": "jest --reporters=default --reporters=jest-junit --env node --verbose --runInBand --bail",
+    "test-e2e": "pnpm test",
+    "type-check": "tsc --noEmit"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "lodash": "^4.17.21",
+    "execa": "5"
+  },
+  "devDependencies": {
+    "typescript": "^4.9.4",
+    "@types/jest": "^29.4.0",
+    "@types/lodash": "^4.14.191",
+    "@types/ms": "^0.7.31",
+    "@types/node": "^18.11.18",
+    "@types/node-fetch": "^2.6.2",
+    "@vercel/build-utils": "13.1.0",
+    "@vercel/routing-utils": "5.2.2",
+    "@vercel/style-guide": "^4.0.2",
+    "eslint": "^8.35.0",
+    "husky": "^8.0.3",
+    "jest": "^29.5.0",
+    "ms": "^2.1.3",
+    "node-fetch": "2.6.0",
+    "prettier": "^2.8.4",
+    "rimraf": "^4.1.1",
+    "ts-jest": "^29.0.5"
+  }
+}