@hono/vite-build 1.10.1 → 1.11.1

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/bun/{index.d.ts → index.d.mts}

@@ -1,11 +1,11 @@
-import { Plugin } from 'vite';
-import { BuildOptions } from '../../base.js';
-import '../../entry/index.js';
+import { BuildOptions } from "../../base.mjs";
+import { Plugin } from "vite";
 
+//#region src/adapter/bun/index.d.ts
 type BunBuildOptions = {
-    staticRoot?: string | undefined;
+  staticRoot?: string | undefined;
 } & BuildOptions;
 declare const defaultOptions: BunBuildOptions;
 declare const bunBuildPlugin: (pluginOptions?: BunBuildOptions) => Plugin;
-
-export { BunBuildOptions, bunBuildPlugin as default, defaultOptions };
+//#endregion
+export { BunBuildOptions, bunBuildPlugin as default, defaultOptions };

package/dist/adapter/bun/index.mjs

@@ -0,0 +1,47 @@
+import buildPlugin, { defaultOptions as defaultOptions$1 } from "../../base.mjs";
+import { serveStaticHook } from "../../entry/serve-static.mjs";
+//#region src/adapter/bun/index.ts
+const defaultOptions = {
+	...defaultOptions$1,
+	entryContentAfterHooks: [() => `
+      let websocket
+      for (const [, app] of Object.entries(modules)) {
+        if (
+          app &&
+          typeof app === 'object' &&
+          'websocket' in app &&
+          app.websocket !== undefined
+        ) {
+          if (websocket !== undefined) {
+            throw new Error(
+              \`Handler "websocket" is defined in multiple entry files. Please ensure each handler is defined only once.\`
+            )
+          }
+          websocket = app.websocket
+        }
+      }
+    `],
+	entryContentDefaultExportHook: (appName) => `export default websocket !== undefined ? { fetch: ${appName}.fetch.bind(${appName}), websocket } : ${appName}`
+};
+const bunBuildPlugin = (pluginOptions) => {
+	return {
+		...buildPlugin({
+			ssrTarget: "node",
+			entryContentBeforeHooks: [async (appName, options) => {
+				let code = "import { serveStatic } from 'hono/bun'\n";
+				code += serveStaticHook(appName, {
+					filePaths: options?.staticPaths,
+					root: pluginOptions?.staticRoot
+				});
+				return code;
+			}],
+			...pluginOptions,
+			external: ["bun", ...pluginOptions?.external ?? []],
+			entryContentAfterHooks: pluginOptions?.entryContentAfterHooks ?? defaultOptions.entryContentAfterHooks,
+			entryContentDefaultExportHook: pluginOptions?.entryContentDefaultExportHook ?? defaultOptions.entryContentDefaultExportHook
+		}),
+		name: "@hono/vite-build/bun"
+	};
+};
+//#endregion
+export { bunBuildPlugin as default, defaultOptions };

package/dist/adapter/cloudflare-pages/{index.d.ts → index.d.mts}

@@ -1,8 +1,8 @@
-import { Plugin } from 'vite';
-import { BuildOptions } from '../../base.js';
-import '../../entry/index.js';
+import { BuildOptions } from "../../base.mjs";
+import { Plugin } from "vite";
 
+//#region src/adapter/cloudflare-pages/index.d.ts
 type CloudflarePagesBuildOptions = BuildOptions;
 declare const cloudflarePagesBuildPlugin: (pluginOptions?: CloudflarePagesBuildOptions) => Plugin;
-
-export { CloudflarePagesBuildOptions, cloudflarePagesBuildPlugin as default };
+//#endregion
+export { CloudflarePagesBuildOptions, cloudflarePagesBuildPlugin as default };

package/dist/adapter/cloudflare-pages/index.mjs

