@vercel/hono 0.2.0 → 0.2.1

package/dist/index.js

@@ -32,14 +32,12 @@ var src_exports = {};
 __export(src_exports, {
   build: () => build,
   entrypointCallback: () => entrypointCallback,
-  experimentalBuild: () => build2,
-  experimentalVersion: () => version,
   findEntrypoint: () => findEntrypoint,
   name: () => name,
   require_: () => require_,
   shouldServe: () => shouldServe,
   startDevServer: () => startDevServer,
-  version: () => version2
+  version: () => version
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -83,20 +81,20 @@ var build = async (args) => {
       return entrypointCallback(args);
     }
   });
-  let version3 = void 0;
+  let version2 = void 0;
   try {
     const resolved = require_.resolve(`${frameworkName}/package.json`, {
       paths: [args.workPath]
     });
     const honoVersion = require_(resolved).version;
     if (honoVersion) {
-      version3 = honoVersion;
+      version2 = honoVersion;
     }
   } catch (e) {
   }
   res.output.framework = {
     slug: frameworkName,
-    version: version3
+    version: version2
   };
   return res;
 };
@@ -205,632 +203,9 @@ var findMainPackageEntrypoint = (files) => {
   return null;
 };
 
-// src/experimental/build.ts
-var import_build_utils5 = require("@vercel/build-utils");
-
-// src/experimental/utils.ts
-var import_path2 = require("path");
-var import_build_utils2 = require("@vercel/build-utils");
-async function downloadInstallAndBundle(args) {
-  const { entrypoint, files, workPath, meta, config } = args;
-  await (0, import_build_utils2.download)(files, workPath, meta);
-  const entrypointFsDirname = (0, import_path2.join)(workPath, (0, import_path2.dirname)(entrypoint));
-  const nodeVersion = await (0, import_build_utils2.getNodeVersion)(
-    entrypointFsDirname,
-    void 0,
-    config,
-    meta
-  );
-  const spawnOpts = (0, import_build_utils2.getSpawnOptions)(meta || {}, nodeVersion);
-  const {
-    cliType,
-    lockfileVersion,
-    packageJsonPackageManager,
-    turboSupportsCorepackHome
-  } = await (0, import_build_utils2.scanParentDirs)(entrypointFsDirname, true);
-  spawnOpts.env = (0, import_build_utils2.getEnvForPackageManager)({
-    cliType,
-    lockfileVersion,
-    packageJsonPackageManager,
-    env: spawnOpts.env || {},
-    turboSupportsCorepackHome,
-    projectCreatedAt: config.projectSettings?.createdAt
-  });
-  const installCommand = config.projectSettings?.installCommand;
-  if (typeof installCommand === "string") {
-    if (installCommand.trim()) {
-      console.log(`Running "install" command: \`${installCommand}\`...`);
-      await (0, import_build_utils2.execCommand)(installCommand, {
-        ...spawnOpts,
-        cwd: entrypointFsDirname
-      });
-    } else {
-      console.log(`Skipping "install" command...`);
-    }
-  } else {
-    await (0, import_build_utils2.runNpmInstall)(
-      entrypointFsDirname,
-      [],
-      spawnOpts,
-      meta,
-      config.projectSettings?.createdAt
-    );
-  }
-  return { entrypointFsDirname, nodeVersion, spawnOpts };
-}
-async function maybeExecBuildCommand(args, options) {
-  const projectBuildCommand = args.config.projectSettings?.buildCommand;
-  if (projectBuildCommand) {
-    await (0, import_build_utils2.execCommand)(projectBuildCommand, {
-      ...options.spawnOpts,
-      cwd: args.workPath
-    });
-  } else {
-    const possibleScripts = ["build"];
-    await (0, import_build_utils2.runPackageJsonScript)(
-      options.entrypointFsDirname,
-      possibleScripts,
-      options.spawnOpts,
-      args.config.projectSettings?.createdAt
-    );
-  }
-}
-
-// src/experimental/rolldown.ts
-var import_build_utils3 = require("@vercel/build-utils");
-var import_nft = require("@vercel/nft");
-var import_fs2 = require("fs");
-var import_path3 = require("path");
-var import_rolldown = require("rolldown");
-var rolldown = async (args) => {
-  const baseDir = args.repoRootPath || args.workPath;
-  const entrypointPath = (0, import_path3.join)(args.workPath, args.entrypoint);
-  const files = {};
-  const shouldAddSourcemapSupport = false;
-  const extension = (0, import_path3.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 format = extensionInfo.format;
-  const packageJsonPath = (0, import_path3.join)(args.workPath, "package.json");
-  const external = [];
-  if ((0, import_fs2.existsSync)(packageJsonPath)) {
-    const { mode } = (0, import_fs2.lstatSync)(packageJsonPath);
-    const source = (0, import_fs2.readFileSync)(packageJsonPath);
-    const relPath = (0, import_path3.relative)(baseDir, packageJsonPath);
-    let pkg;
-    try {
-      pkg = JSON.parse(source.toString());
-    } catch (_e) {
-      pkg = {};
-    }
-    if (format === "auto") {
-      if (pkg.type === "module") {
-        format = "esm";
-      } else {
-        format = "cjs";
-      }
-    }
-    for (const dependency of Object.keys(pkg.dependencies || {})) {
-      external.push(dependency);
-    }
-    for (const dependency of Object.keys(pkg.devDependencies || {})) {
-      external.push(dependency);
-    }
-    for (const dependency of Object.keys(pkg.peerDependencies || {})) {
-      external.push(dependency);
-    }
-    for (const dependency of Object.keys(pkg.optionalDependencies || {})) {
-      external.push(dependency);
-    }
-    files[relPath] = new import_build_utils3.FileBlob({ data: source, mode });
-  }
-  const absoluteImportPlugin = {
-    name: "absolute-import-resolver",
-    resolveId(source) {
-      if (external.includes(source)) {
-        return { id: source, external: true };
-      }
-      return null;
-    }
-  };
-  let tsconfigPath = (0, import_path3.join)(baseDir, "tsconfig.json");
-  if (!(0, import_fs2.existsSync)(tsconfigPath)) {
-    tsconfigPath = await (0, import_build_utils3.walkParentDirs)({
-      base: baseDir,
-      start: args.workPath,
-      filename: "tsconfig.json"
-    });
-  }
-  const relativeOutputDir = (0, import_path3.join)(
-    ".vercel",
-    "output",
-    "functions",
-    "index.func"
-  );
-  const outputDir = (0, import_path3.join)(baseDir, relativeOutputDir);
-  let handler = null;
-  await (0, import_rolldown.build)({
-    input: entrypointPath,
-    cwd: baseDir,
-    platform: "node",
-    external: /node_modules/,
-    plugins: [absoluteImportPlugin],
-    tsconfig: tsconfigPath || void 0,
-    output: {
-      dir: outputDir,
-      // FIXME: This is a bit messy, not sure what facadeModuleId even is and the only reason for renaming here
-      // is to preserve the proper extension for mjs/cjs scenario.
-      // There doesn't seem to be another way to do only specify the entrypoint extension.
-      entryFileNames: (info) => {
-        if (info.name === "rolldown_runtime") {
-          return "rolldown_runtime.js";
-        }
-        const facadeModuleId = info.facadeModuleId;
-        if (!facadeModuleId) {
-          throw new Error(`Unable to resolve module for ${info.name}`);
-        }
-        const relPath = (0, import_path3.relative)(baseDir, facadeModuleId);
-        const extension2 = (0, import_path3.extname)(relPath);
-        const extensionMap2 = {
-          ".ts": ".js",
-          ".mts": ".mjs",
-          ".mjs": ".mjs",
-          ".cts": ".cjs",
-          ".cjs": ".cjs",
-          ".js": ".js"
-        };
-        const ext = extensionMap2[extension2] || ".js";
-        const nameWithJS = relPath.slice(0, -extension2.length) + ext;
-        if (info.isEntry) {
-          handler = nameWithJS;
-        }
-        return nameWithJS;
-      },
-      format,
-      preserveModules: true,
-      sourcemap: false
-    }
-  });
-  if (typeof handler !== "string") {
-    throw new Error(`Unable to resolve module for ${args.entrypoint}`);
-  }
-  const nftResult = await (0, import_nft.nodeFileTrace)([(0, import_path3.join)(outputDir, handler)], {
-    // This didn't work as I expected it to, didn't find node_modules
-    // base: outputDir,
-    // processCwd: outputDir,
-    ignore: args.config.excludeFiles
-  });
-  for (const file of nftResult.fileList) {
-    if (file.startsWith(relativeOutputDir)) {
-      continue;
-    }
-    files[file] = new import_build_utils3.FileFsRef({ fsPath: file, mode: 420 });
-  }
-  return {
-    files,
-    shouldAddSourcemapSupport,
-    handler,
-    outputDir
-  };
-};
-
-// src/experimental/find-entrypoint.ts
-var import_build_utils4 = require("@vercel/build-utils");
-var import_node2 = require("@vercel/node");
-var import_module2 = require("module");
-var import_path4 = require("path");
-var import_fs3 = __toESM(require("fs"));
-var REGEX2 = /(?:from|require|import)\s*(?:\(\s*)?["']hono["']\s*(?:\))?/g;
-var validFilenames2 = [
-  "app",
-  "index",
-  "server",
-  "src/app",
-  "src/index",
-  "src/server"
-];
-var require_2 = (0, import_module2.createRequire)(__filename);
-var validExtensions2 = ["js", "cjs", "mjs", "ts", "cts", "mts"];
-var entrypointsForMessage2 = validFilenames2.map((filename) => `- ${filename}.{${validExtensions2.join(",")}}`).join("\n");
-var entrypointCallback2 = async (args) => {
-  const mainPackageEntrypoint = findMainPackageEntrypoint2(args.files);
-  const entrypointGlob = `{${validFilenames2.map((entrypoint) => `${entrypoint}`).join(",")}}.{${validExtensions2.join(",")}}`;
-  const dir = args.config.projectSettings?.outputDirectory?.replace(
-    /^\/+|\/+$/g,
-    ""
-  );
-  if (dir) {
-    const { entrypoint: entrypointFromOutputDir, entrypointsNotMatchingRegex: entrypointsNotMatchingRegex2 } = findEntrypoint2(await (0, import_build_utils4.glob)(entrypointGlob, (0, import_path4.join)(args.workPath, dir)));
-    if (entrypointFromOutputDir) {
-      return (0, import_path4.join)(dir, entrypointFromOutputDir);
-    }
-    if (entrypointsNotMatchingRegex2.length > 0) {
-      throw new Error(
-        `No entrypoint found which imports hono. Found possible ${pluralize2("entrypoint", entrypointsNotMatchingRegex2.length)}: ${entrypointsNotMatchingRegex2.join(", ")}`
-      );
-    }
-    throw new Error(
-      `No entrypoint found in output directory: "${dir}". Searched for: 
-${entrypointsForMessage2}`
-    );
-  }
-  const files = await (0, import_build_utils4.glob)(entrypointGlob, args.workPath);
-  const { entrypoint: entrypointFromRoot, entrypointsNotMatchingRegex } = findEntrypoint2(files);
-  if (entrypointFromRoot) {
-    return entrypointFromRoot;
-  }
-  if (mainPackageEntrypoint) {
-    const entrypointFromPackageJson = await (0, import_build_utils4.glob)(
-      mainPackageEntrypoint,
-      args.workPath
-    );
-    if (entrypointFromPackageJson[mainPackageEntrypoint]) {
-      if (checkMatchesRegex2(entrypointFromPackageJson[mainPackageEntrypoint])) {
-        return mainPackageEntrypoint;
-      }
-    }
-  }
-  if (entrypointsNotMatchingRegex.length > 0) {
-    throw new Error(
-      `No entrypoint found which imports hono. Found possible ${pluralize2("entrypoint", entrypointsNotMatchingRegex.length)}: ${entrypointsNotMatchingRegex.join(", ")}`
-    );
-  }
-  throw new Error(
-    `No entrypoint found. Searched for:
-${entrypointsForMessage2}`
-  );
-};
-function pluralize2(word, count) {
-  return count === 1 ? word : `${word}s`;
-}
-var findEntrypoint2 = (files) => {
-  const allEntrypoints = validFilenames2.flatMap(
-    (filename) => validExtensions2.map((extension) => `${filename}.${extension}`)
-  );
-  const possibleEntrypointsInFiles = allEntrypoints.filter((entrypoint2) => {
-    return files[entrypoint2] !== void 0;
-  });
-  const entrypointsMatchingRegex = possibleEntrypointsInFiles.filter(
-    (entrypoint2) => {
-      const file = files[entrypoint2];
-      return checkMatchesRegex2(file);
-    }
-  );
-  const entrypointsNotMatchingRegex = possibleEntrypointsInFiles.filter(
-    (entrypoint2) => {
-      const file = files[entrypoint2];
-      return !checkMatchesRegex2(file);
-    }
-  );
-  const entrypoint = entrypointsMatchingRegex[0];
-  if (entrypointsMatchingRegex.length > 1) {
-    console.warn(
-      `Multiple entrypoints found: ${entrypointsMatchingRegex.join(", ")}. Using ${entrypoint}.`
-    );
-  }
-  return {
-    entrypoint,
-    entrypointsNotMatchingRegex
-  };
-};
-var checkMatchesRegex2 = (file) => {
-  const content = import_fs3.default.readFileSync(file.fsPath, "utf-8");
-  const matchesContent = content.match(REGEX2);
-  return matchesContent !== null;
-};
-var findMainPackageEntrypoint2 = (files) => {
-  const packageJson = files["package.json"];
-  if (packageJson) {
-    if (packageJson.type === "FileFsRef") {
-      const packageJsonContent = import_fs3.default.readFileSync(packageJson.fsPath, "utf-8");
-      let packageJsonJson;
-      try {
-        packageJsonJson = JSON.parse(packageJsonContent);
-      } catch (_e) {
-        packageJsonJson = {};
-      }
-      if ("main" in packageJsonJson && typeof packageJsonJson.main === "string") {
-        return packageJsonJson.main;
-      }
-    }
-  }
-  return null;
-};
-
-// src/experimental/introspection.ts
-var import_path5 = require("path");
-var import_fs_extra = require("fs-extra");
-var import_fs4 = require("fs");
-var import_promises = require("fs/promises");
-var import_child_process = require("child_process");
-var import_path_to_regexp = require("path-to-regexp");
-var import_zod = require("zod");
-var introspectApp = async (args, options) => {
-  await injectRouteCapture(options);
-  await invokeFunction(args, options);
-  const {
-    routes: routesFromIntrospection,
-    views,
-    staticPaths,
-    viewEngine
-  } = await processIntrospection(options);
-  await cleanup(options);
-  console.log(
-    `Generated introspection.json with ${routesFromIntrospection.length} routes for observability`
-  );
-  return { routes: routesFromIntrospection, views, staticPaths, viewEngine };
-};
-var processIntrospection = async (options) => {
-  const schema = import_zod.z.object({
-    routes: import_zod.z.record(
-      import_zod.z.string(),
-      import_zod.z.object({
-        methods: import_zod.z.array(import_zod.z.string())
-      })
-    ).transform(
-      (value) => Object.entries(value).map(([path, route]) => convertHonoRoute(path, route)).filter(Boolean)
-    ),
-    views: import_zod.z.string().optional(),
-    staticPaths: import_zod.z.array(import_zod.z.string()).optional(),
-    viewEngine: import_zod.z.string().optional()
-  });
-  try {
-    const introspectionPath = (0, import_path5.join)(options.outputDir, "introspection.json");
-    const introspection = (0, import_fs4.readFileSync)(introspectionPath, "utf8");
-    const parsedData = JSON.parse(introspection);
-    console.log("Parsed introspection data:", Object.keys(parsedData));
-    console.log("Routes count:", Object.keys(parsedData.routes || {}).length);
-    return schema.parse(parsedData);
-  } catch (error) {
-    console.log("Schema validation error:", error);
-    console.log(
-      `Unable to extract routes from hono, route level observability will not be available`
-    );
-    return {
-      routes: [],
-      views: void 0,
-      staticPaths: void 0,
-      viewEngine: void 0
-    };
-  }
-};
-var getIntrospectionPath = (options) => {
-  return (0, import_path5.join)(options.outputDir, "introspection.json");
-};
-var cleanup = async (options) => {
-  await (0, import_promises.rm)((0, import_path5.join)(options.outputDir, "node_modules"), {
-    recursive: true,
-    force: true
-  });
-  await (0, import_promises.rm)(getIntrospectionPath(options), { force: true });
-};
-var invokeFunction = async (args, options) => {
-  await new Promise((resolve) => {
-    try {
-      const child = (0, import_child_process.spawn)("node", [(0, import_path5.join)(options.outputDir, options.handler)], {
-        stdio: ["pipe", "pipe", "pipe"],
-        cwd: options.outputDir,
-        env: {
-          ...process.env,
-          ...args.meta?.env || {},
-          ...args.meta?.buildEnv || {}
-        }
-      });
-      setTimeout(() => {
-        child.kill("SIGTERM");
-      }, 5e3);
-      child.on("error", () => {
-        console.log(
-          `Unable to extract routes from hono, route level observability will not be available`
-        );
-        resolve(void 0);
-      });
-      child.on("close", () => {
-        resolve(void 0);
-      });
-    } catch (error) {
-      console.log(
-        `Unable to extract routes from hono, route level observability will not be available`
-      );
-      resolve(void 0);
-    }
-  });
-};
-var injectRouteCapture = async (options) => {
-  const bundlePath = (0, import_path5.join)(options.outputDir, options.handler);
-  const introspectionPath = getIntrospectionPath(options);
-  try {
-    let bundleContent = (0, import_fs4.readFileSync)(bundlePath, "utf8");
-    const routeCaptureCode = `
-// Route capture for introspection using Hono's built-in methods
-import fs from 'fs';
-import path from 'path';
-const routes = {};
-let routesExtracted = false;
-
-// Function to extract routes using Hono's built-in app.routes
-function extractRoutesFromApp(app) {
-  if (!app || !app.routes) {
-    return;
-  }
-  
-  // Use Hono's built-in routes property
-  for (const route of app.routes) {
-    const routePath = route.path;
-    const method = route.method.toUpperCase();
-    
-    if (!routes[routePath]) {
-      routes[routePath] = { methods: [] };
-    }
-    if (!routes[routePath].methods.includes(method)) {
-      routes[routePath].methods.push(method);
-    }
-  }
-}
-
-// Handle app.all() routes - they should include all HTTP methods
-const processAllRoutes = () => {
-  for (const [path, routeData] of Object.entries(routes)) {
-    if (routeData.methods.includes('ALL')) {
-      routeData.methods = [
-        'GET',
-        'POST',
-        'PUT',
-        'DELETE',
-        'PATCH',
-        'OPTIONS',
-        'HEAD',
-      ];
-    }
-  }
-};
-
-const extractRoutes = () => {
-  if (routesExtracted) {
-    return;
-  }
-  routesExtracted = true;
-
-  // Extract routes from all Hono instances
-  if (typeof app !== 'undefined') {
-    extractRoutesFromApp(app);
-  }
-  
-  // Also check for other common variable names
-  const commonNames = ['api', 'router', 'server', 'hono', 'honoApp'];
-  for (const name of commonNames) {
-    if (typeof globalThis[name] !== 'undefined') {
-      extractRoutesFromApp(globalThis[name]);
-    }
-  }
-
-  processAllRoutes();
-
-  // Ensure directory exists
-  const dir = path.dirname('${introspectionPath}');
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-
-  fs.writeFileSync('${introspectionPath}', JSON.stringify({
-    routes,
-    views: undefined,
-    staticPaths: undefined,
-    viewEngine: undefined
-  }, null, 2));
-};
-
-process.on('exit', () => {
-  extractRoutes();
-});
-
-process.on('SIGINT', () => {
-  extractRoutes();
-  process.exit(0);
-});
-
-process.on('SIGTERM', () => {
-  extractRoutes();
-  process.exit(0);
-});
-
-`;
-    const importEndIndex = bundleContent.indexOf("//#region index.js");
-    if (importEndIndex !== -1) {
-      bundleContent = bundleContent.slice(0, importEndIndex) + routeCaptureCode + bundleContent.slice(importEndIndex);
-    } else {
-      bundleContent = routeCaptureCode + bundleContent;
-    }
-    await (0, import_fs_extra.outputFile)(bundlePath, bundleContent);
-    console.log("Injected route capture into bundled JavaScript");
-  } catch (error) {
-    console.log("Failed to inject route capture:", error);
-    throw error;
-  }
-};
-var convertHonoRoute = (route, routeData) => {
-  try {
-    const { regexp } = (0, import_path_to_regexp.pathToRegexp)(route);
-    const dest = route;
-    const src = regexp.source;
-    return {
-      src,
-      dest,
-      methods: routeData.methods
-    };
-  } catch (error) {
-    console.log(`Skipping route with invalid path: ${route}`);
-    const escapedRoute = route.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return {
-      src: `^${escapedRoute}$`,
-      dest: route,
-      methods: routeData.methods
-    };
-  }
-};
-
-// src/experimental/build.ts
-var version = 2;
-var build2 = async (args) => {
-  console.log(`Using experimental hono build`);
-  const downloadResult = await downloadInstallAndBundle(args);
-  await maybeExecBuildCommand(args, downloadResult);
-  args.entrypoint = await entrypointCallback2(args);
-  const rolldownResult = await rolldown(args);
-  const { routes } = await introspectApp(args, rolldownResult);
-  const lambda = new import_build_utils5.Lambda({
-    runtime: downloadResult.nodeVersion.runtime,
-    ...rolldownResult
-  });
-  const output = { index: lambda };
-  const usedPaths = /* @__PURE__ */ new Set();
-  for (const route of routes) {
-    if (route.dest) {
-      if (route.dest === "/") {
-        continue;
-      }
-      const normalizedPath = route.dest.replace(/\/$/, "");
-      if (!usedPaths.has(normalizedPath)) {
-        output[normalizedPath] = lambda;
-        usedPaths.add(normalizedPath);
-      }
-    }
-  }
-  const normalizedRoutes = routes.map((route) => {
-    if (route.dest && route.dest !== "/") {
-      return {
-        ...route,
-        dest: route.dest.replace(/\/$/, "")
-      };
-    }
-    return route;
-  });
-  const mainRoutes = [
-    {
-      handle: "filesystem"
-    },
-    ...normalizedRoutes,
-    {
-      src: "/(.*)",
-      dest: "/"
-    }
-  ];
-  return {
-    routes: mainRoutes,
-    output
-  };
-};
-
 // src/index.ts
-var import_node3 = require("@vercel/node");
-var version2 = 3;
+var import_node2 = require("@vercel/node");
+var version = 3;
 var name = "hono";
 var shouldServe = async (opts) => {
   const requestPath = opts.requestPath.replace(/\/$/, "");
@@ -842,7 +217,7 @@ var shouldServe = async (opts) => {
 var startDevServer = async (opts) => {
   const entrypoint = await entrypointCallback(opts);
   process.env.EXPERIMENTAL_NODE_TYPESCRIPT_ERRORS = "1";
-  return (0, import_node3.startDevServer)({
+  return (0, import_node2.startDevServer)({
     ...opts,
     entrypoint,
     publicDir: "public"
@@ -852,8 +227,6 @@ var startDevServer = async (opts) => {
 0 && (module.exports = {
   build,
   entrypointCallback,
-  experimentalBuild,
-  experimentalVersion,
   findEntrypoint,
   name,
   require_,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/hono",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "homepage": "https://vercel.com/docs",