1 files changed, 192 insertions, 198 deletions
diff --git a/server/src/http_server.cppm b/server/src/http_server.cppm
index 0f7fda7..366037f 100644
--- a/server/src/http_server.cppm
+++ b/server/src/http_server.cppm
@@ -41,7 +41,7 @@ private:
    virtual ~impl_base() = default;
    virtual auto header() -> bhttp::response_header<bhttp::fields>& = 0;
    virtual auto header() const
-        -> bhttp::response_header<bhttp::fields> const& = 0;
+      -> bhttp::response_header<bhttp::fields> const& = 0;
    virtual auto is_done() const -> bool = 0;
    virtual auto prepare(beast::error_code&) -> const_buffers_type = 0;
    virtual auto consume(std::size_t n) -> void = 0;
@@ -121,12 +121,12 @@ private:
    auto keep_alive() const noexcept -> bool override
    {
      return state_.visit(
-          util::overloaded{
+        util::overloaded{
-              [](bhttp::response<Body> const& rsp) -> bool
+          [](bhttp::response<Body> const& rsp) -> bool
-              { return rsp.keep_alive(); },
+          { return rsp.keep_alive(); },
-              [](bhttp::message_generator const& gen) -> bool
+          [](bhttp::message_generator const& gen) -> bool
-              { return gen.keep_alive(); },
+          { return gen.keep_alive(); },
-          });
+        });
    }
  };
@@ -164,15 +164,15 @@ using next_handler_t = std::function<auto(Ctx)->net::awaitable<presponse>>;
 template <class OuterCtx, class InnerCtx>
 using middleware_t =
-    std::function<auto(
+  std::function<auto(
-                      OuterCtx, bhttp::request_header<bhttp::fields>&,
+                  OuterCtx, bhttp::request_header<bhttp::fields>&,
-                      next_handler_t<InnerCtx>)
+                  next_handler_t<InnerCtx>)
-                      ->net::awaitable<presponse>>;
+                  ->net::awaitable<presponse>>;
 template <class Ctx>
 auto lax_cors_middleware(
-    Ctx ctx, bhttp::request_header<bhttp::fields>& req_hdr,
+  Ctx ctx, bhttp::request_header<bhttp::fields>& req_hdr,
-    next_handler_t<Ctx> next) -> net::awaitable<presponse>
+  next_handler_t<Ctx> next) -> net::awaitable<presponse>
 {
  std::ignore = req_hdr;
  auto prersp = co_await next(ctx);
@@ -188,16 +188,16 @@ struct trace_id_ctx : InnerCtx
 template <class OuterCtx>
 auto trace_id_middleware(
-    OuterCtx ctx0, bhttp::request_header<bhttp::fields>& req_hdr,
+  OuterCtx ctx0, bhttp::request_header<bhttp::fields>& req_hdr,
-    next_handler_t<trace_id_ctx<OuterCtx>> next) -> net::awaitable<presponse>
+  next_handler_t<trace_id_ctx<OuterCtx>> next) -> net::awaitable<presponse>
 {
  std::ignore = req_hdr;
  auto ctx = trace_id_ctx{std::move(ctx0)};
  auto prersp = co_await next(std::move(ctx));
  prersp.header().set(
-      "X-Routemon-Trace-Id", std::string_view{ctx.trace_id.as_string()});
+    "X-Routemon-Trace-Id", std::string_view{ctx.trace_id.as_string()});
  prersp.header().insert(
-      bhttp::field::access_control_expose_headers, "X-Routemon-Trace-Id");
+    bhttp::field::access_control_expose_headers, "X-Routemon-Trace-Id");
  co_return std::move(prersp);
 }
@@ -208,8 +208,8 @@ struct base_ctx
 template <class Ctx>
 using basic_route_handler_fn_t = std::function<
-    auto(Ctx, readable_request, std::vector<std::string> const& matches)
+  auto(Ctx, readable_request, std::vector<std::string> const& matches)
-        ->net::awaitable<presponse>>;
+    ->net::awaitable<presponse>>;
 struct keep_alive
 {
@@ -228,8 +228,8 @@ auto make_rsp(bhttp::status status, keep_alive ka) -> bhttp::response<Body>
 }
 auto problem_rsp(
-    base_ctx const& ctx, problem::details const& problem, keep_alive ka)
+  base_ctx const& ctx, problem::details const& problem, keep_alive ka)
-    -> presponse
+  -> presponse
 {
  auto rsp = make_rsp<bhttp::string_body>(problem.status, ka);
  rsp.set(bhttp::field::content_type, "application/problem+json");
@@ -244,18 +244,17 @@ struct preflight_response
  std::vector<bhttp::field> allow_headers;
 };
 auto make_preflight_rsp(preflight_response res, keep_alive ka)