@@ -0,0 +1,41 @@
+import buildPlugin, { defaultOptions } from "../../base.mjs";
+import { resolve } from "node:path";
+import { readdir, writeFile } from "node:fs/promises";
+//#region src/adapter/cloudflare-pages/index.ts
+const WORKER_JS_NAME = "_worker.js";
+const ROUTES_JSON_NAME = "_routes.json";
+const cloudflarePagesBuildPlugin = (pluginOptions) => {
+	let config;
+	const staticPaths = [];
+	return {
+		...buildPlugin({
+			...pluginOptions,
+			output: WORKER_JS_NAME
+		}),
+		configResolved: async (resolvedConfig) => {
+			config = resolvedConfig;
+		},
+		writeBundle: async () => {
+			const paths = await readdir(resolve(config.root, config.build.outDir), { withFileTypes: true });
+			if (paths.some((p) => p.name === ROUTES_JSON_NAME)) return;
+			else {
+				paths.forEach((p) => {
+					if (p.isDirectory()) staticPaths.push(`/${p.name}/*`);
+					else {
+						if (p.name === WORKER_JS_NAME) return;
+						staticPaths.push(`/${p.name}`);
+					}
+				});
+				const staticRoutes = {
+					version: 1,
+					include: ["/*"],
+					exclude: staticPaths
+				};
+				await writeFile(resolve(config.root, pluginOptions?.outputDir ?? defaultOptions.outputDir, "_routes.json"), JSON.stringify(staticRoutes));
+			}
+		},
+		name: "@hono/vite-build/cloudflare-pages"
+	};
+};
+//#endregion
+export { cloudflarePagesBuildPlugin as default };

package/dist/adapter/cloudflare-workers/{index.d.ts → index.d.mts}

@@ -1,9 +1,10 @@
-import { Plugin } from 'vite';
-import { BuildOptions } from '../../base.js';
-import { GetEntryContentOptions } from '../../entry/index.js';
+import { GetEntryContentOptions } from "../../entry/index.mjs";
+import { BuildOptions } from "../../base.mjs";
+import { Plugin } from "vite";
 
+//#region src/adapter/cloudflare-workers/index.d.ts
 type CloudflareWorkersBuildOptions = BuildOptions & Pick<GetEntryContentOptions, 'entryContentAfterHooks' | 'entryContentDefaultExportHook'>;
 declare const defaultOptions: CloudflareWorkersBuildOptions;
 declare const cloudflareWorkersBuildPlugin: (pluginOptions?: CloudflareWorkersBuildOptions) => Plugin;
-
-export { CloudflareWorkersBuildOptions, cloudflareWorkersBuildPlugin as default, defaultOptions };
+//#endregion
+export { CloudflareWorkersBuildOptions, cloudflareWorkersBuildPlugin as default, defaultOptions };

package/dist/adapter/cloudflare-workers/index.mjs

@@ -0,0 +1,33 @@
+import buildPlugin, { defaultOptions as defaultOptions$1 } from "../../base.mjs";
+//#region src/adapter/cloudflare-workers/index.ts
+const defaultOptions = {
+	...defaultOptions$1,
+	entryContentAfterHooks: [() => `
+      const merged = {}
+      const definedHandlers = new Set()
+      for (const [file, app] of Object.entries(modules)) {
+        for (const [key, handler] of Object.entries(app)) {
+          if (key !== 'fetch') {
+            if (definedHandlers.has(key)) {
+              throw new Error(\`Handler "\${key}" is defined in multiple entry files. Please ensure each handler (except fetch) is defined only once.\`);
+            }
+            definedHandlers.add(key)
+            merged[key] = handler
+          }
+        }
+      }
+    `],
+	entryContentDefaultExportHook: (appName) => `export default { ...merged, fetch: ${appName}.fetch }`
+};
+const cloudflareWorkersBuildPlugin = (pluginOptions) => {
+	return {
+		...buildPlugin({
+			...pluginOptions,
+			entryContentAfterHooks: pluginOptions?.entryContentAfterHooks ?? defaultOptions.entryContentAfterHooks,
+			entryContentDefaultExportHook: pluginOptions?.entryContentDefaultExportHook ?? defaultOptions.entryContentDefaultExportHook
+		}),
+		name: "@hono/vite-build/cloudflare-workers"
+	};
+};
+//#endregion
+export { cloudflareWorkersBuildPlugin as default, defaultOptions };

