feat: generate InternalFetch signature

src/build.ts

@@ -77,29 +77,79 @@ export async function build(nitro: Nitro) {
     : _build(nitro, rollupConfig);
 }
 
+const DYNAMIC_PARAM_RE = /(\*\*)(?!:)|((\*\*)?:[^/]+)/g;
+
 export async function writeTypes(nitro: Nitro) {
   const routeTypes: Record<
     string,
     Partial<Record<RouterMethod | "default", string[]>>
   > = {};
 
+  const fetchSignatures = [] as Array<[route: string, type: string]>;
+  const eventHandlerImports = new Set<string>();
+
   const typesDir = resolve(nitro.options.buildDir, "types");
 
   const middleware = [...nitro.scannedHandlers, ...nitro.options.handlers];
 
+  let i = 1;
   for (const mw of middleware) {
     if (typeof mw.handler !== "string" || !mw.route) {
       continue;
     }
-    const relativePath = relative(typesDir, mw.handler).replace(
-      /\.[a-z]+$/,
-      ""
-    );
+    const relativePath = relative(
+      typesDir,
+      resolveAlias(mw.handler, nitro.options.alias)
+    ).replace(/\.[a-z]+$/, "");
 
     if (!routeTypes[mw.route]) {
       routeTypes[mw.route] = {};
     }
 
+    const eventHandlerType = `EventHandler${i++}`;
+    eventHandlerImports.add(
+      `type ${eventHandlerType} = typeof import('${relativePath}').default`
+    );
+
+    // const isOptionsOptional
+    const isMethodOptional = !mw.method || mw.method.toUpperCase() === "GET";
+    const excludedMethods = middleware
+      .filter(
+        (other) => other.method && other.route === mw.route && other !== mw
+      )
+      .flatMap((m) =>
+        [m.method.toUpperCase(), m.method.toLowerCase()].map((m) => `'${m}'`)
+      )
+      .join(" | ");
+
+    const defaultMethod = excludedMethods
+      ? `Exclude<DefaultMethod, ${excludedMethods}>`
+      : "DefaultMethod";
+
+    const methodType = mw.method
+      ? [mw.method.toUpperCase(), mw.method.toLowerCase()]
+          .filter((m) => m !== "patch")
+          .map((m) => `'${m}'`)
+          .join(" | ")
+      : defaultMethod;
+
+    // TODO: 1. Fine-tune matching algorithm?
+    // TODO: merge return types
+    // TODO: 2. infer returns when we provide typed input
+    // TODO: 3. require options object when we provide typed input
+
+    const routeType = DYNAMIC_PARAM_RE.test(mw.route)
+      ? `\`${mw.route.replace(DYNAMIC_PARAM_RE, `\${string}`)}\``
+      : `'${mw.route}' | \`${mw.route}?$\{string}\``;
+
+    fetchSignatures.push([
+      mw.route,
+      `    <T = ${eventHandlerType} extends EventHandler<any, infer Output> ? Simplify<Serialize<Awaited<Output>>> : unknown>(url: ${routeType}, options?: BaseFetchOptions & { method${
+        isMethodOptional ? "?" : ""
+      }: ${methodType} } & (${eventHandlerType} extends EventHandler<infer Input> ? Input : {})): Promise<T>
+    `,
+    ]);
+
     const method = mw.method || "default";
     if (!routeTypes[mw.route][method]) {
       routeTypes[mw.route][method] = [];
@@ -135,6 +185,11 @@ export async function writeTypes(nitro: Nitro) {
   const routes = [
     "// Generated by nitro",
     "import type { Serialize, Simplify } from 'nitropack'",
+    "import type { EventHandler, HTTPMethod } from 'h3'",
+    "import type { FetchOptions } from 'ofetch'",
+    "type DefaultMethod = HTTPMethod | Lowercase<Exclude<HTTPMethod, 'PATCH'>>",
+    "type BaseFetchOptions = Omit<FetchOptions, 'method' | 'body' | 'query'>",
+    ...eventHandlerImports,
     "declare module 'nitropack' {",
     "  type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T",
     "  interface InternalApi {",
@@ -148,6 +203,16 @@ export async function writeTypes(nitro: Nitro) {
       ].join("\n")
     ),
     "  }",
+    "  interface InternalFetch {",
+    ...fetchSignatures
+      .sort(([a], [b]) => {
+        return b
+          .replace(DYNAMIC_PARAM_RE, "____")
+          .localeCompare(a.replace(DYNAMIC_PARAM_RE, "____"));
+      })
+      .map(([route, type]) => type),
+    "  }",
+    "",
     "}",
     // Makes this a module for augmentation purposes
     "export {}",

src/runtime/app.ts

@@ -110,7 +110,7 @@ function createNitroApp(): NitroApp {
       event.$fetch = ((req, init) =>
         fetchWithEvent(event, req, init as RequestInit, {
           fetch: $fetch,
-        })) as $Fetch<unknown, NitroFetchRequest>;
+        })) as $Fetch;
 
       // https://github.com/unjs/nitro/issues/1420
       event.waitUntil = (promise) => {

src/runtime/client.ts

@@ -3,5 +3,5 @@ import { $fetch } from "ofetch";
 import { $Fetch, NitroFetchRequest } from "../types";
 
 if (!globalThis.$fetch) {
-  globalThis.$fetch = $fetch as $Fetch<unknown, NitroFetchRequest>;
+  globalThis.$fetch = $fetch as $Fetch;
 }

src/types/fetch.ts

@@ -6,6 +6,14 @@ import type { MatchedRoutes } from "./utils";
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface InternalApi {}
 
+export interface InternalFetch {
+  <T = unknown>(
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    request: Exclude<FetchRequest, string> | (string & {}),
+    opts?: FetchOptions
+  ): Promise<T>;
+}
+
 export type NitroFetchRequest =
   | Exclude<keyof InternalApi, `/_${string}` | `/api/_${string}`>
   | Exclude<FetchRequest, string>
@@ -68,31 +76,9 @@ export type ExtractedRouteMethod<
   ? Lowercase<O["method"]>
   : "get";
 
-export interface $Fetch<
-  DefaultT = unknown,
-  DefaultR extends NitroFetchRequest = NitroFetchRequest,
-> {
-  <
-    T = DefaultT,
-    R extends NitroFetchRequest = DefaultR,
-    O extends NitroFetchOptions<R> = NitroFetchOptions<R>,
-  >(
-    request: R,
-    opts?: O
-  ): Promise<TypedInternalResponse<R, T, ExtractedRouteMethod<R, O>>>;
-  raw<
-    T = DefaultT,
-    R extends NitroFetchRequest = DefaultR,
-    O extends NitroFetchOptions<R> = NitroFetchOptions<R>,
-  >(
-    request: R,
-    opts?: O
-  ): Promise<
-    FetchResponse<TypedInternalResponse<R, T, ExtractedRouteMethod<R, O>>>
-  >;
-  create<T = DefaultT, R extends NitroFetchRequest = DefaultR>(
-    defaults: FetchOptions
-  ): $Fetch<T, R>;
+export interface $Fetch extends InternalFetch {
+  raw: InternalFetch;
+  create(defaults: FetchOptions): InternalFetch;
 }
 
 declare global {

src/types/h3.ts

@@ -6,7 +6,7 @@ export type H3EventFetch = (
   init?: RequestInit
 ) => Promise<Response>;
 
-export type H3Event$Fetch = $Fetch<unknown, NitroFetchRequest>;
+export type H3Event$Fetch = $Fetch;
 
 declare module "h3" {
   interface H3Event {

test/fixture/types.ts

@@ -98,16 +98,12 @@ describe("API routes", () => {
   });
 
   it("generates types for routes matching prefix", () => {
-    expectTypeOf($fetch("/api/hey/**")).toEqualTypeOf<Promise<string>>();
     expectTypeOf($fetch("/api/param/{id}/**")).toEqualTypeOf<Promise<string>>();
     expectTypeOf(
       $fetch("/api/typed/user/{someUserId}/post/{somePostId}/**")
     ).toEqualTypeOf<
       Promise<{ internalApiKey: "/api/typed/user/:userId/post/:postId" }>
     >();
-    expectTypeOf($fetch("/api/typed/user/john/post/coffee/**")).toEqualTypeOf<
-      Promise<{ internalApiKey: "/api/typed/user/john/post/coffee" }>
-    >();
     expectTypeOf(
       $fetch(`/api/typed/user/${dynamicString}/post/${dynamicString}/**`)
     ).toEqualTypeOf<
@@ -144,16 +140,14 @@ describe("API routes", () => {
       $fetch("/api/typed/todos/firstTodo/comments/foo")
     ).toEqualTypeOf<
       Promise<
-        | { internalApiKey: "/api/typed/todos/**" }
-        | { internalApiKey: "/api/typed/todos/:todoId/comments/**:commentId" }
+        { internalApiKey: "/api/typed/todos/:todoId/comments/**:commentId" }
       >
     >();
     expectTypeOf(
       $fetch(`/api/typed/todos/firstTodo/comments/${dynamicString}`)
     ).toEqualTypeOf<
       Promise<
-        | { internalApiKey: "/api/typed/todos/**" }
-        | { internalApiKey: "/api/typed/todos/:todoId/comments/**:commentId" }
+        { internalApiKey: "/api/typed/todos/:todoId/comments/**:commentId" }
       >
     >();
     expectTypeOf(
@@ -212,7 +206,7 @@ describe("API routes", () => {
     >();
 
     expectTypeOf($fetch("/api/serialized/void")).toEqualTypeOf<
-      Promise<unknown>
+      Promise<never>
     >();
 
     expectTypeOf($fetch("/api/serialized/null")).toEqualTypeOf<Promise<any>>();