✨ Added middleware and pre-commit

Author: SirPaulO

.flake8

@@ -0,0 +1,20 @@
+[flake8]
+max-line-length = 120
+select = C,E,F,W,B,B950
+extend-ignore = E203, E50, E712, W503
+exclude =
+    # No need to traverse our git directory
+    .git,
+    # There's no value in checking cache directories
+    __pycache__,
+    __init__.py,
+    .mypy_cache,
+    .pytest_cache,
+    # There's no value in checking IDE configs
+    .idea,
+    # There's no value in checking venv directories
+    venv
+
+per-file-ignores =
+    # imported but unused
+    __init__.py: F401

.gitignore

@@ -2,3 +2,4 @@
 venv
 __pycache__
 dist
+fastapi_exceptionshandler.egg-info/

.pre-commit-config.yaml

@@ -0,0 +1,26 @@
+files: ^fastapi_exceptionshandler/
+default_language_version:
+  python: python3.11
+repos:
+  - repo: https://github.com/psf/black
+    rev: 23.9.1
+    hooks:
+      - id: black
+
+  - repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+
+  - repo: https://github.com/pycqa/flake8
+    rev: 6.1.0
+    hooks:
+      - id: flake8
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: 'v1.5.1'
+    hooks:
+      - id: mypy
+        additional_dependencies: [
+          pydantic,
+        ]

fastapi_exceptionshandler/__init__.py

@@ -1,6 +1,6 @@
-from .api_exception import APIException, APIError
-from .api_exception_manager import APIExceptionManager
+from .api_exception import APIError, APIException
 from .api_exception_handler import APIExceptionHandler
