handle unsupported http methods

Author: svozza

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

@@ -15,21 +15,22 @@ import type {
   RouteOptions,
   RouterOptions,
 } from '../types/rest.js';
-import { HttpVerbs } from './constants.js';
+import { HttpErrorCodes, HttpVerbs } from './constants.js';
 import {
   handlerResultToProxyResult,
   proxyEventToWebRequest,
   responseToProxyResult,
 } from './converters.js';
 import { ErrorHandlerRegistry } from './ErrorHandlerRegistry.js';
 import {
+  InternalServerError,
   MethodNotAllowedError,
   NotFoundError,
   ServiceError,
 } from './errors.js';
 import { Route } from './Route.js';
 import { RouteHandlerRegistry } from './RouteHandlerRegistry.js';
-import { isAPIGatewayProxyEvent } from './utils.js';
+import { isAPIGatewayProxyEvent, isHttpMethod } from './utils.js';
 
 abstract class BaseRouter {
   protected context: Record<string, unknown>;
@@ -156,16 +157,27 @@ abstract class BaseRouter {
     options?: ResolveOptions
   ): Promise<APIGatewayProxyResult | undefined> {
     if (!isAPIGatewayProxyEvent(event)) {
-      this.logger.warn(
+      this.logger.error(
         'Received an event that is not compatible with this resolver'
       );
-      return;
+      throw new InternalServerError();
+    }
+
+    const method = event.requestContext.httpMethod.toUpperCase();
+    if (!isHttpMethod(method)) {
+      this.logger.error(`HTTP method ${method} is not supported.`);
+      // We can't throw a MethodNotAllowedError outside the try block as it
+      // will be converted to an internal server error by the API Gateway runtime
+      return {
+        statusCode: HttpErrorCodes.METHOD_NOT_ALLOWED,
+        body: '',
+      };
     }
 
+    const request = proxyEventToWebRequest(event);
+
     try {
-      const request = proxyEventToWebRequest(event);
       const path = new URL(request.url).pathname as Path;
-      const method = request.method.toUpperCase() as HttpMethod;
 
       const route = this.routeRegistry.resolve(method, path);
 
@@ -184,8 +196,9 @@ abstract class BaseRouter {
 
       return await handlerResultToProxyResult(result);
     } catch (error) {
+      this.logger.debug(`There was an error processing the request: ${error}`);
       const result = await this.handleError(error as Error, {
-        request: proxyEventToWebRequest(event),
+        request,
         event,
         context,
         scope: options?.scope,

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

@@ -1,7 +1,17 @@
 import { isRecord, isString } from '@aws-lambda-powertools/commons/typeutils';
 import type { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
-import type { CompiledRoute, Path, ValidationResult } from '../types/rest.js';
-import { PARAM_PATTERN, SAFE_CHARS, UNSAFE_CHARS } from './constants.js';
+import type {
+  CompiledRoute,
+  HttpMethod,
+  Path,
+  ValidationResult,
+} from '../types/rest.js';
+import {
+  HttpVerbs,
+  PARAM_PATTERN,
+  SAFE_CHARS,
+  UNSAFE_CHARS,
+} from './constants.js';
 
 export function compilePath(path: Path): CompiledRoute {
   const paramNames: string[] = [];
@@ -69,6 +79,10 @@ export const isAPIGatewayProxyEvent = (
   );
 };
 
+export const isHttpMethod = (method: string): method is HttpMethod => {
+  return Object.keys(HttpVerbs).includes(method);
+};
+
 /**
  * Type guard to check if the provided result is an API Gateway Proxy result.
  *

packages/event-handler/tests/unit/rest/BaseRouter.test.ts

@@ -79,6 +79,23 @@ describe('Class: BaseRouter', () => {
     });
   });
 
+  it.each([['CONNECT'], ['TRACE']])(
+    'throws MethodNotAllowedError for %s requests',
+    async (method) => {
+      // Prepare
+      const app = new TestResolver();
+
+      // Act & Assess
+      const result = await app.resolve(
+        createTestEvent('/test', method),
+        context
+      );
+
+      expect(result?.statusCode).toBe(HttpErrorCodes.METHOD_NOT_ALLOWED);
+      expect(result?.body).toEqual('');
+    }
+  );
+
   it('accepts multiple HTTP methods', async () => {
     // Act
     const app = new TestResolver();
@@ -965,18 +982,14 @@ describe('Class: BaseRouter', () => {
   });
 
   describe('resolve method', () => {
-    it('returns undefined and logs warning for non-API Gateway events', async () => {
+    it('throws an internal server error for non-API Gateway events', async () => {
       // Prepare
       const app = new TestResolver();
       const nonApiGatewayEvent = { Records: [] }; // SQS-like event
 
-      // Act
-      const result = await app.resolve(nonApiGatewayEvent, context);
-
-      // Assess
-      expect(result).toBeUndefined();
-      expect(console.warn).toHaveBeenCalledWith(
-        'Received an event that is not compatible with this resolver'
+      // Act & Assess
+      expect(app.resolve(nonApiGatewayEvent, context)).rejects.toThrowError(
+        InternalServerError
       );
     });