feat: generate InternalFetch signature

src/build.ts

@@ -82,35 +82,105 @@ 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) {
+    if (
+      typeof mw.handler !== "string" ||
+      !mw.route ||
+      /^(\/_|\/api\/_)/.test(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`
+    );
+    eventHandlerImports.add(
+      `type ${eventHandlerType}Output = ${eventHandlerType} extends EventHandler<any, infer Output> ? Simplify<Serialize<Awaited<Output>>> : unknown`
+    );
+    eventHandlerImports.add(
+      `type ${eventHandlerType}Input = ${eventHandlerType} extends EventHandler<infer Input> ? Input : EventHandlerRequest`
+    );
+
+    const Output = `${eventHandlerType}Output`;
+    const Input = `${eventHandlerType}Input`;
+
+    // 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;
+
+    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 = ${Output}>(
+        url: ${routeType},
+        options: BaseFetchOptions & { method${
+          isMethodOptional ? "?" : ""
+        }: ${methodType} } & ${Input}
+      ): true extends Raw ? Promise<FetchResponse<T>> : Promise<T>
+      ${
+        isMethodOptional
+          ? `
+      <T = ${Output}>(
+        url: IsOptional<${Input}> extends true ? ${routeType} : never,
+        options?: BaseFetchOptions & { method${
+          isMethodOptional ? "?" : ""
+        }: ${methodType} } & ${Input}
+      ): true extends Raw ? Promise<FetchResponse<T>> : Promise<T>
+      `
+          : ""
+      }`,
+    ]);
+
     const method = mw.method || "default";
-    if (!routeTypes[mw.route][method]) {
-      routeTypes[mw.route][method] = [];
-    }
+    routeTypes[mw.route][method] ||= [];
     routeTypes[mw.route][method].push(
-      `Simplify<Serialize<Awaited<ReturnType<typeof import('${relativePath}').default>>>>`
+      `Simplify<Serialize<Awaited<ReturnType<${eventHandlerType}>>>>`
     );
   }
 
