feat(event-handler): Add http ProxyEvent handler

Author: michaelbrewer

aws_lambda_powertools/utilities/data_classes/alb_event.py

@@ -21,14 +21,6 @@ class ALBEvent(BaseProxyEvent):
     def request_context(self) -> ALBEventRequestContext:
         return ALBEventRequestContext(self._data)
 
-    @property
-    def http_method(self) -> str:
-        return self["httpMethod"]
-
-    @property
-    def path(self) -> str:
-        return self["path"]
-
     @property
     def multi_value_query_string_parameters(self) -> Optional[Dict[str, List[str]]]:
         return self.get("multiValueQueryStringParameters")

aws_lambda_powertools/utilities/data_classes/api_gateway_proxy_event.py

@@ -212,15 +212,6 @@ def version(self) -> str:
     def resource(self) -> str:
         return self["resource"]
 
-    @property
-    def path(self) -> str:
-        return self["path"]
-
-    @property
-    def http_method(self) -> str:
-        """The HTTP method used. Valid values include: DELETE, GET, HEAD, OPTIONS, PATCH, POST, and PUT."""
-        return self["httpMethod"]
-
     @property
     def multi_value_headers(self) -> Dict[str, List[str]]:
         return self["multiValueHeaders"]
@@ -441,3 +432,12 @@ def path_parameters(self) -> Optional[Dict[str, str]]:
     @property
     def stage_variables(self) -> Optional[Dict[str, str]]:
         return self.get("stageVariables")
+
+    @property
+    def path(self) -> str:
+        return self.raw_path
+
+    @property
+    def http_method(self) -> str:
+        """The HTTP method used. Valid values include: DELETE, GET, HEAD, OPTIONS, PATCH, POST, and PUT."""
+        return self.request_context.http.method

aws_lambda_powertools/utilities/data_classes/common.py

@@ -59,6 +59,15 @@ def is_base64_encoded(self) -> Optional[bool]:
     def body(self) -> Optional[str]:
         return self.get("body")
 
