Adding header - Initial commit

Author: leandrodamascena

aws_lambda_powertools/event_handler/middlewares/openapi_validation.py

@@ -81,9 +81,22 @@ def handler(self, app: EventHandlerInstance, next_middleware: NextMiddleware) ->
             query_string,
         )
 
+        # Normalize query values before validate this
+        headers = _normalize_multi_header_values_with_param(
+            app.current_event.resolved_headers_field,
+            route.dependant.header_params,
+        )
+
+        # Process header values
+        header_values, header_errors = _request_params_to_args(
+            route.dependant.header_params,
+            headers,
+        )
+
         values.update(path_values)
         values.update(query_values)
-        errors += path_errors + query_errors
+        values.update(header_values)
+        errors += path_errors + query_errors + header_errors
 
         # Process the request body, if it exists
         if route.dependant.body_params:
@@ -377,3 +390,29 @@ def _normalize_multi_query_string_with_param(query_string: Optional[Dict[str, st
             except KeyError:
                 pass
     return query_string
+
+
+def _normalize_multi_header_values_with_param(headers: Optional[Dict[str, str]], params: Sequence[ModelField]):
+    """
+    Extract and normalize resolved_headers_field
+
+    Parameters
+    ----------
+    headers: Dict
+        A dictionary containing the initial header parameters.
+    params: Sequence[ModelField]
+        A sequence of ModelField objects representing parameters.
+
+    Returns
+    -------
+    A dictionary containing the processed headers.
+    """
+    if headers:
+        for param in filter(is_scalar_field, params):
+            try:
+                # if the target parameter is a scalar, we keep the first value of the headers
+                # regardless if there are more in the payload
+                headers[param.name] = headers[param.name][0]
+            except KeyError:
+                pass
+    return headers

aws_lambda_powertools/event_handler/openapi/dependant.py

@@ -14,12 +14,12 @@
 from aws_lambda_powertools.event_handler.openapi.params import (
     Body,
     Dependant,
+    Header,
     Param,
     ParamTypes,
     Query,
     _File,
     _Form,
-    _Header,
     analyze_param,
     create_response_field,
     get_flat_dependant,
@@ -59,16 +59,21 @@ def add_param_to_fields(
 
     """
     field_info = cast(Param, field.field_info)
-    if field_info.in_ == ParamTypes.path:
-        dependant.path_params.append(field)
-    elif field_info.in_ == ParamTypes.query:
-        dependant.query_params.append(field)
-    elif field_info.in_ == ParamTypes.header:
-        dependant.header_params.append(field)
+
+    # Dictionary to map ParamTypes to their corresponding lists in dependant
+    param_type_map = {
+        ParamTypes.path: dependant.path_params,
+        ParamTypes.query: dependant.query_params,
+        ParamTypes.header: dependant.header_params,
+        ParamTypes.cookie: dependant.cookie_params,
+    }
+
+    # Check if field_info.in_ is a valid key in param_type_map and append the field to the corresponding list
+    # or raise an exception if it's not a valid key.
+    if field_info.in_ in param_type_map:
+        param_type_map[field_info.in_].append(field)
     else:
-        if field_info.in_ != ParamTypes.cookie:
-            raise AssertionError(f"Unsupported param type: {field_info.in_}")
-        dependant.cookie_params.append(field)
+        raise AssertionError(f"Unsupported param type: {field_info.in_}")
 
 
 def get_typed_annotation(annotation: Any, globalns: Dict[str, Any]) -> Any:
@@ -265,7 +270,7 @@ def is_body_param(*, param_field: ModelField, is_path_param: bool) -> bool:
         return False
     elif is_scalar_field(field=param_field):
         return False
-    elif isinstance(param_field.field_info, (Query, _Header)) and is_scalar_sequence_field(param_field):
+    elif isinstance(param_field.field_info, (Query, Header)) and is_scalar_sequence_field(param_field):
         return False
     else:
         if not isinstance(param_field.field_info, Body):

aws_lambda_powertools/event_handler/openapi/params.py

@@ -486,7 +486,7 @@ def __init__(
         )
 
 
-class _Header(Param):
+class Header(Param):
     """
     A class used internally to represent a header parameter in a path operation.
     """
@@ -527,6 +527,67 @@ def __init__(
         json_schema_extra: Union[Dict[str, Any], None] = None,
         **extra: Any,
     ):
+        """
+        Constructs a new Query param.
+
+        Parameters
+        ----------
+        default: Any
+            The default value of the parameter
+        default_factory: Callable[[], Any], optional
+            Callable that will be called when a default value is needed for this field
+        annotation: Any, optional
+            The type annotation of the parameter
+        alias: str, optional
+            The public name of the field
+        alias_priority: int, optional
+            Priority of the alias. This affects whether an alias generator is used
+        validation_alias: str | AliasPath | AliasChoices | None, optional
+            Alias to be used for validation only
+        serialization_alias: str | AliasPath | AliasChoices | None, optional
+            Alias to be used for serialization only
+        convert_underscores: bool
+            If true convert "_" to "-"
+            See RFC: https://www.rfc-editor.org/rfc/rfc9110.html#name-field-name-registry
+        title: str, optional
+            The title of the parameter
+        description: str, optional
+            The description of the parameter
+        gt: float, optional
+            Only applies to numbers, required the field to be "greater than"
+        ge: float, optional
+            Only applies to numbers, required the field to be "greater than or equal"
+        lt: float, optional
+            Only applies to numbers, required the field to be "less than"
+        le: float, optional
+            Only applies to numbers, required the field to be "less than or equal"
+        min_length: int, optional
+            Only applies to strings, required the field to have a minimum length
+        max_length: int, optional
+            Only applies to strings, required the field to have a maximum length
+        pattern: str, optional
+            Only applies to strings, requires the field match against a regular expression pattern string
+        discriminator: str, optional
+            Parameter field name for discriminating the type in a tagged union
+        strict: bool, optional
+            Enables Pydantic's strict mode for the field
+        multiple_of: float, optional
+            Only applies to numbers, requires the field to be a multiple of the given value
+        allow_inf_nan: bool, optional
+            Only applies to numbers, requires the field to allow infinity and NaN values
+        max_digits: int, optional
+            Only applies to Decimals, requires the field to have a maxmium number of digits within the decimal.
+        decimal_places: int, optional
+            Only applies to Decimals, requires the field to have at most a number of decimal places
+        examples: List[Any], optional
+            A list of examples for the parameter
+        deprecated: bool, optional
+            If `True`, the parameter will be marked as deprecated
+        include_in_schema: bool, optional
+            If `False`, the parameter will be excluded from the generated OpenAPI schema
+        json_schema_extra: Dict[str, Any], optional
+            Extra values to include in the generated OpenAPI schema
+        """
         self.convert_underscores = convert_underscores
         super().__init__(
             default=default,

aws_lambda_powertools/utilities/data_classes/alb_event.py

@@ -42,6 +42,13 @@ def resolved_query_string_parameters(self) -> Optional[Dict[str, Any]]:
 
         return self.query_string_parameters
 
+    @property
+    def resolved_headers_field(self) -> Optional[Dict[str, Any]]:
+        if self.multi_value_headers:
+            return self.multi_value_headers
+
+        return self.headers
+
     @property
     def multi_value_headers(self) -> Optional[Dict[str, List[str]]]:
         return self.get("multiValueHeaders")

aws_lambda_powertools/utilities/data_classes/api_gateway_proxy_event.py

@@ -125,6 +125,13 @@ def resolved_query_string_parameters(self) -> Optional[Dict[str, Any]]:
 
         return self.query_string_parameters
 
+    @property
+    def resolved_headers_field(self) -> Optional[Dict[str, Any]]:
+        if self.multi_value_headers:
+            return self.multi_value_headers
+
+        return self.headers
+
     @property
     def request_context(self) -> APIGatewayEventRequestContext:
         return APIGatewayEventRequestContext(self._data)
@@ -316,3 +323,11 @@ def resolved_query_string_parameters(self) -> Optional[Dict[str, Any]]:
             return query_string
 
         return {}
+
+    @property
+    def resolved_headers_field(self) -> Optional[Dict[str, Any]]:
+        if self.headers is not None:
+            headers = {key: value.split(",") if "," in value else value for key, value in self.headers.items()}
+            return headers
+
+        return {}

aws_lambda_powertools/utilities/data_classes/bedrock_agent_event.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from aws_lambda_powertools.utilities.data_classes.common import BaseProxyEvent, DictWrapper
 
@@ -112,3 +112,7 @@ def query_string_parameters(self) -> Optional[Dict[str, str]]:
     @property
     def resolved_query_string_parameters(self) -> Optional[Dict[str, str]]:
         return self.query_string_parameters
+
+    @property
+    def resolved_headers_field(self) -> Optional[Dict[str, Any]]:
+        return {}

aws_lambda_powertools/utilities/data_classes/common.py

@@ -114,6 +114,17 @@ def resolved_query_string_parameters(self) -> Optional[Dict[str, str]]:
         """
         return self.query_string_parameters
 
+    @property
+    def resolved_headers_field(self) -> Optional[Dict[str, Any]]:
+        """
+        This property determines the appropriate header to be used
+        as a trusted source for validating OpenAPI.
+
+        This is necessary because different resolvers use different formats to encode
+        headers parameters.
+        """
+        return self.headers
+
     @property
     def is_base64_encoded(self) -> Optional[bool]:
         return self.get("isBase64Encoded")

aws_lambda_powertools/utilities/data_classes/vpc_lattice.py

@@ -30,6 +30,10 @@ def headers(self) -> Dict[str, str]:
         """The VPC Lattice event headers."""
         return self["headers"]
 
+    @property
+    def resolved_headers_field(self) -> Optional[Dict[str, Any]]:
+        return self.headers
+
     @property
     def decoded_body(self) -> str:
         """Dynamically base64 decode body as a str"""

tests/functional/event_handler/test_openapi_params.py

@@ -13,11 +13,11 @@
 )
 from aws_lambda_powertools.event_handler.openapi.params import (
     Body,
+    Header,
     Param,
     ParamTypes,
     Query,
     _create_model_field,
-    _Header,
 )
 from aws_lambda_powertools.shared.types import Annotated
 
@@ -431,7 +431,7 @@ def handler():
 
 
 def test_create_header():
-    header = _Header(convert_underscores=True)
+    header = Header(convert_underscores=True)
     assert header.convert_underscores is True
 
 
@@ -456,7 +456,7 @@ def test_create_model_field_with_empty_in():
 
 # Tests that when we try to create a model field with convert_underscore, we convert the field name
 def test_create_model_field_convert_underscore():
-    field_info = _Header(alias=None, convert_underscores=True)
+    field_info = Header(alias=None, convert_underscores=True)
 
     result = _create_model_field(field_info, int, "user_id", False)
     assert result.alias == "user-id"