refactor!: explicit use of handlers or middleware (#1128)

Author: pi0

src/h3.ts

@@ -4,20 +4,14 @@ import { toResponse, kNotFound } from "./response.ts";
 import { callMiddleware, normalizeMiddleware } from "./middleware.ts";
 
 import type { RouterContext, MatchedRoute } from "rou3";
-import type {
-  FetchHandler,
-  H3Config,
-  H3Plugin,
-  H3RouteMeta,
-} from "./types/h3.ts";
+import type { FetchHandler, H3Config, H3Plugin } from "./types/h3.ts";
 import type { H3EventContext } from "./types/context.ts";
 import type { EventHandler, Middleware } from "./types/handler.ts";
 import type {
   H3Route,
   HTTPMethod,
   H3 as H3Type,
   RouteOptions,
-  RouteHandler,
   MiddlewareOptions,
 } from "./types/h3.ts";
 import type { ServerRequest } from "srvx";
@@ -120,32 +114,24 @@ export const H3Core = /* @__PURE__ */ (() => {
       return this as unknown as H3Type;
     }
 
-    all(route: string, handler: RouteHandler, opts?: RouteOptions): H3Type {
+    all(route: string, handler: EventHandler, opts?: RouteOptions): H3Type {
       return this.on("", route, handler, opts);
     }
 
     on(
       method: HTTPMethod | Lowercase<HTTPMethod> | "",
       route: string,
-      handler: RouteHandler,
+      handler: EventHandler,
       opts?: RouteOptions,
     ): H3Type {
       const _method = (method || "").toUpperCase();
-      let _handler: EventHandler;
-      let meta: H3RouteMeta | undefined = opts?.meta;
-      if ((handler as H3Type).handler) {
-        _handler = (handler as H3Type).handler;
-      } else {
-        _handler = handler as EventHandler;
-        meta = { ...(handler as EventHandler).meta, ...meta };
-      }
       route = new URL(route, "h://_").pathname;
       this._addRoute({
         method: _method as HTTPMethod,
         route,
-        handler: _handler,
+        handler,
         middleware: opts?.middleware,
-        meta,
+        meta: { ...(handler as EventHandler).meta, ...opts?.meta },
       });
       return this as unknown as H3Type;
     }
@@ -176,7 +162,7 @@ export const H3Core = /* @__PURE__ */ (() => {
     (H3Core as any).prototype[method.toLowerCase()] = function (
       this: H3Type,
       route: string,
-      handler: EventHandler | H3Type,
+      handler: EventHandler,
       opts?: RouteOptions,
     ) {
       return this.on(method, route, handler, opts);

src/index.ts

@@ -8,7 +8,6 @@ export type {
   HTTPMethod,
   PreparedResponse,
   RouteOptions,
-  RouteHandler,
   MiddlewareOptions,
   FetchHandler,
 } from "./types/h3.ts";

src/middleware.ts

@@ -1,7 +1,6 @@
 import { routeToRegExp } from "rou3";
 import { kNotFound } from "./response.ts";
 
-import type { H3 } from "./h3.ts";
 import type { H3Event } from "./event.ts";
 import type { MiddlewareOptions } from "./types/h3.ts";
 import type { EventHandler, Middleware } from "./types/handler.ts";
@@ -11,44 +10,23 @@ export function defineMiddleware(input: Middleware): Middleware {
 }
 
 export function normalizeMiddleware(
-  input: Middleware | H3,
+  input: Middleware,
   opts: MiddlewareOptions & { route?: string } = {},
 ): Middleware {
   const matcher = createMatcher(opts);
-
-  if (typeof input === "function") {
-    if (
-      !matcher &&
-      (input.length > 1 || input.constructor?.name === "AsyncFunction")
-    ) {
-      return input; // Fast path: async or with explicit next() and no matcher filters
-    }
-    return (event, next) => {
-      if (matcher && !matcher(event)) {
-        return next();
-      }
-      const res = input(event, next);
-      return res === undefined ? next() : res;
-    };
-  }
-  // H3 sub-app
-  if (typeof (input as H3).handler === "function") {
-    return (event, next) => {
-      if (matcher && !matcher(event)) {
-        return next();
-      }
-      const res = (input as H3).handler(event);
-      if (res === kNotFound) {
-        return next();
-      } else if (res instanceof Promise) {
-        return res.then((resolved) =>
-          resolved === kNotFound ? next() : resolved,
-        );
-      }
-      return res === undefined ? next() : res;
-    };
+  if (
+    !matcher &&
+    (input.length > 1 || input.constructor?.name === "AsyncFunction")
+  ) {
+    return input; // Fast path: async or with explicit next() and no matcher filters
   }
-  throw new Error(`Invalid middleware: ${input}`);
+  return (event, next) => {
+    if (matcher && !matcher(event)) {
+      return next();
+    }
+    const res = input(event, next);
+    return res === undefined || res === kNotFound ? next() : res;
+  };
 }
 
 function createMatcher(opts: MiddlewareOptions & { route?: string }) {
@@ -93,9 +71,11 @@ export function callMiddleware(
   const fn = middleware[index];
   const next = () => callMiddleware(event, middleware, handler, index + 1);
   const ret = fn(event, next);
-  return ret === undefined
+  return ret === undefined || ret === kNotFound
     ? next()
     : ret instanceof Promise
-      ? ret.then((resolved) => (resolved === undefined ? next() : resolved))
+      ? ret.then((resolved) =>
+          resolved === undefined || resolved === kNotFound ? next() : resolved,
+        )
       : ret;
 }

src/types/h3.ts

@@ -48,8 +48,6 @@ export function definePlugin<T = unknown>(
 
 // --- H3 App ---
 
-export type RouteHandler = EventHandler | { handler: EventHandler };
-
 export type FetchHandler = (req: ServerRequest) => Response | Promise<Response>;
 
 export type RouteOptions = {
@@ -130,31 +128,31 @@ export declare class H3 {
   /**
    * Register a global middleware.
    */
-  use(route: string, handler: Middleware | H3, opts?: MiddlewareOptions): this;
-  use(handler: Middleware | H3, opts?: MiddlewareOptions): this;
+  use(route: string, handler: Middleware, opts?: MiddlewareOptions): this;
+  use(handler: Middleware, opts?: MiddlewareOptions): this;
 
   /**
    * Register a route handler for the specified HTTP method and route.
    */
   on(
     method: HTTPMethod | Lowercase<HTTPMethod> | "",
     route: string,
-    handler: RouteHandler,
+    handler: EventHandler,
     opts?: RouteOptions,
   ): this;
 
   /**
    * Register a route handler for all HTTP methods.
    */
-  all(route: string, handler: RouteHandler, opts?: RouteOptions): this;
-
-  get(route: string, handler: RouteHandler, opts?: RouteOptions): this;
-  post(route: string, handler: RouteHandler, opts?: RouteOptions): this;
-  put(route: string, handler: RouteHandler, opts?: RouteOptions): this;
-  delete(route: string, handler: RouteHandler, opts?: RouteOptions): this;
-  patch(route: string, handler: RouteHandler, opts?: RouteOptions): this;
-  head(route: string, handler: RouteHandler, opts?: RouteOptions): this;
-  options(route: string, handler: RouteHandler, opts?: RouteOptions): this;
-  connect(route: string, handler: RouteHandler, opts?: RouteOptions): this;
-  trace(route: string, handler: RouteHandler, opts?: RouteOptions): this;
+  all(route: string, handler: EventHandler, opts?: RouteOptions): this;
+
+  get(route: string, handler: EventHandler, opts?: RouteOptions): this;
+  post(route: string, handler: EventHandler, opts?: RouteOptions): this;
+  put(route: string, handler: EventHandler, opts?: RouteOptions): this;
+  delete(route: string, handler: EventHandler, opts?: RouteOptions): this;
+  patch(route: string, handler: EventHandler, opts?: RouteOptions): this;
+  head(route: string, handler: EventHandler, opts?: RouteOptions): this;
+  options(route: string, handler: EventHandler, opts?: RouteOptions): this;
+  connect(route: string, handler: EventHandler, opts?: RouteOptions): this;
+  trace(route: string, handler: EventHandler, opts?: RouteOptions): this;
 }

test/middleware.test.ts

@@ -35,7 +35,7 @@ describeMatrix("middleware", (t, { it, expect }) => {
         event.req.headers.has("x-async")
           ? Promise.resolve("Hello World!")
           : "Hello World!",
-      ),
+      ).handler,
       {
         method: "GET",
         match: (event) => !event.req.headers.has("x-skip"),

test/router.test.ts

@@ -20,7 +20,7 @@ describeMatrix("router", (t, { it, expect, describe }) => {
   it("Multiple Routers", async () => {
     const secondRouter = new H3().get("/router2", () => "router2");
 
-    t.app.use(secondRouter);
+    t.app.use(secondRouter.handler);
 
     const res1 = await t.fetch("/");
     expect(await res1.text()).toEqual("Hello");
@@ -84,7 +84,7 @@ describeMatrix("router", (t, { it, expect, describe }) => {
       router = new H3()
         .get("/preemptive/test", () => "Test")
         .get("/preemptive/undefined", () => undefined);
-      t.app.all("/**", router);
+      t.app.all("/**", router.handler);
     });
 
     it("Handle /test", async () => {
@@ -120,7 +120,7 @@ describeMatrix("router", (t, { it, expect, describe }) => {
           expect(getRouterParams(event)).toMatchObject({ name: "string" });
           return "200";
         });
-        t.app.use(router);
+        t.app.use(router.handler);
         const result = await t.fetch("/test/params/string");
 
         expect(await result.text()).toBe("200");
@@ -133,7 +133,7 @@ describeMatrix("router", (t, { it, expect, describe }) => {
           });
           return "200";
         });
-        t.app.use(router);
+        t.app.use(router.handler);
         const result = await t.fetch("/test/params/string with space");
 
         expect(await result.text()).toBe("200");
@@ -160,7 +160,7 @@ describeMatrix("router", (t, { it, expect, describe }) => {
           expect(getRouterParam(event, "name")).toEqual("string");
           return "200";
         });
-        t.app.use(router);
+        t.app.use(router.handler);
         const result = await t.fetch("/test/params/string");
 
         expect(await result.text()).toBe("200");
@@ -173,7 +173,7 @@ describeMatrix("router", (t, { it, expect, describe }) => {
           );
           return "200";
         });
-        t.app.use(router);
+        t.app.use(router.handler);
         const result = await t.fetch("/test/params/string with space");
 
         expect(await result.text()).toBe("200");
@@ -204,7 +204,7 @@ describeMatrix("router", (t, { it, expect, describe }) => {
           });
           return "200";
         });
-        t.app.use(router);
+        t.app.use(router.handler);
         const result = await t.fetch("/test/path");
 
         expect(await result.text()).toBe("200");

test/session.test.ts

@@ -24,7 +24,7 @@ describeMatrix("session", (t, { it, expect }) => {
       }
       return { session };
     });
-    t.app.use(app);
+    t.app.use(app.handler);
   });
 
   it("initiates session", async () => {