Get full route path

[marcellino-ornelas]

Hello quick question, is it possible to get the full route path?

example app:

const app = express();

const router = express.Router();

router.get('/my/path');

app.use("/api", router);

Now when someone calls /api/my/path, is there a way to get this full route path from req?

currently im using req.route.path but since this is a child router, it only returning '/my/path and not /api/my/path.

Edited: req.originalUrl doesn't work for me because it doesn't return the parametrized version when urls takes params see comment

Maybe related topic?: #5961

[krzysdz]

Have you tried req.originalUrl?

const express = require("express");
const app = express();
const router = express.Router();

router.get('/my/path', (req,res) => {
    console.log(req.originalUrl); // '/api/my/path'
    console.log(req.url);         // '/my/path'
    console.log(req.baseUrl);     // '/api'
    console.log(req.path);        // '/my/path'
    res.send("ok");
});

app.use("/api", router);

const server = app.listen(8080, async () => {
    await fetch("http://127.0.0.1:8080/api/my/path");
    server.close();
});

[marcellino-ornelas]

That does give me the whole path but issue with that is that it doesn't give me the parametrized route version and only the original API that was called. I definitely should of made that more clear sorry 😄

Sooo I don't want this:

/api/data/1234543/action

but want this instead:

/api/data/:id/action

My purpose for this is to group APIs together in metrics when there are parameters

[krzysdz]

I don't think there is a good way to do it now. @bjohansebas is working on a PR that might help (pillarjs/router#174), but it is intended to return all paths of a router, so I'm not sure if it will be exactly what you want.

If you don't mind some repetitions (and chance to make mistakes), you can add middleware functions that save (and restore) current prefix (that has to be specified manually...):

const express = require("express");
const app = express();

function trim(str, ch) {
    let start = 0;
    let end = str.length;
    while (start < str.length && str[start] === ch) ++start;
    while (end > start && str[end - 1] === ch) --end;
    return str.substring(start, end);
}

// This function must be called with a path and returns a middleware function
// DON'T USE DIRECTLY AS MIDDLEWARE
function pathPrefixSaver(path) {
    return (req, res, next) => {
        req.pathSoFar = req.pathSoFar || [];
        // Trim "/" for better path segment combining
        req.pathSoFar.push(trim(path, "/"));
        next();
    }
}

// On the other hand this is just normal middleware, called when there was no handler for the given route
// in a router that was called anyway due to a shared prefix.
// If you design your code reasonably it might not be necessary.
function pathPrefixPopper(req, res, next) {
    if (Array.isArray(req.pathSoFar))
        req.pathSoFar.pop();
    next();
}

// Just join everything nicely. I'm not 100% sure if the `path` property of Route is a public API.
function recoverFullPath(req) {
    return "/" + [...(req.pathSoFar || []), trim(req.route.path, "/")].join("/");
}

const somethingRouter = express.Router();
somethingRouter.get('/my/:pathParam', (req, res) => {
    console.log(recoverFullPath(req)); // '/api/:something/my/:pathParam'
    res.send("ok");
});

// This one is here just to mount it under a shared prefix, to show why pathPrefixPopper may be necessary.
const otherRouter = express.Router();
otherRouter.get('/asdf', (req, res) => {
    console.log(recoverFullPath(req));
    res.send("ok");
});

app.use("/api", pathPrefixSaver("/api"), otherRouter, pathPrefixPopper);
app.use("/api/:something", pathPrefixSaver("/api/:something"), somethingRouter, pathPrefixPopper);

const server = app.listen(8080, async () => {
    await fetch("http://127.0.0.1:8080/api/param1/my/param2");
    server.close();
});

As noted in the code, I'm not sure if req.route.path is public API, since it is not documented in Express docs nor router README.