modmex-lambda 0.1.0__py3-none-any.whl

modmex_lambda/event_handler/gateway_response.py

@@ -0,0 +1,96 @@
+"""API Gateway proxy response building."""
+
+from __future__ import annotations
+
+import base64
+import zlib
+from collections.abc import Callable, Mapping
+from typing import Any
+
+from modmex_lambda.data_classes.common import BaseProxyEvent
+from modmex_lambda.event_handler.cors import CORSConfig
+from modmex_lambda.event_handler.response import Response
+from modmex_lambda.event_handler.routing import Route
+
+
+class GatewayResponseBuilder:
+    def __init__(self, response: Response, route: Route | None, json_serializer: Callable[[Any], str]) -> None:
+        self.response = response
+        self.route = route
+        self.json_serializer = json_serializer
+
+    def serialize(self, event: BaseProxyEvent, cors: CORSConfig | None = None) -> dict[str, Any]:
+        if self.response.is_json() and not isinstance(self.response.body, (str, bytes)):
+            self.response.body = self.json_serializer(self.response.body)
+
+        self._handle_route_configuration(event, cors)
+
+        if isinstance(self.response.body, bytes):
+            self.response.base64_encoded = True
+            self.response.body = base64.b64encode(self.response.body).decode()
+
+        return {
+            "statusCode": self.response.status_code,
+            "body": self.response.body,
+            "isBase64Encoded": self.response.base64_encoded,
+            **event.header_serializer().serialize(
+                headers=self.response.headers,
+                cookies=self.response.cookies,
+            ),
+        }
+
+    def _handle_route_configuration(self, event: BaseProxyEvent, cors: CORSConfig | None) -> None:
+        if self.route is None:
+            return
+        if self.route.cors:
+            self._add_cors(event, cors or CORSConfig())
+        if self.route.cache_control:
+            self._add_cache_control(self.route.cache_control)
+        if self._compression_enabled(
+            route_compression=self.route.compress,
+            response_compression=self.response.compress,
+            event=event,
+        ):
+            self._compress()
+
+    def _add_cors(self, event: BaseProxyEvent, cors: CORSConfig) -> None:
+        origin_header = self._extract_origin_header(event.resolved_headers_field)
+        origin = cors.allowed_origin(origin_header)
+        if origin is not None:
+            self.response.headers.update(cors.to_dict(origin))
+
+    def _add_cache_control(self, cache_control: str) -> None:
+        self.response.headers["Cache-Control"] = cache_control if self.response.status_code == 200 else "no-cache"
+
+    def _compress(self) -> None:
+        self.response.headers["Content-Encoding"] = "gzip"
+        if isinstance(self.response.body, str):
+            self.response.body = bytes(self.response.body, "utf-8")
+        gzip = zlib.compressobj(9, zlib.DEFLATED, zlib.MAX_WBITS | 16)
+        self.response.body = gzip.compress(self.response.body) + gzip.flush()
+
+    @staticmethod
+    def _extract_origin_header(resolved_headers: Mapping[str, Any]) -> str | None:
+        resolved_header = resolved_headers.get("origin")
+        if isinstance(resolved_header, list):
+            return resolved_header[0]
+        return resolved_header
+
+    @staticmethod
+    def _compression_enabled(
+        route_compression: bool,
+        response_compression: bool | None,
+        event: BaseProxyEvent,
+    ) -> bool:
+        encoding = event.resolved_headers_field.get("accept-encoding", "")
+        if isinstance(encoding, list):
+            encoding = ",".join(encoding)
+
+        if not isinstance(encoding, str) or "gzip" not in encoding:
+            return False
+        if response_compression is not None:
+            return response_compression
+        return route_compression
+
+
+__all__ = ["GatewayResponseBuilder"]

modmex_lambda/event_handler/middlewares.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Protocol, Generic
+
+from modmex_lambda.event_handler.response import Response
+from modmex_lambda.event_handler.types import EventHandlerInstance, IApiGatewayResolver
+
+__all__ = ["NextMiddleware", "IMiddleware"]
+
+
+class NextMiddleware(Protocol):
+    def __call__(self, app: IApiGatewayResolver) -> Response:
+        ...
+
+    @property
+    def __name__(self) -> str:
+        ...
+
+
+class IMiddleware(ABC, Generic[EventHandlerInstance]):
+    
+    @abstractmethod
+    def handler(self, app: EventHandlerInstance, next_middleware: NextMiddleware) -> Response:
+        raise NotImplementedError()
+    
+    
+    @property
+    def __name__(self) -> str:
+        return self.__class__.__name__
+    
+    def __call__(self, app: EventHandlerInstance, next_middleware: NextMiddleware) -> Response:
+        return self.handler(app, next_middleware)

