Accessing req parameters for` Node.js` route before request is sent

In a Node.js server routes get request data as follows:

router.get("/dog", (req, res) => {
   // req.something...
});

For debugging purposes, I want to inspect what gets sent as the req object for a call like the following:

fetch("/app/dog").then(/*...*/)

Is there a way for me to access the req parameters before the request is sent? (Presumably I could do such debugging in my route, but I'm wanting to perform this inspection before making the fetch call). Thanks!

If you use fetch, you might want to add functionality (methods) to the native window.fetch function which is not a good idea IMHO.
The simplest is to use (on the frontend) a library that already provides request interceptors like Axios.

Here's an example in which we send name=doggo as a request param,
we than modify the string to "doggo intercepted" still on the frontend,
we than modify that string on the backend using Express Middleware to "doggo intercepted and middlewared" and finally log the final string in the designated route handler:

_index.html

<script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>

<script>
// Add a request interceptor
// https://axios-http.com/docs/interceptors
axios.interceptors.request.use((config) => {
  // Do something before request is sent:
  // Modify param name
  config.params.name += " intercepted"; // << modify the "doggo" string
  console.log(config);
  return config;
}, (err) => Promise.reject(err));


// Init GET request:
axios.get("/app/dog", {
  params: {
    name: "doggo"
  }
});
</script>

_{index.js (Node)}

import express from "express";
import path from "path"
import url from "url";
const __dirname = url.fileURLToPath(new URL(".", import.meta.url));

const app = express();
const port = 3000;

// Create a middleware:
// https://expressjs.com/en/guide/using-middleware.html
app.use('/app/:animal', (req, res, next) => {
  // If route "dog", do something
  if (req.params.animal === "dog") {
    req.query.name += " and middlewared"; // << modify the "doggo intercepted"
  }
  // Pass through
  next();
})

app.get("/", (req, res) => {
  res.sendFile(path.join(__dirname, "/index.html"));
});

app.get("/app/dog", (req, res) => {
  console.log(req.query); // { name: 'doggo intercepted and middlewared' }
});

app.listen(port, () => {
  console.log(`Example app listening on port ${port}`)
});

The short version is 'no'. The req parameter gets created after the request is sent by the client, and after it's headers are received by the server.