-    -> bhttp::response<bhttp::empty_body>
+  -> bhttp::response<bhttp::empty_body>
 {
  auto rsp = make_rsp<bhttp::empty_body>(bhttp::status::no_content, ka);
  auto allow_headers_str = res.allow_headers
                           | std::views::transform(
-                               [](auto const& field) -> std::string_view
+                             [](auto const& field) -> std::string_view
-                               { return bhttp::to_string(field); })
+                             { return bhttp::to_string(field); })
                           | std::views::join_with(std::string_view{", "})
                           | std::ranges::to<std::string>();
  rsp.set(
-      bhttp::field::access_control_allow_methods,
+    bhttp::field::access_control_allow_methods, res.allow_methods.to_string());
-      res.allow_methods.to_string());
  rsp.set(bhttp::field::access_control_allow_headers, allow_headers_str);
  rsp.prepare_payload();
  return rsp;
@@ -266,7 +265,7 @@ auto make_preflight_rsp(preflight_response res, keep_alive ka)
 // anyway, but all context types should derive from base_ctx).
 template <bhttp::concepts::body_reader Body>
 auto read_request(base_ctx const& ctx, readable_request&& r)
-    -> net::awaitable<std::expected<bhttp::request<Body>, presponse>>
+  -> net::awaitable<std::expected<bhttp::request<Body>, presponse>>
 {
  std::ignore = ctx;
  auto p = bhttp::request_parser<Body>{std::move(*r.p)};
@@ -276,20 +275,19 @@ auto read_request(base_ctx const& ctx, readable_request&& r)
 template <>
 auto read_request<bhttp::empty_body>(base_ctx const& ctx, readable_request&& r)
-    -> net::awaitable<
+  -> net::awaitable<std::expected<bhttp::request<bhttp::empty_body>, presponse>>
-        std::expected<bhttp::request<bhttp::empty_body>, presponse>>
 {
  auto [ec, _] =
-      co_await bhttp::async_read(*r.strm, *r.buf, *r.p, net::as_tuple);
+    co_await bhttp::async_read(*r.strm, *r.buf, *r.p, net::as_tuple);
  if (ec == bhttp::error::unexpected_body)
  {
    auto tpl = problem::tpl{
-        .status = bhttp::status::bad_request,
+      .status = bhttp::status::bad_request,
-        .title = translate("No body expected for this request"),
+      .title = translate("No body expected for this request"),
-        .type_uri = "https://routemon.fautchen.eu/problems/unexpected-body",
+      .type_uri = "https://routemon.fautchen.eu/problems/unexpected-body",
    };
    co_return std::unexpected{problem_rsp(
-        ctx, tpl.instantiate(), keep_alive{false})};
+      ctx, tpl.instantiate(), keep_alive{false})};
  }
  else if (ec)
  {
@@ -310,8 +308,8 @@ template <class Ctx>
    []<class InnerCtx>(routed_ctx<InnerCtx> const&) {}(ctx);
  }
 auto default_options_handler(
-    Ctx const& ctx, readable_request r, std::vector<std::string> const&)
+  Ctx const& ctx, readable_request r, std::vector<std::string> const&)
-    -> net::awaitable<presponse>
+  -> net::awaitable<presponse>
 {
  auto mreq = co_await read_request<bhttp::empty_body>(ctx, std::move(r));
  if (!mreq)
@@ -321,18 +319,18 @@ auto default_options_handler(
  {
    // CORS preflight request
    co_return make_preflight_rsp(
-        preflight_response{
+      preflight_response{
-            // TODO: should access-control-allow-methods contain OPTIONS?
+        // TODO: should access-control-allow-methods contain OPTIONS?
-            .allow_methods = ctx.route_methods,
+        .allow_methods = ctx.route_methods,
-            .allow_headers = {bhttp::field::content_type},
+        .allow_headers = {bhttp::field::content_type},
-        },
+      },
-        keep_alive{mreq->keep_alive()});
+      keep_alive{mreq->keep_alive()});
  }
  else
  {
    // Normal OPTIONS request
    auto rsp = make_rsp<bhttp::empty_body>(
-        bhttp::status::no_content, keep_alive{mreq->keep_alive()});
+      bhttp::status::no_content, keep_alive{mreq->keep_alive()});
    rsp.set(bhttp::field::allow, ctx.route_methods.to_string());
    rsp.prepare_payload();
    co_return std::move(rsp);
@@ -340,7 +338,7 @@ auto default_options_handler(
 }
 auto global_options_handler(base_ctx const& ctx, readable_request r)
-    -> net::awaitable<presponse>
+  -> net::awaitable<presponse>
 {
  // TODO: switch to "small (4KB) discarded" body type, similar to what Go
  // does? Same goes for default_options_handler? Not sure.
@@ -349,46 +347,45 @@ auto global_options_handler(base_ctx const& ctx, readable_request r)
    co_return std::move(res.error());
  auto req = r.p->release();
  auto rsp = make_rsp<bhttp::empty_body>(
-      bhttp::status::no_content, keep_alive{req.keep_alive()});
+    bhttp::status::no_content, keep_alive{req.keep_alive()});
  rsp.prepare_payload();
  co_return std::move(rsp);
 }
 template <class Ctx>
 auto id_middleware(
-    Ctx ctx, bhttp::request_header<bhttp::fields>&, next_handler_t<Ctx> next)
+  Ctx ctx, bhttp::request_header<bhttp::fields>&, next_handler_t<Ctx> next)
-    -> net::awaitable<presponse>
+  -> net::awaitable<presponse>
 {
  co_return co_await next(std::move(ctx));
 }
 template <class A, class B, class C>
 auto middleware_compose(middleware_t<A, B> ab, middleware_t<B, C> bc)
