Merge branch 'develop' into fix/8185

Author: leandrodamascena

aws_lambda_powertools/event_handler/openapi/params.py

@@ -901,7 +901,7 @@ def analyze_param(
     if is_response_param:
         field_info.default = Required
 
-    field = _create_model_field(field_info, type_annotation, param_name, is_path_param)
+    field = _create_model_field(field_info, type_annotation, param_name, is_path_param, is_response_param)
     return field
 
 
@@ -1138,6 +1138,7 @@ def _create_model_field(
     type_annotation: Any,
     param_name: str,
     is_path_param: bool,
+    is_response_param: bool = False,
 ) -> ModelField | None:
     """
     Create a new ModelField from a FieldInfo and type annotation.
@@ -1164,4 +1165,5 @@ def _create_model_field(
         alias=field_info.alias,
         required=field_info.default in (Required, Undefined),
         field_info=field_info,
+        mode="serialization" if is_response_param else "validation",
     )

aws_lambda_powertools/utilities/idempotency/base.py

@@ -167,7 +167,7 @@ def _process_idempotency(self, is_replay: bool):
             # We give preference to ReturnValuesOnConditionCheckFailure because it is a faster and more cost-effective
             # way of retrieving the existing record after a failed conditional write operation.
             record = exc.old_data_record or self._get_idempotency_record()
-            if is_replay and record is not None and record.status == "INPROGRESS":
+            if is_replay and record is not None and record.status == STATUS_CONSTANTS["INPROGRESS"]:
                 return self._get_function_response()
             # If a record is found, handle it for status
             if record:
@@ -296,7 +296,7 @@ def _get_function_response(self):
 
         else:
             try:
-                serialized_response: dict = self.output_serializer.to_dict(response) if response else None
+                serialized_response: dict = self.output_serializer.to_dict(response) if response is not None else None
                 self.persistence_store.save_success(data=self.data, result=serialized_response)
             except Exception as save_exception:
                 raise IdempotencyPersistenceLayerError(

aws_lambda_powertools/utilities/idempotency/persistence/redis.py

@@ -332,8 +332,8 @@ def _item_to_data_record(self, idempotency_key: str, item: dict[str, Any]) -> Da
             idempotency_key=idempotency_key,
             status=item[self.status_attr],
             in_progress_expiry_timestamp=in_progress_expiry_timestamp,
-            response_data=str(item.get(self.data_attr)),
-            payload_hash=str(item.get(self.validation_key_attr)),
+            response_data=item.get(self.data_attr, ""),
+            payload_hash=item.get(self.validation_key_attr, ""),
             expiry_timestamp=item.get("expiration"),
         )
 

examples/event_handler_graphql/src/requirements.txt

@@ -1,2 +1,2 @@
 aws-lambda-powertools[tracer]
-requests>=2.32.0
+requests>=2.33.1

tests/functional/event_handler/_pydantic/test_openapi_schema_pydantic_v2.py

@@ -3,7 +3,7 @@
 from typing import Literal, Optional
 
 import pytest
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, computed_field
 from typing_extensions import Annotated
 
 from aws_lambda_powertools.event_handler import APIGatewayRestResolver
@@ -110,3 +110,79 @@ def create_todo(todo: TodoEnvelope): ...
 
     # THEN the schema should be valid
     assert openapi31_schema(schema)
+
+
+@pytest.mark.usefixtures("pydanticv2_only")
+def test_openapi_schema_includes_computed_field():
+    # GIVEN a model with a computed_field
+    class User(BaseModel):
+        first_name: str
+        last_name: str
+
+        @computed_field
+        @property
+        def full_name(self) -> str:
+            return f"{self.first_name} {self.last_name}"
+
+    # GIVEN APIGatewayRestResolver with a handler returning that model
+    app = APIGatewayRestResolver(enable_validation=True)
+
+    @app.get("/user")
+    def get_user() -> User:
+        return User(first_name="John", last_name="Doe")
+
+    # WHEN we get the schema
+    schema = json.loads(app.get_openapi_json_schema())
+
+    # THEN the computed_field should appear in the response schema
+    user_schema = schema["components"]["schemas"]["User"]
+    assert "full_name" in user_schema["properties"]
+    assert user_schema["properties"]["full_name"]["type"] == "string"
+    assert user_schema["properties"]["full_name"].get("readOnly") is True
+
+
+@pytest.mark.usefixtures("pydanticv2_only")
+def test_openapi_schema_computed_field_not_in_request_body():
+    # GIVEN a model with a computed_field used as both request and response
+    class Item(BaseModel):
+        price: float
+        quantity: int
+
+        @computed_field
+        @property
+        def total(self) -> float:
+            return self.price * self.quantity
+
+    # GIVEN APIGatewayRestResolver with handlers using the model
+    app = APIGatewayRestResolver(enable_validation=True)
+
+    @app.post("/items")
+    def create_item(item: Item) -> Item:
+        return item
+
+    # WHEN we get the schema
+    schema = json.loads(app.get_openapi_json_schema())
+
+    # THEN the request body schema should NOT include computed_field
+    request_body = schema["paths"]["/items"]["post"]["requestBody"]
+    request_ref = request_body["content"]["application/json"]["schema"]["$ref"]
+    request_schema_name = request_ref.split("/")[-1]
+
+    # THEN the response schema SHOULD include computed_field
+    response_ref = schema["paths"]["/items"]["post"]["responses"]["200"]["content"]["application/json"]["schema"][
+        "$ref"
+    ]
+    response_schema_name = response_ref.split("/")[-1]
+
+    # When input/output schemas are separate, we expect different schema names
+    # When they share a schema, computed_field should be present
+    if request_schema_name == response_schema_name:
+        # Shared schema - computed_field should be present (serialization mode wins)
+        item_schema = schema["components"]["schemas"][response_schema_name]
+        assert "total" in item_schema["properties"]
+    else:
+        # Separate schemas
+        input_schema = schema["components"]["schemas"][request_schema_name]
+        output_schema = schema["components"]["schemas"][response_schema_name]
+        assert "total" not in input_schema["properties"]
+        assert "total" in output_schema["properties"]

tests/functional/idempotency/_redis/test_redis_layer.py

@@ -330,6 +330,25 @@ def test_item_to_datarecord_conversion(valid_record):
     assert record.in_progress_expiry_timestamp == item[layer.in_progress_expiry_attr]
 
 
+def test_item_to_datarecord_conversion_missing_optional_attributes(persistence_store_standalone_redis):
+    """
+    When data_attr or validation_key_attr is missing from Redis,
+    response_data and payload_hash should be empty string, not the string "None".
+    Regression test for: https://github.com/aws-powertools/powertools-lambda-python/issues/8090
+    """
+    idempotency_key = "test-func#abc123"
+    item = {
+        persistence_store_standalone_redis.status_attr: "COMPLETED",
+        persistence_store_standalone_redis.expiry_attr: 9999999999,
+        # data_attr and validation_key_attr intentionally absent
+    }
+
+    record = persistence_store_standalone_redis._item_to_data_record(idempotency_key, item)
+
+    assert record.response_data == ""
+    assert record.payload_hash == ""
+
+
 def test_idempotent_function_and_lambda_handler_redis_basic(
     persistence_store_standalone_redis: RedisCachePersistenceLayer,
     lambda_context,