fix(event-handler): pass event, context and request objects into handler

packages/event-handler/src/rest/BaseRouter.ts

@@ -8,6 +8,7 @@ import type { ResolveOptions } from '../types/index.js';
 import type {
   ErrorConstructor,
   ErrorHandler,
+  ErrorResolveOptions,
   HttpMethod,
   Path,
   RouteHandler,
@@ -157,12 +158,19 @@ abstract class BaseRouter {
    */
   protected async handleError(
     error: Error,
-    options?: ResolveOptions
+    options: ErrorResolveOptions
   ): Promise<Response> {
     const handler = this.errorHandlerRegistry.resolve(error);
     if (handler !== null) {
       try {
-        const body = await handler.apply(options?.scope ?? this, [error]);
+        const body = await handler.apply(options.scope ?? this, [
+          error,
+          {
+            request: options.request,
+            event: options.event,
+            context: options.context,
+          },
+        ]);
         return new Response(JSON.stringify(body), {
           status: body.statusCode,
           headers: { 'Content-Type': 'application/json' },
@@ -273,24 +281,6 @@ abstract class BaseRouter {
   ): MethodDecorator | undefined {
     return this.#handleHttpMethod(HttpVerbs.OPTIONS, path, handler);
   }
-
-  public connect(path: Path, handler: RouteHandler): void;
-  public connect(path: Path): MethodDecorator;
-  public connect(
-    path: Path,
-    handler?: RouteHandler
-  ): MethodDecorator | undefined {
-    return this.#handleHttpMethod(HttpVerbs.CONNECT, path, handler);
-  }
-
-  public trace(path: Path, handler: RouteHandler): void;
-  public trace(path: Path): MethodDecorator;
-  public trace(
-    path: Path,
-    handler?: RouteHandler
-  ): MethodDecorator | undefined {
-    return this.#handleHttpMethod(HttpVerbs.TRACE, path, handler);
-  }
 }
 
 export { BaseRouter };

packages/event-handler/src/rest/constants.ts

@@ -1,6 +1,4 @@
 export const HttpVerbs = {
-  CONNECT: 'CONNECT',
-  TRACE: 'TRACE',
   GET: 'GET',
   POST: 'POST',
   PUT: 'PUT',

packages/event-handler/src/types/rest.ts

@@ -1,25 +1,30 @@
-import type { GenericLogger } from '@aws-lambda-powertools/commons/types';
+import type {
+  GenericLogger,
+  JSONObject,
+} from '@aws-lambda-powertools/commons/types';
+import type { APIGatewayProxyEvent, Context } from 'aws-lambda';
 import type { BaseRouter } from '../rest/BaseRouter.js';
 import type { HttpErrorCodes, HttpVerbs } from '../rest/constants.js';
 import type { Route } from '../rest/Route.js';
+import type { ResolveOptions } from './common.js';
 
 type ErrorResponse = {
   statusCode: HttpStatusCode;
   error: string;
   message: string;
 };
 
-interface ErrorContext {
-  path: string;
-  method: string;
-  headers: Record<string, string>;
-  timestamp: string;
-  requestId?: string;
-}
+type RequestOptions = {
+  request: Request;
+  event: APIGatewayProxyEvent;
+  context: Context;
+};
+
+type ErrorResolveOptions = RequestOptions & ResolveOptions;
 
 type ErrorHandler<T extends Error = Error> = (
   error: T,
-  context?: ErrorContext
+  options?: RequestOptions
 ) => Promise<ErrorResponse>;
 
 interface ErrorConstructor<T extends Error = Error> {
@@ -49,7 +54,10 @@ interface CompiledRoute {
 type DynamicRoute = Route & CompiledRoute;
 
 // biome-ignore lint/suspicious/noExplicitAny: we want to keep arguments and return types as any to accept any type of function
-type RouteHandler<T = any, R = any> = (...args: T[]) => R;
+type RouteHandler<
+  TParams = Record<string, unknown>,
+  TReturn = Response | JSONObject,
+> = (args: TParams, options?: RequestOptions) => Promise<TReturn>;
 
 type HttpMethod = keyof typeof HttpVerbs;
 
@@ -98,9 +106,11 @@ export type {
   ErrorConstructor,
   ErrorHandlerRegistryOptions,
   ErrorHandler,
+  ErrorResolveOptions,
   HttpStatusCode,
   HttpMethod,
   Path,
+  RequestOptions,
   RouterOptions,
   RouteHandler,
   RouteOptions,