+    @property
+    def path(self) -> str:
+        return self["path"]
+
+    @property
+    def http_method(self) -> str:
+        """The HTTP method used. Valid values include: DELETE, GET, HEAD, OPTIONS, PATCH, POST, and PUT."""
+        return self["httpMethod"]
+
     def get_query_string_value(self, name: str, default_value: Optional[str] = None) -> Optional[str]:
         """Get query string value by name
 

aws_lambda_powertools/utilities/event_handler/__init__.py

@@ -0,0 +1,103 @@
+from enum import Enum
+from typing import Any, Callable, Dict, List, Tuple, Union
+
+from aws_lambda_powertools.utilities.data_classes import ALBEvent, APIGatewayProxyEvent, APIGatewayProxyEventV2
+from aws_lambda_powertools.utilities.data_classes.common import BaseProxyEvent
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+
+class ProxyEventType(Enum):
+    http_api_v1 = "APIGatewayProxyEvent"
+    http_api_v2 = "APIGatewayProxyEventV2"
+    alb_event = "ALBEvent"
+
+
+class ApiGatewayResolver:
+    def __init__(self, proxy_type: Enum = ProxyEventType.http_api_v1):
+        self._proxy_type: Enum = proxy_type
+        self._resolvers: List[Dict] = []
+
+    def get(self, uri: str, include_event: bool = False, include_context: bool = False, **kwargs):
+        return self.route("GET", uri, include_event, include_context, **kwargs)
+
+    def post(self, uri: str, include_event: bool = False, include_context: bool = False, **kwargs):
+        return self.route("POST", uri, include_event, include_context, **kwargs)
+
+    def put(self, uri: str, include_event: bool = False, include_context: bool = False, **kwargs):
+        return self.route("PUT", uri, include_event, include_context, **kwargs)
+
+    def delete(self, uri: str, include_event: bool = False, include_context: bool = False, **kwargs):
+        return self.route("DELETE", uri, include_event, include_context, **kwargs)
+
+    def route(
+        self,
+        method: str,
+        uri: str,
+        include_event: bool = False,
+        include_context: bool = False,
+        **kwargs,
+    ):
+        def register_resolver(func: Callable[[Any, Any], Tuple[int, str, str]]):
+            self._register(func, method.upper(), uri, include_event, include_context, kwargs)
+            return func
+
+        return register_resolver
+
+    def resolve(self, event: Dict, context: LambdaContext) -> Dict:
+        proxy_event: BaseProxyEvent = self._as_proxy_event(event)
+        resolver: Callable[[Any], Tuple[int, str, str]]
+        config: Dict
+        resolver, config = self._find_resolver(proxy_event.http_method.upper(), proxy_event.path)
+        kwargs = self._kwargs(proxy_event, context, config)
+        result = resolver(**kwargs)
+        return {"statusCode": result[0], "headers": {"Content-Type": result[1]}, "body": result[2]}
+
+    def _register(
+        self,
+        func: Callable[[Any, Any], Tuple[int, str, str]],
+        http_method: str,
+        uri_starts_with: str,
+        include_event: bool,
+        include_context: bool,
+        kwargs: Dict,
+    ):
+        kwargs["include_event"] = include_event
+        kwargs["include_context"] = include_context
+        self._resolvers.append(
+            {
+                "http_method": http_method,
+                "uri_starts_with": uri_starts_with,
+                "func": func,
+                "config": kwargs,
+            }
+        )
+
+    def _as_proxy_event(self, event: Dict) -> Union[ALBEvent, APIGatewayProxyEvent, APIGatewayProxyEventV2]:
+        if self._proxy_type == ProxyEventType.http_api_v1:
+            return APIGatewayProxyEvent(event)
+        if self._proxy_type == ProxyEventType.http_api_v2:
+            return APIGatewayProxyEventV2(event)
+        return ALBEvent(event)
+
+    def _find_resolver(self, http_method: str, path: str) -> Tuple[Callable, Dict]:
+        for resolver in self._resolvers:
+            expected_method = resolver["http_method"]
+            if http_method != expected_method:
+                continue
+            path_starts_with = resolver["uri_starts_with"]
+            if path.startswith(path_starts_with):
+                return resolver["func"], resolver["config"]
+
+        raise ValueError(f"No resolver found for '{http_method}.{path}'")
+
+    @staticmethod
+    def _kwargs(event: BaseProxyEvent, context: LambdaContext, config: Dict) -> Dict[str, Any]:
+        kwargs: Dict[str, Any] = {}
+        if config.get("include_event", False):
+            kwargs["event"] = event
+        if config.get("include_context", False):
+            kwargs["context"] = context
+        return kwargs
+
+    def __call__(self, event, context) -> Any:
+        return self.resolve(event, context)

aws_lambda_powertools/utilities/event_handler/api_gateway.py

@@ -0,0 +1,96 @@
+import json
+import os
+
+import pytest
+
+from aws_lambda_powertools.utilities.data_classes import ALBEvent, APIGatewayProxyEvent, APIGatewayProxyEventV2
+from aws_lambda_powertools.utilities.event_handler.api_gateway import ApiGatewayResolver, ProxyEventType
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+
+def load_event(file_name: str) -> dict:
+    full_file_name = os.path.dirname(os.path.realpath(__file__)) + "/../../events/" + file_name
+    with open(full_file_name) as fp:
+        return json.load(fp)
+
+
+def test_alb_event():
+    app = ApiGatewayResolver(proxy_type=ProxyEventType.alb_event)
+
+    @app.get("/lambda", include_event=True, include_context=True)
+    def foo(event: ALBEvent, context: LambdaContext):
+        assert isinstance(event, ALBEvent)
+        assert context == {}
+        return 200, "text/html", "foo"
+
+    result = app(load_event("albEvent.json"), {})
+
+    assert result["statusCode"] == 200
+    assert result["headers"]["Content-Type"] == "text/html"
+    assert result["body"] == "foo"
+
+
+def test_api_gateway_v1():
+    app = ApiGatewayResolver(proxy_type=ProxyEventType.http_api_v1)
+
+    @app.get("/my/path", include_event=True, include_context=True)
+    def get_lambda(event: APIGatewayProxyEvent, context: LambdaContext):
+        assert isinstance(event, APIGatewayProxyEvent)
+        assert context == {}
+        return 200, "application/json", json.dumps({"foo": "value"})
+
+    result = app(load_event("apiGatewayProxyEvent.json"), {})
+
+    assert result["statusCode"] == 200
+    assert result["headers"]["Content-Type"] == "application/json"
+
+
+def test_include_event_false():
+    app = ApiGatewayResolver()
+
+    @app.get("/my/path")
+    def get_lambda():
+        return 200, "plain/html", "foo"
+
+    result = app(load_event("apiGatewayProxyEvent.json"), {})
+
+    assert result["statusCode"] == 200
+    assert result["body"] == "foo"
+
+
+def test_api_gateway_v2():
+    app = ApiGatewayResolver(proxy_type=ProxyEventType.http_api_v2)
+
+    @app.post("/my/path", include_event=True)
+    def my_path(event: APIGatewayProxyEventV2):
+        assert isinstance(event, APIGatewayProxyEventV2)
+        post_data = json.loads(event.body or "{}")
+        return 200, "plain/text", post_data["username"]
+
+    result = app(load_event("apiGatewayProxyV2Event.json"), {})
+
+    assert result["statusCode"] == 200
+    assert result["headers"]["Content-Type"] == "plain/text"
+    assert result["body"] == "tom"
+
+
+def test_no_matching():
+    app = ApiGatewayResolver()
+
+    @app.get("/not_matching_get")
+    def no_get_matching():
+        raise RuntimeError()
+
+    @app.put("/no_matching")
+    def no_put_matching():
+        raise RuntimeError()
+
+    @app.delete("/no_matching")
+    def no_delete_matching():
+        raise RuntimeError()
+
+    def handler(event, context):
+        app.resolve(event, context)
+
+    with pytest.raises(ValueError):
+        handler(load_event("apiGatewayProxyEvent.json"), None)