Add error handler & Change API route to /api/v1 and frontend route to /

Author: MU-Software

Diff for: runtime/chalicelib/route/__init__.py

@@ -2,13 +2,30 @@
 import typing
 
 import chalice.app
+import chalicelib.util.chalice_util as chalice_util
 import chalicelib.util.import_util as import_util
 
+ROUTE_DIR = pathlib.Path(__file__).parent
+RUNTIME_DIR = ROUTE_DIR.parent.parent
+FRONTEND_DIR = RUNTIME_DIR / "frontend"
+FRONTEND_ADMIN_PATH = FRONTEND_DIR / "admin" / "index.html"
+
 
 def register_blueprints(app: chalice.app.Chalice) -> None:
+    app.register_middleware(func=chalice_util.exception_handler_middleware, event_type="http")
+
     for bps in typing.cast(
         list[chalice.app.Blueprint],
         import_util.auto_import_patterns(pattern="blueprints", file_prefix="", dir=pathlib.Path(__file__).parent),
     ):
         for bp in bps:
-            app.register_blueprint(blueprint=bp, url_prefix=bp.url_prefix)
+            if bp.url_prefix.startswith("/"):
+                raise ValueError(f"URL Prefix must not start with '/': {bp.url_prefix}")
+
+            app.register_blueprint(blueprint=bp, url_prefix=f"/api/v1/{bp.url_prefix}")
+
+    @app.route("/", methods=["GET"])
+    def get_admin_frontend() -> str:
+        if not FRONTEND_ADMIN_PATH.exists():
+            raise chalice.app.NotFoundError("Admin frontend not found")
+        return chalice.app.Response(body=FRONTEND_ADMIN_PATH.read_text(), headers={"Content-Type": "text/html"})

Diff for: runtime/chalicelib/route/health_check.py

@@ -1,15 +1,18 @@
 import chalice.app
+import chalicelib.util.chalice_util as chalice_util
 
 health_check_api = chalice.app.Blueprint(__name__)
-health_check_api.url_prefix = "/health"
+health_check_api.url_prefix = "health"
 
 
 @health_check_api.route("/readyz", methods=["GET"])
+@chalice_util.exception_catcher
 def readyz() -> dict[str, str]:
     return {"status": "ok"}
 
 
 @health_check_api.route("/livez", methods=["GET"])
+@chalice_util.exception_catcher
 def livez() -> dict[str, str]:
     return {"status": "ok"}
 

Diff for: runtime/chalicelib/route/index.py

@@ -1,24 +1,14 @@
-import pathlib
-
 import chalice.app
-
-runtime_dir = pathlib.Path(__file__).parent.parent.parent
-frontend_path = runtime_dir / "frontend" / "admin" / "index.html"
+import chalicelib.util.chalice_util as chalice_util
 
 index_api = chalice.app.Blueprint(__name__)
 index_api.url_prefix = ""
 
 
 @index_api.route("/service", methods=["GET"])
+@chalice_util.exception_catcher
 def get_service_identity() -> dict[str, str]:
     return {"service": "notico"}
 
 
-@index_api.route("/admin", methods=["GET"])
-def get_admin_frontend() -> str:
-    if not frontend_path.exists():
-        raise chalice.app.NotFoundError("Admin frontend not found")
-    return chalice.app.Response(body=frontend_path.read_text(), headers={"Content-Type": "text/html"})
-
-
 blueprints: list[chalice.app.Blueprint] = [index_api]

Diff for: runtime/chalicelib/route/send_manager.py

@@ -4,12 +4,14 @@
 import chalice.app
 import chalicelib.send_manager as send_manager
 import chalicelib.send_manager.__interface__ as send_mgr_interface
+import chalicelib.util.chalice_util as chalice_util
 
 send_manager_api = chalice.app.Blueprint(__name__)