modmex_lambda/event_handler/params.py

@@ -0,0 +1,44 @@
+"""Route parameter binding markers.
+
+Use these markers with ``Annotated[T, Body()]`` style annotations.
+"""
+
+from __future__ import annotations
+
+from typing import Generic, TypeVar
+
+from modmex import BaseModel
+
+T = TypeVar("T")
+
+
+class Param(BaseModel, Generic[T]):
+    name: str | None = None
+
+
+class Body(Param[T]):
+    pass
+
+
+class Query(Param[T]):
+    pass
+
+
+class Path(Param[T]):
+    pass
+
+
+class Header(Param[T]):
+    pass
+
+
+class Cookie(Param[T]):
+    pass
+
+
+class RawEvent(Param[T]):
+    pass
+
+
+class LambdaContext(Param[T]):
+    pass

modmex_lambda/event_handler/request.py

@@ -0,0 +1,70 @@
+"""API Gateway event normalization."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from modmex_lambda.data_classes.common import BaseProxyEvent
+
+
+class Request:
+    
+    __slots__ = (
+        "_route_path",
+        "_path_parameters",
+        "_current_event",
+        "_context",
+    )
+    
+    def __init__(
+        self,
+        route_path: str,
+        path_parameters: dict[str, Any],
+        current_event: BaseProxyEvent,
+        context: dict[str, Any] | None = None,
+    )->None:
+        self._route_path = route_path
+        self._path_parameters = path_parameters
+        self._current_event = current_event
+        self._context = context if context is not None else {}
+
+    
+    @property
+    def route(self) -> str:
+        return self._route_path
+    
+    @property
+    def path_parameters(self) -> dict[str, Any]:
+        return self._path_parameters
+    
+    @property
+    def method(self) -> str:
+        return self._current_event.http_method.upper()
+    
+    @property
+    def headers(self) -> dict[str, str]:
+        return self._current_event.headers or {}
+    
+    @property
+    def query_parameters(self) -> dict[str, str] | None:
+        return self._current_event.query_string_parameters
+    
+    @property
+    def resolved_event(self) -> BaseProxyEvent:
+        return self._current_event
+    
+    @property
+    def body(self) -> Any:
+        return self._current_event.body
+    
+    @property
+    def json_body(self) -> Any:
+        return self._current_event.json_body
+    
+    @property
+    def current_event(self) -> BaseProxyEvent:
+        return self._current_event
+    
+    @property
+    def context(self) -> dict[str, Any]:
+        return self._context

modmex_lambda/event_handler/response.py

@@ -0,0 +1,60 @@
+"""API Gateway response helpers."""
+
+from __future__ import annotations
+
+from typing import TypeVar, Generic, Mapping
+from modmex_lambda.shared.cookies import Cookie
+
+
+
+
+T = TypeVar("T")
+
+
+class Response(Generic[T]):
+    """Response data class that provides greater control over what is returned from the proxy event"""
+
+    def __init__(
+        self,
+        status_code: int,
+        content_type: str | None = None,
+        body: T | None = None,
+        headers: Mapping[str, str | list[str]] | None = None,
+        cookies: list[Cookie] | None = None,
+        compress: bool | None = None,
+    ):
+        """
+
+        Parameters
+        ----------
+        status_code: int
+            Http status code, example 200
+        content_type: str
+            Optionally set the Content-Type header, example "application/json". Note this will be merged into any
+            provided http headers
+        body: str | bytes | None
+            Optionally set the response body. Note: bytes body will be automatically base64 encoded
+        headers: Mapping[str, str | list[str]]
+            Optionally set specific http headers. Setting "Content-Type" here would override the `content_type` value.
+        cookies: list[Cookie]
+            Optionally set cookies.
+        """
+        self.status_code = status_code
+        self.body = body
+        self.base64_encoded = False
+        self.headers: dict[str, str | list[str]] = dict(headers) if headers else {}
+        self.cookies = cookies or []
+        self.compress = compress
+        self.content_type = content_type
+        if content_type:
+            self.headers.setdefault("Content-Type", content_type)
+
+    def is_json(self) -> bool:
+        """
+        Helper method to check if the response content type is JSON
+        """
+        content_type = self.headers.get("Content-Type", "")
+        if isinstance(content_type, list):
+            content_type = content_type[0]
+        return content_type.startswith("application/json")
+