How can I extract the complete URL with inner query parameters in a NestJS GET request?

NestJS (and the underlying HTTP libraries like Express or Fastify) relies on standard parsing rules where the query string is split at each &. In your URL, the inner URL (the value for the url parameter) contains its own query string (with ? and &), and the parser treats portions after the first & as separate query parameters. That’s why using @Query('url') only returns the part before the first &.

There are two main approaches to solve this:

---

1. Encode the URL Parameter

Before sending the request, you can use URL encoding (e.g., encodeURIComponent in JavaScript) for the entire URL value. For example, if your inner URL is:

new://way?si=asdas@direction&pn=(null)&mc=7&tr=HD&tp=Pay&am=17&mam=17&cu=INR

You would encode it like so:

JAVASCRIPTCopied
const innerUrl = "new://way?si=asdas@direction&pn=(null)&mc=7&tr=HD&tp=Pay&am=17&mam=17&cu=INR";
const encodedUrl = encodeURIComponent(innerUrl);

// Then, use it in your request:
const fullQuery = `url=${encodedUrl}`;

On the server side in your NestJS controller, you’d then decode the URL:

TYPESCRIPTCopied
@Get('new-url')
getUrl(@Query('url') encodedUrl: string) {
  const fullUrl = decodeURIComponent(encodedUrl);
  return { fullUrl };
}

This is the ideal solution if you control how the URL is constructed on the client side.

---

2. Extract the Raw Query String on the Server

If, for some reason, you can’t change the request format, another option is to access the raw query string from the request object and do custom parsing.

For example, using Express, you can create a custom decorator to extract the original URL and then perform manual extraction of the portion after the parameter url=:

TYPESCRIPTCopied
import { createParamDecorator, ExecutionContext } from '@nestjs/common';

export const RawUrlQuery = createParamDecorator(
  (data: string, ctx: ExecutionContext) => {
    const req = ctx.switchToHttp().getRequest();
    // req.originalUrl will contain the full URL like:
    // "/seni/abc/new-url?url=new://way?si=asdas@direction&pn=(null)&mc=7&tr=HD&tp=Pay&am=17&mam=17&cu=INR"
    // You can then try to extract the "url" parameter value including the subsequent & parameters.
    const originalUrl: string = req.originalUrl;
    const queryString = originalUrl.split('?')[1] || '';
    // Look for "url=" and capture everything after it
    const urlParamIndicator = 'url=';
    const startIndex = queryString.indexOf(urlParamIndicator);
    if (startIndex < 0) return null;
    // Get substring starting from "url=" and split at the first parameter break that doesn't belong to url
    // NOTE: This assumes that the url parameter is always the one that starts and spans the rest of the query.
    return queryString.substring(startIndex + urlParamIndicator.length);
  },
);

Then in your controller:

TYPESCRIPTCopied
@Get('new-url')
getUrl(@RawUrlQuery() fullUrl: string) {
  return { fullUrl };
}

This approach is a bit hacky and assumes the URL is structured in a way that all remaining parameters belong to the url value. It can be error-prone if there are other separate query parameters that should not be part of the URL.

---

Conclusion

The recommended method is to encode the inner URL on the client-side so that the parser correctly identifies it as a single parameter. This avoids ambiguity and leverages standard decoding on the server. If that’s not possible, then you would need a custom decorator or middleware to access and manipulate the raw query string.