-    -> middleware_t<A, C>
+  -> middleware_t<A, C>
 {
  return [ab = std::move(ab), bc = std::move(bc)](
-             A a, bhttp::request_header<bhttp::fields>& header,
+           A a, bhttp::request_header<bhttp::fields>& header,
-             next_handler_t<C> next) -> net::awaitable<presponse>
+           next_handler_t<C> next) -> net::awaitable<presponse>
  {
    co_return co_await ab(
-        std::move(a), header, [&](B b) -> net::awaitable<presponse>
+      std::move(a), header, [&](B b) -> net::awaitable<presponse>
-        { co_return co_await bc(std::move(b), header, next); });
+      { co_return co_await bc(std::move(b), header, next); });
  };
 }
 template <class A, class B>
 auto middleware_wrap_fn(middleware_t<A, B> ab, basic_route_handler_fn_t<B> fn)
-    -> basic_route_handler_fn_t<A>
+  -> basic_route_handler_fn_t<A>
 {
-  return
+  return [ab = std::move(ab), fn = std::move(fn)](
-      [ab = std::move(ab), fn = std::move(fn)](
+           A a_ctx, readable_request r,
-          A a_ctx, readable_request r,
+           std::vector<std::string> const& matches) -> net::awaitable<presponse>
-          std::vector<std::string> const& matches) -> net::awaitable<presponse>
  {
    co_return co_await ab(
-        std::move(a_ctx), r.p->get().base(),
+      std::move(a_ctx), r.p->get().base(),
-        [&](B b_ctx) -> net::awaitable<presponse>
+      [&](B b_ctx) -> net::awaitable<presponse>
-        { co_return co_await fn(std::move(b_ctx), r, matches); });
+      { co_return co_await fn(std::move(b_ctx), r, matches); });
  };
 }
@@ -448,15 +445,15 @@ struct handler_map
  template <std::default_initializable U>
  auto map(std::invocable<V const&> auto f) const -> handler_map<U>
    requires std::assignable_from<
-        U&, std::invoke_result_t<decltype(f), V const&>>
+      U&, std::invoke_result_t<decltype(f), V const&>>
  {
    return {
-        .options = static_cast<bool>(options) ? f(options) : U{},
+      .options = static_cast<bool>(options) ? f(options) : U{},
-        .delete_ = static_cast<bool>(delete_) ? f(delete_) : U{},
+      .delete_ = static_cast<bool>(delete_) ? f(delete_) : U{},
-        .get = static_cast<bool>(get) ? f(get) : U{},
+      .get = static_cast<bool>(get) ? f(get) : U{},
-        .head = static_cast<bool>(head) ? f(head) : U{},
+      .head = static_cast<bool>(head) ? f(head) : U{},
-        .post = static_cast<bool>(post) ? f(post) : U{},
+      .post = static_cast<bool>(post) ? f(post) : U{},
-        .put = static_cast<bool>(put) ? f(put) : U{},
+      .put = static_cast<bool>(put) ? f(put) : U{},
    };
  }
 };