@@ -169,7 +239,26 @@ export async function writeTypes(nitro: Nitro) {
 
   const routes = [
     "// Generated by nitro",
-    "import type { Serialize, Simplify } from 'nitropack'",
+    "import type { MatchedRoutes, Serialize, Simplify } from 'nitropack'",
+    "import type { EventHandler, EventHandlerRequest, HTTPMethod } from 'h3'",
+    "import type { FetchOptions, FetchResponse } from 'ofetch'",
+    "type DefaultMethod = HTTPMethod | Lowercase<Exclude<HTTPMethod, 'PATCH'>>",
+    `type IsOptional<T extends Record<string, any>> =
+  'body' extends keyof T
+    ? 'query' extends keyof T
+      ? undefined extends T['body'] & T['query']
+        ? true
+        : false
+      : T['body'] extends undefined
+        ? true
+        : false
+    : 'query' extends keyof T
+      ? T['query'] extends undefined
+        ? true
+        : false
+      : true`,
+    "type BaseFetchOptions = Omit<FetchOptions, 'method' | 'body' | 'query'>",
+    ...eventHandlerImports,
     "declare module 'nitropack' {",
     "  type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T",
     "  interface InternalApi {",
@@ -183,6 +272,19 @@ export async function writeTypes(nitro: Nitro) {
       ].join("\n")
     ),
     "  }",
+    "  interface InternalFetch<DefaultResponse, DefaultFetchRequest, Raw> {",
+    ...fetchSignatures
+      .sort(([a], [b]) => {
+        return b
+          .replace(DYNAMIC_PARAM_RE, "____")
+          .localeCompare(a.replace(DYNAMIC_PARAM_RE, "____"));
+      })
+      .map(([route, type]) => type),
+    `
+      (message: 'Could not match any route because of missing or incorrect method, query or body options for that route.', _?: any): never
+    `,
+    "  }",
+    "",
     "}",
     // Makes this a module for augmentation purposes
     "export {}",

src/types/fetch.ts

@@ -6,19 +6,50 @@ import type { MatchedRoutes } from "./utils";
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface InternalApi {}
 
+export interface InternalFetch<
+  DefaultResponse = unknown,
+  DefaultFetchRequest extends string | Request | URL =
+    | Exclude<FetchRequest, string>
+    | URL,
+  Raw extends boolean = false,
+> {
+  <T = DefaultResponse, R extends string = string>(
+    url: MatchedRoutes<R> extends never ? R : never,
+    options?: FetchOptions
+  ): true extends Raw ? Promise<FetchResponse<T>> : Promise<T>;
+
+  <T = DefaultResponse, R extends Request | URL = Request | URL>(
+    url: R,
+    options?: FetchOptions
+  ): true extends Raw ? Promise<FetchResponse<T>> : Promise<T>;
+}
+
+export interface ExternalFetch<
+  DefaultResponse = unknown,
+  DefaultFetchRequest extends string | Request | URL = FetchRequest | URL,
+  Raw extends boolean = false,
+> {
+  <T = DefaultResponse, R extends string | Request | URL = DefaultFetchRequest>(
+    url: R
+  ): true extends Raw ? Promise<FetchResponse<T>> : Promise<T>;
+}
+
 export type NitroFetchRequest =
-  | Exclude<keyof InternalApi, `/_${string}` | `/api/_${string}`>
+  | keyof InternalApi
   | Exclude<FetchRequest, string>
   // eslint-disable-next-line @typescript-eslint/ban-types
-  | (string & {});
+  | (string & {})
+  | URL;
 
+/** @deprecated */
 export type MiddlewareOf<
   Route extends string,
   Method extends RouterMethod | "default",
 > = Method extends keyof InternalApi[MatchedRoutes<Route>]
   ? Exclude<InternalApi[MatchedRoutes<Route>][Method], Error | void>
   : never;
 
+/** @deprecated */
 export type TypedInternalResponse<
   Route,
   Default = unknown,
@@ -37,6 +68,7 @@ export type TypedInternalResponse<
 
 // Extracts the available http methods based on the route.
 // Defaults to all methods if there aren't any methods available or if there is a catch-all route.
+/** @deprecated */
 export type AvailableRouterMethod<R extends NitroFetchRequest> =
   R extends string
     ? keyof InternalApi[MatchedRoutes<R>] extends undefined
@@ -51,6 +83,7 @@ export type AvailableRouterMethod<R extends NitroFetchRequest> =
 
 // Argumented fetch options to include the correct request methods.
 // This overrides the default, which is only narrowed to a string.
+/** @deprecated */
 export interface NitroFetchOptions<
   R extends NitroFetchRequest,
   M extends AvailableRouterMethod<R> = AvailableRouterMethod<R>,
@@ -59,6 +92,7 @@ export interface NitroFetchOptions<
 }
 
 // Extract the route method from options which might be undefined or without a method parameter.
+/** @deprecated */
 export type ExtractedRouteMethod<
   R extends NitroFetchRequest,
   O extends NitroFetchOptions<R>,
@@ -69,30 +103,16 @@ export type ExtractedRouteMethod<
   : "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>;
+  DefaultResponse = unknown,
+  DefaultFetchRequest extends string | Request | URL =
+    | Exclude<FetchRequest, string>
+    | URL,
+> extends InternalFetch<DefaultResponse, DefaultFetchRequest> {
+  raw: InternalFetch<DefaultResponse, DefaultFetchRequest, true>;
+  create(
+    defaults: Omit<FetchOptions, "baseURL">
+  ): InternalFetch<DefaultResponse>;
+  create(defaults: FetchOptions): ExternalFetch;
 }
 
 declare global {

test/fixture/routes/typed-routes.ts

@@ -0,0 +1 @@
+export default eventHandler<{ query: { id: string } }, string>(() => 'foo');