+from .api_exception_manager import APIExceptionManager
 
 __all__ = [
     "APIException",

fastapi_exceptionshandler/api_exception.py

@@ -9,7 +9,7 @@ class APIException(ABC, Exception):
     class ErrorCode(Enum):
         InternalError = "Internal Server Error"
 
-    def __init__(self, error_code: Enum = ErrorCode.InternalError, exc: Exception = None) -> None:
+    def __init__(self, error_code: Enum = ErrorCode.InternalError, exc: Optional[Exception] = None) -> None:
         self._error_code = error_code
         self._exc = exc
 

fastapi_exceptionshandler/api_exception_handler.py

@@ -1,16 +1,27 @@
-from .api_exception import APIException
-from starlette.responses import JSONResponse
-from typing import Any, Dict
+import logging
 import os
+from typing import Any, Dict, Optional
+
+from fastapi.exceptions import RequestValidationError
+from pydantic import ValidationError
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+from .api_exception import APIException
 
 
 class APIExceptionHandler:
     error_label = "errorCode"
     message_label = "message"
 
     @classmethod
-    async def handled(cls, exc: APIException, body_extra: Dict = None, **kwargs: Any) -> JSONResponse:
-        body_content = {cls.error_label: exc.get_error_code(), cls.message_label: str(exc)}
+    def handled(
+        cls, request: Request, exc: APIException, body_extra: Optional[Dict] = None, **kwargs: Any
+    ) -> JSONResponse:
+        body_content = {
+            cls.error_label: exc.get_error_code(),
+            cls.message_label: str(exc),
+        }
         if body_extra is not None:
             body_content = {**body_content, **body_extra}
 
@@ -21,6 +32,36 @@ async def handled(cls, exc: APIException, body_extra: Dict = None, **kwargs: Any
         return JSONResponse(status_code=exc.status_code, content=body_content, **kwargs)
 
     @classmethod
-    async def unhandled(cls, exc: Exception, body_extra: Dict = None, **kwargs: Any) -> JSONResponse:
+    def unhandled(
+        cls, request: Request, exc: Exception, body_extra: Optional[Dict] = None, **kwargs: Any
+    ) -> JSONResponse:
         api_exc = APIException(exc=exc)
-        return await cls.handled(api_exc, body_extra, **kwargs)
+        return cls.handled(request, api_exc, body_extra, **kwargs)
+
+    @classmethod
+    def handle_exception(
+        cls,
+        request: Request,
+        exc: Exception,
+        capture_unhandled: bool = True,
+        capture_validation: bool = False,
+        log_error: bool = True,
+        logger_name: str = "app.exception_handler",
+    ) -> JSONResponse:
+        logger = logging.getLogger(logger_name) if log_error else None
+
+        if issubclass(type(exc), APIException):
+            if log_error:
+                logger.error(str(exc))
+            return APIExceptionHandler.handled(request, exc)  # type: ignore
+
+        if log_error:
+            logger.error(str(exc))
+
+        if issubclass(type(exc), (RequestValidationError, ValidationError)) and not capture_validation:
+            raise
+
+        if not capture_unhandled:
+            raise
+
+        return APIExceptionHandler.unhandled(request, exc)

fastapi_exceptionshandler/api_exception_manager.py

@@ -1,33 +1,40 @@
-from fastapi.exceptions import RequestValidationError
-from .api_exception import APIException
-from .api_exception_handler import APIExceptionHandler
+from typing import Callable, List, Optional, Type
+
 from fastapi_routesmanager import RouteManager
-from pydantic import ValidationError
 from starlette.requests import Request
 from starlette.responses import Response
-from typing import Callable, List, Type, Optional
 
+from . import APIExceptionHandler
 
-class APIExceptionManager(RouteManager):
 
-    def __init__(self, capture_unhandled: bool = True, capture_validation=False):
+class APIExceptionManager(RouteManager):
+    def __init__(
+        self,
+        capture_unhandled: bool = True,
+        capture_validation: bool = False,
+        logger_name: Optional[str] = None,
+        log_error: bool = True,
+    ):
         self.capture_unhandled = capture_unhandled
         self.capture_validation = capture_validation
+        self.logger_name = logger_name
+        self.log_error = log_error
 
     async def run(
-            self,
-            request: Request,
-            call_next: Callable,
-            remaining_managers: List[Type[RouteManager]],
+        self,
+        request: Request,
+        call_next: Callable,
+        remaining_managers: List[Type[RouteManager]],
     ) -> Optional[Response]:
         try:
-            response: Response = await call_next(request, remaining_managers)
-        except APIException as exc:
-            return await APIExceptionHandler.handled(exc)
+            response = await call_next(request, remaining_managers)
         except Exception as exc:
-            if type(exc) in [RequestValidationError, ValidationError] and not self.capture_validation:
-                raise
-            if not self.capture_unhandled:
-                raise
-            return await APIExceptionHandler.unhandled(exc)
+            return APIExceptionHandler.handle_exception(
+                request,
+                exc,
+                capture_unhandled=self.capture_unhandled,
+                capture_validation=self.capture_validation,
+                logger_name=self.logger_name,
+                log_error=self.log_error,
+            )
         return response

fastapi_exceptionshandler/api_exceptions_middleware.py

@@ -0,0 +1,39 @@
+import typing
+
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware, DispatchFunction, RequestResponseEndpoint
+from starlette.types import ASGIApp
+
+from . import APIExceptionHandler
+
+
+class APIExceptionMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware that catches and transforms exceptions
+    """
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        dispatch: typing.Optional[DispatchFunction] = None,
+        capture_unhandled: bool = True,
+        logger_name: typing.Optional[str] = None,
+        log_error: bool = True,
+    ):
+        super().__init__(app, dispatch)
+        self.capture_unhandled = capture_unhandled
+        self.logger_name = logger_name
+        self.log_error = log_error
+
+    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
+        try:
+            response = await call_next(request)
+        except Exception as exc:
+            return APIExceptionHandler.handle_exception(
+                request,
+                exc,
+                capture_unhandled=self.capture_unhandled,
+                log_error=self.log_error,
+                logger_name=self.logger_name,
+            )
+        return response

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = 'fastapi_exceptionshandler'
-version = "0.0.1"
+version = "0.0.2"
 license = {text = "MIT License"}
 authors = [
   { name="SirPaulO", email="me@sirpauloliver.com" },
@@ -26,3 +26,35 @@ classifiers = [
 "Homepage" = "https://github.com/SirPaulO/fastapi_exceptionshandler"
 "Bug Tracker" = "https://github.com/SirPaulO/fastapi_exceptionshandler/issues"
 "Repository" = "https://github.com/SirPaulO/fastapi_exceptionshandler.git"
+
+[tool.mypy]
+plugins = ["pydantic.mypy"]
+ignore_missing_imports = true
+disallow_untyped_defs = true
+warn_unused_ignores = true
+no_strict_optional = true
+no_implicit_optional = true
+implicit_reexport = true
+explicit_package_bases = true
+namespace_packages = true
+follow_imports = "silent"
+warn_redundant_casts = true
+check_untyped_defs = true
+no_implicit_reexport = true
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_required_dynamic_aliases = true
+warn_untyped_fields = true
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+line_length = 120
+
+[tool.black]
+line-length = 120
+target-version = ['py39']

requirements.txt

@@ -1,4 +1,4 @@
 starlette~=0.27.0
-fastapi_routesmanager~=0.0.3
 pydantic>=1.10.7
-fastapi>=0.95.2
+fastapi>=0.95.2
+pre-commit~=3.4.0