qena-shared-lib 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

qena_shared_lib/exceptions.py

@@ -2,6 +2,9 @@ from enum import Enum
 from typing import Any
 
 from fastapi import status
+from typing_extensions import Self
+
+from .enums import ServiceType
 
 __all__ = [
     "BadGateway",
@@ -18,6 +21,7 @@ __all__ = [
     "IAmATeapot",
     "InsufficientStorage",
     "InternalServerError",
+    "KafkaDisconnectedError",
     "LengthRequired",
     "Locked",
     "LoopDetected",
@@ -64,8 +68,8 @@ class Severity(Enum):
 
 
 class ServiceException(Exception):
-    _GENERAL_SEVERITY: Severity | None = None
-    _GENERAL_EXTRACT_EXC_INFO: bool | None = None
+    GENERAL_SEVERITY: Severity | None = None
+    GENERAL_EXTRACT_EXC_INFO: bool | None = None
 
     def __init__(
         self,
@@ -80,8 +84,8 @@ class ServiceException(Exception):
 
         if severity is not None:
             self._severity = severity
-        elif self._GENERAL_SEVERITY is not None:
-            self._severity = self._GENERAL_SEVERITY
+        elif self.GENERAL_SEVERITY is not None:
+            self._severity = self.GENERAL_SEVERITY
         else:
             self._severity = Severity.LOW
 
@@ -95,8 +99,8 @@ class ServiceException(Exception):
 
         if extract_exc_info is not None:
             self._extract_exc_info = extract_exc_info
-        elif self._GENERAL_EXTRACT_EXC_INFO is not None:
-            self._extract_exc_info = self._GENERAL_EXTRACT_EXC_INFO
+        elif self.GENERAL_EXTRACT_EXC_INFO is not None:
+            self._extract_exc_info = self.GENERAL_EXTRACT_EXC_INFO
         else:
             self._extract_exc_info = False
 
@@ -132,7 +136,7 @@ class ServiceException(Exception):
 
 
 class HTTPServiceError(ServiceException):
-    _GENERAL_STATUS_CODE: int | None = None
+    GENERAL_STATUS_CODE: int | None = None
 
     def __init__(
         self,
@@ -163,7 +167,7 @@ class HTTPServiceError(ServiceException):
         if status_code is not None:
             self._status_code = status_code
         else:
-            self._status_code = self._GENERAL_STATUS_CODE
+            self._status_code = self.GENERAL_STATUS_CODE
 
         self._headers = headers
         self._response_code = response_code
@@ -197,179 +201,179 @@ class HTTPServiceError(ServiceException):
 
 
 class ClientError(HTTPServiceError):
-    _GENERAL_SEVERITY = Severity.MEDIUM
-    _GENERAL_EXTRACT_EXC_INFO = False
+    GENERAL_SEVERITY = Severity.MEDIUM
+    GENERAL_EXTRACT_EXC_INFO = False
 
 
 class BadRequest(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_400_BAD_REQUEST
+    GENERAL_STATUS_CODE = status.HTTP_400_BAD_REQUEST
 
 
 class Unauthorized(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_401_UNAUTHORIZED
+    GENERAL_STATUS_CODE = status.HTTP_401_UNAUTHORIZED
 
 
 class PaymentRequired(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_402_PAYMENT_REQUIRED
+    GENERAL_STATUS_CODE = status.HTTP_402_PAYMENT_REQUIRED
 
 
 class Forbidden(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_403_FORBIDDEN
+    GENERAL_STATUS_CODE = status.HTTP_403_FORBIDDEN
 
 
 class NotFound(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_404_NOT_FOUND
+    GENERAL_STATUS_CODE = status.HTTP_404_NOT_FOUND
 
 
 class MethodNotAllowed(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_405_METHOD_NOT_ALLOWED
+    GENERAL_STATUS_CODE = status.HTTP_405_METHOD_NOT_ALLOWED
 
 
 class NotAcceptable(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_406_NOT_ACCEPTABLE
+    GENERAL_STATUS_CODE = status.HTTP_406_NOT_ACCEPTABLE
 
 
 class ProxyAuthenticationRequired(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_407_PROXY_AUTHENTICATION_REQUIRED
+    GENERAL_STATUS_CODE = status.HTTP_407_PROXY_AUTHENTICATION_REQUIRED
 
 
 class RequestTimeout(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_408_REQUEST_TIMEOUT
+    GENERAL_STATUS_CODE = status.HTTP_408_REQUEST_TIMEOUT
 
 
 class Conflict(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_409_CONFLICT
+    GENERAL_STATUS_CODE = status.HTTP_409_CONFLICT
 
 
 class Gone(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_410_GONE
+    GENERAL_STATUS_CODE = status.HTTP_410_GONE
 
 
 class LengthRequired(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_411_LENGTH_REQUIRED
+    GENERAL_STATUS_CODE = status.HTTP_411_LENGTH_REQUIRED
 
 
 class PreconditionFailed(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_412_PRECONDITION_FAILED
+    GENERAL_STATUS_CODE = status.HTTP_412_PRECONDITION_FAILED
 
 
 class PayloadTooLarge(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_413_REQUEST_ENTITY_TOO_LARGE
+    GENERAL_STATUS_CODE = status.HTTP_413_REQUEST_ENTITY_TOO_LARGE
 
 
 class URITooLong(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_414_REQUEST_URI_TOO_LONG
+    GENERAL_STATUS_CODE = status.HTTP_414_REQUEST_URI_TOO_LONG
 
 
 class UnsupportedMediaType(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_415_UNSUPPORTED_MEDIA_TYPE
+    GENERAL_STATUS_CODE = status.HTTP_415_UNSUPPORTED_MEDIA_TYPE
 
 
 class RangeNotSatisfiable(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE
+    GENERAL_STATUS_CODE = status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE
 
 
 class ExpectationFailed(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_417_EXPECTATION_FAILED
+    GENERAL_STATUS_CODE = status.HTTP_417_EXPECTATION_FAILED
 
 
 class IAmATeapot(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_418_IM_A_TEAPOT
+    GENERAL_STATUS_CODE = status.HTTP_418_IM_A_TEAPOT
 
 
 class MisdirectedRequest(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_421_MISDIRECTED_REQUEST
+    GENERAL_STATUS_CODE = status.HTTP_421_MISDIRECTED_REQUEST
 
 
 class UnprocessableEntity(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_422_UNPROCESSABLE_ENTITY
+    GENERAL_STATUS_CODE = status.HTTP_422_UNPROCESSABLE_ENTITY
 
 
 class Locked(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_423_LOCKED
+    GENERAL_STATUS_CODE = status.HTTP_423_LOCKED
 
 
 class FailedDependency(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_424_FAILED_DEPENDENCY
+    GENERAL_STATUS_CODE = status.HTTP_424_FAILED_DEPENDENCY
 
 
 class TooEarly(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_425_TOO_EARLY
+    GENERAL_STATUS_CODE = status.HTTP_425_TOO_EARLY
 
 
 class UpgradeRequired(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_426_UPGRADE_REQUIRED
+    GENERAL_STATUS_CODE = status.HTTP_426_UPGRADE_REQUIRED
 
 
 class PreconditionRequired(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_428_PRECONDITION_REQUIRED
+    GENERAL_STATUS_CODE = status.HTTP_428_PRECONDITION_REQUIRED
 
 
 class TooManyRequests(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_429_TOO_MANY_REQUESTS
+    GENERAL_STATUS_CODE = status.HTTP_429_TOO_MANY_REQUESTS
 
 
 class RequestHeaderFieldsTooLarge(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE
+    GENERAL_STATUS_CODE = status.HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE
 
 
 class UnavailableForLegalReasons(ClientError):
-    _GENERAL_STATUS_CODE = status.HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS
+    GENERAL_STATUS_CODE = status.HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS
 
 
 class ServerError(HTTPServiceError):
-    _GENERAL_SEVERITY = Severity.HIGH
-    _GENERAL_EXTRACT_EXC_INFO = True
+    GENERAL_SEVERITY = Severity.HIGH
+    GENERAL_EXTRACT_EXC_INFO = True
 
 
 class InternalServerError(ServerError):
-    _GENERAL_STATUS_CODE = status.HTTP_500_INTERNAL_SERVER_ERROR
+    GENERAL_STATUS_CODE = status.HTTP_500_INTERNAL_SERVER_ERROR
 
 
 class NotImplemented(ServerError):
-    _GENERAL_STATUS_CODE = status.HTTP_501_NOT_IMPLEMENTED
+    GENERAL_STATUS_CODE = status.HTTP_501_NOT_IMPLEMENTED
 
 
 class BadGateway(ServerError):
-    _GENERAL_STATUS_CODE = status.HTTP_502_BAD_GATEWAY
+    GENERAL_STATUS_CODE = status.HTTP_502_BAD_GATEWAY
 
 
 class ServiceUnavailable(ServerError):
-    _GENERAL_STATUS_CODE = status.HTTP_503_SERVICE_UNAVAILABLE
+    GENERAL_STATUS_CODE = status.HTTP_503_SERVICE_UNAVAILABLE
 
 
 class GatewayTimeout(ServerError):
-    _GENERAL_STATUS_CODE = status.HTTP_504_GATEWAY_TIMEOUT
+    GENERAL_STATUS_CODE = status.HTTP_504_GATEWAY_TIMEOUT
 
 
 class HTTPVersionNotSupported(ServerError):
-    _GENERAL_STATUS_CODE = status.HTTP_505_HTTP_VERSION_NOT_SUPPORTED
+    GENERAL_STATUS_CODE = status.HTTP_505_HTTP_VERSION_NOT_SUPPORTED
 
 
 class VariantAlsoNegotiates(ServerError):
-    _GENERAL_STATUS_CODE = status.HTTP_506_VARIANT_ALSO_NEGOTIATES
+    GENERAL_STATUS_CODE = status.HTTP_506_VARIANT_ALSO_NEGOTIATES
 
 
 class InsufficientStorage(ServerError):
-    _GENERAL_STATUS_CODE = status.HTTP_507_INSUFFICIENT_STORAGE
+    GENERAL_STATUS_CODE = status.HTTP_507_INSUFFICIENT_STORAGE
 
 
 class LoopDetected(ServerError):
-    _GENERAL_STATUS_CODE = status.HTTP_508_LOOP_DETECTED
+    GENERAL_STATUS_CODE = status.HTTP_508_LOOP_DETECTED
 
 
 class NotExtended(ServerError):
-    _GENERAL_STATUS_CODE = status.HTTP_510_NOT_EXTENDED
+    GENERAL_STATUS_CODE = status.HTTP_510_NOT_EXTENDED
 
 
 class NetworkAuthenticationRequired(ServerError):
-    _GENERAL_STATUS_CODE = status.HTTP_511_NETWORK_AUTHENTICATION_REQUIRED
+    GENERAL_STATUS_CODE = status.HTTP_511_NETWORK_AUTHENTICATION_REQUIRED
 
 
 class RabbitMQServiceException(ServiceException):
-    _GENERAL_SEVERITY = Severity.HIGH
-    _GENERAL_EXTRACT_EXC_INFO = True
-    _GENERAL_CODE: int | None = None
+    GENERAL_SEVERITY = Severity.HIGH
+    GENERAL_EXTRACT_EXC_INFO = True
+    GENERAL_CODE: int | None = None
 
     def __init__(
         self,
@@ -393,8 +397,8 @@ class RabbitMQServiceException(ServiceException):
 
         if code is not None:
             self._code = code
-        elif self._GENERAL_CODE is not None:
-            self._code = self._GENERAL_CODE
+        elif self.GENERAL_CODE is not None:
+            self._code = self.GENERAL_CODE
         else:
             self._code = 0
 
@@ -429,3 +433,109 @@ class RabbitMQRpcRequestPendingError(Exception):
 
 class RabbitMQConnectionUnhealthyError(Exception):
     pass
+
+
+class KafkaDisconnectedError(Exception):
+    pass
+
+
+class GenericServiceExceptionFactory:
+    def __init__(
+        self,
+        message: str,
+        severity: Severity | None = None,
+        tags: list[str] | None = None,
+        extra: dict[str, str] | None = None,
+        remote_logging: bool = True,
+        extract_exc_info: bool = True,
+    ):
+        self._message = message
+        self._severity = severity
+        self._tags = tags
+        self._extra = extra
+        self._remote_logging = remote_logging
+        self._extract_exc_info = extract_exc_info
+
+        self._http_service_error: type[HTTPServiceError] = InternalServerError
+        self._rabbitmq_service_exception: type[RabbitMQServiceException] = (
+            RabbitMQServiceException
+        )
+
+        self._body: Any | None = None
+        self._status_code: int | None = None
+        self._headers: dict[str, str] | None = None
+        self._response_code: int | None = None
+        self._corrective_action: str | None = None
+        self._code: int | None = None
+        self._data: Any | None = None
+
+    def for_http_service_error(
+        self, http_service_error: type[HTTPServiceError]
+    ) -> Self:
+        self._http_service_error = http_service_error
+
+        return self
+
+    def for_rabbitmq_service_exception(
+        self, rabbitmq_service_exception: type[RabbitMQServiceException]
+    ) -> Self:
+        self._rabbitmq_service_exception = rabbitmq_service_exception
+
+        return self
+
+    def with_http_service_error(
+        self,
+        body: Any | None = None,
+        status_code: int | None = None,
+        headers: dict[str, str] | None = None,
+        response_code: int | None = None,
+        corrective_action: str | None = None,
+    ) -> Self:
+        self._body = body
+        self._status_code = status_code
+        self._headers = headers
+        self._response_code = response_code
+        self._corrective_action = corrective_action
+
+        return self
+
+    def with_rabbitmq_service_exception(
+        self,
+        code: int | None = None,
+        data: Any | None = None,
+    ) -> Self:
+        self._code = code
+        self._data = data
+
+        return self
+
+    def create(self, service_type: ServiceType) -> ServiceException:
+        assert self._http_service_error is not None
+        assert self._rabbitmq_service_exception is not None
+
+        match service_type:
+            case ServiceType.HTTP:
+                return self._http_service_error(
+                    message=self._message,
+                    body=self._body,
+                    status_code=self._status_code,
+                    headers=self._headers,
+                    response_code=self._response_code,
+                    corrective_action=self._corrective_action,
+                    severity=self._severity,
+                    tags=self._tags,
+                    extra=self._extra,
+                    remote_logging=self._remote_logging,
+                    extract_exc_info=self._extract_exc_info,
+                )
+            case ServiceType.RABBIT_MQ:
+                return self._rabbitmq_service_exception(
+                    message=self._message,
+                    code=self._code,
+                    data=self._data,
+                    severity=self._severity,
+                    tags=self._tags,
+                    extra=self._extra,
+                    remote_logging=self._remote_logging,
+                    extract_exc_info=self._extract_exc_info,
+                )

qena_shared_lib/http/__init__.py

@@ -0,0 +1,110 @@
+from ._base import (
+    ROUTE_HANDLER_ATTRIBUTE,
+    APIRouter,
+    BackgroundTasks,
+    Body,
+    ControllerBase,
+    Cookie,
+    Depends,
+    File,
+    FileResponse,
+    Form,
+    Header,
+    HTMLResponse,
+    HTTPException,
+    JSONResponse,
+    Path,
+    PlainTextResponse,
+    Query,
+    RedirectResponse,
+    Request,
+    Response,
+    RouteHandlerMetadata,
+    Security,
+    StreamingResponse,
+    UploadFile,
+    WebSocket,
+    WebSocketDisconnect,
+    WebSocketException,
+    api_controller,
+    delete,
+    get,
+    head,
+    options,
+    patch,
+    post,
+    put,
+    status,
+    trace,
+)
+from ._exception_handlers import (
+    AbstractHttpExceptionHandler,
+    HttpGeneralExceptionHandler,
+    HTTPServiceExceptionHandler,
+    RequestValidationErrorHandler,
+)
+from ._request import (
+    CamelCaseRequest,
+    InboundRequest,
+    OutboundRequest,
+    SnakeCaseRequest,
+)
+from ._response import (
+    CamelCaseResponse,
+    InboundResponse,
+    OutboundResponse,
+    SnakeCaseRespose,
+)
+
+__all__ = [
+    "AbstractHttpExceptionHandler",
+    "api_controller",
+    "APIRouter",
+    "BackgroundTasks",
+    "Body",
+    "CamelCaseRequest",
+    "CamelCaseResponse",
+    "ControllerBase",
+    "Cookie",
+    "delete",
+    "Depends",
+    "File",
+    "FileResponse",
+    "Form",
+    "get",
+    "head",
+    "Header",
+    "HTMLResponse",
+    "HTTPException",
+    "HttpGeneralExceptionHandler",
+    "HTTPServiceExceptionHandler",
+    "InboundRequest",
+    "InboundResponse",
+    "JSONResponse",
+    "options",
+    "OutboundRequest",
+    "OutboundResponse",
+    "patch",
+    "Path",
+    "PlainTextResponse",
+    "post",
+    "put",
+    "Query",
+    "RedirectResponse",
+    "Request",
+    "RequestValidationErrorHandler",
+    "Response",
+    "Response",
+    "ROUTE_HANDLER_ATTRIBUTE",
+    "RouteHandlerMetadata",
+    "Security",
+    "SnakeCaseRequest",
+    "SnakeCaseRespose",
+    "status",
+    "StreamingResponse",
+    "trace",
+    "UploadFile",
+    "WebSocket",
+    "WebSocketDisconnect",
+    "WebSocketException",
+]

qena_shared_lib/{http.py → http/_base.py}

@@ -75,7 +75,7 @@ __all__ = [
 
 AC = TypeVar("AC")
 API_CONTROLLER_ATTRIBUTE = "__api_controller_router__"
-ROUTE_HANDLER_ATTRIBUTE = "__route_handler_meta__"
+ROUTE_HANDLER_ATTRIBUTE = "__route_handler_metadata__"
 
 
 class HTTPMethods(Enum):
@@ -90,7 +90,7 @@ class HTTPMethods(Enum):
 
 
 @dataclass
-class RouteHandlerMeta:
+class RouteHandlerMetadata:
     method: HTTPMethods
     path: str | None = None
     response_model: Any | None = None
@@ -173,7 +173,7 @@ def get(
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
-            RouteHandlerMeta(
+            RouteHandlerMetadata(
                 method=HTTPMethods.GET,
                 path=path,
                 response_model=response_model,
@@ -230,7 +230,7 @@ def put(
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
-            RouteHandlerMeta(
+            RouteHandlerMetadata(
                 method=HTTPMethods.PUT,
                 path=path,
                 response_model=response_model,
@@ -287,7 +287,7 @@ def post(
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
-            RouteHandlerMeta(
+            RouteHandlerMetadata(
                 method=HTTPMethods.POST,
                 path=path,
                 response_model=response_model,
@@ -344,7 +344,7 @@ def delete(
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
-            RouteHandlerMeta(
+            RouteHandlerMetadata(
                 method=HTTPMethods.DELETE,
                 path=path,
                 response_model=response_model,
@@ -401,7 +401,7 @@ def options(
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
-            RouteHandlerMeta(
+            RouteHandlerMetadata(
                 method=HTTPMethods.OPTIONS,
                 path=path,
                 response_model=response_model,
@@ -458,7 +458,7 @@ def head(
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
-            RouteHandlerMeta(
+            RouteHandlerMetadata(
                 method=HTTPMethods.HEAD,
                 path=path,
                 response_model=response_model,
@@ -515,7 +515,7 @@ def patch(
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
-            RouteHandlerMeta(
+            RouteHandlerMetadata(
                 method=HTTPMethods.PATCH,
                 path=path,
                 response_model=response_model,
@@ -572,7 +572,7 @@ def trace(
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
-            RouteHandlerMeta(
+            RouteHandlerMetadata(
                 method=HTTPMethods.TRACE,
                 path=path,
                 response_model=response_model,
@@ -622,21 +622,21 @@ class ControllerBase:
             if attribute is None:
                 continue
 
-            route_handler_meta = getattr(
+            route_handler_metadata = getattr(
                 attribute, ROUTE_HANDLER_ATTRIBUTE, None
             )
 
-            if route_handler_meta is None:
+            if route_handler_metadata is None:
                 continue
 
-            if not isinstance(route_handler_meta, RouteHandlerMeta):
+            if not isinstance(route_handler_metadata, RouteHandlerMetadata):
                 raise TypeError(
-                    f"expected `{ROUTE_HANDLER_ATTRIBUTE}` to be of type `RouteHandlerMeta`, got {type(route_handler_meta)}"
+                    f"expected `{ROUTE_HANDLER_ATTRIBUTE}` to be of type `RouteHandlerMetadata`, got {type(route_handler_metadata)}"
                 )
 
             api_router_method = None
 
-            match route_handler_meta.method:
+            match route_handler_metadata.method:
                 case HTTPMethods.GET:
                     api_router_method = api_router.get
                 case HTTPMethods.PUT:
@@ -656,30 +656,30 @@ class ControllerBase:
 
             if api_router_method is None:
                 raise ValueError(
-                    f"api router method {route_handler_meta.method} not supported"
+                    f"api router method {route_handler_metadata.method} not supported"
                 )
 
             api_router_method(
-                path=route_handler_meta.path or "",
-                response_model=route_handler_meta.response_model,
-                status_code=route_handler_meta.status_code,
-                tags=route_handler_meta.tags,
-                dependencies=route_handler_meta.dependencies,
-                summary=route_handler_meta.summary,
-                description=route_handler_meta.description,
-                response_description=route_handler_meta.response_description,
-                responses=route_handler_meta.responses,
-                deprecated=route_handler_meta.deprecated,
-                response_model_include=route_handler_meta.response_model_include,
-                response_model_exclude=route_handler_meta.response_model_exclude,
-                response_model_by_alias=route_handler_meta.response_model_by_alias,
-                response_model_exclude_unset=route_handler_meta.response_model_exclude_unset,
-                response_model_exclude_defaults=route_handler_meta.response_model_exclude_defaults,
-                response_model_exclude_none=route_handler_meta.response_model_exclude_none,
-                include_in_schema=route_handler_meta.include_in_schema,
-                response_class=route_handler_meta.response_class,
-                name=route_handler_meta.name,
-                openapi_extra=route_handler_meta.openapi_extra,
+                path=route_handler_metadata.path or "",
+                response_model=route_handler_metadata.response_model,
+                status_code=route_handler_metadata.status_code,
+                tags=route_handler_metadata.tags,
+                dependencies=route_handler_metadata.dependencies,
+                summary=route_handler_metadata.summary,
+                description=route_handler_metadata.description,
+                response_description=route_handler_metadata.response_description,
+                responses=route_handler_metadata.responses,
+                deprecated=route_handler_metadata.deprecated,
+                response_model_include=route_handler_metadata.response_model_include,
+                response_model_exclude=route_handler_metadata.response_model_exclude,
+                response_model_by_alias=route_handler_metadata.response_model_by_alias,
+                response_model_exclude_unset=route_handler_metadata.response_model_exclude_unset,
+                response_model_exclude_defaults=route_handler_metadata.response_model_exclude_defaults,
+                response_model_exclude_none=route_handler_metadata.response_model_exclude_none,
+                include_in_schema=route_handler_metadata.include_in_schema,
+                response_class=route_handler_metadata.response_class,
+                name=route_handler_metadata.name,
+                openapi_extra=route_handler_metadata.openapi_extra,
             )(attribute)
 
         return api_router