package/dist/adapter/deno/index.d.mts

@@ -0,0 +1,10 @@
+import { BuildOptions } from "../../base.mjs";
+import { Plugin } from "vite";
+
+//#region src/adapter/deno/index.d.ts
+type DenoBuildOptions = {
+  staticRoot?: string | undefined;
+} & BuildOptions;
+declare const denoBuildPlugin: (pluginOptions?: DenoBuildOptions) => Plugin;
+//#endregion
+export { DenoBuildOptions, denoBuildPlugin as default };

package/dist/adapter/deno/index.mjs

@@ -0,0 +1,21 @@
+import buildPlugin from "../../base.mjs";
+import { serveStaticHook } from "../../entry/serve-static.mjs";
+//#region src/adapter/deno/index.ts
+const denoBuildPlugin = (pluginOptions) => {
+	return {
+		...buildPlugin({
+			entryContentBeforeHooks: [async (appName, options) => {
+				let code = `import { serveStatic } from '${pluginOptions?.preset ?? "hono"}/deno'\n`;
+				code += serveStaticHook(appName, {
+					filePaths: options?.staticPaths,
+					root: pluginOptions?.staticRoot
+				});
+				return code;
+			}],
+			...pluginOptions
+		}),
+		name: "@hono/vite-build/deno"
+	};
+};
+//#endregion
+export { denoBuildPlugin as default };

package/dist/adapter/netlify-functions/{index.d.ts → index.d.mts}

@@ -1,8 +1,8 @@
-import { Plugin } from 'vite';
-import { BuildOptions } from '../../base.js';
-import '../../entry/index.js';
+import { BuildOptions } from "../../base.mjs";
+import { Plugin } from "vite";
 
+//#region src/adapter/netlify-functions/index.d.ts
 type NetlifyFunctionsBuildOptions = BuildOptions;
 declare function netlifyFunctionsBuildPlugin(pluginOptions?: NetlifyFunctionsBuildOptions): Plugin;
-
-export { NetlifyFunctionsBuildOptions, netlifyFunctionsBuildPlugin as default };
+//#endregion
+export { NetlifyFunctionsBuildOptions, netlifyFunctionsBuildPlugin as default };

package/dist/adapter/netlify-functions/index.mjs

@@ -0,0 +1,16 @@
+import buildPlugin from "../../base.mjs";
+//#region src/adapter/netlify-functions/index.ts
+function netlifyFunctionsBuildPlugin(pluginOptions) {
+	return {
+		...buildPlugin({
+			ssrTarget: "node",
+			entryContentBeforeHooks: [() => "import { handle } from \"hono/netlify\""],
+			entryContentAfterHooks: [() => "export const config = { path: \"/*\", preferStatic: true }"],
+			entryContentDefaultExportHook: (appName) => `export default handle(${appName})`,
+			...pluginOptions
+		}),
+		name: "@hono/vite-build/netlify-functions"
+	};
+}
+//#endregion
+export { netlifyFunctionsBuildPlugin as default };

package/dist/adapter/node/index.d.mts

@@ -0,0 +1,19 @@
+import { BuildOptions } from "../../base.mjs";
+import { Plugin } from "vite";
+
+//#region src/adapter/node/index.d.ts
+type NodeBuildOptions = {
+  staticRoot?: string | undefined;
+  port?: number | undefined;
+  /**
+   * Enable graceful shutdown on SIGINT and SIGTERM signals.
+   * Set to a number to specify the timeout in milliseconds before forcing shutdown.
+   * Set to 0 to wait indefinitely for connections to close.
+   * Leave undefined to disable graceful shutdown.
+   * @default undefined
+   */
+  shutdownTimeoutMs?: number | undefined;
+} & BuildOptions;
+declare const nodeBuildPlugin: (pluginOptions?: NodeBuildOptions) => Plugin;
+//#endregion
+export { NodeBuildOptions, nodeBuildPlugin as default };