@@ -478,29 +475,29 @@ struct route_tree
 template <class OuterCtx, class InnerCtx>
 auto middleware_wrap_tree(
-    middleware_t<OuterCtx, InnerCtx> mw, route_tree<InnerCtx> const& tree)
+  middleware_t<OuterCtx, InnerCtx> mw, route_tree<InnerCtx> const& tree)
-    -> route_tree<OuterCtx>
+  -> route_tree<OuterCtx>
 {
  auto new_leaves = tree.here.template map<basic_route_handler_fn_t<OuterCtx>>(
-      std::bind_front(middleware_wrap_fn<OuterCtx, InnerCtx>, mw));
+    std::bind_front(middleware_wrap_fn<OuterCtx, InnerCtx>, mw));
  auto new_sub = tree.sub.visit(
-      util::overloaded{
+    util::overloaded{
-          [&mw](route_tree<InnerCtx>::named_subtrees const& subtrees)
+      [&mw](route_tree<InnerCtx>::named_subtrees const& subtrees)
-              -> decltype(route_tree<OuterCtx>::sub)
+        -> decltype(route_tree<OuterCtx>::sub)
-          {
+      {
-            auto new_subtrees = typename route_tree<OuterCtx>::named_subtrees{};
+        auto new_subtrees = typename route_tree<OuterCtx>::named_subtrees{};
-            for (auto [seg, subtree] : subtrees)
+        for (auto [seg, subtree] : subtrees)
-              new_subtrees[seg] = middleware_wrap_tree(mw, subtree);
+          new_subtrees[seg] = middleware_wrap_tree(mw, subtree);
-            return new_subtrees;
+        return new_subtrees;
-          },
+      },
-          [&mw](route_tree<InnerCtx>::wildcard_subtree const& subtree)
+      [&mw](route_tree<InnerCtx>::wildcard_subtree const& subtree)
-              -> decltype(route_tree<OuterCtx>::sub)
+        -> decltype(route_tree<OuterCtx>::sub)
-          {
+      {
-            return typename route_tree<OuterCtx>::wildcard_subtree{
+        return typename route_tree<OuterCtx>::wildcard_subtree{
-                middleware_wrap_tree(mw, *subtree)
+          middleware_wrap_tree(mw, *subtree)
-            };
+        };
-          },
+      },
-      });
+    });
  return {.here = new_leaves, .sub = new_sub};
 }
@@ -509,23 +506,21 @@ concept match_arg = std::constructible_from<T, std::string const&>;
 template <class Ctx, match_arg... MatchArgs>
 using route_handler_fn_t = std::function<
-    auto(Ctx, readable_request, MatchArgs...)->net::awaitable<presponse>>;
+  auto(Ctx, readable_request, MatchArgs...)->net::awaitable<presponse>>;
 template <class Ctx, match_arg... MatchArgs>
 auto degen_route_handler(route_handler_fn_t<Ctx, MatchArgs...> fn)
-    -> basic_route_handler_fn_t<Ctx>
+  -> basic_route_handler_fn_t<Ctx>
 {
-  return
+  return [fn = std::move(fn)](
-      [fn = std::move(fn)](
+           Ctx ctx, readable_request r,
-          Ctx ctx, readable_request r,
+           std::vector<std::string> const& matches) -> net::awaitable<presponse>
-          std::vector<std::string> const& matches) -> net::awaitable<presponse>
  {
    if (sizeof...(MatchArgs) != matches.size())
      throw std::runtime_error{"got unexpected amount of matches"};
    auto it = matches.begin();
    co_return co_await fn(
-        std::move(ctx), r,
+      std::move(ctx), r, MatchArgs{static_cast<std::string const&>(*it++)}...);
-        MatchArgs{static_cast<std::string const&>(*it++)}...);
  };
 }
