@hono/vite-build 1.10.1 → 1.11.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @hono/vite-build
 
+## 1.11.0
+
+### Minor Changes
+
+- [#340](https://github.com/honojs/vite-plugins/pull/340) [`1f2b2fc308fe39b3bf940b948199f5fe1c184d65`](https://github.com/honojs/vite-plugins/commit/1f2b2fc308fe39b3bf940b948199f5fe1c184d65) Thanks [@josiahwiebe](https://github.com/josiahwiebe)! - feat: configure multiple function output for Vercel
+
 ## 1.10.1
 
 ### Patch Changes

package/README.md

@@ -10,6 +10,7 @@ Here are the modules included:
 - `@hono/vite-build/bun`
 - `@hono/vite-build/node`
 - `@hono/vite-build/netlify-functions`
+- `@hono/vite-build/vercel`
 
 ## Usage
 
@@ -125,6 +126,42 @@ export const defaultOptions = {
 
 This plugin generates `_routes.json` automatically. The automatic generation can be overridden by creating a `public/_routes.json`. See [Create a `_routes.json` file](https://developers.cloudflare.com/pages/functions/routing/#create-a-_routesjson-file) on Cloudflare Docs for more details.
 
+### Vercel
+
+By default, the Vercel adapter emits a single function named `__hono` and a catch-all route.
+
+To emit multiple functions, add the Vercel adapter multiple times in `plugins`.
+
+```ts
+import { defineConfig } from 'vite'
+import build from '@hono/vite-build/vercel'
+
+export default defineConfig({
+  plugins: [
+    build({
+      entry: './src/server.ts',
+      vercel: {
+        name: 'api',
+        routes: [{ src: '^/api(?:/.*)?$' }],
+      },
+    }),
+    build({
+      entry: './src/auth.ts',
+      vercel: {
+        name: 'auth',
+        routes: [{ src: '^/auth(?:/.*)?$' }],
+        function: {
+          maxDuration: 30,
+        },
+      },
+    }),
+  ],
+})
+```
+
+If `vercel.routes` is omitted, the adapter generates `^/<function-name>(?:/.*)?$`.
+If `vercel.name` is omitted, the adapter uses `__hono`.
+
 ## Example project
 
 `src/index.tsx`:

package/dist/adapter/vercel/index.d.ts

@@ -3,10 +3,18 @@ import { BuildOptions } from '../../base.js';
 import { VercelBuildConfigV3, VercelNodejsServerlessFunctionConfig } from './types.js';
 import '../../entry/index.js';
 
+type VercelSourceRoute = Extract<NonNullable<VercelBuildConfigV3['routes']>[number], {
+    src: string;
+}>;
+type VercelRouteConfig = Array<Omit<VercelSourceRoute, 'dest'> & {
+    dest?: string;
+}>;
 type VercelBuildOptions = {
     vercel?: {
         config?: VercelBuildConfigV3;
         function?: Partial<VercelNodejsServerlessFunctionConfig>;
+        name?: string;
+        routes?: VercelRouteConfig;
     };
 } & Omit<BuildOptions, 'output' | 'outputDir'>;
 declare const vercelBuildPlugin: (pluginOptions?: VercelBuildOptions) => Plugin;

package/dist/adapter/vercel/index.js

@@ -1,9 +1,20 @@
-import { existsSync, mkdirSync } from "node:fs";
+import { builtinModules } from "module";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { cp, writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import buildPlugin from "../../base.js";
+import { defaultOptions } from "../../base.js";
+import { getEntryContent } from "../../entry/index.js";
 const BUNDLE_NAME = "index.js";
-const FUNCTION_NAME = "__hono";
+const DEFAULT_FUNCTION_NAME = "__hono";
+const VIRTUAL_ENTRY_PREFIX = "virtual:build-entry-module-vercel-";
+const functionEntryHooks = {
+  entryContentAfterHooks: [
+    // eslint-disable-next-line quotes
+    () => "import { handle } from '@hono/node-server/vercel'"
+  ],
+  entryContentDefaultExportHook: (appName) => `export default handle(${appName})`
+};
+const configWriteQueues = /* @__PURE__ */ new Map();
 const writeJSON = (path, data) => {
   const dir = resolve(path, "..");
   if (!existsSync(dir)) {
@@ -11,6 +22,27 @@ const writeJSON = (path, data) => {
   }
   return writeFile(path, JSON.stringify(data));
 };
+const readJSON = (path) => {
+  if (!existsSync(path)) {
+    return;
+  }
+  return JSON.parse(readFileSync(path, "utf-8"));
+};
+const enqueueConfigWrite = async (key, writeTask) => {
+  const previousTask = configWriteQueues.get(key);
+  if (previousTask) {
+    await previousTask;
+  }
+  const nextTask = writeTask();
+  configWriteQueues.set(key, nextTask);
+  try {
+    await nextTask;
+  } finally {
+    if (configWriteQueues.get(key) === nextTask) {
+      configWriteQueues.delete(key);
+    }
+  }
+};
 const getRuntimeVersion = () => {
   try {
     const systemNodeVersion = process.versions.node.split(".")[0];
@@ -19,64 +51,160 @@ const getRuntimeVersion = () => {
     return "nodejs22.x";
   }
 };
+const escapeRouteSegment = (value) => {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+const getDefaultRoutePattern = (functionName) => {
+  return `^/${escapeRouteSegment(functionName)}(?:/.*)?$`;
+};
+const appendRouteIfMissing = (target, seen, route) => {
+  const key = JSON.stringify(route);
+  if (seen.has(key)) {
+    return;
+  }
+  seen.add(key);
+  target.push(route);
+};
+const getFunctionConfig = (config, functionConfig) => {
+  return {
+    ...functionConfig,
+    runtime: getRuntimeVersion(),
+    launcherType: "Nodejs",
+    handler: BUNDLE_NAME,
+    shouldAddHelpers: Boolean(functionConfig?.shouldAddHelpers),
+    shouldAddSourcemapSupport: Boolean(config.build.sourcemap),
+    supportsResponseStreaming: true
+  };
+};
+const getRoutesForFunction = (functionName, configuredRoutes) => {
+  if (configuredRoutes && configuredRoutes.length > 0) {
+    return configuredRoutes;
+  }
+  if (functionName === DEFAULT_FUNCTION_NAME) {
+    return [{ src: "/(.*)", dest: `/${DEFAULT_FUNCTION_NAME}` }];
+  }
+  return [{ src: getDefaultRoutePattern(functionName), dest: `/${functionName}` }];
+};
+const mergeVercelConfig = async (configPath, routesToAdd, configOverride, functionName) => {
+  const existingConfig = readJSON(configPath);
+  const mergedRoutes = [];
+  const seenRoutes = /* @__PURE__ */ new Set();
+  for (const route of existingConfig?.routes ?? []) {
+    appendRouteIfMissing(mergedRoutes, seenRoutes, route);
+  }
+  for (const route of configOverride?.routes ?? []) {
+    appendRouteIfMissing(mergedRoutes, seenRoutes, route);
+  }
+  appendRouteIfMissing(mergedRoutes, seenRoutes, { handle: "filesystem" });
+  for (const route of routesToAdd) {
+    appendRouteIfMissing(mergedRoutes, seenRoutes, {
+      ...route,
+      dest: route.dest ?? `/${functionName}`
+    });
+  }
+  const buildConfig = {
+    ...existingConfig,
+    ...configOverride,
+    version: 3,
+    routes: mergedRoutes
+  };
+  await writeJSON(configPath, buildConfig);
+};
+const copyStaticFiles = async (publicDirPath, outputDir) => {
+  if (!existsSync(publicDirPath)) {
+    return;
+  }
+  try {
+    await cp(publicDirPath, resolve(outputDir, "static"), {
+      recursive: true,
+      force: true
+    });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+};
 const vercelBuildPlugin = (pluginOptions) => {
   let config;
+  const functionName = pluginOptions?.vercel?.name ?? DEFAULT_FUNCTION_NAME;
+  if (!functionName) {
+    throw new Error("`vercel.name` is required and cannot be empty.");
+  }
+  const virtualEntryId = `${VIRTUAL_ENTRY_PREFIX}${functionName}`;
+  const resolvedVirtualEntryId = `\0${virtualEntryId}`;
   return {
-    ...buildPlugin({
-      ssrTarget: "node",
-      output: `functions/${FUNCTION_NAME}.func/${BUNDLE_NAME}`,
-      outputDir: ".vercel/output",
-      ...{
-        entryContentAfterHooks: [
-          // eslint-disable-next-line quotes
-          () => "import { handle } from '@hono/node-server/vercel'"
-        ],
-        entryContentDefaultExportHook: (appName) => `export default handle(${appName})`
-      },
-      ...pluginOptions
-    }),
+    name: "@hono/vite-build/vercel",
+    apply: pluginOptions?.apply ?? defaultOptions.apply,
+    resolveId(id) {
+      if (id === virtualEntryId) {
+        return resolvedVirtualEntryId;
+      }
+    },
+    async load(id) {
+      if (id !== resolvedVirtualEntryId) {
+        return;
+      }
+      const entry = pluginOptions?.entry ?? defaultOptions.entry;
+      return await getEntryContent({
+        entry: Array.isArray(entry) ? entry : [entry],
+        entryContentBeforeHooks: pluginOptions?.entryContentBeforeHooks,
+        entryContentAfterHooks: pluginOptions?.entryContentAfterHooks ?? functionEntryHooks.entryContentAfterHooks,
+        entryContentDefaultExportHook: pluginOptions?.entryContentDefaultExportHook ?? functionEntryHooks.entryContentDefaultExportHook,
+        staticPaths: pluginOptions?.staticPaths,
+        preset: pluginOptions?.preset
+      });
+    },
     configResolved: (resolvedConfig) => {
       config = resolvedConfig;
     },
-    writeBundle: async () => {
-      const outputDir = resolve(config.root, config.build.outDir);
-      const functionDir = resolve(outputDir, "functions", `${FUNCTION_NAME}.func`);
-      const buildConfig = {
-        ...pluginOptions?.vercel?.config,
-        version: 3,
-        routes: [
-          ...pluginOptions?.vercel?.config?.routes ?? [],
-          {
-            handle: "filesystem"
-          },
-          {
-            src: "/(.*)",
-            dest: `/${FUNCTION_NAME}`
+    config: async () => {
+      return {
+        ssr: {
+          external: pluginOptions?.external ?? defaultOptions.external,
+          noExternal: true,
+          target: "node"
+        },
+        build: {
+          outDir: ".vercel/output",
+          emptyOutDir: pluginOptions?.emptyOutDir ?? defaultOptions.emptyOutDir,
+          minify: pluginOptions?.minify ?? defaultOptions.minify,
+          ssr: true,
+          rollupOptions: {
+            external: [...builtinModules, /^node:/],
+            input: {
+              [functionName]: virtualEntryId
+            },
+            output: {
+              entryFileNames: `functions/[name].func/${BUNDLE_NAME}`
+            }
           }
-        ]
-      };
-      const functionConfig = {
-        ...pluginOptions?.vercel?.function,
-        runtime: getRuntimeVersion(),
-        launcherType: "Nodejs",
-        handler: BUNDLE_NAME,
-        shouldAddHelpers: Boolean(pluginOptions?.vercel?.function?.shouldAddHelpers),
-        shouldAddSourcemapSupport: Boolean(config.build.sourcemap),
-        supportsResponseStreaming: true
+        }
       };
+    },
+    writeBundle: async () => {
+      const outputDir = resolve(config.root, config.build.outDir);
+      const functionDir = resolve(outputDir, "functions", `${functionName}.func`);
+      const configPath = resolve(outputDir, "config.json");
       const publicDirPath = resolve(config.root, config.publicDir);
+      const routesToAdd = getRoutesForFunction(functionName, pluginOptions?.vercel?.routes);
+      const functionConfig = getFunctionConfig(config, pluginOptions?.vercel?.function);
+      await copyStaticFiles(publicDirPath, outputDir);
       await Promise.all([
-        // Copy static files to the .vercel/output/static directory
-        ...existsSync(publicDirPath) ? [cp(publicDirPath, resolve(outputDir, "static"), { recursive: true })] : [],
-        // Write the all necessary config files
-        writeJSON(resolve(outputDir, "config.json"), buildConfig),
         writeJSON(resolve(functionDir, ".vc-config.json"), functionConfig),
         writeJSON(resolve(functionDir, "package.json"), {
           type: "module"
         })
       ]);
-    },
-    name: "@hono/vite-build/vercel"
+      await enqueueConfigWrite(configPath, async () => {
+        await mergeVercelConfig(
+          configPath,
+          routesToAdd,
+          pluginOptions?.vercel?.config,
+          functionName
+        );
+      });
+    }
   };
 };
 var vercel_default = vercelBuildPlugin;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hono/vite-build",
   "description": "Vite plugin to build your Hono app",
-  "version": "1.10.1",
+  "version": "1.11.0",
   "types": "dist/index.d.ts",
   "module": "dist/index.js",
   "type": "module",