package/dist/adapter/node/index.mjs

@@ -0,0 +1,37 @@
+import buildPlugin from "../../base.mjs";
+import { serveStaticHook } from "../../entry/serve-static.mjs";
+//#region src/adapter/node/index.ts
+const nodeBuildPlugin = (pluginOptions) => {
+	const port = pluginOptions?.port ?? 3e3;
+	const shutdownTimeoutMs = pluginOptions?.shutdownTimeoutMs;
+	return {
+		...buildPlugin({
+			ssrTarget: "node",
+			entryContentBeforeHooks: [async (appName, options) => {
+				let code = "import { serveStatic } from '@hono/node-server/serve-static'\n";
+				code += serveStaticHook(appName, {
+					filePaths: options?.staticPaths,
+					root: pluginOptions?.staticRoot
+				});
+				return code;
+			}],
+			entryContentAfterHooks: [async (appName) => {
+				let code = "import { serve } from '@hono/node-server'\n";
+				if (shutdownTimeoutMs !== void 0) {
+					code += `const server = serve({ fetch: ${appName}.fetch, port: ${port.toString()} })\n`;
+					code += "const gracefulShutdown = () => {\n";
+					code += "  server.close(() => process.exit(0))\n";
+					if (shutdownTimeoutMs > 0) code += `  setTimeout(() => process.exit(1), ${shutdownTimeoutMs}).unref()\n`;
+					code += "}\n";
+					code += "process.on('SIGINT', gracefulShutdown)\n";
+					code += "process.on('SIGTERM', gracefulShutdown)";
+				} else code += `serve({ fetch: ${appName}.fetch, port: ${port.toString()} })`;
+				return code;
+			}],
+			...pluginOptions
+		}),
+		name: "@hono/vite-build/node"
+	};
+};
+//#endregion
+export { nodeBuildPlugin as default };

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

@@ -0,0 +1,22 @@
+import { BuildOptions } from "../../base.mjs";
+import { VercelBuildConfigV3, VercelNodejsServerlessFunctionConfig } from "./types.mjs";
+import { Plugin } from "vite";
+
+//#region src/adapter/vercel/index.d.ts
+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;
+//#endregion
+export { VercelBuildOptions, vercelBuildPlugin as default };

package/dist/adapter/vercel/index.mjs

@@ -0,0 +1,170 @@
+import { getEntryContent } from "../../entry/index.mjs";
+import { defaultOptions } from "../../base.mjs";
+import { builtinModules } from "module";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { cp, writeFile } from "node:fs/promises";
+//#region src/adapter/vercel/index.ts
+const BUNDLE_NAME = "index.js";
+const DEFAULT_FUNCTION_NAME = "__hono";
+const VIRTUAL_ENTRY_PREFIX = "virtual:build-entry-module-vercel-";
+const functionEntryHooks = {
+	entryContentAfterHooks: [() => "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)) mkdirSync(dir, { recursive: true });
+	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];
+		return `nodejs${Number(systemNodeVersion)}.x`;
+	} catch {
+		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}`
+	});
+	await writeJSON(configPath, {
+		...existingConfig,
+		...configOverride,
+		version: 3,
+		routes: mergedRoutes
+	});
+};
+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 {
+		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;
+		},
+		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}` }
+					}
+				}
+			};
+		},
+		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([writeJSON(resolve(functionDir, ".vc-config.json"), functionConfig), writeJSON(resolve(functionDir, "package.json"), { type: "module" })]);
+			await enqueueConfigWrite(configPath, async () => {
+				await mergeVercelConfig(configPath, routesToAdd, pluginOptions?.vercel?.config, functionName);
+			});
+		}
+	};
+};
+//#endregion
+export { vercelBuildPlugin as default };