@@ -534,7 +529,7 @@ struct ctree : route_tree<Ctx>
 {
  template <class OuterCtx>
  auto wrap(middleware_t<OuterCtx, Ctx> mw) const
-      -> ctree<OuterCtx, MatchArgs...>
+    -> ctree<OuterCtx, MatchArgs...>
  {
    return {middleware_wrap_tree(std::move(mw), *this)};
  }
@@ -546,25 +541,24 @@ struct dtree : handler_map<route_handler_fn_t<Ctx, MatchArgs...>>
  [[nodiscard]] auto to_leaves() const -> typename route_tree<Ctx>::leaves
  {
    auto here = this->template map<basic_route_handler_fn_t<Ctx>>(
-        degen_route_handler<Ctx, MatchArgs...>);
+      degen_route_handler<Ctx, MatchArgs...>);
    if (!here.verbs().empty() && !static_cast<bool>(this->options))
      here.options = default_options_handler<Ctx>;
    return here;
  }
  [[nodiscard]] auto named_subtrees(
-      std::initializer_list<std::pair<std::string, ctree<Ctx, MatchArgs...>>>
+    std::initializer_list<std::pair<std::string, ctree<Ctx, MatchArgs...>>>
-          subtrees) const -> ctree<Ctx, MatchArgs...>
+      subtrees) const -> ctree<Ctx, MatchArgs...>
  {
    auto sub = typename route_tree<Ctx>::named_subtrees{
-        std::from_range, subtrees
+      std::from_range, subtrees
-                             | std::views::transform(
+                         | std::views::transform(
-                                 [](auto const& p)
+                           [](auto const& p)
-                                 {
+                           {
-                                   return std::make_pair(
+                             return std::make_pair(
-                                       p.first,
+                               p.first, static_cast<route_tree<Ctx>>(p.second));
-                                       static_cast<route_tree<Ctx>>(p.second));
+                           })
-                                 })
    };
    return {route_tree<Ctx>{.here = to_leaves(), .sub = sub}};
  }
@@ -572,13 +566,13 @@ struct dtree : handler_map<route_handler_fn_t<Ctx, MatchArgs...>>
  template <match_arg MatchArg>
  [[nodiscard]] auto
  wildcard_subtree(ctree<Ctx, MatchArgs..., MatchArg> subtree)
-      -> ctree<Ctx, MatchArgs...>
+    -> ctree<Ctx, MatchArgs...>
  {
    return {route_tree<Ctx>{
-        .here = to_leaves(),
+      .here = to_leaves(),
-        .sub = typename route_tree<Ctx>::wildcard_subtree{
+      .sub = typename route_tree<Ctx>::wildcard_subtree{
-            static_cast<route_tree<Ctx>>(subtree)
+        static_cast<route_tree<Ctx>>(subtree)
-        }
+      }
    }};
  }
@@ -598,9 +592,9 @@ class server
 public:
  explicit server(
-      log::logger const& l, locale::selector&& lsel,
+    log::logger const& l, locale::selector&& lsel,
-      middleware_t<base_ctx, PreRouteCtx> global_middleware,
+    middleware_t<base_ctx, PreRouteCtx> global_middleware,
-      route_tree<routed_ctx<PreRouteCtx>> routes)
+    route_tree<routed_ctx<PreRouteCtx>> routes)
    : l_{l.sub("http_server")}, lsel_{std::move(lsel)},
      global_middleware_{std::move(global_middleware)},
      routes_{std::move(routes)}
@@ -610,55 +604,56 @@ public:
  struct match_result
  {
    util::not_null<
-        handler_map<basic_route_handler_fn_t<routed_ctx<PreRouteCtx>>> const*>
+      handler_map<basic_route_handler_fn_t<routed_ctx<PreRouteCtx>>> const*>
-        route_handlers;
+      route_handlers;
    std::vector<std::string> wildcard_matches;
    auto allowed_methods() const -> verb_set { return route_handlers->verbs(); }
  };
  auto match(boost::urls::segments_view segments) const
