#include "core/SNodeC.h"
#include "express/legacy/in/WebApp.h"
#include "log/Logger.h"
#include <nlohmann/json.hpp>
#include <string>

Include dependency graph for express_compat_server.cpp:

Classes
class	Router

Typedefs
using	Trace = std::vector<json>

Functions
static json	snapshot (const std::shared_ptr< express::Request > &req, const std::string &label)
static void	ensureTrace (const std::shared_ptr< express::Request > &req)
static void	tracePush (const std::shared_ptr< express::Request > &req, const std::string &label)
static json	traceGet (const std::shared_ptr< express::Request > &req)
int	main (int argc, char *argv[])

Typedef Documentation

◆ Trace

typedef std::vector< json > Trace = std::vector<json>

Definition at line 19 of file express_compat_server.cpp.

Function Documentation

◆ ensureTrace()

void ensureTrace ( const std::shared_ptr< express::Request > & req )

static

Definition at line 49 of file express_compat_server.cpp.

                                                                  {
    // Create the trace attribute if it doesn't exist yet.
    req->setAttribute<Trace>(Trace{}, "trace");
}

References utils::MultibleAttributeInjector::setAttribute().

Referenced by tracePush().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 75 of file express_compat_server.cpp.

                                 {
    core::SNodeC::init(argc, argv);
 
    const express::legacy::in::WebApp app("express-compat");
 
    // Meta
    app.get("/__meta", [] APPLICATION(req, res) {
        res->json({{"ok", true}, {"server", "snodec"}, {"express", true}});
    });
 
    // Basic
    app.get("/health", [] APPLICATION(req, res) {
        res->json({{"ok", true}, {"label", "health"}});
    });
 
    // Case-insensitive routing demo
    app.get("/Case/Path", [] APPLICATION(req, res) {
        res->json(snapshot(req, "case"));
    });
 
    // Trailing slash demo (strictRouting off => matches both)
    app.get("/trail/", [] APPLICATION(req, res) {
        res->json(snapshot(req, "trail"));
    });
 
    // Wildcards
    app.get("/file/*", [] APPLICATION(req, res) {
        res->json(snapshot(req, "file"));
    });
    app.get("/a/*/b/*", [] APPLICATION(req, res) {
        res->json(snapshot(req, "multi_wild"));
    });
 
    // Param decoding
    app.get("/p/:x", [] APPLICATION(req, res) {
        res->json(snapshot(req, "param"));
    });
 
    // Query decoding/casing
    app.get("/query/echo", [] APPLICATION(req, res) {
        res->json(snapshot(req, "query_echo"));
    });
 
    // HEAD -> GET fallback (handled by dispatcher/response code)
    app.get("/head-demo", [] APPLICATION(req, res) {
        res->set("X-Demo", "1");
        res->send("head body");
    });
 
    // next('route') demo
    app.get(
        "/nr/:id(\\d+)",
        [] MIDDLEWARE(req, res, next) {
            if (req->params["id"] == "0") {
                next("route");
                return;
            }
            next();
        },
        [] APPLICATION(req, res) {
            res->json(snapshot(req, "nr_primary"));
        });
    app.get("/nr/:id(\\d+)", [] APPLICATION(req, res) {
        res->json(snapshot(req, "nr_fallback"));
    });
 
    // next('router') demo
    const Router guarded;
    guarded.use([] MIDDLEWARE(req, res, next) {
        if (req->queries["allow"] != "true") {
            next("router");
            return;
        }
        next();
    });
    guarded.get("/stats", [] APPLICATION(req, res) {
        res->json(snapshot(req, "guarded_stats"));
    });
    app.use("/guarded", guarded);
 
    // Fallback when router skipped
    app.get("/guarded/:rest(.*)", [] APPLICATION(req, res) {
        res->status(403).json({{"label", "guarded_fallback"}, {"status", 403}});
    });
 
    // Root-mounted router (baseUrl should be empty string)
    const Router root;
    root.get("/root/test", [] APPLICATION(req, res) {
        res->json(snapshot(req, "root_mount"));
    });
    app.use("/", root);
 
    // Nested routers trace: req.url / baseUrl stripping
    const Router api;
    api.use([] MIDDLEWARE(req, res, next) {
        tracePush(req, "api.use");
        next();
    });
 
    const Router v1;
    v1.use([] MIDDLEWARE(req, res, next) {
        tracePush(req, "v1.use");
        next();
    });
    v1.get("/users/:id", [] APPLICATION(req, res) {
        tracePush(req, "handler");
        res->json({{"label", "nested_trace"}, {"trace", traceGet(req)}});
    });
 
    api.use("/v1", v1);
    app.use("/api", api);
 
    // mergeParams demo (requires your mergeParams patch-set)
    const Router mpMerge;
    mpMerge.setMergeParams(true);
    mpMerge.get("/users/:id", [] APPLICATION(req, res) {
        res->json(snapshot(req, "mp_merge"));
    });
    app.use("/mp/merge/t/:tenant", mpMerge);
 
    const Router mpNoMerge;
    mpNoMerge.get("/users/:id", [] APPLICATION(req, res) {
        res->json(snapshot(req, "mp_nomerge"));
    });
    app.use("/mp/nomerge/t/:tenant", mpNoMerge);
 
    // Params scoping trace: merge vs no-merge
    auto makeScope = [](bool merge) {
        const Router parent;
        parent.setMergeParams();
        parent.use([merge](auto const& req, auto const&, auto& next) {
            tracePush(req, merge ? "scopeMerge.parent" : "scopeNoMerge.parent");
            next();
        });
 
        const Router child;
        child.setMergeParams(merge);
        child.use([merge](auto const& req, auto const&, auto& next) {
            tracePush(req, merge ? "scopeMerge.child" : "scopeNoMerge.child");
            next();
        });
        child.get("/end", [merge](auto const& req, auto const& res) {
            tracePush(req, merge ? "scopeMerge.handler" : "scopeNoMerge.handler");
            res->json({{"label", merge ? "scope_merge" : "scope_nomerge"}, {"trace", traceGet(req)}});
        });
 
        parent.use("/b/:b", child);
        return parent;
    };
 
    app.use("/scope/nomerge/:a", makeScope(false));
    app.use("/scope/merge/:a", makeScope(true));
 
    // Param decoding (valid)
    app.get("/decode/:p", [] APPLICATION(req, res) {
        res->json(snapshot(req, "decode_ok"));
    });
 
    // 404 (GET only, enough for this suite)
    app.get("/:rest(.*)", [] APPLICATION(req, res) {
        res->status(404).json({{"label", "not_found"}, {"path", req->path}});
    });
 
    app.listen(8080, [](const express::legacy::in::WebApp::SocketAddress& socketAddress, const core::socket::State& state) {
        switch (state) {
            case core::socket::State::OK:
                VLOG(1) << "express-compat listening on '" << socketAddress.toString() << "'";
                break;
            case core::socket::State::DISABLED:
                VLOG(1) << "express-compat disabled";
                break;
            case core::socket::State::ERROR:
                LOG(ERROR) << "express-compat " << socketAddress.toString() << ": " << state.what();
                break;
            case core::socket::State::FATAL:
                LOG(FATAL) << "express-compat " << socketAddress.toString() << ": " << state.what();
                break;
        }
    });
 
    return core::SNodeC::start();
}

