feat: Add hono enhancer to cloudflare

packages/waku/src/cli.ts

@@ -3,13 +3,13 @@ import { existsSync, readFileSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { parseArgs } from 'node:util';
 import { createRequire } from 'node:module';
-import { Hono } from 'hono';
+import { Hono, type MiddlewareHandler } from 'hono';
 import { compress } from 'hono/compress';
 import { serve } from '@hono/node-server';
 import { serveStatic } from '@hono/node-server/serve-static';
 import * as dotenv from 'dotenv';
 
-import type { Config } from './config.js';
+import type { Config, unstable_HonoEnhancer } from './config.js';
 import { runner } from './lib/hono/runner.js';
 import { build } from './lib/builder/build.js';
 import { DIST_ENTRIES_JS, DIST_PUBLIC } from './lib/builder/constants.js';
@@ -98,13 +98,20 @@ if (values.version) {
 
 async function runDev() {
  const config = await loadConfig();
- const honoEnhancer =
- config.unstable_honoEnhancer || ((createApp) => createApp);
+ const honoEnhancer: unstable_HonoEnhancer<Hono, MiddlewareHandler> =
+ config.unstable_honoEnhancer
+ ? (config.unstable_honoEnhancer as unknown as unstable_HonoEnhancer<
+ Hono,
+ MiddlewareHandler
+ >)
+ : async (createApp: (app: Hono, _serveWaku: MiddlewareHandler) => Hono) =>
+ createApp;
+ const serveWaku = runner({ cmd: 'dev', config, env: process.env as any });
  const createApp = (app: Hono) => {
  if (values['experimental-compress']) {
  app.use(compress());
  }
- app.use(runner({ cmd: 'dev', config, env: process.env as any }));
+ app.use(serveWaku);
  app.notFound((c) => {
  // FIXME can we avoid hardcoding the public path?
  const file = path.join('public', '404.html');
@@ -116,7 +123,10 @@ async function runDev() {
  return app;
  };
  const port = parseInt(values.port || '3000', 10);
- await startServer(honoEnhancer(createApp)(new Hono()), port);
+ await startServer(
+ (await honoEnhancer(createApp))(new Hono(), serveWaku),
+ port,
+ );
 }
 
 async function runBuild() {
@@ -147,16 +157,28 @@ async function runBuild() {
 async function runStart() {
  const config = await loadConfig();
  const { distDir = 'dist' } = config;
- const honoEnhancer =
- config.unstable_honoEnhancer || ((createApp) => createApp);
+ const honoEnhancer: unstable_HonoEnhancer<Hono, MiddlewareHandler> =
+ config.unstable_honoEnhancer
+ ? (config.unstable_honoEnhancer as unknown as unstable_HonoEnhancer<
+ Hono,
+ MiddlewareHandler
+ >)
+ : async (createApp: (app: Hono) => Hono) =>
+ (app: Hono, _serveWaku: MiddlewareHandler) =>
+ createApp(app);
  const loadEntries = () =>
  import(pathToFileURL(path.resolve(distDir, DIST_ENTRIES_JS)).toString());
+ const serveWaku = runner({
+ cmd: 'start',
+ loadEntries,
+ env: process.env as any,
+ });
  const createApp = (app: Hono) => {
  if (values['experimental-compress']) {
  app.use(compress());
  }
  app.use(serveStatic({ root: path.join(distDir, DIST_PUBLIC) }));
- app.use(runner({ cmd: 'start', loadEntries, env: process.env as any }));
+ app.use(serveWaku);
  app.notFound((c) => {
  // FIXME better implementation using node stream?
  const file = path.join(distDir, DIST_PUBLIC, '404.html');
@@ -168,7 +190,10 @@ async function runStart() {
  return app;
  };
  const port = parseInt(values.port || '8080', 10);
- await startServer(honoEnhancer(createApp)(new Hono()), port);
+ await startServer(
+ (await honoEnhancer(createApp))(new Hono(), serveWaku),
+ port,
+ );
 }
 
 function startServer(app: Hono, port: number) {

packages/waku/src/config.ts

@@ -49,14 +49,16 @@ export interface Config {
  */
  middleware?: () => Promise<{ default: Middleware }>[];
  /**
- * Enhander for Hono
+ * Enhancer for Hono
  * Defaults to `undefined`
  */
- unstable_honoEnhancer?:
- | (<Hono>(createApp: (app: Hono) => Hono) => (app: Hono) => Hono)
- | undefined;
+ unstable_honoEnhancer?: unstable_HonoEnhancer | undefined;
 }
 
+export type unstable_HonoEnhancer<Hono = never, MiddlewareHandler = never> = (
+ createApp: (app: Hono) => Hono,
+) => Promise<(app: Hono, serveWaku: MiddlewareHandler) => Hono>;
+
 export function defineConfig(config: Config) {
  return config;
 }

packages/waku/src/lib/plugins/vite-plugin-deploy-cloudflare.ts

@@ -17,34 +17,49 @@ import { DIST_ENTRIES_JS, DIST_PUBLIC } from '../builder/constants.js';
 const SERVE_JS = 'serve-cloudflare.js';
 
 const getServeJsContent = (srcEntriesFile: string) => `
-import { runner, importHono } from 'waku/unstable_hono';
+import { runner, importHono } from "waku/unstable_hono";
 
 const { Hono } = await importHono();
 
-const loadEntries = () => import('${srcEntriesFile}');
+const loadEntries = () => import("${srcEntriesFile}");
 let serveWaku;
 
-const app = new Hono();
-app.use((c, next) => serveWaku(c, next));
-app.notFound(async (c) => {
- const assetsFetcher = c.env.ASSETS;
- const url = new URL(c.req.raw.url);
- const errorHtmlUrl = url.origin + '/404.html';
- const notFoundStaticAssetResponse = await assetsFetcher.fetch(
- new URL(errorHtmlUrl),
- );
- if (notFoundStaticAssetResponse && notFoundStaticAssetResponse.status < 400) {
- return c.body(notFoundStaticAssetResponse.body, 404);
- }
- return c.text('404 Not Found', 404);
-});
+const configPromise = loadEntries().then((entries) => entries.loadConfig());
+
+const createApp = (app) => {
+ app.use((c, next) => serveWaku(c, next));
+ app.notFound(async (c) => {
+ const assetsFetcher = c.env.ASSETS;
+ const url = new URL(c.req.raw.url);
+ const errorHtmlUrl = url.origin + "/404.html";
+ const notFoundStaticAssetResponse = await assetsFetcher.fetch(
+ new URL(errorHtmlUrl)
+ );
+ if (
+ notFoundStaticAssetResponse &&
+ notFoundStaticAssetResponse.status < 400
+ ) {
+ return c.body(notFoundStaticAssetResponse.body, 404);
+ }
+ return c.text("404 Not Found", 404);
+ });
+ return app;
+};
+
+let honoEnhanced;
 
 export default {
  async fetch(request, env, ctx) {
  if (!serveWaku) {
- serveWaku = runner({ cmd: 'start', loadEntries, env });
+ serveWaku = runner({ cmd: "start", loadEntries, env });
+ }
+ if (!honoEnhanced) {
+ const honoEnhancer =
+ (await configPromise).unstable_honoEnhancer ||
+ (async (createApp) => createApp);
+ honoEnhanced = (await honoEnhancer(createApp))(new Hono(), serveWaku);
  }
- return app.fetch(request, env, ctx);
+ return honoEnhanced.fetch(request, env, ctx);
  },
 };
 `;