-      -> std::optional<match_result>
+    -> std::optional<match_result>
  {
    auto const* tree = &routes_;
    auto wildcard_matches = std::vector<std::string>{};
    for (auto const& seg : segments)
    {
      tree->sub.visit(
-          util::overloaded{
+        util::overloaded{
-              [&](route_tree<routed_ctx<PreRouteCtx>>::named_subtrees const&
+          [&](
-                      subtrees)
+            route_tree<routed_ctx<PreRouteCtx>>::named_subtrees const& subtrees)
-              {
+          {
-                auto it = subtrees.find(seg);
+            auto it = subtrees.find(seg);
-                tree = it == subtrees.end() ? nullptr : &it->second;
+            tree = it == subtrees.end() ? nullptr : &it->second;
-              },
+          },
-              [&](route_tree<routed_ctx<PreRouteCtx>>::wildcard_subtree const&
+          [&](
-                      wildcard_subtree)
+            route_tree<routed_ctx<PreRouteCtx>>::wildcard_subtree const&
-              {
+              wildcard_subtree)
-                wildcard_matches.push_back(seg);
+          {
-                tree = &*wildcard_subtree;
+            wildcard_matches.push_back(seg);
-              },
+            tree = &*wildcard_subtree;
-          });
+          },
+        });
      if (!tree)
        return std::nullopt;
    }
    if (tree->here.empty())
      return std::nullopt;
    return match_result{
-        .route_handlers = util::not_null{&tree->here},
+      .route_handlers = util::not_null{&tree->here},
-        .wildcard_matches = wildcard_matches,
+      .wildcard_matches = wildcard_matches,
    };
  }
  auto route_request(PreRouteCtx ctx, readable_request r) const
-      -> net::awaitable<presponse>
+    -> net::awaitable<presponse>
  {
    auto req_base = r.p->get().base();
    auto const bad_request_tpl = problem::tpl{
-        .status = bhttp::status::bad_request,
+      .status = bhttp::status::bad_request,
-        .title = translate("Bad request"),
+      .title = translate("Bad request"),
-        .type_uri = "https://routemon.fautchen.eu/problems/bad-request",
+      .type_uri = "https://routemon.fautchen.eu/problems/bad-request",
    };
    if (req_base.target() == "*")
@@ -669,10 +664,10 @@ public:
      if (req_base.method() != bhttp::verb::options)
      {
        auto tpl = problem::tpl{
-            .status = bhttp::status::method_not_allowed,
+          .status = bhttp::status::method_not_allowed,
-            .title = translate("Method not allowed"),
+          .title = translate("Method not allowed"),
-            .type_uri = "https://routemon.fautchen.eu/problems/"
+          .type_uri = "https://routemon.fautchen.eu/problems/"
-                        "method-not-allowed",
+                      "method-not-allowed",
        };
        co_return problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
      }
@@ -690,10 +685,10 @@ public:
      if (!req_url.is_path_absolute())
      {
        auto problem = bad_request_tpl.instantiate().set_detail(translate(
-            "Path of normalized (RFC 3986, § 6) "
+          "Path of normalized (RFC 3986, § 6) "
-            "origin-form request-target (RFC "
+          "origin-form request-target (RFC "
-            "9112, § 3.2.1) should be "
+          "9112, § 3.2.1) should be "
-            "absolute"));
+          "absolute"));
        co_return problem_rsp(ctx, problem, keep_alive{false});
      }
@@ -701,9 +696,9 @@ public:
      if (!mres)
      {
        auto tpl = problem::tpl{
-            .status = bhttp::status::not_found,
+          .status = bhttp::status::not_found,
-            .title = translate("Not found"),
+          .title = translate("Not found"),
-            .type_uri = "https://routemon.fautchen.eu/problems/not-found",
+          .type_uri = "https://routemon.fautchen.eu/problems/not-found",
        };
        co_return problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
      }
@@ -713,10 +708,10 @@ public:
      {
        // Method not implemented.
        auto tpl = problem::tpl{
-            .status = bhttp::status::not_implemented,
+          .status = bhttp::status::not_implemented,
-            .title = translate("Method not implemented"),
+          .title = translate("Method not implemented"),
-            .type_uri = "https://routemon.fautchen.eu/problems/"
+          .type_uri = "https://routemon.fautchen.eu/problems/"
-                        "method-not-implemented",
+                      "method-not-implemented",
        };
        co_return problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
      }
@@ -724,21 +719,21 @@ public:
      if (auto mhdl = mres->route_handlers->lookup(*mverb))
      {
        auto new_ctx =
-            routed_ctx<PreRouteCtx>{std::move(ctx), mres->allowed_methods()};
+          routed_ctx<PreRouteCtx>{std::move(ctx), mres->allowed_methods()};
        co_return co_await mhdl(std::move(new_ctx), r, mres->wildcard_matches);
      }
      else
      {
        // Path recognized, but method not allowed.
        auto tpl = problem::tpl{
-            .status = bhttp::status::method_not_allowed,
+          .status = bhttp::status::method_not_allowed,
-            .title = translate("Method not allowed"),
+          .title = translate("Method not allowed"),
-            .type_uri = "https://routemon.fautchen.eu/problems/"
+          .type_uri = "https://routemon.fautchen.eu/problems/"
-                        "method-not-allowed",
+                      "method-not-allowed",
        };
        auto rsp = problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
        rsp.header().set(
-            bhttp::field::allow, mres->allowed_methods().to_string());
+          bhttp::field::allow, mres->allowed_methods().to_string());
        co_return std::move(rsp);
      }
    }
@@ -747,9 +742,9 @@ public:
      // We do not accept any other request-target forms.
      auto problem = bad_request_tpl.instantiate().set_detail(translate(
-          "Invalid request-target, expected "
+        "Invalid request-target, expected "
-          "asterisk-form or origin-form "
+        "asterisk-form or origin-form "
-          "(see RFC 9112, § 3.2)"));
+        "(see RFC 9112, § 3.2)"));
      co_return problem_rsp(ctx, problem, keep_alive{false});
    }
  }
@@ -761,9 +756,8 @@ public:
    auto ctx0 = base_ctx{.locale = locale};
    co_return co_await global_middleware_(
-        std::move(ctx0), header,
+      std::move(ctx0), header, [&](PreRouteCtx ctx) -> net::awaitable<presponse>
-        [&](PreRouteCtx ctx) -> net::awaitable<presponse>
+      { co_return co_await route_request(std::move(ctx), std::move(r)); });
-        { co_return co_await route_request(std::move(ctx), std::move(r)); });
  }
  auto do_session(beast::tcp_stream strm) -> net::awaitable<void>
@@ -775,7 +769,7 @@ public:
      auto p0 = bhttp::request_parser<bhttp::empty_body>{};
      p0.body_limit(boost::none);
      auto [ec, _] =
-          co_await bhttp::async_read_header(strm, buf, p0, net::as_tuple);
+        co_await bhttp::async_read_header(strm, buf, p0, net::as_tuple);
      if (ec == bhttp::error::end_of_stream)
        break;
      else if (ec)
@@ -783,11 +777,11 @@ public:
      auto http_version = p0.get().version();
      auto&& rsp = co_await handle_request(
-          readable_request{
+        readable_request{
-              .p = util::not_null{&p0},
+          .p = util::not_null{&p0},
-              .strm = util::not_null{&strm},
+          .strm = util::not_null{&strm},
-              .buf = util::not_null{&buf},
+          .buf = util::not_null{&buf},
-          });
+        });
      rsp.header().version(http_version);
      bool keep_alive = rsp.keep_alive();
      co_await beast::async_write(strm, std::move(rsp));
@@ -806,27 +800,27 @@ public:
    auto acceptor = tcp::acceptor{executor, endpoint};
    l_.with("endpoint", endpoint.address().to_string())
-        .with("port", std::to_string(endpoint.port()))
+      .with("port", std::to_string(endpoint.port()))
-        .info("Serving");
+      .info("Serving");
    while (true)
    {
      net::co_spawn(
-          executor,
+        executor,
-          do_session(beast::tcp_stream{co_await acceptor.async_accept()}),
+        do_session(beast::tcp_stream{co_await acceptor.async_accept()}),
-          [this](std::exception_ptr e)
+        [this](std::exception_ptr e)
+        {
+          if (e)
          {
-            if (e)
+            try
+            {
+              std::rethrow_exception(e);
+            }
+            catch (std::exception const& e)
            {
-              try
+              l_.error("Error in session: {}", e.what());
-              {
-                std::rethrow_exception(e);
-              }
-              catch (std::exception const& e)
-              {
-                l_.error("Error in session: {}", e.what());
-              }
            }
-          });
+          }
+        });
    }
  }
@@ -837,21 +831,21 @@ public:
    // TODO: make exception handling as nice as in srv.cpp
    net::co_spawn(
-        ioc, do_listen(endpoint),
+      ioc, do_listen(endpoint),
-        [this](std::exception_ptr e)
+      [this](std::exception_ptr e)
+      {
+        if (e)
        {
-          if (e)
+          try
          {
-            try
+            std::rethrow_exception(e);
-            {
-              std::rethrow_exception(e);
-            }
-            catch (std::exception const& e)
-            {
-              l_.error("Error: {}", e.what());
-            }
          }
-        });
+          catch (std::exception const& e)
+          {
+            l_.error("Error: {}", e.what());
+          }
+        }
+      });
  }
 };