feat(fetch): typed body/query options for $fetch

src/build.ts

@@ -109,6 +109,7 @@ export async function build(nitro: Nitro) {
 export async function writeTypes(nitro: Nitro) {
   const types: NitroTypes = {
     routes: {},
+    handlers: {}
   };
 
   const typesDir = resolve(nitro.options.buildDir, "types");
@@ -131,6 +132,12 @@ export async function writeTypes(nitro: Nitro) {
     types.routes[mw.route][method]!.push(
       `Simplify<Serialize<Awaited<ReturnType<typeof import('${relativePath}').default>>>>`
     );
+
+    types.handlers[mw.route] ??= {};
+    types.handlers[mw.route][method] ??= [];
+    types.handlers[mw.route][method]!.push(
+      `typeof import('${relativePath}').default`
+    );
   }
 
   let autoImportedTypes: string[] = [];
@@ -208,6 +215,17 @@ export async function writeTypes(nitro: Nitro) {
       ].join("\n")
     ),
     "  }",
+    "  interface InternalApiHandlers {",
+    ...Object.entries(types.handlers).map(([path, methods]) =>
+      [
+        `    '${path}': {`,
+        ...Object.entries(methods).map(
+          ([method, types]) => `      '${method}': ${types.join(" | ")}`
+        ),
+        "    }",
+      ].join("\n")
+    ),
+    "  }",
     "}",
     // Makes this a module for augmentation purposes
     "export {}",

src/types/fetch.ts

@@ -1,10 +1,10 @@
-import type { RouterMethod } from "h3";
+import type { EventHandler, EventHandlerRequest, RouterMethod } from "h3";
 import type { FetchRequest, FetchOptions, FetchResponse } from "ofetch";
 import type { MatchedRoutes } from "./utils";
 
-// An interface to extend in a local project
-
+// Interfaces to extend in a local project
 export interface InternalApi {}
+export interface InternalApiHandlers {}
 
 export type NitroFetchRequest =
   | Exclude<keyof InternalApi, `/_${string}` | `/api/_${string}`>
@@ -49,14 +49,40 @@ export type AvailableRouterMethod<R extends NitroFetchRequest> =
         : RouterMethod
     : RouterMethod;
 
-// Argumented fetch options to include the correct request methods.
-// This overrides the default, which is only narrowed to a string.
-export interface NitroFetchOptions<
+// Extracts the body or query parameter types expected for a route
+// based on the types inferred from bodyValidator/queryValidator.
+export type HandlerInputType<
+  R extends NitroFetchRequest, 
+  M extends AvailableRouterMethod<R>, 
+  P extends "body" | "query"
+> = 
+  R extends string
+    ? keyof InternalApiHandlers[MatchedRoutes<R>] extends undefined
+      ? any
+      : InternalApiHandlers[MatchedRoutes<R>][
+        Extract<
+          keyof InternalApiHandlers[MatchedRoutes<R>],
+          "default"
+        > extends undefined ? M : "default"
+      ] extends EventHandler<EventHandlerRequest<infer Body, infer Query>>
+        ? P extends "query" ? Query : Body
+        : any
+    : any;
+
+// Argumented fetch options to include the correct request methods,
+// body types, and query parameter types.
+export type NitroFetchOptions<
   R extends NitroFetchRequest,
   M extends AvailableRouterMethod<R> = AvailableRouterMethod<R>,
-> extends FetchOptions {
-  method?: Uppercase<M> | M;
-}
+> = Omit<FetchOptions, 'body' | 'query'> & (
+  M extends string 
+    ? {
+      method?: Uppercase<M> | M;
+      body?: HandlerInputType<R, M, "body">;
+      query?: HandlerInputType<R, M, "query">;
+    } 
+    : never
+  );
 
 // Extract the route method from options which might be undefined or without a method parameter.
 export type ExtractedRouteMethod<

src/types/nitro.ts

@@ -83,9 +83,10 @@ export type PrerenderGenerateRoute = PrerenderRoute;
 
 type HookResult = void | Promise<void>;
 
-export type NitroTypes = {
-  routes: Record<string, Partial<Record<RouterMethod | "default", string[]>>>;
-};
+export type NitroTypes = Record<
+  'routes' | 'handlers', 
+  Record<string, Partial<Record<RouterMethod | "default", string[]>>>
+>;
 
 export interface NitroHooks {
   "types:extend": (types: NitroTypes) => HookResult;