@nestia/core 14.0.0 → 14.0.1

package/src/adaptors/internal/RoutePathMatcher.ts

@@ -0,0 +1,91 @@
+import { Token, match, parse } from "path-to-regexp";
+
+/**
+ * A WebSocket route's path, matched as NestJS 11's Express router matches an
+ * HTTP route: path-to-regexp 8's syntax, where `\:` is a literal colon, `*name`
+ * a wildcard, and `{...}` an optional group; find-my-way's (Fastify) literal
+ * colon `::` is read too, as `@nestia/sdk` reads it when it builds the SDK's
+ * URL.
+ *
+ * @internal
+ */
+export class RoutePathMatcher {
+  /** The names of the path's parameters and wildcards, in order. */
+  public readonly params: string[];
+
+  private readonly match_: (
+    path: string,
+  ) => false | { params: Partial<Record<string, string | string[]>> };
+
+  public constructor(private readonly path: string) {
+    const route: string = fromFastifyColons(path);
+    this.params = names(parse(route).tokens);
+    this.match_ = match(route, {
+      decode: (value: string) => {
+        try {
+          return decodeURIComponent(value);
+        } catch {
+          return value;
+        }
+      },
+    });
+  }
+
+  /**
+   * The parameters of a matching request path, or `null`. A wildcard's segments
+   * are joined by `/`, and an optional parameter absent is left out.
+   */
+  public test(path: string): Record<string, string> | null {
+    const matched = this.match_(path);
+    if (matched === false) return null;
+    const output: Record<string, string> = {};
+    for (const [key, value] of Object.entries(matched.params))
+      if (value !== undefined)
+        output[key] = Array.isArray(value) ? value.join("/") : value;
+    return output;
+  }
+
+  public toString(): string {
+    return this.path;
+  }
+}
+
+const names = (tokens: Token[]): string[] =>
+  tokens.flatMap((token) =>
+    token.type === "param" || token.type === "wildcard"
+      ? [token.name]
+      : token.type === "group"
+        ? names(token.tokens)
+        : [],
+  );
+
+/**
+ * A route with find-my-way's (Fastify) literal colon `::` spelled as
+ * path-to-regexp's `\:`. find-my-way reads `::` as a colon in static text
+ * alone: after a parameter it is part of the parameter's name, so it is left as
+ * is there, and path-to-regexp then rejects the route, as no parameter of that
+ * name is what the handler reads.
+ *
+ * @internal
+ */
+const fromFastifyColons = (route: string): string => {
+  let output: string = "";
+  for (let i: number = 0; i < route.length; ) {
+    if (route[i] === "\\") {
+      output += route.slice(i, i + 2);
+      i += 2;
+    } else if (route.startsWith("::", i)) {
+      output += "\\:";
+      i += 2;
+    } else if (route[i] === ":") {
+      const name: string = /^:[A-Za-z0-9_$]*/.exec(route.slice(i))![0];
+      output += name;
+      i += name.length;
+      if (route.startsWith("::", i)) {
+        output += "::";
+        i += 2;
+      }
+    } else output += route[i++];
+  }
+  return output;
+};

package/src/adaptors/internal/external_context.ts

@@ -0,0 +1,50 @@
+import { ContextId, ContextIdFactory, NestContainer } from "@nestjs/core";
+import { ExternalContextCreator } from "@nestjs/core/helpers/external-context-creator";
+import { REQUEST_CONTEXT_ID } from "@nestjs/core/router/request/request-constants";
+
+/**
+ * The creator of NestJS's enhancer pipeline (guards, interceptors, pipes, and
+ * exception filters) for the controllers of one module.
+ *
+ * `ExternalContextCreator` looks the module up among those providing the class,
+ * and a controller is provided by none, so its enhancers would not resolve: the
+ * module is named here instead.
+ *
+ * @internal
+ */
+export const create_external_context_creator = (
+  container: NestContainer,
+  moduleKey: string,
+): ExternalContextCreator => {
+  const creator: ExternalContextCreator =
+    ExternalContextCreator.fromContainer(container);
+  creator.getContextModuleKey = () => moduleKey;
+  return creator;
+};
+
+/**
+ * The context a request-scoped provider is built in for this request, the one
+ * NestJS's router attaches to it, registering the request as `REQUEST`.
+ *
+ * @internal
+ */
+export const get_request_context_id = (
+  container: NestContainer,
+  request: any,
+  durable: boolean,
+): ContextId => {
+  const contextId: ContextId = ContextIdFactory.getByRequest(request);
+  if (!request[REQUEST_CONTEXT_ID]) {
+    Object.defineProperty(request, REQUEST_CONTEXT_ID, {
+      value: contextId,
+      enumerable: false,
+      writable: false,
+      configurable: false,
+    });
+    container.registerRequestProvider(
+      durable ? contextId.payload : Object.assign(request, contextId.payload),
+      contextId,
+    );
+  }
+  return contextId;
+};

