feat(events): bodyValidator and queryValidator event arguments

src/event/utils.ts

@@ -8,6 +8,9 @@ import type {
  _ResponseMiddleware,
 } from "../types";
 import { hasProp } from "../utils/internal/object";
+import { validateData } from "../utils/internal/validate";
+import { readBody } from "../utils/body";
+import { getQuery } from "../utils/request";
 import type { H3Event } from "./event";
 
 type _EventHandlerHooks = {
@@ -16,12 +19,17 @@ type _EventHandlerHooks = {
 };
 
 export function defineEventHandler<
- Request extends EventHandlerRequest = EventHandlerRequest,
+ Body extends EventHandlerRequest["body"] = EventHandlerRequest["body"],
+ Query extends EventHandlerRequest["query"] = EventHandlerRequest["query"],
+ Request extends EventHandlerRequest<Body, Query> = EventHandlerRequest<
+ Body,
+ Query
+ >,
  Response = EventHandlerResponse,
 >(
  handler:
  | EventHandler<Request, Response>
- | EventHandlerObject<Request, Response>,
+ | EventHandlerObject<Body, Query, Request, Response>,
 ): EventHandler<Request, Response>;
 // TODO: remove when appropriate
 // This signature provides backwards compatibility with previous signature where first generic was return type
@@ -38,12 +46,17 @@ export function defineEventHandler<
  Request extends EventHandlerRequest ? Response : Request
 >;
 export function defineEventHandler<
- Request extends EventHandlerRequest,
+ Body extends EventHandlerRequest["body"] = EventHandlerRequest["body"],
+ Query extends EventHandlerRequest["query"] = EventHandlerRequest["query"],
+ Request extends EventHandlerRequest<Body, Query> = EventHandlerRequest<
+ Body,
+ Query
+ >,
  Response = EventHandlerResponse,
 >(
  handler:
  | EventHandler<Request, Response>
- | EventHandlerObject<Request, Response>,
+ | EventHandlerObject<Body, Query, Request, Response>,
 ): EventHandler<Request, Response> {
  // Function Syntax
  if (typeof handler === "function") {
@@ -55,7 +68,15 @@ export function defineEventHandler<
  onRequest: _normalizeArray(handler.onRequest),
  onBeforeResponse: _normalizeArray(handler.onBeforeResponse),
  };
- const _handler: EventHandler<Request, any> = (event) => {
+ const _handler: EventHandler<Request, any> = async (event) => {
+ if (handler.bodyValidator) {
+ const body = await readBody(event);
+ await validateData(body, handler.bodyValidator);
+ }
+ if (handler.queryValidator) {
+ const query = getQuery(event);
+ await validateData(query, handler.queryValidator);
+ }
  return _callHandler(event, handler.handler, _hooks);
  };
  _handler.__is_handler__ = true;

src/types.ts

@@ -3,6 +3,7 @@ import type { Hooks as WSHooks } from "crossws";
 import type { H3Event } from "./event";
 import type { Session } from "./utils/session";
 import type { RouteNode } from "./router";
+import type { ValidateFunction } from "./types";
 
 export type {
  ValidateFunction,
@@ -51,9 +52,12 @@ export interface H3EventContext extends Record<string, any> {
 
 export type EventHandlerResponse<T = any> = T | Promise<T>;
 
-export interface EventHandlerRequest {
- body?: any; // TODO: Default to unknown in next major version
- query?: QueryObject;
+export interface EventHandlerRequest<
+ Body = any, // TODO: Default to unknown in next major version
+ Query extends QueryObject | undefined = QueryObject | undefined,
+> {
+ body?: Body;
+ query?: Query;
  routerParams?: Record<string, string>;
 }
 
@@ -92,7 +96,12 @@ export type _ResponseMiddleware<
 ) => void | Promise<void>;
 
 export type EventHandlerObject<
- Request extends EventHandlerRequest = EventHandlerRequest,
+ Body extends EventHandlerRequest["body"] = EventHandlerRequest["body"],
+ Query extends EventHandlerRequest["query"] = EventHandlerRequest["query"],
+ Request extends EventHandlerRequest<Body, Query> = EventHandlerRequest<
+ Body,
+ Query
+ >,
  Response extends EventHandlerResponse = EventHandlerResponse,
 > = {
  onRequest?: _RequestMiddleware<Request> | _RequestMiddleware<Request>[];
@@ -101,6 +110,8 @@ export type EventHandlerObject<
  | _ResponseMiddleware<Request, Response>[];
  /** @experimental */
  websocket?: Partial<WSHooks>;
+ bodyValidator?: ValidateFunction<Body>;
+ queryValidator?: ValidateFunction<Query>;
  handler: EventHandler<Request, Response>;
 };
 

src/utils/body.ts

@@ -142,7 +142,7 @@ export function readRawBody<E extends Encoding = "utf8">(
 export async function readBody<
  T,
  Event extends H3Event = H3Event,
- _T = InferEventInput<"body", Event, T>,
+ _T = Exclude<InferEventInput<"body", Event, T>, undefined>,
 >(event: Event, options: { strict?: boolean } = {}): Promise<_T> {
  const request = event.node.req as InternalRequest<T>;
  if (hasProp(request, ParsedBodySymbol)) {

test/types.test-d.ts

@@ -34,6 +34,7 @@ describe("types", () => {
  foo: string;
  }>();
  });
+
  it("return type (inferred)", () => {
  const handler = eventHandler(() => {
  return {
@@ -45,7 +46,7 @@ describe("types", () => {
  });
 
  it("return type (simple generic)", () => {
- const handler = eventHandler<string>(() => {
+ const handler = eventHandler<undefined, undefined, {}, string>(() => {
  return "";
  });
  const response = handler({} as H3Event);
@@ -77,10 +78,19 @@ describe("types", () => {
  expectTypeOf(body).not.toBeAny();
  expectTypeOf(body).toEqualTypeOf<{ id: string }>();
  });
+
+ eventHandler({
+ bodyValidator: (body: unknown) => body as { id: string },
+ handler: async (event) => {
+ const body = await readBody(event);
+ expectTypeOf(body).not.toBeAny();
+ expectTypeOf(body).toEqualTypeOf<{ id: string }>();
+ }
+ });
  });
 
  it("typed via event handler", () => {
- eventHandler<{ body: { id: string } }>(async (event) => {
+ eventHandler<{ id: string }>(async (event) => {
  const body = await readBody(event);
  expectTypeOf(body).not.toBeAny();
  expectTypeOf(body).toEqualTypeOf<{ id: string }>();
@@ -107,15 +117,24 @@ describe("types", () => {
 
  it("typed via validator", () => {
  eventHandler(async (event) => {
- const validator = (body: unknown) => body as { id: string };
- const body = await getValidatedQuery(event, validator);
- expectTypeOf(body).not.toBeAny();
- expectTypeOf(body).toEqualTypeOf<{ id: string }>();
+ const validator = (query: unknown) => query as { id: string };
+ const query = await getValidatedQuery(event, validator);
+ expectTypeOf(query).not.toBeAny();
+ expectTypeOf(query).toEqualTypeOf<{ id: string }>();
+ });
+
+ eventHandler({
+ queryValidator: (query: unknown) => query as { id: string },
+ handler: (event) => {
+ const query = getQuery(event);
+ expectTypeOf(query).not.toBeAny();
+ expectTypeOf(query).toEqualTypeOf<{ id: string }>();
+ }
  });
  });
 
  it("typed via event handler", () => {
- eventHandler<{ query: { id: string } }>((event) => {
+ eventHandler<undefined, { id: string }>((event) => {
  const query = getQuery(event);
  expectTypeOf(query).not.toBeAny();
  expectTypeOf(query).toEqualTypeOf<{ id: string }>();