feat: add ReturnValuesOnConditionCheckFailure to DynamoDB idempotency to return a copy of the item on failure and avoid a subsequent get aws-powertools#3327. Changes after PR comments

Author: Dan Straw

aws_lambda_powertools/utilities/idempotency/exceptions.py

@@ -33,18 +33,16 @@ class IdempotencyItemAlreadyExistsError(BaseError):
     """
 
     def __init__(self, *args: Optional[Union[str, Exception]], old_data_record: Optional[DataRecord] = None):
-        self.message = str(args[0]) if args else ""
-        self.details = "".join(str(arg) for arg in args[1:]) if args[1:] else None
         self.old_data_record = old_data_record
+        super().__init__(*args)
 
     def __str__(self):
         """
         Return all arguments formatted or original message
         """
         old_data_record = f" from [{(str(self.old_data_record))}]" if self.old_data_record else ""
-        details = f" - ({self.details})" if self.details else ""
-
-        return f"{self.message}{details}{old_data_record}"
+        message = super().__str__()
+        return f"{message}{old_data_record}"
 
 
 class IdempotencyItemNotFoundError(BaseError):

aws_lambda_powertools/utilities/idempotency/persistence/base.py

@@ -8,7 +8,7 @@
 import os
 import warnings
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Union
 
 import jmespath
 
@@ -160,16 +160,20 @@ def _generate_hash(self, data: Any) -> str:
         hashed_data = self.hash_function(json.dumps(data, cls=Encoder, sort_keys=True).encode())
         return hashed_data.hexdigest()
 
-    def _validate_payload(self, data: Dict[str, Any], data_record: DataRecord) -> None:
+    def _validate_payload(
+        self,
+        data_payload: Union[Dict[str, Any], DataRecord],
+        stored_data_record: DataRecord,
+    ) -> None:
         """
         Validate that the hashed payload matches data provided and stored data record
 
         Parameters
         ----------
-        data: Dict[str, Any]
+        data_payload: Union[Dict[str, Any], DataRecord]
             Payload
-        data_record: DataRecord
-            DataRecord instance
+        stored_data_record: DataRecord
+            DataRecord fetched from Dynamo or cache
 
         Raises
         ----------
@@ -178,30 +182,13 @@ def _validate_payload(self, data: Dict[str, Any], data_record: DataRecord) -> No
 
         """
         if self.payload_validation_enabled:
-            data_hash = self._get_hashed_payload(data=data)
-            if data_record.payload_hash != data_hash:
-                raise IdempotencyValidationError("Payload does not match stored record for this event key")
-
-    def _validate_hashed_payload(self, old_data_record: DataRecord, data_record: DataRecord) -> None:
-        """
-        Validate that the hashed data provided matches the payload_hash stored data record
-
-        Parameters
-        ----------
-        old_data_record: DataRecord
-            DataRecord instance fetched from Dynamo
-        data_record: DataRecord
-            DataRecord instance which failed insert into Dynamo
+            if isinstance(data_payload, DataRecord):
+                data_hash = data_payload.payload_hash
+            else:
+                data_hash = self._get_hashed_payload(data=data_payload)
 
-        Raises
-        ----------
-        IdempotencyValidationError
-            Payload doesn't match the stored record for the given idempotency key
-
-        """
-        if self.payload_validation_enabled:
-            if old_data_record.payload_hash != data_record.payload_hash:
-                raise IdempotencyValidationError("Hashed payload does not match stored record for this event key")
+            if stored_data_record.payload_hash != data_hash:
+                raise IdempotencyValidationError("Payload does not match stored record for this event key")
 
     def _get_expiry_timestamp(self) -> int:
         """
@@ -391,14 +378,14 @@ def get_record(self, data: Dict[str, Any]) -> Optional[DataRecord]:
         cached_record = self._retrieve_from_cache(idempotency_key=idempotency_key)
         if cached_record:
             logger.debug(f"Idempotency record found in cache with idempotency key: {idempotency_key}")
-            self._validate_payload(data=data, data_record=cached_record)
+            self._validate_payload(data_payload=data, stored_data_record=cached_record)
             return cached_record
 
         record = self._get_record(idempotency_key=idempotency_key)
 
         self._save_to_cache(data_record=record)
 
-        self._validate_payload(data=data, data_record=record)
+        self._validate_payload(data_payload=data, stored_data_record=record)
         return record
 
     @abstractmethod

aws_lambda_powertools/utilities/idempotency/persistence/dynamodb.py

@@ -257,9 +257,9 @@ def _put_record(self, data_record: DataRecord) -> None:
                     self._save_to_cache(data_record=old_data_record)
 
                     try:
-                        self._validate_hashed_payload(old_data_record=old_data_record, data_record=data_record)
-                    except IdempotencyValidationError as ive:
-                        raise ive from exc
+                        self._validate_payload(data_payload=data_record, stored_data_record=old_data_record)
+                    except IdempotencyValidationError as idempotency_validation_error:
+                        raise idempotency_validation_error from exc
 
                     raise IdempotencyItemAlreadyExistsError(old_data_record=old_data_record) from exc
 
@@ -271,17 +271,23 @@ def _put_record(self, data_record: DataRecord) -> None:
             raise
 
     @staticmethod
-    def boto3_supports_condition_check_failure(boto3_version: str):
-        version = boto3_version.split(".")
+    def boto3_supports_condition_check_failure(boto3_version: str) -> bool:
+        """
+        Check if the installed boto3 version supports condition check failure.
+
+        Params
+        ------
+        boto3_version: str
+            The boto3 version
+
+        Returns
+        -------
+        bool
+            True if the boto3 version supports condition check failure, False otherwise.
+        """
         # Only supported in boto3 1.26.164 and above
-        if len(version) >= 3 and int(version[0]) == 1 and int(version[1]) == 26 and int(version[2]) >= 164:
-            return True
-        if len(version) >= 2 and int(version[0]) == 1 and int(version[1]) > 26:
-            return True
-        if int(version[0]) > 1:
-            return True
-
-        return False
+        major, minor, *patch = map(int, boto3_version.split("."))
+        return (major, minor, *patch) >= (1, 26, 164)
 
     def _update_record(self, data_record: DataRecord):
         logger.debug(f"Updating record for idempotency key: {data_record.idempotency_key}")