-send_manager_api.url_prefix = "/send-manager"
+send_manager_api.url_prefix = "send-manager"
 
 
 @send_manager_api.route("/", methods=["GET"])
+@chalice_util.exception_catcher
 def list_send_manager_services() -> list[dict[str, str | bool | dict]]:
     return [
         {
@@ -22,6 +24,7 @@ def list_send_manager_services() -> list[dict[str, str | bool | dict]]:
 
 
 @send_manager_api.route("/{service_name}", methods=["POST"])
+@chalice_util.exception_catcher
 def send_message(service_name: str) -> dict[str, str | None]:
     request: chalice.app.Request = send_manager_api.current_request
     if not (payload := typing.cast(dict[str, str] | None, request.json_body)):

Diff for: runtime/chalicelib/route/template_manager.py

@@ -3,14 +3,16 @@
 import chalice
 import chalice.app
 import chalicelib.template_manager as template_manager
+import chalicelib.util.chalice_util as chalice_util
 
 HttpMethodType = typing.Literal["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"]
 
 template_manager_api = chalice.app.Blueprint(__name__)
-template_manager_api.url_prefix = "/template-manager"
+template_manager_api.url_prefix = "template-manager"
 
 
 @template_manager_api.route("/", methods=["GET"])
+@chalice_util.exception_catcher
 def list_template_manager_services() -> list[dict[str, str]]:
     return [
         {
@@ -23,13 +25,15 @@ def list_template_manager_services() -> list[dict[str, str]]:
 
 
 @template_manager_api.route("/{service_name}", methods=["GET"])
+@chalice_util.exception_catcher
 def list_templates(service_name: str) -> list[dict[str, str]]:
     if service_name not in template_manager.template_managers:
         raise chalice.NotFoundError(f"Service {service_name} not found")
     return [t.model_dump(mode="json") for t in template_manager.template_managers[service_name].list()]
 
 
 @template_manager_api.route("/{service_name}/{template_code}", methods=["GET", "POST", "PUT", "DELETE"])
+@chalice_util.exception_catcher
 def crud_template(service_name: str, template_code: str) -> dict[str, str]:
     request: chalice.app.Request = template_manager_api.current_request
     method: HttpMethodType = request.method.upper()
@@ -58,6 +62,7 @@ def crud_template(service_name: str, template_code: str) -> dict[str, str]:
 
 
 @template_manager_api.route("/{service_name}/{template_code}/render", methods=["POST"])
+@chalice_util.exception_catcher
 def render_template(service_name: str, template_code: str) -> dict[str, str]:
     request: chalice.app.Request = template_manager_api.current_request
     requested_content_type: str = request.headers.get("Accept", "text/html")

Diff for: runtime/chalicelib/util/chalice_util.py

@@ -0,0 +1,31 @@
+import functools
+import traceback
+import typing
+
+import chalice.app
+
+Param = typing.ParamSpec("Param")
+RetType = typing.TypeVar("RetType")
+ReqHandlerType = typing.Callable[[chalice.app.Request], chalice.app.Response]
+
+
+def exception_catcher(func: typing.Callable[Param, RetType]) -> typing.Callable[Param, RetType]:
+    @functools.wraps(wrapped=func)
+    def wrapper(*args: Param.args, **kwargs: Param.kwargs) -> RetType:
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            raise chalice.app.ChaliceUnhandledError(str(e)) from e
+
+    return wrapper
+
+
+def exception_handler_middleware(request: chalice.app.Request, get_response: ReqHandlerType) -> chalice.app.Response:
+    try:
+        return get_response(request)
+    except chalice.app.ChaliceUnhandledError as e:
+        traceback_msg = "".join(traceback.format_exception(e.__cause__ or e))
+        return chalice.app.Response(status_code=500, body={"traceback": traceback_msg})
+    except Exception as e:
+        traceback_msg = "".join(traceback.format_exception(e))
+        return chalice.app.Response(status_code=500, body={"traceback": traceback_msg})