fix(core): let the middleware can get the params in the global prefix

integration/hello-world/e2e/middleware-with-versioning.spec.ts

@@ -77,6 +77,26 @@ describe('Middleware', () => {
     });
   });
 
+  describe('when using default URI versioning with the global prefix', () => {
+    beforeEach(async () => {
+      app = await createAppWithVersioning(
+        {
+          type: VersioningType.URI,
+          defaultVersion: VERSION_NEUTRAL,
+        },
+        async (app: INestApplication) => {
+          app.setGlobalPrefix('api');
+        },
+      );
+    });
+
+    it(`forRoutes({ path: '/versioned', version: '1', method: RequestMethod.ALL })`, () => {
+      return request(app.getHttpServer())
+        .get('/api/v1/versioned')
+        .expect(200, VERSIONED_VALUE);
+    });
+  });
+
   describe('when using HEADER versioning', () => {
     beforeEach(async () => {
       app = await createAppWithVersioning({
@@ -133,6 +153,7 @@ describe('Middleware', () => {
 
 async function createAppWithVersioning(
   versioningOptions: VersioningOptions,
+  beforeInit?: (app: INestApplication) => Promise<void>,
 ): Promise<INestApplication> {
   const app = (
     await Test.createTestingModule({
@@ -141,6 +162,9 @@ async function createAppWithVersioning(
   ).createNestApplication();
 
   app.enableVersioning(versioningOptions);
+  if (beforeInit) {
+    await beforeInit(app);
+  }
   await app.init();
 
   return app;

integration/nest-application/global-prefix/e2e/global-prefix.spec.ts

@@ -119,6 +119,17 @@ describe('Global prefix', () => {
     await request(server).get('/api/v1/middleware/foo').expect(404);
   });
 
+  it(`should get the params in the global prefix`, async () => {
+    app.setGlobalPrefix('/api/:tenantId');
+
+    server = app.getHttpServer();
+    await app.init();
+
+    await request(server)
+      .get('/api/test/params')
+      .expect(200, { '0': 'params', tenantId: 'test' });
+  });
+
   afterEach(async () => {
     await app.close();
   });

integration/nest-application/global-prefix/src/app.controller.ts

@@ -7,6 +7,11 @@ export class AppController {
     return 'Hello: ' + req.extras?.data;
   }
 
+  @Get('params')
+  getParams(@Req() req): any {
+    return req.middlewareParams;
+  }
+
   @Get('health')
   getHealth(): string {
     return 'up';

integration/nest-application/global-prefix/src/app.module.ts

@@ -22,6 +22,11 @@ export class AppModule {
         req.extras = { data: 'Data attached in middleware' };
         next();
       })
+      .forRoutes({ path: '*', method: RequestMethod.GET })
+      .apply((req, res, next) => {
+        req.middlewareParams = req.params;
+        next();
+      })
       .forRoutes({ path: '*', method: RequestMethod.GET });
   }
 }

packages/common/constants.ts

@@ -35,7 +35,7 @@ export const ENHANCER_KEY_TO_SUBTYPE_MAP = {
 } as const;
 
 export type EnhancerSubtype =
-  typeof ENHANCER_KEY_TO_SUBTYPE_MAP[keyof typeof ENHANCER_KEY_TO_SUBTYPE_MAP];
+  (typeof ENHANCER_KEY_TO_SUBTYPE_MAP)[keyof typeof ENHANCER_KEY_TO_SUBTYPE_MAP];
 
 export const RENDER_METADATA = '__renderTemplate__';
 export const HTTP_CODE_METADATA = '__httpCode__';

packages/common/exceptions/http.exception.ts

@@ -99,9 +99,9 @@ export class HttpException extends Error {
     ) {
       this.message = (this.response as Record<string, any>).message;
     } else if (this.constructor) {
-      this.message = this.constructor.name
-        .match(/[A-Z][a-z]+|[0-9]+/g)
-        ?.join(' ') ?? 'Error';
+      this.message =
+        this.constructor.name.match(/[A-Z][a-z]+|[0-9]+/g)?.join(' ') ??
+        'Error';
     }
   }
 

packages/core/injector/injector.ts

@@ -353,7 +353,9 @@ export class Injector {
   }
 
   public reflectConstructorParams<T>(type: Type<T>): any[] {
-    const paramtypes = [...(Reflect.getMetadata(PARAMTYPES_METADATA, type) || [])];
+    const paramtypes = [
+      ...(Reflect.getMetadata(PARAMTYPES_METADATA, type) || []),
+    ];
     const selfParams = this.reflectSelfParams<T>(type);
 
     selfParams.forEach(({ index, param }) => (paramtypes[index] = param));

packages/core/middleware/middleware-module.ts

@@ -1,15 +1,12 @@
-import { HttpServer, Logger, VersioningType } from '@nestjs/common';
+import { HttpServer, Logger } from '@nestjs/common';
 import { RequestMethod } from '@nestjs/common/enums/request-method.enum';
 import {
   MiddlewareConfiguration,
   NestMiddleware,
   RouteInfo,
 } from '@nestjs/common/interfaces/middleware';
 import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
-import {
-  addLeadingSlash,
-  isUndefined,
-} from '@nestjs/common/utils/shared.utils';
+import { isUndefined } from '@nestjs/common/utils/shared.utils';
 import { ApplicationConfig } from '../application-config';
 import { InvalidMiddlewareException } from '../errors/exceptions/invalid-middleware.exception';
 import { RuntimeException } from '../errors/exceptions/runtime.exception';
@@ -26,13 +23,13 @@ import {
   MiddlewareEntrypointMetadata,
 } from '../inspector/interfaces/entrypoint.interface';
 import { REQUEST_CONTEXT_ID } from '../router/request/request-constants';
-import { RoutePathFactory } from '../router/route-path-factory';
 import { RouterExceptionFilters } from '../router/router-exception-filters';
 import { RouterProxy } from '../router/router-proxy';
-import { isRequestMethodAll, isRouteExcluded } from '../router/utils';
+import { isRequestMethodAll } from '../router/utils';
 import { MiddlewareBuilder } from './builder';
 import { MiddlewareContainer } from './container';
 import { MiddlewareResolver } from './resolver';
+import { RouteInfoPathExtractor } from './route-info-path-extractor';
 import { RoutesMapper } from './routes-mapper';
 
 export class MiddlewareModule<
@@ -46,13 +43,11 @@ export class MiddlewareModule<
   private routerExceptionFilter: RouterExceptionFilters;
   private routesMapper: RoutesMapper;
   private resolver: MiddlewareResolver;
-  private config: ApplicationConfig;
   private container: NestContainer;
   private httpAdapter: HttpServer;
   private graphInspector: GraphInspector;
   private appOptions: TAppOptions;
-
-  constructor(private readonly routePathFactory: RoutePathFactory) {}
+  private routeInfoPathExtractor: RouteInfoPathExtractor;
 
   public async register(
     middlewareContainer: MiddlewareContainer,
@@ -73,8 +68,7 @@ export class MiddlewareModule<
     );
     this.routesMapper = new RoutesMapper(container);
     this.resolver = new MiddlewareResolver(middlewareContainer, injector);
-
-    this.config = config;
+    this.routeInfoPathExtractor = new RouteInfoPathExtractor(config);
     this.injector = injector;
     this.container = container;
     this.httpAdapter = httpAdapter;
@@ -307,44 +301,18 @@ export class MiddlewareModule<
 
   private async registerHandler(
     applicationRef: HttpServer,
-    { path, method, version }: RouteInfo,
+    routeInfo: RouteInfo,
     proxy: <TRequest, TResponse>(
       req: TRequest,
       res: TResponse,
       next: () => void,
     ) => void,
   ) {
-    const prefix = this.config.getGlobalPrefix();
-    const excludedRoutes = this.config.getGlobalPrefixOptions().exclude;
-    const isAWildcard = ['*', '/*', '(.*)', '/(.*)'].includes(path);
-    if (
-      (Array.isArray(excludedRoutes) &&
-        isRouteExcluded(excludedRoutes, path, method)) ||
-      isAWildcard
-    ) {
-      path = addLeadingSlash(path);
-    } else {
-      const basePath = addLeadingSlash(prefix);
-      if (basePath?.endsWith('/') && path?.startsWith('/')) {
-        // strip slash when a wildcard is being used
-        // and global prefix has been set
-        path = path?.slice(1);
-      }
-      path = basePath + path;
-    }
-
-    const applicationVersioningConfig = this.config.getVersioning();
-    if (version && applicationVersioningConfig.type === VersioningType.URI) {
-      const versionPrefix = this.routePathFactory.getVersionPrefix(
-        applicationVersioningConfig,
-      );
-      path = `/${versionPrefix}${version.toString()}${path}`;
-    }
-
+    const { method } = routeInfo;
+    const paths = this.routeInfoPathExtractor.extractPathsFrom(routeInfo);
     const isMethodAll = isRequestMethodAll(method);
     const requestMethod = RequestMethod[method];
     const router = await applicationRef.createMiddlewareFactory(method);
-
     const middlewareFunction = isMethodAll
       ? proxy
       : <TRequest, TResponse>(
@@ -357,8 +325,7 @@ export class MiddlewareModule<
           }
           return next();
         };
-
-    router(path, middlewareFunction);
+    paths.forEach(path => router(path, middlewareFunction));
   }
 
   private getContextId(request: unknown, isTreeDurable: boolean): ContextId {

packages/core/middleware/route-info-path-extractor.ts

@@ -0,0 +1,55 @@
+import { VersioningType } from '@nestjs/common';
+import { RouteInfo } from '@nestjs/common/interfaces';
+import {
+  addLeadingSlash,
+  stripEndSlash,
+} from '@nestjs/common/utils/shared.utils';
+import { ApplicationConfig } from '../application-config';
+import { isRouteExcluded } from '../router/utils';
+import { RoutePathFactory } from './../router/route-path-factory';
+
+export class RouteInfoPathExtractor {
+  private routePathFactory: RoutePathFactory;
+
+  constructor(private readonly applicationConfig: ApplicationConfig) {
+    this.routePathFactory = new RoutePathFactory(applicationConfig);
+  }
+
+  public extractPathsFrom({ path, method, version }: RouteInfo) {
+    const prefixPath = stripEndSlash(
+      addLeadingSlash(this.applicationConfig.getGlobalPrefix()),
+    );
+    const excludedRoutes =
+      this.applicationConfig.getGlobalPrefixOptions().exclude;
+
+    const applicationVersioningConfig = this.applicationConfig.getVersioning();
+    let versionPath = '';
+    if (version && applicationVersioningConfig?.type === VersioningType.URI) {
+      const versionPrefix = this.routePathFactory.getVersionPrefix(
+        applicationVersioningConfig,
+      );
+      versionPath = addLeadingSlash(versionPrefix + version.toString());
+    }
+
+    const isAWildcard = ['*', '/*', '/*/', '(.*)', '/(.*)'].includes(path);
+    if (isAWildcard) {
+      return Array.isArray(excludedRoutes)
+        ? [
+            prefixPath + versionPath + addLeadingSlash(path),
+            ...excludedRoutes.map(
+              route => versionPath + addLeadingSlash(route.path),
+            ),
+          ]
+        : [prefixPath + versionPath + addLeadingSlash(path)];
+    }
+
+    if (
+      Array.isArray(excludedRoutes) &&
+      isRouteExcluded(excludedRoutes, path, method)
+    ) {
+      return [versionPath + addLeadingSlash(path)];
+    }
+
+    return [prefixPath + versionPath + addLeadingSlash(path)];
+  }
+}

packages/core/middleware/utils.ts

@@ -1,20 +1,33 @@
 import { RequestMethod } from '@nestjs/common';
 import { HttpServer, RouteInfo, Type } from '@nestjs/common/interfaces';
-import { isFunction } from '@nestjs/common/utils/shared.utils';
+import {
+  addLeadingSlash,
+  isFunction,
+  isString,
+} from '@nestjs/common/utils/shared.utils';
 import { iterate } from 'iterare';
 import * as pathToRegexp from 'path-to-regexp';
 import { v4 as uuid } from 'uuid';
 import { ExcludeRouteMetadata } from '../router/interfaces/exclude-route-metadata.interface';
 import { isRouteExcluded } from '../router/utils';
 
 export const mapToExcludeRoute = (
-  routes: RouteInfo[],
+  routes: (string | RouteInfo)[],
 ): ExcludeRouteMetadata[] => {
-  return routes.map(({ path, method }) => ({
-    pathRegex: pathToRegexp(path),
-    requestMethod: method,
-    path,
-  }));
+  return routes.map(route => {
+    if (isString(route)) {
+      return {
+        path: route,
+        requestMethod: RequestMethod.ALL,
+        pathRegex: pathToRegexp(addLeadingSlash(route)),
+      };
+    }
+    return {
+      path: route.path,
+      requestMethod: route.method,
+      pathRegex: pathToRegexp(addLeadingSlash(route.path)),
+    };
+  });
 };
 
 export const filterMiddleware = <T extends Function | Type<any> = any>(