fix sonarqube code smell findings

Author: tonnico

aws_lambda_powertools/event_handler/api_gateway.py

@@ -92,7 +92,7 @@
         Server,
         Tag,
     )
-    from aws_lambda_powertools.event_handler.openapi.params import Dependant
+    from aws_lambda_powertools.event_handler.openapi.params import Dependant, Param
     from aws_lambda_powertools.event_handler.openapi.swagger_ui.oauth2 import (
         OAuth2Config,
     )
@@ -812,74 +812,110 @@ def _openapi_operation_parameters(
         """
         Returns the OpenAPI operation parameters.
         """
-        from aws_lambda_powertools.event_handler.openapi.compat import get_schema_from_model_field
         from aws_lambda_powertools.event_handler.openapi.params import Param
 
-        parameters = []
-        parameter: dict[str, Any] = {}
+        parameters: list[dict[str, Any]] = []
 
         for param in all_route_params:
-            field_info = param.field_info
-            field_info = cast(Param, field_info)
+            field_info = cast(Param, param.field_info)
             if not field_info.include_in_schema:
                 continue
 
             # Check if this is a Pydantic model that should be expanded
-            from pydantic import BaseModel
-
-            from aws_lambda_powertools.event_handler.openapi.compat import lenient_issubclass
-
-            if lenient_issubclass(field_info.annotation, BaseModel):
-                # Expand Pydantic model into individual parameters
-                model_class = cast(type[BaseModel], field_info.annotation)
-
-                for field_name, field_def in model_class.model_fields.items():
-                    if not field_def.annotation:
-                        continue
-                    # Create individual parameter for each model field
-                    param_name = field_def.alias or field_name
-
-                    individual_param = {
-                        "name": param_name,
-                        "in": field_info.in_.value,
-                        "required": field_def.is_required()
-                        if hasattr(field_def, "is_required")
-                        else field_def.default is ...,
-                        "schema": Route._get_basic_type_schema(field_def.annotation),
-                    }
+            if Route._is_pydantic_model_param(field_info):
+                parameters.extend(Route._expand_pydantic_model_parameters(field_info))
+            else:
+                parameters.append(Route._create_regular_parameter(param, model_name_map, field_mapping))
 
-                    if field_def.description:
-                        individual_param["description"] = field_def.description
+        return parameters
 
-                    parameters.append(individual_param)
-            else:
-                # Regular parameter processing
-                param_schema = get_schema_from_model_field(
-                    field=param,
-                    model_name_map=model_name_map,
-                    field_mapping=field_mapping,
-                )
+    @staticmethod
+    def _is_pydantic_model_param(field_info: ModelField | Param) -> bool:
+        """Check if the field info represents a Pydantic model parameter."""
+        from pydantic import BaseModel
+
+        from aws_lambda_powertools.event_handler.openapi.compat import lenient_issubclass
+        from aws_lambda_powertools.event_handler.openapi.params import Param
 
-                parameter = {
-                    "name": param.alias,
-                    "in": field_info.in_.value,
-                    "required": param.required,
-                    "schema": param_schema,
-                }
+        if not isinstance(field_info, Param):
+            return False
+        return lenient_issubclass(field_info.annotation, BaseModel)
 
-                if field_info.description:
-                    parameter["description"] = field_info.description
+    @staticmethod
+    def _expand_pydantic_model_parameters(field_info: Param) -> list[dict[str, Any]]:
+        """Expand a Pydantic model into individual OpenAPI parameters."""
+        from pydantic import BaseModel
 
-                if field_info.openapi_examples:
-                    parameter["examples"] = field_info.openapi_examples
+        model_class = cast(type[BaseModel], field_info.annotation)
+        parameters: list[dict[str, Any]] = []
 
-                if field_info.deprecated:
-                    parameter["deprecated"] = field_info.deprecated
+        for field_name, field_def in model_class.model_fields.items():
+            if not field_def.annotation:
+                continue
 
-                parameters.append(parameter)
+            param_name = field_def.alias or field_name
+            individual_param = Route._create_pydantic_field_parameter(
+                param_name=param_name,
+                field_def=field_def,
+                param_location=field_info.in_.value,
+            )
+            parameters.append(individual_param)
 
         return parameters
 
+    @staticmethod
+    def _create_pydantic_field_parameter(
+        param_name: str,
+        field_def: Any,
+        param_location: str,
+    ) -> dict[str, Any]:
+        """Create an OpenAPI parameter from a Pydantic field definition."""
+        individual_param: dict[str, Any] = {
+            "name": param_name,
+            "in": param_location,
+            "required": field_def.is_required() if hasattr(field_def, "is_required") else field_def.default is ...,
+            "schema": Route._get_basic_type_schema(field_def.annotation or type(None)),
+        }
+
+        if field_def.description:
+            individual_param["description"] = field_def.description
+
+        return individual_param
+
+    @staticmethod
+    def _create_regular_parameter(
+        param: ModelField,
+        model_name_map: dict[TypeModelOrEnum, str],
+        field_mapping: dict[tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue],
+    ) -> dict[str, Any]:
+        """Create an OpenAPI parameter from a regular ModelField."""
+        from aws_lambda_powertools.event_handler.openapi.compat import get_schema_from_model_field
+        from aws_lambda_powertools.event_handler.openapi.params import Param
+
+        field_info = cast(Param, param.field_info)
+        param_schema = get_schema_from_model_field(
+            field=param,
+            model_name_map=model_name_map,
+            field_mapping=field_mapping,
+        )
+
+        parameter: dict[str, Any] = {
+            "name": param.alias,
+            "in": field_info.in_.value,
+            "required": param.required,
+            "schema": param_schema,
+        }
+
+        # Add optional attributes if present
+        if field_info.description:
+            parameter["description"] = field_info.description
+        if field_info.openapi_examples:
+            parameter["examples"] = field_info.openapi_examples
+        if field_info.deprecated:
+            parameter["deprecated"] = field_info.deprecated
+
+        return parameter
+
     @staticmethod
     def _get_basic_type_schema(param_type: type) -> dict[str, str]:
         """

tests/functional/event_handler/_pydantic/test_openapi_validation_middleware.py

@@ -2449,7 +2449,7 @@ def query_model_advanced(params: Annotated[QueryAdvanced, Query()]) -> Dict[str,
 
     # Test QuerySimple validation error (name doesn't start with "Powertools")
     gw_event["queryStringParameters"] = {
-        "full_name": "Lambda Powertools",  # Wrong order
+        "full_name": "Lambda Powertools",
         "next_token": "dGVzdA==",
         "search_id": "search-123",
     }
@@ -2461,6 +2461,15 @@ def query_model_advanced(params: Annotated[QueryAdvanced, Query()]) -> Dict[str,
     assert "detail" in body
     errors = body["detail"]
 
+    # Should have validation error for full_name with proper location
+    full_name_error = next((e for e in errors if "full_name" in e["loc"]), None)
+
+    assert full_name_error is not None, "Should have error for full_name field"
+
+    # Check error details for full_name
+    assert full_name_error["loc"] == ["query", "params", "full_name"]
+    assert full_name_error["type"] == "value_error"
+
     # Test QueryAdvanced with ConfigDict and alias_generator
     gw_event["path"] = "/query-model-advanced"
     gw_event["queryStringParameters"] = {