1  """
  2  Standardized error response DTOs for HTTP APIs.
  3  
  4  This module provides consistent error response formats that can be used
  5  across any web application for uniform error handling.
  6  """
  7  
  8  from typing import Dict, List, Optional
  9  from pydantic import BaseModel, Field
 10  
 11  
 12  class EventErrorDTO(BaseModel):
 13      """
 14      Simplified and standardized error response format.
 15  
 16      This provides consistent error responses across all endpoints with:
 17      - message: Human-readable error description
 18      - validationDetails: Field-level validation errors (optional)
 19  
 20      Examples:
 21          404 Not Found:
 22          {
 23              "message": "Could not find User with id: 123",
 24              "validationDetails": null
 25          }
 26  
 27          422 Validation Error:
 28          {
 29              "message": "Invalid input data",
 30              "validationDetails": {
 31                  "email": ["Invalid email format"],
 32                  "name": ["Name is required"]
 33              }
 34          }
 35      """
 36      message: str = Field(..., description="Human-readable error message")
 37      validationDetails: Optional[Dict[str, List[str]]] = Field(
 38          default=None,
 39          description="Field-level validation errors"
 40      )
 41  
 42      @classmethod
 43      def create(
 44          cls,
 45          message: str,
 46          validation_details: Optional[Dict[str, List[str]]] = None
 47      ) -> "EventErrorDTO":
 48          """
 49          Create a new EventErrorDTO.
 50  
 51          Args:
 52              message: Human-readable error message
 53              validation_details: Optional field-level validation errors
 54  
 55          Returns:
 56              EventErrorDTO instance
 57          """
 58          return cls(
 59              message=message,
 60              validationDetails=validation_details
 61          )
 62  
 63      @classmethod
 64      def not_found(cls, entity_type: str, entity_id: str) -> "EventErrorDTO":
 65          """
 66          Create a 404 Not Found error with standardized message format.
 67  
 68          Args:
 69              entity_type: The type of entity (e.g., "User", "Product", "Order")
 70              entity_id: The ID that was not found
 71  
 72          Returns:
 73              EventErrorDTO with 404 message format
 74  
 75          Example:
 76              EventErrorDTO.not_found("User", "123")
 77              # Returns: {"message": "Could not find User with id: 123", "validationDetails": null}
 78          """
 79          message = f"Could not find {entity_type} with id: {entity_id}"
 80          return cls.create(message=message)
 81  
 82      @classmethod
 83      def validation_error(
 84          cls,
 85          message: str,
 86          validation_details: Dict[str, List[str]]
 87      ) -> "EventErrorDTO":
 88          """
 89          Create a validation error with field-level details.
 90  
 91          Args:
 92              message: Main validation error message
 93              validation_details: Dict mapping field names to error lists
 94  
 95          Returns:
 96              EventErrorDTO with validation details
 97  
 98          Example:
 99              EventErrorDTO.validation_error(
100                  "Invalid user data",
101                  {"email": ["Invalid format"], "age": ["Must be positive"]}
102              )
103          """
104          return cls.create(
105              message=message,
106              validation_details=validation_details
107          )