Update get method with the overloads as in the issue description

sdangol · sdangol · commit 624c61dd37a4 · 2025-12-06T03:32:54.000Z
diff --git a/packages/event-handler/src/http/Route.ts b/packages/event-handler/src/http/Route.ts
@@ -1,21 +1,23 @@
 import type {
+  HandlerResponse,
   HttpMethod,
   Middleware,
   Path,
   RouteHandler,
+  TypedRouteHandler,
 } from '../types/http.js';
 
-class Route {
+class Route<TReqBody = never, TResBody extends HandlerResponse = HandlerResponse> {
   readonly id: string;
   readonly method: string;
   readonly path: Path;
-  readonly handler: RouteHandler;
+  readonly handler: RouteHandler | TypedRouteHandler<TReqBody, TResBody>;
   readonly middleware: Middleware[];
 
   constructor(
     method: HttpMethod,
     path: Path,
-    handler: RouteHandler,
+    handler: RouteHandler | TypedRouteHandler<TReqBody, TResBody>,
     middleware: Middleware[] = []
   ) {
     this.id = `${method}:${path}`;
diff --git a/packages/event-handler/src/http/RouteHandlerRegistry.ts b/packages/event-handler/src/http/RouteHandlerRegistry.ts
@@ -2,6 +2,7 @@ import type { GenericLogger } from '@aws-lambda-powertools/commons/types';
 import { isRegExp } from '@aws-lambda-powertools/commons/typeutils';
 import type {
   DynamicRoute,
+  HandlerResponse,
   HttpMethod,
   HttpRouteHandlerOptions,
   Path,
@@ -94,7 +95,7 @@ class RouteHandlerRegistry {
    *
    * @param route - The route to register
    */
-  public register(route: Route): void {
+  public register<TReqBody = never, TResBody extends HandlerResponse = HandlerResponse>(route: Route<TReqBody, TResBody>): void {
     this.#shouldSort = true;
     const { isValid, issues } = validatePathPattern(route.path);
     if (!isValid) {
diff --git a/packages/event-handler/src/http/Router.ts b/packages/event-handler/src/http/Router.ts
@@ -28,12 +28,14 @@ import type {
   HttpRouteOptions,
   HttpRouterOptions,
   Middleware,
+  ValidationConfig,
   Path,
   RequestContext,
   ResolveStreamOptions,
   ResponseStream,
   RouteHandler,
   RouterResponse,
+  TypedRouteHandler,
 } from '../types/http.js';
 import type { HandlerResponse, ResolveOptions } from '../types/index.js';
 import { HttpStatusCodes, HttpVerbs } from './constants.js';
@@ -443,14 +445,17 @@ class Router {
     }
   }
 
-  public route(handler: RouteHandler, options: HttpRouteOptions): void {
+  public route<TReqBody = never, TResBody extends HandlerResponse = HandlerResponse>(
+    handler: RouteHandler | TypedRouteHandler<TReqBody, TResBody>,
+    options: HttpRouteOptions
+  ): void {
     const { method, path, middleware = [], validation } = options;
     const methods = Array.isArray(method) ? method : [method];
     const resolvedPath = resolvePrefixedPath(path, this.prefix);
 
     // Create validation middleware if validation config provided
     const allMiddleware = validation
-      ? [...middleware, createValidationMiddleware(validation)]
+      ? [...middleware, createValidationMiddleware<TReqBody, TResBody>(validation as ValidationConfig<TReqBody, TResBody>)]
       : middleware;
 
     for (const method of methods) {
@@ -570,15 +575,12 @@ class Router {
     );
   }
 
-  #handleHttpMethod<
-    TReqBody = never,
-    TResBody extends HandlerResponse = HandlerResponse
-  >(
+  #handleHttpMethod<TReqBody = never, TResBody extends HandlerResponse = HandlerResponse>(
     method: HttpMethod,
     path: Path,
     middlewareOrHandler?: Middleware[] | RouteHandler,
-    handlerOrOptions?: RouteHandler | Omit<HttpRouteOptions, 'method' | 'path'>,
-    options?: Omit<HttpRouteOptions, 'method' | 'path' | 'middleware'>
+    handlerOrOptions?: RouteHandler | TypedRouteHandler<TReqBody, TResBody>,
+    options?: { validation: ValidationConfig<TReqBody, TResBody> }
   ): MethodDecorator | undefined {
     // Case 1: post(path, [middleware], handler, { validation })
     if (Array.isArray(middlewareOrHandler)) {
@@ -628,27 +630,31 @@ class Router {
   public get(
     path: Path,
     handler: RouteHandler,
-    options?: Omit<HttpRouteOptions, 'method' | 'path'>
   ): void;
   public get(
     path: Path,
     middleware: Middleware[],
     handler: RouteHandler,
-    options?: Omit<HttpRouteOptions, 'method' | 'path' | 'middleware'>
   ): void;
   public get(path: Path): MethodDecorator;
   public get(path: Path, middleware: Middleware[]): MethodDecorator;
+  public get<TReqBody = never, TResBody extends HandlerResponse = HandlerResponse>(
+    path: Path,
+    middleware: Middleware[],
+    handler: TypedRouteHandler<TReqBody, TResBody>,
+    options: { validation: ValidationConfig<TReqBody, TResBody> }
+  ): void;
   public get<TReqBody = never, TResBody extends HandlerResponse = HandlerResponse>(
     path: Path,
     middlewareOrHandler?: Middleware[] | RouteHandler,
-    handlerOrOptions?: RouteHandler | Omit<HttpRouteOptions, 'method' | 'path'>,
-    options?: Omit<HttpRouteOptions, 'method' | 'path' | 'middleware'>
+    handler?: RouteHandler | TypedRouteHandler<TReqBody, TResBody>,
+    options?: { validation: ValidationConfig<TReqBody, TResBody> }
   ): MethodDecorator | undefined {
     return this.#handleHttpMethod<TReqBody, TResBody>(
       HttpVerbs.GET,
       path,
       middlewareOrHandler,
-      handlerOrOptions,
+      handler,
       options
     );
   }
@@ -666,6 +672,12 @@ class Router {
   ): void;
   public post(path: Path): MethodDecorator;
   public post(path: Path, middleware: Middleware[]): MethodDecorator;
+  public post<TReqBody = never, TResBody extends HandlerResponse = HandlerResponse>(
+    path: Path,
+    middlewareOrHandler?: Middleware[] | RouteHandler,
+    handlerOrOptions?: RouteHandler | Omit<HttpRouteOptions, 'method' | 'path'>,
+    options?: Omit<HttpRouteOptions, 'method' | 'path' | 'middleware'>
+  ): MethodDecorator | undefined;
   public post<TReqBody = never, TResBody extends HandlerResponse = HandlerResponse>(
     path: Path,
     middlewareOrHandler?: Middleware[] | RouteHandler,
diff --git a/packages/event-handler/src/http/middleware/validation.ts b/packages/event-handler/src/http/middleware/validation.ts
@@ -1,5 +1,11 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { HttpRouteOptions, Middleware } from '../../types/http.js';
+import type {
+  HandlerResponse,
+  Middleware,
+  ValidatedRequest,
+  ValidatedResponse,
+  ValidationConfig,
+} from '../../types/http.js';
 import { RequestValidationError, ResponseValidationError } from '../errors.js';
 
 /**
@@ -8,13 +14,22 @@ import { RequestValidationError, ResponseValidationError } from '../errors.js';
  * @param config - Validation configuration for request and response
  * @returns Middleware function that validates request/response
  */
-export const createValidationMiddleware = (
-  config: HttpRouteOptions['validation']
+export const createValidationMiddleware = <
+  TReqBody = unknown,
+  TResBody extends HandlerResponse = HandlerResponse
+>(
+  config: ValidationConfig<TReqBody, TResBody>
 ): Middleware => {
   const reqSchemas = config?.req;
   const resSchemas = config?.res;
 
   return async ({ reqCtx, next }) => {
+    // Initialize valid object
+    reqCtx.valid = {
+      req: {} as ValidatedRequest<TReqBody>,
+      res: {} as ValidatedResponse<TResBody>,
+    };
+
     // Validate request
     if (reqSchemas) {
       if (reqSchemas.body) {
@@ -33,20 +48,20 @@ export const createValidationMiddleware = (
           bodyData = await clonedRequest.text();
         }
 
-        await validateRequest(reqSchemas.body, bodyData, 'body');
+        reqCtx.valid.req.body = await validateRequest(reqSchemas.body, bodyData, 'body') as TReqBody;
       }
       if (reqSchemas.headers) {
         const headers = Object.fromEntries(reqCtx.req.headers.entries());
-        await validateRequest(reqSchemas.headers, headers, 'headers');
+        reqCtx.valid.req.headers = await validateRequest(reqSchemas.headers, headers, 'headers') as Record<string, string>;
       }
       if (reqSchemas.path) {
-        await validateRequest(reqSchemas.path, reqCtx.params, 'path');
+        reqCtx.valid.req.path = await validateRequest(reqSchemas.path, reqCtx.params, 'path') as Record<string, string>;
       }
       if (reqSchemas.query) {
         const query = Object.fromEntries(
           new URL(reqCtx.req.url).searchParams.entries()
         );
-        await validateRequest(reqSchemas.query, query, 'query');
+        reqCtx.valid.req.query = await validateRequest(reqSchemas.query, query, 'query') as Record<string, string>;
       }
     }
 
@@ -64,12 +79,12 @@ export const createValidationMiddleware = (
           ? await clonedResponse.json()
           : await clonedResponse.text();
 
-        await validateResponse(resSchemas.body, bodyData, 'body');
+        reqCtx.valid.res.body = await validateResponse(resSchemas.body, bodyData, 'body') as TResBody;
       }
 
       if (resSchemas.headers) {
         const headers = Object.fromEntries(response.headers.entries());
-        await validateResponse(resSchemas.headers, headers, 'headers');
+        reqCtx.valid.res.headers = await validateResponse(resSchemas.headers, headers, 'headers') as Record<string, string>;
       }
     }
   };
@@ -79,7 +94,7 @@ async function validateRequest(
   schema: StandardSchemaV1,
   data: unknown,
   component: 'body' | 'headers' | 'path' | 'query'
-): Promise<void> {
+): Promise<unknown> {
   try {
     const result = await schema['~standard'].validate(data);
 
@@ -88,6 +103,8 @@ async function validateRequest(
       const error = new Error('Validation failed');
       throw new RequestValidationError(message, component, error);
     }
+    
+    return result.value;
   } catch (error) {
     // Handle schemas that throw errors instead of returning issues
     if (error instanceof RequestValidationError) {
@@ -106,7 +123,7 @@ async function validateResponse(
   schema: StandardSchemaV1,
   data: unknown,
   component: 'body' | 'headers'
-): Promise<void> {
+): Promise<unknown> {
   try {
     const result = await schema['~standard'].validate(data);
 
@@ -115,6 +132,8 @@ async function validateResponse(
       const error = new Error('Validation failed');
       throw new ResponseValidationError(message, component, error);
     }
+    
+    return result.value;
   } catch (error) {
     // Handle schemas that throw errors instead of returning issues
     if (error instanceof ResponseValidationError) {
diff --git a/packages/event-handler/src/types/http.ts b/packages/event-handler/src/types/http.ts
@@ -25,14 +25,36 @@ type ResponseTypeMap = {
   ALB: ALBResult;
 };
 
-type RequestContext = {
+/**
+ * Validated request data
+ */
+type ValidatedRequest<TBody = unknown> = {
+  body: TBody;
+  headers?: Record<string, string>;
+  path?: Record<string, string>;
+  query?: Record<string, string>;
+};
+
+/**
+ * Validated response data
+ */
+type ValidatedResponse<TBody extends HandlerResponse = HandlerResponse> = {
+  body?: TBody;
+  headers?: Record<string, string>;
+};
+
+type RequestContext<TReqBody = never, TResBody extends HandlerResponse = HandlerResponse> = {
   req: Request;
   event: APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBEvent;
   context: Context;
   res: Response;
   params: Record<string, string>;
   responseType: ResponseType;
   isBase64Encoded?: boolean;
+  valid?: {
+    req: ValidatedRequest<TReqBody>;
+    res: ValidatedResponse<TResBody>;
+  };
 };
 
 type HttpResolveOptions = ResolveOptions & { isHttpStreaming?: boolean };
@@ -46,7 +68,7 @@ type ErrorHandler<T extends Error = Error> = (
 
 interface ErrorConstructor<T extends Error = Error> {
   // biome-ignore lint/suspicious/noExplicitAny: this is a generic type that is intentionally open
-  new (...args: any[]): T;
+  new(...args: any[]): T;
   prototype: T;
 }
 
@@ -95,6 +117,10 @@ type RouteHandler<TReturn = HandlerResponse> = (
   reqCtx: RequestContext
 ) => Promise<TReturn> | TReturn;
 
+type TypedRouteHandler<TReqBody, TResBody extends HandlerResponse = HandlerResponse, TReturn = HandlerResponse> = (
+  reqCtx: RequestContext<TReqBody, TResBody>
+) => Promise<TReturn> | TReturn;
+
 type HttpMethod = keyof typeof HttpVerbs;
 
 type HttpStatusCode = (typeof HttpStatusCodes)[keyof typeof HttpStatusCodes];
@@ -254,6 +280,7 @@ type RouterResponse =
   | APIGatewayProxyResult
   | APIGatewayProxyStructuredResultV2
   | ALBResult;
+
 /**
  * Configuration for request validation
  */
@@ -329,4 +356,7 @@ export type {
   ResponseValidationConfig,
   ValidationConfig,
   ValidationErrorDetail,
+  ValidatedRequest,
+  ValidatedResponse,
+  TypedRouteHandler
 };
diff --git a/packages/event-handler/tests/unit/http/Router/validation.test.ts b/packages/event-handler/tests/unit/http/Router/validation.test.ts
