Feature/cdapi 95

pathology-api/lambda_handler.py

@@ -1,30 +1,111 @@
-import json
-import logging
+from collections.abc import Callable
 from functools import reduce
+from json import JSONDecodeError
 from typing import Any
 
+import pydantic
 from aws_lambda_powertools.event_handler import (
     APIGatewayHttpResolver,
     Response,
 )
+from aws_lambda_powertools.event_handler.exceptions import NotFoundError
 from aws_lambda_powertools.utilities.typing import LambdaContext
-from pathology_api.fhir.r4.resources import Bundle
+from pathology_api.exception import ValidationError
+from pathology_api.fhir.r4.resources import Bundle, OperationOutcome
 from pathology_api.handler import handle_request
-from pydantic import ValidationError
+from pathology_api.logging import get_logger
 
-_INVALID_PAYLOAD_MESSAGE = "Invalid payload provided."
-
-_logger = logging.getLogger(__name__)
+_logger = get_logger(__name__)
 
 app = APIGatewayHttpResolver()
 
+type _ExceptionHandler[T: Exception] = Callable[[T], Response[str]]
+
+
+def _exception_handler[T: Exception](
+    exception_type: type[T],
+) -> Callable[[_ExceptionHandler[T]], _ExceptionHandler[T]]:
+    """
+    Exception handler decorator that registers a function as an exception handler with
+    the created app whilst maintaining type information.
+    """
+
+    def decorator(func: _ExceptionHandler[T]) -> _ExceptionHandler[T]:
+        def wrapper(exception: T) -> Response[str]:
+            return func(exception)
+
+        app.exception_handler(exception_type)(wrapper)
+        return wrapper
 
-def _with_default_headers(status_code: int, body: str) -> Response[str]:
-    content_type = "application/fhir+json" if status_code == 200 else "text/plain"
+    return decorator
+
+
+def _with_default_headers(status_code: int, body: pydantic.BaseModel) -> Response[str]:
     return Response(
         status_code=status_code,
-        headers={"Content-Type": content_type},
-        body=body,
+        headers={"Content-Type": "application/fhir+json"},
+        body=body.model_dump_json(by_alias=True, exclude_none=True),
+    )
+
+
+@_exception_handler(ValidationError)
+def handle_validation_error(exception: ValidationError) -> Response[str]:
+    # LOG014: False positive, we are within an exception handler here.
+    _logger.info(
+        "ValidationError encountered: %s",
+        exception,
+        exc_info=True,  # noqa: LOG014
+    )
+    return _with_default_headers(
+        status_code=400,
+        body=OperationOutcome.create_validation_error(exception.message),
+    )
+
+
+@_exception_handler(pydantic.ValidationError)
+def handle_pydantic_validation_error(
+    exception: pydantic.ValidationError,
+) -> Response[str]:
+    # LOG014: False positive, we are within an exception handler here.
+    _logger.info(
+        "Pydantic ValidationError encountered: %s",
+        exception,
+        exc_info=True,  # noqa: LOG014
+    )
+
+    operation_outcome = OperationOutcome.create_validation_error(
+        reduce(
+            lambda acc, e: acc + f"{str(e['loc'])} - {e['msg']} \n",
+            exception.errors(),
+            "",
+        )
+    )
+    return _with_default_headers(
+        status_code=400,
+        body=operation_outcome,
+    )
+
+
+@app.not_found
+def handle_not_found_error(exception: NotFoundError) -> Response[str]:
+    _logger.info("NotFoundError encountered: %s", exception, exec_info=True)
+    return _with_default_headers(
+        status_code=404,
+        body=OperationOutcome.create_not_found_error(
+            "No resource found for requested path. "
+            f"Path: ({app.current_event.http_method}) {app.current_event.path}"
+        ),
+    )
+
+
+@_exception_handler(Exception)
+def handle_exception(exception: Exception) -> Response[str]:
+    _logger.exception("Unhandled Exception encountered: %s", exception)
+    return _with_default_headers(
+        status_code=500,
+        body=OperationOutcome.create_server_error(
+            "An unexpected error has occurred. Please try again later."
+        ),
     )
 
 
@@ -37,42 +118,27 @@ def status() -> Response[str]:
 @app.post("/FHIR/R4/Bundle")
 def post_result() -> Response[str]:
     _logger.debug("Post result endpoint called.")
+
     try:
         payload = app.current_event.json_body
-    except json.JSONDecodeError as err:
-        _logger.error("Error decoding JSON payload. error: %s", err)
-        return _with_default_headers(status_code=400, body=_INVALID_PAYLOAD_MESSAGE)
-    _logger.debug("Payload received: %s", payload)
+    except JSONDecodeError as e:
+        raise ValidationError("Invalid payload provided.") from e
 
-    if not payload:
-        _logger.error("No payload provided.")
-        return _with_default_headers(status_code=400, body="No payload provided.")
+    _logger.debug("Payload received: %s", payload)
 
-    try:
-        bundle = Bundle.model_validate(payload, by_alias=True)
-    except ValidationError as err:
-        _logger.error(
-            "Error parsing payload. error: %s issues: %s",
-            err,
-            reduce(lambda acc, e: acc + "," + str(e), err.errors(), ""),
+    if payload is None:
+        raise ValidationError(
+            "Resources must be provided as a bundle of type 'document'"
         )
-        return _with_default_headers(status_code=400, body=_INVALID_PAYLOAD_MESSAGE)
-    except TypeError as err:
-        _logger.error("Error parsing payload. error: %s", err)
-        return _with_default_headers(status_code=400, body=_INVALID_PAYLOAD_MESSAGE)
 
-    try:
-        response = handle_request(bundle)
+    bundle = Bundle.model_validate(payload, by_alias=True)
 
-        return _with_default_headers(
-            status_code=200,
-            body=response.model_dump_json(by_alias=True, exclude_none=True),
-        )
-    except ValueError as err:
-        _logger.error("Error processing payload. error: %s", err)
-        return _with_default_headers(
-            status_code=400, body="Error processing provided bundle."
-        )
+    response = handle_request(bundle)
+
+    return _with_default_headers(
+        status_code=200,
+        body=response,
+    )
 
 
 def handler(data: dict[str, Any], context: LambdaContext) -> dict[str, Any]: