Fix custom route request forwarding regressions

Author: 0xeb

include/fastmcpp/app.hpp

@@ -10,6 +10,7 @@
 #include <chrono>
 #include <functional>
 #include <initializer_list>
+#include <map>
 #include <memory>
 #include <optional>
 #include <string>
@@ -33,6 +34,8 @@ struct CustomRouteRequest
     std::string path;
     std::string body;
     std::unordered_map<std::string, std::string> headers;
+    std::string target;
+    std::multimap<std::string, std::string> query_params;
 };
 
 /// HTTP response returned by a custom-route handler.
@@ -49,7 +52,7 @@ struct CustomRouteResponse
 /// fixed forwarding from mounted servers).
 struct CustomRoute
 {
-    std::string method; // GET, POST, etc. (uppercase)
+    std::string method; // GET, POST, PUT, DELETE, PATCH
     std::string path;   // Absolute path, e.g. "/health" — must start with '/'
     std::function<CustomRouteResponse(const CustomRouteRequest&)> handler;
 };

include/fastmcpp/providers/transforms/catalog.hpp

@@ -108,7 +108,9 @@ class CatalogTransform : public Transform
             if (!entry.available_versions.empty())
             {
                 fastmcpp::Json meta =
-                    entry.item.meta().has_value() ? *entry.item.meta() : fastmcpp::Json::object();
+                    entry.item.meta().has_value() && entry.item.meta()->is_object()
+                        ? *entry.item.meta()
+                        : fastmcpp::Json::object();
                 fastmcpp::Json fm = meta.contains("fastmcp") && meta["fastmcp"].is_object()
                                         ? meta["fastmcp"]
                                         : fastmcpp::Json::object();

include/fastmcpp/util/http_methods.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "fastmcpp/exceptions.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cctype>
+#include <string>
+
+namespace fastmcpp::util::http
+{
+
+inline std::string normalize_custom_route_method(std::string method)
+{
+    if (method.empty())
+        throw ValidationError("CustomRoute.method is required");
+
+    std::transform(method.begin(), method.end(), method.begin(),
+                   [](unsigned char ch) { return static_cast<char>(std::toupper(ch)); });
+
+    static constexpr std::array<const char*, 5> kSupportedMethods = {"GET", "POST", "PUT", "DELETE",
+                                                                     "PATCH"};
+    const auto supported = std::find(kSupportedMethods.begin(), kSupportedMethods.end(), method);
+    if (supported != kSupportedMethods.end())
+        return method;
+
+    if (method == "HEAD" || method == "OPTIONS")
+        throw ValidationError("CustomRoute.method '" + method +
+                              "' is reserved and not supported for custom routes");
+
+    throw ValidationError("CustomRoute.method '" + method +
+                          "' is unsupported; expected GET, POST, PUT, DELETE, or PATCH");
+}
+
+} // namespace fastmcpp::util::http

src/app.cpp

@@ -6,6 +6,7 @@
 #include "fastmcpp/mcp/handler.hpp"
 #include "fastmcpp/providers/provider.hpp"
 #include "fastmcpp/resources/template.hpp"
+#include "fastmcpp/util/http_methods.hpp"
 #include "fastmcpp/util/json_schema.hpp"
 #include "fastmcpp/util/schema_build.hpp"
 
@@ -287,11 +288,11 @@ FastMCP& FastMCP::add_custom_route(CustomRoute route)
 {
     if (route.path.empty() || route.path.front() != '/')
         throw ValidationError("CustomRoute.path must start with '/' (got '" + route.path + "')");
-    if (route.method.empty())
-        throw ValidationError("CustomRoute.method is required");
     if (!route.handler)
         throw ValidationError("CustomRoute.handler is required");
 
+    route.method = util::http::normalize_custom_route_method(std::move(route.method));
+
     // Re-registering the same (method, path) replaces the previous entry —
     // matches Python `@server.custom_route()` decorator semantics.
     for (auto& existing : custom_routes_)

src/server/http_server.cpp

@@ -2,6 +2,7 @@
 
 #include "fastmcpp/app.hpp"
 #include "fastmcpp/exceptions.hpp"
+#include "fastmcpp/util/http_methods.hpp"
 #include "fastmcpp/util/json.hpp"
 
 #include <httplib.h>
@@ -11,6 +12,14 @@ namespace fastmcpp::server
 
 void HttpServerWrapper::set_custom_routes(std::vector<fastmcpp::CustomRoute> routes)
 {
+    for (auto& route : routes)
+    {
+        route.method = fastmcpp::util::http::normalize_custom_route_method(std::move(route.method));
+        if (route.path.empty() || route.path.front() != '/')
+            throw ValidationError("CustomRoute.path must start with '/' (got '" + route.path + "')");
+        if (!route.handler)
+            throw ValidationError("CustomRoute.handler is required");
+    }
     custom_routes_ = std::move(routes);
 }
 
@@ -107,9 +116,11 @@ bool HttpServerWrapper::start()
 
             apply_additional_response_headers(res);
             fastmcpp::CustomRouteRequest cr;
-            cr.method = route.method;
+            cr.method = req.method;
             cr.path = req.path;
             cr.body = req.body;
+            cr.target = req.target;
+            cr.query_params = req.params;
             for (const auto& [k, v] : req.headers)
                 cr.headers[k] = v;
             try

tests/app/custom_route_forwarding.cpp

@@ -65,9 +65,10 @@ static int test_register_replaces_duplicate()
 {
     std::cout << "  test_register_replaces_duplicate..." << std::endl;
     FastMCP app("a", "1.0.0");
-    app.add_custom_route(make_route("GET", "/x", "first"));
+    app.add_custom_route(make_route("get", "/x", "first"));
     app.add_custom_route(make_route("GET", "/x", "second"));
     ASSERT_EQ(app.custom_routes().size(), 1u, "still one route");
+    ASSERT_EQ(app.custom_routes().front().method, std::string("GET"), "method normalized to uppercase");
     auto resp = app.custom_routes().front().handler({"GET", "/x", "", {}});
     ASSERT_EQ(resp.body, std::string("second"), "second handler wins");
     std::cout << "    PASS" << std::endl;
@@ -89,6 +90,28 @@ static int test_validation_rejects_bad_inputs()
     }
     ASSERT_TRUE(threw, "missing leading slash rejected");
 
+    threw = false;
+    try
+    {
+        app.add_custom_route(make_route("", "/x", "x"));
+    }
+    catch (const fastmcpp::ValidationError&)
+    {
+        threw = true;
+    }
+    ASSERT_TRUE(threw, "missing method rejected");
+
+    threw = false;
+    try
+    {
+        app.add_custom_route(make_route("HEAD", "/x", "x"));
+    }
+    catch (const fastmcpp::ValidationError&)
+    {
+        threw = true;
+    }
+    ASSERT_TRUE(threw, "unsupported method rejected");
+
     threw = false;
     CustomRoute no_handler;
     no_handler.method = "GET";
@@ -106,6 +129,28 @@ static int test_validation_rejects_bad_inputs()
     return 0;
 }
 
+static int test_http_wrapper_rejects_unsupported_custom_route_method()
+{
+    std::cout << "  test_http_wrapper_rejects_unsupported_custom_route_method..." << std::endl;
+
+    auto core = std::make_shared<server::Server>();
+    server::HttpServerWrapper http(core, "127.0.0.1", 0);
+
+    bool threw = false;
+    try
+    {
+        http.set_custom_routes({make_route("HEAD", "/health", "ok")});
+    }
+    catch (const fastmcpp::ValidationError&)
+    {
+        threw = true;
+    }
+
+    ASSERT_TRUE(threw, "direct wrapper route registration rejects unsupported methods");
+    std::cout << "    PASS" << std::endl;
+    return 0;
+}
+
 static int test_aggregate_from_mounted_child()
 {
     std::cout << "  test_aggregate_from_mounted_child..." << std::endl;
@@ -198,6 +243,93 @@ static int test_http_end_to_end_serves_route()
     return 0;
 }
 
+static int test_http_custom_route_preserves_query_params()
+{
+    std::cout << "  test_http_custom_route_preserves_query_params..." << std::endl;
+
+    CustomRouteRequest captured;
+    bool called = false;
+
+    FastMCP child("child", "1.0.0");
+    CustomRoute query_route;
+    query_route.method = "GET";
+    query_route.path = "/search";
+    query_route.handler = [&](const CustomRouteRequest& req)
+    {
+        called = true;
+        captured = req;
+
+        CustomRouteResponse resp;
+        resp.body = "query ok";
+        resp.content_type = "text/plain";
+        return resp;
+    };
+    child.add_custom_route(std::move(query_route));
+
+    FastMCP parent("parent", "1.0.0");
+    parent.mount(child, "kids");
+
+    auto core = std::make_shared<server::Server>(parent.server());
+
+    int port = 0;
+    std::unique_ptr<server::HttpServerWrapper> http;
+    for (int candidate = 18481; candidate <= 18500; ++candidate)
+    {
+        auto trial = std::make_unique<server::HttpServerWrapper>(core, "127.0.0.1", candidate);
+        trial->set_custom_routes(parent.all_custom_routes());
+        if (trial->start())
+        {
+            port = trial->port();
+            http = std::move(trial);
+            break;
+        }
+    }
+    ASSERT_TRUE(http && port > 0, "HTTP server started");
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(150));
+
+    httplib::Client client("127.0.0.1", port);
+    client.set_connection_timeout(std::chrono::seconds(2));
+    client.set_read_timeout(std::chrono::seconds(2));
+
+    auto resp = client.Get("/kids/search?q=a&q=b&lang=en");
+    ASSERT_TRUE(resp != nullptr, "GET with query params returned a response");
+    ASSERT_EQ(resp->status, 200, "query route served");
+    ASSERT_EQ(resp->body, std::string("query ok"), "query route body");
+
+    ASSERT_TRUE(called, "handler was invoked");
+    ASSERT_EQ(captured.method, std::string("GET"), "request method preserved");
+    ASSERT_EQ(captured.path, std::string("/kids/search"), "path preserved without query string");
+    ASSERT_EQ(captured.target, std::string("/kids/search?q=a&q=b&lang=en"),
+              "raw target preserves query string");
+    ASSERT_EQ(captured.query_params.count("q"), 2u, "repeated query param preserved");
+    ASSERT_EQ(captured.query_params.count("lang"), 1u, "single query param preserved");
+
+    auto q_range = captured.query_params.equal_range("q");
+    bool seen_q_a = false;
+    bool seen_q_b = false;
+    size_t q_values = 0;
+    for (auto it = q_range.first; it != q_range.second; ++it)
+    {
+        ++q_values;
+        if (it->second == "a")
+            seen_q_a = true;
+        if (it->second == "b")
+            seen_q_b = true;
+    }
+    ASSERT_EQ(q_values, 2u, "two q values captured");
+    ASSERT_TRUE(seen_q_a, "q=a preserved");
+    ASSERT_TRUE(seen_q_b, "q=b preserved");
+
+    auto lang_it = captured.query_params.find("lang");
+    ASSERT_TRUE(lang_it != captured.query_params.end(), "lang key present");
+    ASSERT_EQ(lang_it->second, std::string("en"), "lang value preserved");
+
+    http->stop();
+    std::cout << "    PASS" << std::endl;
+    return 0;
+}
+
 static int test_http_custom_route_requires_auth()
 {
     std::cout << "  test_http_custom_route_requires_auth..." << std::endl;
@@ -296,9 +428,11 @@ int main()
     failures += test_register_basic();
     failures += test_register_replaces_duplicate();
     failures += test_validation_rejects_bad_inputs();
+    failures += test_http_wrapper_rejects_unsupported_custom_route_method();
     failures += test_aggregate_from_mounted_child();
     failures += test_aggregate_dedups_collisions();
     failures += test_http_end_to_end_serves_route();
+    failures += test_http_custom_route_preserves_query_params();
     failures += test_http_custom_route_requires_auth();
     failures += test_http_custom_route_options_advertises_methods();
     std::cout << std::endl;