Changed EXCEPTION_HANDLERS from dict of exception type or status code to list of IExceptionHandler

Author: eadwinCode

ellar/core/conf/app_settings_models.py

@@ -1,25 +1,23 @@
 import typing as t
 
-from pydantic import Field, root_validator, validator
+from pydantic import Field, validator
 from pydantic.json import ENCODERS_BY_TYPE as encoders_by_type
+from starlette.exceptions import HTTPException as StarletteHTTPException
 from starlette.websockets import WebSocketClose
 
 from ellar.constants import DEFAULT_LOGGING as default_logging, LOG_LEVELS as log_levels
 from ellar.core.response import JSONResponse, PlainTextResponse
 from ellar.core.versioning import DefaultAPIVersioning
-from ellar.exceptions import (
-    APIException,
-    HTTPException as StarletteHTTPException,
-    RequestValidationError,
-)
 from ellar.serializer import Serializer, SerializerFilter
 from ellar.types import ASGIApp, TReceive, TScope, TSend
 
-from ..exception_handlers import (
-    api_exception_handler,
-    request_validation_exception_handler,
+from .mixins import (
+    ConfigDefaultTypesMixin,
+    TEventHandler,
+    TExceptionHandler,
+    TMiddleware,
+    TVersioning,
 )
-from .mixins import ConfigDefaultTypesMixin, TEventHandler, TMiddleware, TVersioning
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.main import App
@@ -95,14 +93,7 @@ class Config:
 
     MIDDLEWARE: t.List[TMiddleware] = []
 
-    _APP_EXCEPTION_HANDLERS: t.Dict[t.Union[int, t.Type[Exception]], t.Callable] = {
-        RequestValidationError: request_validation_exception_handler,
-        APIException: api_exception_handler,
-    }
-
-    USER_CUSTOM_EXCEPTION_HANDLERS: t.Dict[
-        t.Union[int, t.Type[Exception]], t.Callable
-    ] = {}
+    EXCEPTION_HANDLERS: t.List[TExceptionHandler] = []  # type:ignore
 
     # Default not found handler
     DEFAULT_NOT_FOUND_HANDLER: ASGIApp = _not_found
@@ -122,8 +113,6 @@ class Config:
     # logging Level
     LOG_LEVEL: t.Optional[log_levels] = log_levels.info
 
-    MIDDLEWARE_DECORATOR: t.List[TMiddleware] = []
-
     ON_REQUEST_STARTUP: t.List[TEventHandler] = []
     ON_REQUEST_SHUTDOWN: t.List[TEventHandler] = []
 
@@ -132,23 +121,6 @@ class Config:
 
     LOGGING: t.Optional[t.Dict[str, t.Any]] = None
 
-    @root_validator(pre=False)
-    def pre_root_validate(cls, values: t.Any) -> t.Any:
-        app_exception_handlers = dict(cls._APP_EXCEPTION_HANDLERS)
-        user_custom_exception_handlers = values.get(
-            "USER_CUSTOM_EXCEPTION_HANDLERS", {}
-        )
-
-        app_exception_handlers.update(**user_custom_exception_handlers)
-
-        values["EXCEPTION_HANDLERS"] = app_exception_handlers
-        middleware_decorator_handlers = list(values.get("MIDDLEWARE_DECORATOR", []))
-        user_settings_middleware = list(values.get("MIDDLEWARE", []))
-        middleware_decorator_handlers.extend(user_settings_middleware)
-        values["MIDDLEWARE"] = middleware_decorator_handlers
-
-        return values
-
     @validator("MIDDLEWARE", pre=True)
     def pre_middleware_validate(cls, value: t.Any) -> t.Any:
         if isinstance(value, tuple):

ellar/core/conf/mixins.py

@@ -1,17 +1,43 @@
+import inspect
 import typing as t
 
 from starlette.responses import JSONResponse
 from starlette.types import ASGIApp
 
 from ellar.constants import LOG_LEVELS as log_levels
 from ellar.core.events import EventHandler
+from ellar.core.exceptions.interfaces import IExceptionHandler
 from ellar.core.middleware import Middleware
 from ellar.core.versioning import BaseAPIVersioning
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core import App
 
-__all__ = ["ConfigDefaultTypesMixin", "TVersioning", "TMiddleware", "TEventHandler"]
+__all__ = [
+    "ConfigDefaultTypesMixin",
+    "TVersioning",
+    "TMiddleware",
+    "TEventHandler",
+    "TExceptionHandler",
+]
+
+
+class TExceptionHandler:
+    @classmethod
+    def __get_validators__(
+        cls: t.Type["TExceptionHandler"],
+    ) -> t.Iterable[t.Callable[..., t.Any]]:
+        yield cls.validate
+
+    @classmethod
+    def validate(cls: t.Type["TExceptionHandler"], v: t.Any) -> t.Any:
+        if isinstance(v, IExceptionHandler):
+            return v
+
+        if inspect.isclass(v):
+            raise ValueError(f"Expected TExceptionHandler, received: {v}")
+
+        raise ValueError(f"Expected TExceptionHandler, received: {type(v)}")
 
 
 class TVersioning(BaseAPIVersioning):
@@ -89,18 +115,15 @@ class ConfigDefaultTypesMixin:
     # A dictionary mapping either integer status codes,
     # or exception class types onto callables which handle the exceptions.
     # Exception handler callables should be of the form
-    # `handler(request, exc) -> response` and may be be either standard functions, or async functions.
-    EXCEPTION_HANDLERS: t.Dict[t.Union[int, t.Type[Exception]], t.Callable]
+    # `handler(request, exc) -> response` and may be either standard functions, or async functions.
+    EXCEPTION_HANDLERS: t.List[IExceptionHandler]
 
     # static route
     STATIC_MOUNT_PATH: str
 
     # defines other custom json encoders
     SERIALIZER_CUSTOM_ENCODER: t.Dict[t.Any, t.Callable[[t.Any], t.Any]]
 
-    # will be set automatically when @middleware is found in a Module class
-    MIDDLEWARE_DECORATOR: t.List[TMiddleware]
-
     # will be set automatically when @on_startup is found in a Module class
     ON_REQUEST_STARTUP: t.List[TEventHandler]