References core::socket::State::DISABLED, core::socket::State::ERROR, core::socket::State::FATAL, express::Router::get(), core::SNodeC::init(), express::Response::json(), net::in::stream::SocketServer< SocketAcceptorT, ConfigSocketServerT, SocketContextFactoryT, Args >::listen(), core::socket::State::OK, express::Next::operator()(), express::Request::params, express::Request::path, express::Response::send(), express::Response::set(), express::Router::setMergeParams(), snapshot(), core::SNodeC::start(), express::Response::status(), net::in::SocketAddress::toString(), traceGet(), tracePush(), express::WebAppT< ServerT >::WebAppT(), and core::socket::State::what().

Here is the call graph for this function:

◆ snapshot()

json snapshot	(	const std::shared_ptr< express::Request > &	req,
		const std::string &	label )

static

Definition at line 21 of file express_compat_server.cpp.

                                                                                       {
    json out = json::object();
    out["label"] = label;
    out["method"] = req->method;
    out["url"] = req->url;
    out["originalUrl"] = req->originalUrl;
    out["baseUrl"] = req->baseUrl;
    out["path"] = req->path;
 
    json params = json::object();
    for (const auto& [k, v] : req->params) {
        params[k] = v;
    }
    out["params"] = params;
 
    json query = json::object();
    for (const auto& [k, v] : req->queries) {
        query[k] = v;
    }
    out["query"] = query;
 
    json headers = json::object();
    headers["x-test"] = req->get("X-Test");
    out["headers"] = headers;
 
    return out;
}

References express::Request::baseUrl, express::Request::get(), express::Request::method, express::Request::originalUrl, express::Request::params, express::Request::path, express::Request::queries, and express::Request::url.

Referenced by main(), and tracePush().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ traceGet()

json traceGet ( const std::shared_ptr< express::Request > & req )

static

Definition at line 63 of file express_compat_server.cpp.

                                                               {
    json arr = json::array();
    req->getAttribute<Trace>(
        [&](Trace& t) {
            for (auto const& e : t) {
                arr.push_back(e);
            }
        },
        "trace");
    return arr;
}

References utils::MultibleAttributeInjector::getAttribute().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tracePush()

void tracePush	(	const std::shared_ptr< express::Request > &	req,
		const std::string &	label )

static

Definition at line 54 of file express_compat_server.cpp.

                                                                                        {
    ensureTrace(req);
    req->getAttribute<Trace>(
        [&](Trace& t) {
            t.emplace_back(snapshot(req, label));
        },
        "trace");
}

References ensureTrace(), utils::MultibleAttributeInjector::getAttribute(), and snapshot().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

SNode.C

Classes

Typedefs

Functions

Typedef Documentation

◆ Trace

Function Documentation

◆ ensureTrace()

◆ main()

◆ snapshot()

◆ traceGet()

◆ tracePush()