feat: merge return type with context and preserve body/query

src/event/event.ts

@@ -19,13 +19,16 @@ export interface NodeEventContext {
 export class H3Event<
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   _RequestT extends EventHandlerRequest = EventHandlerRequest,
+  Context = unknown,
 > implements Pick<FetchEvent, "respondWith">
 {
   "__is_event__" = true;
 
   // Context
   node: NodeEventContext;
-  context: H3EventContext = {};
+  context = {} as unknown extends Context
+    ? H3EventContext
+    : H3EventContext & Context;
 
   // Request
   _request: Request | undefined;
@@ -56,7 +59,7 @@ export class H3Event<
 
   get url() {
     if (!this._url) {
-      this._url = getRequestURL(this);
+      this._url = getRequestURL(this as H3Event<EventHandlerRequest, unknown>);
     }
     return this._url;
   }
@@ -132,7 +135,7 @@ export class H3Event<
 
   respondWith(response: Response | PromiseLike<Response>): Promise<void> {
     return Promise.resolve(response).then((_response) =>
-      sendWebResponse(this, _response),
+      sendWebResponse(this as H3Event<EventHandlerRequest, unknown>, _response),
     );
   }
 

src/event/utils.ts

@@ -1,3 +1,4 @@
+import { ParsedBodySymbol, ParsedQuerySymbol } from "../utils/symbols";
 import type {
   EventHandler,
   LazyEventHandler,
@@ -63,12 +64,15 @@ export function defineEventHandler<
   }
   // Object Syntax
   const _handler: EventHandler<Request, any> = (event) => {
-    return _callHandler(event, handler);
+    return _callHandler(event, handler as EventHandlerObject);
   };
   return Object.assign(_handler, { __is_handler__: true });
 }
 
-async function _callHandler(event: H3Event, handler: EventHandlerObject) {
+async function _callHandler(
+  event: H3Event<any, any>,
+  handler: EventHandlerObject,
+) {
   if (handler.before) {
     for (const hook of handler.before) {
       await hook(event);
@@ -78,7 +82,21 @@ async function _callHandler(event: H3Event, handler: EventHandlerObject) {
     }
   }
   if (handler.validate) {
-    await validateEvent(event, handler.validate);
+    const res = (await validateEvent(event, handler.validate)) as Record<
+      string,
+      any
+    >;
+    if (res && typeof res === "object") {
+      for (const property in res) {
+        if (property === "body") {
+          (event.node.req as any)[ParsedBodySymbol] = res.body;
+        } else if ("query" in res) {
+          (event.node.req as any)[ParsedQuerySymbol] = res.query;
+        } else {
+          event.context[property] = res[property];
+        }
+      }
+    }
   }
   const body = await handler.handler(event);
   const response = { body };

src/types.ts

@@ -57,9 +57,13 @@ export interface EventHandlerRequest {
 
 export type InferEventInput<
   Key extends keyof EventHandlerRequest,
-  Event extends H3Event,
+  Event extends H3Event<any, any>,
   T,
-> = void extends T ? (Event extends H3Event<infer E> ? E[Key] : never) : T;
+> = unknown extends T
+  ? Event extends H3Event<infer E, any>
+    ? E[Key]
+    : never
+  : T;
 
 export interface EventHandler<
   Request extends EventHandlerRequest = EventHandlerRequest,
@@ -83,6 +87,18 @@ export type EventValidatedRequest<
   ? Awaited<ReturnType<ValidateFunction>>
   : EventHandlerRequest;
 
+export type Simplify<TType> = TType extends any[] | Date
+  ? TType
+  : { [K in keyof TType]: TType[K] };
+
+export type EventFromValidatedRequest<Request extends EventHandlerRequest> =
+  keyof Request extends "body" | "query"
+    ? H3Event<Request>
+    : H3Event<
+        Simplify<Pick<Request, keyof Request & ("body" | "query")>>,
+        Simplify<Omit<Request, "body" | "query">>
+      >;
+
 export type EventHandlerObject<
   Request extends EventHandlerRequest = EventHandlerRequest,
   Response extends EventHandlerResponse = EventHandlerResponse,
@@ -92,7 +108,7 @@ export type EventHandlerObject<
     EventValidatedRequest<_ValidateFunction> = EventValidatedRequest<_ValidateFunction>,
 > = {
   validate?: _ValidateFunction;
-  handler: EventHandler<_ValidatedRequest, Response>;
+  handler: (event: EventFromValidatedRequest<_ValidatedRequest>) => Response;
   before?: ((event: H3Event<EventHandlerRequest>) => void | Promise<void>)[];
   after?: ((
     event: H3Event<_ValidatedRequest>,

src/utils/body.ts

@@ -6,11 +6,10 @@ import { createError } from "../error";
 import { parse as parseMultipartData } from "./internal/multipart";
 import { assertMethod, getRequestHeader } from "./request";
 import { ValidateFunction, validateData } from "./internal/validate";
+import { ParsedBodySymbol, RawBodySymbol } from "./symbols";
 
 export type { MultiPartData } from "./internal/multipart";
 
-const RawBodySymbol = Symbol.for("h3RawBody");
-const ParsedBodySymbol = Symbol.for("h3ParsedBody");
 type InternalRequest<T = any> = IncomingMessage & {
   [RawBodySymbol]?: Promise<Buffer | undefined>;
   [ParsedBodySymbol]?: T;
@@ -94,7 +93,7 @@ export function readRawBody<E extends Encoding = "utf8">(
 
 export async function readBody<
   T,
-  Event extends H3Event = H3Event,
+  Event extends H3Event<any, any> = H3Event<any, any>,
   _T = InferEventInput<"body", Event, T>,
 >(event: Event, options: { strict?: boolean } = {}): Promise<_T> {
   const request = event.node.req as InternalRequest<T>;

src/utils/request.ts

@@ -3,12 +3,16 @@ import { createError } from "../error";
 import type { HTTPMethod, InferEventInput, RequestHeaders } from "../types";
 import type { H3Event } from "../event";
 import { validateData, ValidateFunction } from "./internal/validate";
+import { ParsedQuerySymbol } from "./symbols";
 
 export function getQuery<
   T,
   Event extends H3Event = H3Event,
   _T = Exclude<InferEventInput<"query", Event, T>, undefined>,
 >(event: Event): _T {
+  if (ParsedQuerySymbol in event) {
+    return event[ParsedQuerySymbol] as _T;
+  }
   return _getQuery(event.path || "") as _T;
 }
 

src/utils/symbols.ts

@@ -0,0 +1,3 @@
+export const RawBodySymbol = Symbol.for("h3RawBody");
+export const ParsedBodySymbol = Symbol.for("h3ParsedBody");
+export const ParsedQuerySymbol = Symbol.for("h3ParsedQuery");

test/types.test-d.ts

@@ -101,15 +101,20 @@ describe("types", () => {
         async validate(event) {
           await Promise.resolve();
           expectTypeOf(event).toEqualTypeOf<H3Event>();
-          return {} as { body: { id: string } };
+          return {} as { body: { id: string }; other: true };
         },
         async handler(event) {
           expectTypeOf(event).toEqualTypeOf<
-            H3Event<{ body: { id: string } }>
+            H3Event<{ body: { id: string } }, { other: true }>
           >();
 
+          expectTypeOf(event.context.other).toEqualTypeOf<true>();
+          // TODO: should be unknown in future version of h3
+          expectTypeOf(event.context.body).toBeAny();
+
           const body = await readBody(event);
           expectTypeOf(body).toEqualTypeOf<{ id: string }>();
+          expectTypeOf(await readBody<string>(event)).toEqualTypeOf<string>();
 
           return { foo: "bar" };
         },