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/core/middleware/middleware-module.ts

@@ -8,6 +8,7 @@ import {
 import {
   addLeadingSlash,
   isUndefined,
+  stripEndSlash,
 } from '@nestjs/common/utils/shared.utils';
 import { ApplicationConfig } from '../application-config';
 import { InvalidMiddlewareException } from '../errors/exceptions/invalid-middleware.exception';
@@ -266,56 +267,70 @@ 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 { method } = routeInfo;
+    const paths = this.getPaths(routeInfo);
+    const isMethodAll = isRequestMethodAll(method);
+    const requestMethod = RequestMethod[method];
+    const router = await applicationRef.createMiddlewareFactory(method);
+    paths.forEach(path =>
+      router(
+        path,
+        isMethodAll
+          ? proxy
+          : <TRequest, TResponse>(
+              req: TRequest,
+              res: TResponse,
+              next: () => void,
+            ) => {
+              if (applicationRef.getRequestMethod(req) === requestMethod) {
+                return proxy(req, res, next);
+              }
+              return next();
+            },
+      ),
+    );
+  }
+
+  private getPaths({ path, method, version }: RouteInfo) {
+    const prefixPath = stripEndSlash(
+      addLeadingSlash(this.config.getGlobalPrefix()),
+    );
     const excludedRoutes = this.config.getGlobalPrefixOptions().exclude;
-    if (
-      (Array.isArray(excludedRoutes) &&
-        isRouteExcluded(excludedRoutes, path, method)) ||
-      ['*', '/*', '(.*)', '/(.*)'].includes(path)
-    ) {
-      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) {
+    let versionPath = '';
+    if (version && applicationVersioningConfig?.type === VersioningType.URI) {
       const versionPrefix = this.routePathFactory.getVersionPrefix(
         applicationVersioningConfig,
       );
-      path = `/${versionPrefix}${version.toString()}${path}`;
+      versionPath = addLeadingSlash(versionPrefix + version.toString());
     }
 
-    const isMethodAll = isRequestMethodAll(method);
-    const requestMethod = RequestMethod[method];
-    const router = await applicationRef.createMiddlewareFactory(method);
-    router(
-      path,
-      isMethodAll
-        ? proxy
-        : <TRequest, TResponse>(
-            req: TRequest,
-            res: TResponse,
-            next: () => void,
-          ) => {
-            if (applicationRef.getRequestMethod(req) === requestMethod) {
-              return proxy(req, res, next);
-            }
-            return next();
-          },
-    );
+    if (['*', '/*', '/*/', '(.*)', '/(.*)'].includes(path)) {
+      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,19 +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,
-  }));
+  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>(

packages/core/nest-application.ts

@@ -7,13 +7,11 @@ import {
   NestHybridApplicationOptions,
   NestInterceptor,
   PipeTransform,
-  RequestMethod,
   VersioningOptions,
   VersioningType,
   WebSocketAdapter,
 } from '@nestjs/common';
 import {
-  RouteInfo,
   GlobalPrefixOptions,
   NestApplicationOptions,
 } from '@nestjs/common/interfaces';
@@ -31,16 +29,15 @@ import {
 } from '@nestjs/common/utils/shared.utils';
 import { iterate } from 'iterare';
 import { platform } from 'os';
-import * as pathToRegexp from 'path-to-regexp';
 import { AbstractHttpAdapter } from './adapters';
 import { ApplicationConfig } from './application-config';
 import { MESSAGES } from './constants';
 import { optionalRequire } from './helpers/optional-require';
 import { NestContainer } from './injector/container';
 import { MiddlewareContainer } from './middleware/container';
 import { MiddlewareModule } from './middleware/middleware-module';
+import { mapToExcludeRoute } from './middleware/utils';
 import { NestApplicationContext } from './nest-application-context';
-import { ExcludeRouteMetadata } from './router/interfaces/exclude-route-metadata.interface';
 import { Resolver } from './router/interfaces/resolver.interface';
 import { RoutePathFactory } from './router/route-path-factory';
 import { RoutesResolver } from './router/routes-resolver';
@@ -336,20 +333,9 @@ export class NestApplication
   public setGlobalPrefix(prefix: string, options?: GlobalPrefixOptions): this {
     this.config.setGlobalPrefix(prefix);
     if (options) {
-      const exclude = options?.exclude.map(
-        (route: string | RouteInfo): ExcludeRouteMetadata => {
-          if (isString(route)) {
-            return {
-              requestMethod: RequestMethod.ALL,
-              pathRegex: pathToRegexp(addLeadingSlash(route)),
-            };
-          }
-          return {
-            requestMethod: route.method,
-            pathRegex: pathToRegexp(addLeadingSlash(route.path)),
-          };
-        },
-      );
+      const exclude = options?.exclude
+        ? mapToExcludeRoute(options.exclude)
+        : [];
       this.config.setGlobalPrefixOptions({
         ...options,
         exclude,

packages/core/router/interfaces/exclude-route-metadata.interface.ts

@@ -1,6 +1,11 @@
 import { RequestMethod } from '@nestjs/common';
 
 export interface ExcludeRouteMetadata {
+  /**
+   * Route path.
+   */
+  path: string;
+
   /**
    * Regular expression representing the route path.
    */

packages/core/router/utils/exclude-route.util.ts

@@ -1,4 +1,5 @@
 import { RequestMethod } from '@nestjs/common';
+import { addLeadingSlash } from '@nestjs/common/utils/shared.utils';
 import { ExcludeRouteMetadata } from '../interfaces/exclude-route-metadata.interface';
 
 export const isRequestMethodAll = (method: RequestMethod) => {
@@ -15,7 +16,7 @@ export function isRouteExcluded(
       isRequestMethodAll(route.requestMethod) ||
       route.requestMethod === requestMethod
     ) {
-      return route.pathRegex.exec(path);
+      return route.pathRegex.exec(addLeadingSlash(path));
     }
     return false;
   });

packages/core/test/application-config.spec.ts

@@ -23,7 +23,11 @@ describe('ApplicationConfig', () => {
     it('should set global path options', () => {
       const options: GlobalPrefixOptions<ExcludeRouteMetadata> = {
         exclude: [
-          { pathRegex: new RegExp(/health/), requestMethod: RequestMethod.GET },
+          {
+            path: '/health',
+            pathRegex: new RegExp(/health/),
+            requestMethod: RequestMethod.GET,
+          },
         ],
       };
       appConfig.setGlobalPrefixOptions(options);