package/src/decorators/EncryptedBody.ts

@@ -10,7 +10,7 @@ import type { FastifyRequest } from "fastify";
 
 import { IRequestBodyValidator } from "../options/IRequestBodyValidator";
 import { Singleton } from "../utils/Singleton";
-import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
+import { get_encryption_password } from "./internal/get_encryption_password";
 import { get_text_body } from "./internal/get_text_body";
 import { headers_to_object } from "./internal/headers_to_object";
 import { is_media_type } from "./internal/is_media_type";
@@ -52,7 +52,7 @@ export function EncryptedBody<T>(
       throw new BadRequestException(`Request body type is not "text/plain".`);
 
     const param: IEncryptionPassword | IEncryptionPassword.Closure | undefined =
-      Reflect.getMetadata(ENCRYPTION_METADATA_KEY, context.getClass());
+      get_encryption_password(context.getClass());
     if (!param)
       throw new Error(
         "Error on nestia.core.EncryptedBody(): no encryption password is given.",

package/src/decorators/EncryptedController.ts

@@ -1,7 +1,7 @@
 import { IEncryptionPassword } from "@nestia/fetcher";
 import { Controller } from "@nestjs/common";
 
-import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
+import { ENCRYPTION_CONTROLLER_METADATA_KEY } from "./internal/EncryptedConstant";
 
 /**
  * Encrypted controller.
@@ -34,7 +34,11 @@ export function EncryptedController(
   password: IEncryptionPassword | IEncryptionPassword.Closure,
 ): ClassDecorator {
   return function (target: any) {
-    Reflect.defineMetadata(ENCRYPTION_METADATA_KEY, password, target);
+    Reflect.defineMetadata(
+      ENCRYPTION_CONTROLLER_METADATA_KEY,
+      password,
+      target,
+    );
     Controller(path)(target);
   };
 }

package/src/decorators/EncryptedModule.ts

@@ -16,9 +16,13 @@ import { load_controllers } from "./internal/load_controller";
  *
  * By using this `EncryptedModule` decorator function, all of the
  * {@link Controller controllers} configured in the _metadata_ would be
- * automatically changed to the {@link EncryptedController} with the _password_.
- * If there're some original {@link EncryptedController} decorated classes in the
- * _metadata_, their encryption password would be kept.
+ * automatically changed to the {@link EncryptedController} with the _password_,
+ * and so would the controllers of every module it imports: module classes,
+ * dynamic modules (`{ module, imports, controllers }`), `forwardRef()`s, and
+ * promises of them, however deep and even when cyclic. If there're some
+ * original {@link EncryptedController} decorated classes in the _metadata_,
+ * their encryption password would be kept, as would a subclass's that inherits
+ * one.
  *
  * Therefore, if you're planning to place original {@link EncryptedController}
  * decorated classes in the _metadata_, I hope them to have different encryption
@@ -81,18 +85,70 @@ export namespace EncryptedModule {
   }
 }
 
-/** @internal */
-const iterate =
-  (password: IEncryptionPassword.Closure) =>
-  (modulo: any): void => {
-    const imports = Reflect.getMetadata("imports", modulo);
-    if (Array.isArray(imports))
-      for (const imp of imports)
-        if (typeof imp === "function") iterate(password)(imp);
-
-    const controllers = Reflect.getMetadata("controllers", modulo);
-    if (Array.isArray(controllers))
-      for (const c of controllers)
+/**
+ * Gives every controller the module reaches the module's password: those of the
+ * module itself and of each import, whether a module class, a dynamic module
+ * (its `module`, and its own `imports` and `controllers`), a `forwardRef()`, or
+ * a promise of one. Each module is visited once, so a cyclic import graph
+ * terminates.
+ *
+ * @internal
+ */
+const iterate = (password: IEncryptionPassword.Closure) => {
+  const visited: Set<object> = new Set();
+  const controllers = (list: unknown): void => {
+    if (Array.isArray(list))
+      for (const c of list)
         if (typeof c === "function")
           Reflect.defineMetadata(ENCRYPTION_METADATA_KEY, password, c);
   };
+  const imports = (list: unknown): void => {
+    if (Array.isArray(list)) for (const imp of list) visit(imp);
+  };
+  const visit = (input: unknown): void => {
+    if (
+      typeof input !== "function" &&
+      (typeof input !== "object" || input === null)
+    )
+      return;
+    if (visited.has(input)) return;
+    visited.add(input);
+
+    if (typeof input === "function") {
+      imports(Reflect.getMetadata("imports", input));
+      controllers(Reflect.getMetadata("controllers", input));
+    } else if (typeof (input as PromiseLike<unknown>).then === "function")
+      // an asynchronous dynamic module; NestJS awaits the same promise while
+      // scanning, after this callback, registered first, has run
+      (input as PromiseLike<unknown>).then(visit, () => {});
+    else if (typeof (input as IForwardReference).forwardRef === "function") {
+      // the class a forward reference names may not be defined yet while the
+      // decorators run; it is once the synchronous module graph has loaded
+      const resolve = (): unknown => {
+        try {
+          return (input as IForwardReference).forwardRef();
+        } catch {
+          return undefined;
+        }
+      };
+      const target: unknown = resolve();
+      if (target !== undefined) visit(target);
+      else void Promise.resolve().then(() => visit(resolve()));
+    } else {
+      const dynamic = input as {
+        module?: unknown;
+        imports?: unknown;
+        controllers?: unknown;
+      };
+      visit(dynamic.module);
+      imports(dynamic.imports);
+      controllers(dynamic.controllers);
+    }
+  };
+  return visit;
+};
+
+/** @internal */
+interface IForwardReference {
+  forwardRef: () => unknown;
+}

package/src/decorators/EncryptedRoute.ts

@@ -20,7 +20,7 @@ import typia from "typia";
 import { IResponseBodyStringifier } from "../options/IResponseBodyStringifier";
 import { Singleton } from "../utils/Singleton";
 import { TypedRoute } from "./TypedRoute";
-import { ENCRYPTION_METADATA_KEY } from "./internal/EncryptedConstant";
+import { get_encryption_password } from "./internal/get_encryption_password";
 import { get_path_and_stringify } from "./internal/get_path_and_stringify";
 import { headers_to_object } from "./internal/headers_to_object";
 import { route_error } from "./internal/route_error";
@@ -168,10 +168,7 @@ class EncryptedRouteInterceptor implements NestInterceptor {
         const param:
           | IEncryptionPassword
           | IEncryptionPassword.Closure
-          | undefined = Reflect.getMetadata(
-          ENCRYPTION_METADATA_KEY,
-          context.getClass(),
-        );
+          | undefined = get_encryption_password(context.getClass());
         if (!param)
           throw new Error(
             `Error on EncryptedRoute.${this.method}(): no password found.`,
@@ -196,6 +193,11 @@ class EncryptedRouteInterceptor implements NestInterceptor {
             : param;
 
         if (body === undefined) return body;
+        // the ciphertext is text/plain, as the document declares; set on the
+        // success path alone, so an error keeps its JSON body's type (Express
+        // would otherwise send a string as text/html)
+        const response: express.Response = http.getResponse();
+        response.header("Content-Type", "text/plain");
         return AesPkcs5.encrypt(body, password.key, password.iv);
       }),
       catchError((err) => route_error(http.getRequest(), err)),

package/src/decorators/TypedBody.ts

@@ -23,7 +23,7 @@ import { validate_request_body } from "./internal/validate_request_body";
  * `T`, `BadRequestException` error (status code: 400) would be thrown.
  *
  * @author Jeongho Nam - https://github.com/samchon
- * @param validator Custom validator if required. Default is `typia.assert()`
+ * @param validator Custom validator if required. Default is `typia.validate()`
  */
 export function TypedBody<T>(
   validator?: IRequestBodyValidator<T>,

package/src/decorators/TypedFormData.ts

@@ -1,10 +1,13 @@
 import {
   BadRequestException,
   ExecutionContext,
+  HttpException,
+  PayloadTooLargeException,
   createParamDecorator,
 } from "@nestjs/common";
 import type { HttpArgumentsHost } from "@nestjs/common/interfaces";
 import type express from "express";
+import fs from "fs";
 import type ExpressMulter from "multer";
 
 import type { IRequestFormDataProps } from "../options/IRequestFormDataProps";
@@ -35,10 +38,13 @@ import { validate_request_form_data } from "./internal/validate_request_form_dat
  *    types are allowed
  * 4. By the way, union type never be not allowed
  *
- * By the way, if you're using `fastify`, you have to setup `fastify-multer` and
- * configure like below when composing the NestJS application. If you don't do
- * that, `@TypedFormData.Body()` will not work properly, and throw 500 internal
- * server error when `Blob` or `File` type being utilized.
+ * By the way, if you're using `fastify`, pass a `fastify-multer` instance as
+ * the factory, and register a `multipart/form-data` content type parser that
+ * leaves the request stream to it when composing the NestJS application.
+ * Without the parser, Fastify rejects every multipart request with 415.
+ * `fastify-multer`'s own `contentParser` plugin declares the content type
+ * `multipart` without a subtype, which Fastify 5 (NestJS 11) refuses to
+ * register.
  *
  * ```typescript
  * import { NestFactory } from "@nestjs/core";
@@ -46,16 +52,25 @@ import { validate_request_form_data } from "./internal/validate_request_form_dat
  *   FastifyAdapter,
  *   NestFastifyApplication,
  * } from "@nestjs/platform-fastify";
- * import fastifyMulter from "fastify-multer";
  *
  * export async function main() {
  *   const app = await NestFactory.create<NestFastifyApplication>(
  *     AppModule,
  *     new FastifyAdapter(),
  *   );
- *   app.register(fastifyMulter.contentParser);
+ *   app
+ *     .getHttpAdapter()
+ *     .getInstance()
+ *     .addContentTypeParser("multipart/form-data", (_req, _payload, done) =>
+ *       done(null),
+ *     );
  *   await app.listen(3000);
  * }
+ *
+ * // in the controller, with `import FastifyMulter from "fastify-multer"`
+ * public async upload(
+ *   @TypedFormData.Body(() => FastifyMulter()) body: IMultipart,
+ * ): Promise<void> {}
  * ```
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -69,9 +84,11 @@ export namespace TypedFormData {
    *
    * Much easier and type safer than `@nest.UploadFile()` decorator.
    *
-   * @param factory Factory function ncreating the `multer` or `fastify-multer`
+   * @param factory Factory function creating the `multer` or `fastify-multer`
    *   instance. In the factory function, you also can specify the multer
-   *   composition options like `storage` engine.
+   *   composition options like `storage` engine: memory and disk storage
+   *   deliver the uploaded bytes, and an engine keeping neither the buffer nor
+   *   a file path is rejected.
    */
   export function Body<Multer extends IMulterBase>(
     factory: () => Multer | Promise<Multer>,
@@ -88,7 +105,7 @@ export namespace TypedFormData {
       );
     const checker = validate_request_form_data(props);
     const uploader = new Singleton(async () =>
-      decode((await factory()) as ExpressMulter.Multer, props!),
+      decode((await factory()) as ExpressMulter.Multer, props),
     );
     return createParamDecorator(async function TypedFormDataBody(
       _unknown: any,
@@ -130,18 +147,22 @@ export namespace TypedFormData {
 /** @internal */
 const decode = <T>(
   multer: ExpressMulter.Multer,
-  props: IRequestFormDataProps<T>,
+  props: IRequestFormDataProps<T> | undefined,
 ) => {
-  const upload = multer.fields(
-    props!.files.map((file) => ({
-      name: file.name,
-      ...(file.limit === 1 ? { maxCount: 1 } : {}),
-    })),
-  );
+  // without the transform nothing names the file fields, so accept every file
+  const upload =
+    props === undefined
+      ? multer.any()
+      : multer.fields(
+          props.files.map((file) => ({
+            name: file.name,
+            ...(file.limit === 1 ? { maxCount: 1 } : {}),
+          })),
+        );
   const interceptor = (request: express.Request, response: express.Response) =>
     new Promise<void>((resolve, reject) =>
       upload(request, response, (error) => {
-        if (error) reject(error);
+        if (error) reject(transformMulterError(error));
         else resolve();
       }),
     );
@@ -151,35 +172,118 @@ const decode = <T>(
   }): Promise<FormData> => {
     await interceptor(socket.request, socket.response);
 
-    const data: FormData = new FormData();
-    for (const [key, value] of Object.entries(socket.request.body))
-      if (Array.isArray(value))
-        for (const elem of value) data.append(key, String(elem));
-      else data.append(key, String(value));
-    if (socket.request.files) parseFiles(data)(socket.request.files);
-    return data;
+    const files: Array<[string, Express.Multer.File]> = entries(
+      socket.request.files,
+    );
+    try {
+      const data: FormData = new FormData();
+      for (const [key, value] of Object.entries(socket.request.body))
+        if (Array.isArray(value))
+          for (const elem of value) data.append(key, String(elem));
+        else data.append(key, String(value));
+      for (const [key, file] of files) data.append(key, await toFile(file));
+      return data;
+    } finally {
+      // a disk storage engine leaves each file behind, and the handler only
+      // receives its contents as a File, never the path to remove it by
+      await Promise.all(
+        files.map(([, file]) =>
+          typeof file.path === "string"
+            ? fs.promises.rm(file.path, { force: true })
+            : undefined,
+        ),
+      );
+    }
   };
 };
 
+/**
+ * The client error NestJS's own `FileInterceptor` answers for a multipart
+ * request the multer configuration rejects: 413 for a file over
+ * `limits.fileSize`, 400 for the other limits, an unexpected field, and a
+ * malformed body. Anything else, an `HttpException` a `fileFilter` threw
+ * included, is left as it is.
+ *
+ * @internal
+ */
+const transformMulterError = (error: unknown): unknown => {
+  if (!(error instanceof Error) || error instanceof HttpException) return error;
+  const code: unknown = (error as { code?: unknown }).code;
+  const field: unknown = (error as { field?: unknown }).field;
+  if (code === "LIMIT_FILE_SIZE")
+    return new PayloadTooLargeException(error.message);
+  else if (typeof code === "string" && MULTER_BAD_REQUESTS.has(code))
+    return new BadRequestException(
+      typeof field === "string" ? `${error.message} - ${field}` : error.message,
+    );
+  else if (error.message === "Multipart: Boundary not found")
+    return new BadRequestException(error.message);
+  else if (
+    BUSBOY_BAD_REQUESTS.has(error.message) ||
+    error.message.endsWith(
+      " terminated early due to unexpected end of multipart data",
+    )
+  )
+    return new BadRequestException(`Multipart: ${error.message}`);
+  return error;
+};
+
 /** @internal */
-const parseFiles =
-  (data: FormData) =>
-  (files: Express.Multer.File[] | Record<string, Express.Multer.File[]>) => {
-    if (Array.isArray(files))
-      for (const file of files)
-        data.append(
-          file.fieldname,
-          new File([file.buffer as any], file.originalname, {
-            type: file.mimetype,
-          }),
+const MULTER_BAD_REQUESTS: Set<string> = new Set([
+  "LIMIT_PART_COUNT",
+  "LIMIT_FILE_COUNT",
+  "LIMIT_FIELD_KEY",
+  "LIMIT_FIELD_VALUE",
+  "LIMIT_FIELD_COUNT",
+  "LIMIT_UNEXPECTED_FILE",
+  "MISSING_FIELD_NAME",
+]);
+
+/**
+ * A malformed body, as `busboy` (under `multer`) and `@fastify/busboy` (under
+ * `fastify-multer`) word it.
+ *
+ * @internal
+ */
+const BUSBOY_BAD_REQUESTS: Set<string> = new Set([
+  "Malformed part header",
+  "Unexpected end of form",
+  "Unexpected end of file",
+  "Unexpected end of multipart data",
+]);
+
+/** @internal */
+const entries = (
+  files:
+    | Express.Multer.File[]
+    | Record<string, Express.Multer.File[]>
+    | undefined,
+): Array<[string, Express.Multer.File]> =>
+  files === undefined
+    ? []
+    : Array.isArray(files)
+      ? files.map((file) => [file.fieldname, file])
+      : Object.entries(files).flatMap(([key, value]) =>
+          value.map((file): [string, Express.Multer.File] => [key, file]),
         );
-    else
-      for (const [key, value] of Object.entries(files))
-        for (const file of value)
-          data.append(
-            key,
-            new File([file.buffer as any], file.originalname, {
-              type: file.mimetype,
-            }),
-          );
-  };
+
+/**
+ * The uploaded file as a `File`: memory storage keeps its bytes in `buffer`,
+ * disk storage in the file at `path`. An engine keeping neither cannot deliver
+ * it, which must not pass as an empty or placeholder file.
+ *
+ * @internal
+ */
+const toFile = async (file: Express.Multer.File): Promise<File> => {
+  const bytes: Buffer | undefined =
+    file.buffer !== undefined
+      ? file.buffer
+      : typeof file.path === "string"
+        ? await fs.promises.readFile(file.path)
+        : undefined;
+  if (bytes === undefined)
+    throw new Error(
+      `Error on TypedFormData.Body(): the multer storage engine kept neither the buffer nor the path of the uploaded file ${JSON.stringify(file.fieldname)}, so it cannot be read as a File. Use memory or disk storage.`,
+    );
+  return new File([bytes as any], file.originalname, { type: file.mimetype });
+};

package/src/decorators/TypedParam.ts

@@ -22,9 +22,9 @@ import { NoTransformConfigurationError } from "./NoTransformConfigurationError";
  *
  * \@TypedRoute.Get("shopping/sales/:id/:no/:paused")
  * public async pause(
- *   \@TypedParam("id", "uuid"), id: string & tags.Format<"uuid">,
- *   \@TypedParam("no") id: number & tags.Type<"uint32">
- *   \@TypedParam("paused") paused: boolean | null
+ *   \@TypedParam("id") id: string & tags.Format<"uuid">,
+ *   \@TypedParam("no") no: number & tags.Type<"uint32">,
+ *   \@TypedParam("paused") paused: boolean | null,
  * ): Promise<void>;
  * ```
  *

package/src/decorators/TypedQuery.ts

@@ -15,11 +15,12 @@ import {
 import { HttpArgumentsHost } from "@nestjs/common/interfaces";
 import type express from "express";
 import type { FastifyRequest } from "fastify";
-import { catchError, map } from "rxjs";
+import { catchError, map } from "rxjs/operators";
 import typia from "typia";
 
 import { IRequestQueryValidator } from "../options/IRequestQueryValidator";
 import { IResponseBodyQuerifier } from "../options/IResponseBodyQuerifier";
+import { TypedRoute } from "./TypedRoute";
 import { get_path_and_querify } from "./internal/get_path_and_querify";
 import { is_media_type } from "./internal/is_media_type";
 import { route_error } from "./internal/route_error";
@@ -117,7 +118,7 @@ export namespace TypedQuery {
   export const Post = Generator("Post");
 
   /**
-   * Router decorator function for the PATH method.
+   * Router decorator function for the PATCH method.
    *
    * @param path Path of the HTTP request
    * @returns Method decorator
@@ -150,9 +151,9 @@ export namespace TypedQuery {
     ): MethodDecorator;
 
     function route(...args: any[]): MethodDecorator {
-      const [path, stringify] = get_path_and_querify(`TypedQuery.${method}`)(
-        ...args,
-      );
+      const [path, stringify] = get_path_and_querify(() => TypedRoute.__logger)(
+        `TypedQuery.${method}`,
+      )(...args);
       return applyDecorators(
         ROUTERS[method](path),
         UseInterceptors(new TypedQueryRouteInterceptor(stringify)),
@@ -186,6 +187,10 @@ class FakeURLSearchParams {
     return this.target[key] !== undefined;
   }
 
+  public keys(): string[] {
+    return Object.keys(this.target).filter((key) => this.has(key));
+  }
+
   public get(key: string): string | null {
     const value = this.target[key];
     return value === undefined
@@ -204,16 +209,23 @@ class FakeURLSearchParams {
 /** @internal */
 class TypedQueryRouteInterceptor implements NestInterceptor {
   public constructor(
-    private readonly toSearchParams: (input: any) => URLSearchParams,
+    private readonly toSearchParams: (
+      input: any,
+      method: string,
+      path: string,
+    ) => URLSearchParams,
   ) {}
 
   public intercept(context: ExecutionContext, next: CallHandler) {
     const http: HttpArgumentsHost = context.switchToHttp();
+    const request: express.Request = http.getRequest();
     const response: express.Response = http.getResponse();
     response.header("Content-Type", "application/x-www-form-urlencoded");
 
     return next.handle().pipe(
-      map((value) => this.toSearchParams(value).toString()),
+      map((value) =>
+        this.toSearchParams(value, request.method, request.url).toString(),
+      ),
       catchError((err) => route_error(http.getRequest(), err)),
     );
   }