feat: support fetchable object for dynamic handlers

pi0 · pi0 · commit 0da8e4abba82 · 2025-10-01T09:41:32.000+02:00
diff --git a/src/handler.ts b/src/handler.ts
@@ -10,6 +10,7 @@ import type {
   EventHandlerResponse,
   DynamicEventHandler,
   EventHandlerWithFetch,
+  FetchableObject,
 } from "./types/handler.ts";
 import type {
   InferOutput,
@@ -130,14 +131,14 @@ function handlerWithFetch<
 //  --- dynamic event handler ---
 
 export function dynamicEventHandler(
-  initial?: EventHandler,
+  initial?: EventHandler | FetchableObject,
 ): DynamicEventHandler {
-  let current: EventHandler | undefined = initial;
+  let current: EventHandler | undefined = _toEventHandler(initial);
   return Object.assign(
     defineHandler((event: H3Event) => current?.(event)),
     {
-      set: (handler: EventHandler) => {
-        current = handler;
+      set: (handler: EventHandler | FetchableObject) => {
+        current = _toEventHandler(handler);
       },
     },
   );
@@ -146,7 +147,10 @@ export function dynamicEventHandler(
 // --- lazy event handler ---
 
 export function defineLazyEventHandler(
-  load: () => Promise<EventHandler> | EventHandler,
+  load: () =>
+    | Promise<EventHandler | FetchableObject>
+    | EventHandler
+    | FetchableObject,
 ): EventHandlerWithFetch {
   let _promise: Promise<typeof _resolved>;
   let _resolved: { handler: EventHandler };
@@ -157,14 +161,16 @@ export function defineLazyEventHandler(
     }
     if (!_promise) {
       _promise = Promise.resolve(load()).then((r: any) => {
-        const handler = r.default || r;
+        let handler = r.default || r;
         if (typeof handler !== "function") {
-          throw new (TypeError as any)(
-            "Invalid lazy handler result. It should be a function:",
-            handler,
-          );
+          const _fetchHandler = (handler as FetchableObject).fetch;
+          if (typeof _fetchHandler === "function") {
+            handler = (event: H3Event) => _fetchHandler(event.req);
+          } else {
+            throw new TypeError("Invalid lazy handler: " + r);
+          }
         }
-        _resolved = { handler: r.default || r };
+        _resolved = { handler };
         return _resolved;
       });
     }
@@ -178,3 +184,16 @@ export function defineLazyEventHandler(
     return resolveHandler().then((r) => r.handler(event));
   });
 }
+
+// --- normalize ---
+
+function _toEventHandler(
+  handler: undefined | EventHandler | FetchableObject,
+): EventHandler | undefined {
+  if (typeof handler === "function") {
+    return handler;
+  }
+  if (typeof handler?.fetch === "function") {
+    return (event: H3Event) => handler.fetch!(event.req);
+  }
+}
diff --git a/src/types/handler.ts b/src/types/handler.ts
@@ -68,10 +68,13 @@ export type Middleware = (
 
 // --- lazy event handler ---
 
-export type LazyEventHandler = () => EventHandler | Promise<EventHandler>;
+export type LazyEventHandler = () =>
+  | EventHandler
+  | FetchableObject
+  | Promise<EventHandler | FetchableObject>;
 
 export interface DynamicEventHandler extends EventHandlerWithFetch {
-  set: (handler: EventHandler) => void;
+  set: (handler: EventHandler | FetchableObject) => void;
 }
 
 // --- utils ---
diff --git a/test/handler.test.ts b/test/handler.test.ts
@@ -50,6 +50,17 @@ describe("handler.ts", () => {
       expect(result).toBe("initial");
     });
 
+    it("should call the initial handler if set (fetchable)", async () => {
+      const initialHandler = vi.fn(() => new Response("initial"));
+      const dynamicHandler = dynamicEventHandler(initialHandler);
+
+      const mockEvent = {} as H3Event;
+      const result = await dynamicHandler(mockEvent);
+
+      expect(initialHandler).toHaveBeenCalledWith(mockEvent);
+      expect(result).toBeInstanceOf(Response);
+    });
+
     it("should allow setting a new handler", async () => {
       const initialHandler = vi.fn(async (_: H3Event) => "initial");
       const newHandler = vi.fn(async (_: H3Event) => "new");
@@ -79,14 +90,27 @@ describe("handler.ts", () => {
       expect(result).toBe("lazy");
     });
 
+    it("should resolve and call the lazy-loaded handler (fetchable)", async () => {
+      const lazyHandler = vi.fn(async (_req: Request) => new Response("lazy"));
+      const load = vi.fn(() => Promise.resolve({ fetch: lazyHandler }));
+      const lazyEventHandler = defineLazyEventHandler(load);
+
+      const mockEvent = {} as H3Event;
+      const result = await lazyEventHandler(mockEvent);
+
+      expect(load).toHaveBeenCalled();
+      expect(lazyHandler).toHaveBeenCalled();
+      expect(result).toBeInstanceOf(Response);
+    });
+
     it("should throw an error if the lazy-loaded handler is invalid", async () => {
       const load = vi.fn(() => Promise.resolve({}));
       const lazyEventHandler = defineLazyEventHandler(load as any);
 
       const mockEvent = {} as H3Event;
 
       await expect(lazyEventHandler(mockEvent)).rejects.toThrow(
-        "Invalid lazy handler result. It should be a function:",
+        "Invalid lazy handler:",
       );
     });
   });
