chore(): minor formatting changes

fix(core): use class refs as keys (container)

.github/ISSUE_TEMPLATE/Bug_report.yml

@@ -9,6 +9,7 @@ body:
  
         If you are not sure that your issue is a bug, you could:
 
+        - read the [FAQ's common errors](https://docs.nestjs.com/faq/common-errors) page
         - use our [Discord community](https://discord.gg/NestJS)
         - use [StackOverflow using the tag `nestjs`](https://stackoverflow.com/questions/tagged/nestjs)
         - If it's just a quick question you can ping [our Twitter](https://twitter.com/nestframework)
@@ -20,7 +21,7 @@ body:
   - type: checkboxes
     attributes:
       label: "Is there an existing issue for this?"
-      description: "Please search [here](https://github.com/nestjs/nest/issues?q=is%3Aissue) to see if an issue already exists for the bug you encountered"
+      description: "Please search [here](../issues?q=is%3Aissue) to see if an issue already exists for the bug you encountered"
       options:
       - label: "I have searched the existing issues"
         required: true
@@ -37,7 +38,7 @@ body:
       required: true
     attributes:
       label: "Minimum reproduction code"
-      description: "An URL to some git repository that reproduces this issue. [Wtf is a minimum reproduction?](https://jmcdo29.github.io/wtf-is-a-minimum-reproduction)"
+      description: "An URL to some Git repository/[StackBlitz](https://stackblitz.com/fork/github/nestjs/typescript-starter)/[CodeSandbox](https://codesandbox.io/s/github/nestjs/typescript-starter/tree/master) project that reproduces your issue. [Wtf is a minimum reproduction?](https://jmcdo29.github.io/wtf-is-a-minimum-reproduction)"
       placeholder: "https://github.com/..."
 
   - type: textarea
@@ -47,7 +48,7 @@ body:
         How the issue manifests?
         You could leave this blank if you alread write this in your reproduction code
       placeholder: |
-        1. `npm i`
+        1. `npm ci`
         2. `npm start:dev`
         3. See error...
 
@@ -104,10 +105,13 @@ body:
       required: true
     attributes:
       label: "Packages versions"
-      description: "You could leave your whole `package.json` dependencies list here, or just indicates which version of `@nestjs/*` are you using"
-      placeholder: |
-        - `@nestjs/common`: 8.1.3
-        - `@nestjs/platform-express`: 8.1.3
+      description: |
+        You could leave your whole `package.json` dependencies list here, or just indicate which version of `@nestjs/*` you are using
+        **Tip**: run _npx nest info_
+      value: |
+        ```json
+
+        ```
 
   - type: input
     attributes:

.github/ISSUE_TEMPLATE/Feature_request.yml

@@ -9,6 +9,7 @@ body:
  
         If you are not sure that your issue is a bug, you could:
 
+        - read the [FAQ's common errors](https://docs.nestjs.com/faq/common-errors) page
         - use our [Discord community](https://discord.gg/NestJS)
         - use [StackOverflow using the tag `nestjs`](https://stackoverflow.com/questions/tagged/nestjs)
         - If it's just a quick question you can ping [our Twitter](https://twitter.com/nestframework)
@@ -18,7 +19,7 @@ body:
   - type: checkboxes
     attributes:
       label: "Is there an existing issue that is already proposing this?"
-      description: "Please search [here](https://github.com/nestjs/nest/issues?q=is%3Aissue) to see if an issue already exists for the feature you are requesting"
+      description: "Please search [here](../issues?q=is%3Aissue) to see if an issue already exists for the feature you are requesting"
       options:
       - label: "I have searched the existing issues"
         required: true

.github/ISSUE_TEMPLATE/Regression.yml

@@ -9,6 +9,7 @@ body:
  
         If you are not sure that your issue is a bug, you could:
 
+        - read the [FAQ's common errors](https://docs.nestjs.com/faq/common-errors) page
         - use our [Discord community](https://discord.gg/NestJS)
         - use [StackOverflow using the tag `nestjs`](https://stackoverflow.com/questions/tagged/nestjs)
         - If it's just a quick question you can ping [our Twitter](https://twitter.com/nestframework)
@@ -28,7 +29,7 @@ body:
   - type: checkboxes
     attributes:
       label: "Is there an existing issue that is already proposing this?"
-      description: "Please search [here](https://github.com/nestjs/nest/issues?q=is%3Aissue) to see if an issue already exists for the feature you are requesting"
+      description: "Please search [here](../issues?q=is%3Aissue) to see if an issue already exists for the feature you are requesting"
       options:
       - label: "I have searched the existing issues"
         required: true

.github/ISSUE_TEMPLATE/Suggestion_improve_performance.yml

@@ -6,7 +6,7 @@ body:
   - type: checkboxes
     attributes:
       label: "Is there an existing issue that is already proposing this?"
-      description: "Please search [here](https://github.com/nestjs/nest/issues?q=is%3Aissue) to see if an issue already exists for this"
+      description: "Please search [here](../issues?q=is%3Aissue) to see if an issue already exists for this"
       options:
       - label: "I have searched the existing issues"
         required: true
@@ -34,7 +34,7 @@ body:
 
   - type: textarea
     validations:
-      required: true
+     required: true
     attributes:
       label: "Benchmarks result or another proof (eg: POC)"
       description: |

.github/ISSUE_TEMPLATE/config.yml

@@ -2,6 +2,9 @@
 blank_issues_enabled: false
 
 contact_links:
+  - name: "\u2049 FAQ"
+    url: "https://docs.nestjs.com/faq"
+    about: "Make sure you have read the Frequently Asked Questions page."
   - name: "\u2753 Discord Community of NestJS"
     url: "https://discord.gg/NestJS"
     about: "Please ask support questions or discuss suggestions/enhancements here."

.husky/commit-msg

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx --no-install commitlint --edit $1

.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx lint-staged

LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2021 Kamil Mysliwiec <https://kamilmysliwiec.com>
+Copyright (c) 2017-2022 Kamil Mysliwiec <https://kamilmysliwiec.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

Readme.md

@@ -54,13 +54,16 @@ With official support, you can get expert help straight from Nest core team. We
 
 ## Support
 
-Nest is an MIT-licensed open source project. It can grow thanks to the sponsors and support by the amazing backers. If you'd like to join them, please [read more here](https://docs.nestjs.com/support).
+Nest is an MIT-licensed open source project. It can grow thanks to the sponsors and support from the amazing backers. If you'd like to join them, please [read more here](https://docs.nestjs.com/support).
 
 #### Principal Sponsors
-<table style="text-align:center;"><tr><td>
+<table style="text-align:center;"><tr>
+  <td><a href="https://trilon.io" target="_blank"><img src="https://nestjs.com/img/trilon.svg" width="200" valign="middle" /></a></td>
+  <td><a href="https://www.redhat.com" target="_blank"><img src="https://nestjs.com/img/red-hat-logo.svg" width="200" valign="middle" /></a></td>
+<td>
 <a href="https://github.com/Sanofi-IADC" target="_blank"><img src="https://docs.nestjs.com/assets/sponsors/sanofi.png" width="180" valign="middle" /></a></td>
 <td>
-<a href="https://trilon.io" target="_blank"><img src="https://nestjs.com/img/trilon.svg" width="200" valign="middle" /></a></td>
+<a href="https://nx.dev" target="_blank"><img src="https://nestjs.com/img/nx-logo.png" height="45" valign="middle" /></a></td>
 </tr></table>
 
 #### Gold Sponsors
@@ -78,10 +81,11 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 <table style="text-align:center;"><tr><td>
 <a href="https://neoteric.eu/" target="_blank"><img src="https://nestjs.com/img/neoteric-cut.png" width="120" valign="middle" /></a> </td><td>
   <a href="http://gojob.com" target="_blank"><img src="http://nestjs.com/img/gojob-logo.png" valign="middle" width="100" /></a> </td><td>
-<a href="http://www.leogistics.com" target="_blank"><img src="https://nestjs.com/img/leogistics-logo.jpeg" width="150" valign="middle" /></td><td>
+<a href="https://www.myleodsc.com/" target="_blank"><img src="https://nestjs.com/img/myleo-logo.png" width="180" valign="middle" /></td><td>
 <a href="https://careers.meetdandy.com/?gh_src=063ba61e3us" target="_blank"><img src="https://nestjs.com/img/dandy-roles-logo.svg" width="150" valign="middle" /></td><td>
 <a href="https://www.castlecraft.in" target="_blank"><img src="https://nestjs.com/img/castlecraft-logo.png" width="150" valign="middle" /></td>
-<td><a href="https://www.tinystacks.com" target="_blank"><img src="https://nestjs.com/img/tinystacks-logo.png#1" width="140" valign="middle" /></td></tr></table>
+<td><a href="https://www.tinystacks.com" target="_blank"><img src="https://nestjs.com/img/tinystacks-logo.png#1" width="140" valign="middle" /></td>
+<td><a href="https://n.inc" target="_blank"><img src="https://nestjs.com/img/n-inc-logo.svg" width="120" valign="middle" /></td></tr></table>
 
 #### Sponsors
 
@@ -115,6 +119,11 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 <td align="center" valign="middle"><a href="https://www.naologic.com/" target="_blank"><img src="https://nestjs.com/img/naologic-logo.svg" width="125" valign="middle" /></a></td>
   <td align="center" valign="middle"><a href="https://messaged.com/" target="_blank"><img src="https://nestjs.com/img/messaged-logo.png" width="50" valign="middle" /></a></td>
   <td align="center" valign="middle"><a href="https://triplecore.io" target="_blank"><img src="https://nestjs.com/img/triplecore-logo.svg" width="50" valign="middle" /></a></td>
+   <td align="center" valign="middle"><a href="https://klqc.de" target="_blank"><img src="https://nestjs.com/img/klcqcl-logo.png" width="120" valign="middle" /></a></td>
+   <td align="center" valign="middle"><a href="https://thecasinowizard.com/bonuses/no-deposit-bonuses/" target="_blank"><img src="https://nestjs.com/img/casinowizard-logo.png" width="120" valign="middle" /></a></td></tr><tr>
+     <td align="center" valign="middle"><a href="https://polygon-software.ch/" target="_blank"><img src="https://nestjs.com/img/polygon-logo.svg" width="120" valign="middle" /></a></td>
+   <td align="center" valign="middle"><a href="https://mobilereality.pl/" target="_blank"><img src="https://nestjs.com/img/mobile-reality-logo.png" width="45" valign="middle" /></a></td>
+     <td align="center" valign="middle"><a href="https://boringowl.io/" target="_blank"><img src="https://nestjs.com/img/boringowl-logo.svg" width="120" valign="middle" /></a></td>
   </tr></table>
 
 ## Backers

integration/auto-mock/src/bar.service.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@nestjs/common';
+import { FooService } from './foo.service';
+
+@Injectable()
+export class BarService {
+
+  constructor(private readonly foo: FooService) {}
+
+  bar() {
+    this.foo.foo();
+  }
+}

integration/auto-mock/src/foo.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class FooService {
+  foo() {
+    console.log('foo called');
+  }
+}

integration/auto-mock/test/bar.service.spec.ts

@@ -0,0 +1,63 @@
+import { Test } from '@nestjs/testing';
+import * as chai from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
+import * as sinon from 'sinon';
+import { BarService } from '../src/bar.service';
+import { FooService } from '../src/foo.service';
+chai.use(chaiAsPromised);
+const { expect } = chai;
+
+describe('Auto-Mocking Bar Deps', () => {
+  let service: BarService;
+  let fooService: FooService;
+  const stub = sinon.stub();
+  beforeEach(async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [BarService],
+    })
+      .useMocker(() => ({ foo: stub }))
+      .compile();
+    service = moduleRef.get(BarService);
+    fooService = moduleRef.get(FooService);
+  });
+
+  it('should be defined', () => {
+    expect(service).not.to.be.undefined;
+    expect(fooService).not.to.be.undefined;
+  });
+  it('should call bar.bar', () => {
+    service.bar();
+    expect(stub.called);
+  });
+});
+
+describe('Auto-Mocking with token in factory', () => {
+  it('can mock the dependencies', async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [BarService],
+    })
+      .useMocker((token) => {
+        if (token === FooService) {
+          return { foo: sinon.stub };
+        }
+      })
+      .compile();
+    const service = moduleRef.get(BarService);
+    const fooServ = moduleRef.get<{ foo: sinon.SinonStub }>(FooService as any);
+    service.bar();
+    expect(fooServ.foo.called);
+  });
+  it('cannot mock the dependencies', async () => {
+
+    const moduleRef = Test.createTestingModule({
+      providers: [BarService],
+    })
+      .useMocker((token) => {
+        if (token === FooService.name + 'something that fails the token') {
+          return { foo: sinon.stub };
+        }
+      })
+      .compile;
+    expect(moduleRef()).to.eventually.throw()
+  });
+});

integration/auto-mock/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": false,
+    "noImplicitAny": false,
+    "removeComments": true,
+    "noLib": false,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "es6",
+    "sourceMap": true,
+    "allowJs": true,
+    "outDir": "./dist"
+  },
+  "include": [
+    "src/**/*",
+    "e2e/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+  ]
+}

integration/docker-compose.yml

@@ -48,7 +48,7 @@ services:
   zookeeper:
     container_name: test-zookeeper
     hostname: zookeeper
-    image: confluentinc/cp-zookeeper:6.2.1
+    image: confluentinc/cp-zookeeper:7.0.1
     ports:
       - "2181:2181"
     environment:
@@ -57,7 +57,7 @@ services:
   kafka:
     container_name: test-kafka
     hostname: kafka
-    image: confluentinc/cp-kafka:7.0.0
+    image: confluentinc/cp-kafka:7.0.1
     depends_on:
       - zookeeper
     ports:

integration/graphql-code-first/src/app.module.ts

@@ -1,3 +1,4 @@
+import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
 import { Module } from '@nestjs/common';
 import { GraphQLModule } from '@nestjs/graphql';
 import { join } from 'path';
@@ -6,7 +7,8 @@ import { RecipesModule } from './recipes/recipes.module';
 @Module({
   imports: [
     RecipesModule,
-    GraphQLModule.forRoot({
+    GraphQLModule.forRoot<ApolloDriverConfig>({
+      driver: ApolloDriver,
       debug: false,
       installSubscriptionHandlers: true,
       autoSchemaFile: join(

integration/graphql-schema-first/e2e/graphql-request-scoped.spec.ts

@@ -1,3 +1,4 @@
+import { ApolloDriver } from '@nestjs/apollo';
 import { INestApplication } from '@nestjs/common';
 import { GraphQLModule } from '@nestjs/graphql';
 import { Test } from '@nestjs/testing';
@@ -15,6 +16,7 @@ describe('GraphQL request scoped', () => {
       imports: [
         CatsModule.enableRequestScope(),
         GraphQLModule.forRoot({
+          driver: ApolloDriver,
           typePaths: [join(__dirname, '..', 'src', '**', '*.graphql')],
         }),
       ],

integration/graphql-schema-first/src/app.module.ts

@@ -1,3 +1,4 @@
+import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
 import { Module } from '@nestjs/common';
 import { GraphQLModule } from '@nestjs/graphql';
 import { join } from 'path';
@@ -6,7 +7,8 @@ import { CatsModule } from './cats/cats.module';
 @Module({
   imports: [
     CatsModule,
-    GraphQLModule.forRoot({
+    GraphQLModule.forRoot<ApolloDriverConfig>({
+      driver: ApolloDriver,
       typePaths: [join(__dirname, '**', '*.graphql')],
     }),
   ],

integration/graphql-schema-first/src/async-options-class.module.ts

@@ -1,14 +1,11 @@
+import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
 import { Module } from '@nestjs/common';
-import {
-  GqlModuleOptions,
-  GqlOptionsFactory,
-  GraphQLModule,
-} from '@nestjs/graphql';
+import { GqlOptionsFactory, GraphQLModule } from '@nestjs/graphql';
 import { join } from 'path';
 import { CatsModule } from './cats/cats.module';
 
 class ConfigService implements GqlOptionsFactory {
-  createGqlOptions(): GqlModuleOptions {
+  createGqlOptions(): ApolloDriverConfig {
     return {
       typePaths: [join(__dirname, '**', '*.graphql')],
     };
@@ -18,7 +15,8 @@ class ConfigService implements GqlOptionsFactory {
 @Module({
   imports: [
     CatsModule,
-    GraphQLModule.forRootAsync({
+    GraphQLModule.forRootAsync<ApolloDriverConfig>({
+      driver: ApolloDriver,
       useClass: ConfigService,
     }),
   ],

integration/graphql-schema-first/src/async-options-existing.module.ts

@@ -1,3 +1,4 @@
+import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
 import { Module } from '@nestjs/common';
 import { GraphQLModule } from '@nestjs/graphql';
 import { CatsModule } from './cats/cats.module';
@@ -7,7 +8,8 @@ import { ConfigService } from './config.service';
 @Module({
   imports: [
     CatsModule,
-    GraphQLModule.forRootAsync({
+    GraphQLModule.forRootAsync<ApolloDriverConfig>({
+      driver: ApolloDriver,
       imports: [ConfigModule],
       useExisting: ConfigService,
     }),

integration/graphql-schema-first/src/async-options.module.ts

@@ -1,3 +1,4 @@
+import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
 import { Module } from '@nestjs/common';
 import { GraphQLModule } from '@nestjs/graphql';
 import { join } from 'path';
@@ -6,7 +7,8 @@ import { CatsModule } from './cats/cats.module';
 @Module({
   imports: [
     CatsModule,
-    GraphQLModule.forRootAsync({
+    GraphQLModule.forRootAsync<ApolloDriverConfig>({
+      driver: ApolloDriver,
       useFactory: async () => ({
         typePaths: [join(__dirname, '**', '*.graphql')],
       }),

integration/graphql-schema-first/src/common/scalars/date.scalar.ts

@@ -1,4 +1,4 @@
-import { Scalar } from '@nestjs/graphql/dist/decorators/resolvers.decorators';
+import { Scalar } from '@nestjs/graphql';
 import { Kind } from 'graphql';
 
 @Scalar('Date')

integration/injector/e2e/injector.spec.ts

@@ -1,7 +1,10 @@
 import { RuntimeException } from '@nestjs/core/errors/exceptions/runtime.exception';
+import { UnknownDependenciesException } from '@nestjs/core/errors/exceptions/unknown-dependencies.exception';
 import { UnknownExportException } from '@nestjs/core/errors/exceptions/unknown-export.exception';
 import { Test } from '@nestjs/testing';
 import { expect } from 'chai';
+import * as chai from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
 import {
   DYNAMIC_TOKEN,
   DYNAMIC_VALUE,
@@ -9,6 +12,13 @@ import {
 } from '../src/dynamic/dynamic.module';
 import { ExportsModule } from '../src/exports/exports.module';
 import { InjectModule } from '../src/inject/inject.module';
+import { InjectSameNameModule } from '../src/inject/inject-same-name.module';
+import {
+  SelfInjectionProviderModule,
+  SelfInjectionProviderCustomTokenModule,
+  SelfInjectionForwardProviderModule,
+} from '../src/self-injection/self-injection-provider.module';
+chai.use(chaiAsPromised);
 
 describe('Injector', () => {
   describe('when "providers" and "exports" properties are inconsistent', () => {
@@ -24,6 +34,16 @@ describe('Injector', () => {
     });
   });
 
+  describe("When class injects a provider with the same as class's name", () => {
+    it('should compile with success', async () => {
+      const builder = Test.createTestingModule({
+        imports: [InjectSameNameModule],
+      });
+
+      await expect(builder.compile()).to.eventually.be.fulfilled;
+    });
+  });
+
   describe('when Nest cannot resolve dependencies', () => {
     it(`should fail with "RuntimeException"`, async () => {
       try {
@@ -35,6 +55,42 @@ describe('Injector', () => {
         expect(err).to.be.instanceof(RuntimeException);
       }
     });
+
+    describe('due to self-injection providers', () => {
+      it('should fail with "UnknownDependenciesException" due to self-injection via same class reference', async () => {
+        const builder = Test.createTestingModule({
+          imports: [SelfInjectionProviderModule],
+        });
+
+        await expect(
+          builder.compile(),
+        ).to.eventually.be.rejected.and.be.an.instanceOf(
+          UnknownDependenciesException,
+        );
+      });
+      it('should fail with "UnknownDependenciesException" due to self-injection via forwardRef to the same class reference', async () => {
+        const builder = Test.createTestingModule({
+          imports: [SelfInjectionForwardProviderModule],
+        });
+
+        await expect(
+          builder.compile(),
+        ).to.eventually.be.rejected.and.be.an.instanceOf(
+          UnknownDependenciesException,
+        );
+      });
+      it('should fail with "UnknownDependenciesException" due to self-injection via custom provider', async () => {
+        const builder = Test.createTestingModule({
+          imports: [SelfInjectionProviderCustomTokenModule],
+        });
+
+        await expect(
+          builder.compile(),
+        ).to.eventually.be.rejected.and.be.an.instanceOf(
+          UnknownDependenciesException,
+        );
+      });
+    });
   });
 
   describe('when dynamic module', () => {

integration/injector/e2e/optional-factory-provider-dep.spec.ts

@@ -0,0 +1,96 @@
+import { UnknownDependenciesException } from '@nestjs/core/errors/exceptions/unknown-dependencies.exception';
+import { Test } from '@nestjs/testing';
+import { expect } from 'chai';
+
+describe('Optional factory provider deps', () => {
+  describe('when dependency is optional', () => {
+    describe('and it is available', () => {
+      it('then it should be injected into the factory function', async () => {
+        const defaultValue = 'DEFAULT_VALUE';
+        const moduleRef = await Test.createTestingModule({
+          providers: [
+            {
+              provide: 'FACTORY',
+              useFactory: dep => dep ?? defaultValue,
+              inject: [{ token: 'MISSING_DEP', optional: true }],
+            },
+            { provide: 'MISSING_DEP', useValue: 'OPTIONAL_DEP_VALUE' },
+          ],
+        }).compile();
+
+        const factoryProvider = moduleRef.get('FACTORY');
+        expect(factoryProvider).to.equal('OPTIONAL_DEP_VALUE');
+      });
+    });
+    describe('otherwise', () => {
+      it('"undefined" should be injected into the factory function', async () => {
+        const defaultValue = 'DEFAULT_VALUE';
+        const moduleRef = await Test.createTestingModule({
+          providers: [
+            {
+              provide: 'FACTORY',
+              useFactory: dep => dep ?? defaultValue,
+              inject: [{ token: 'MISSING_DEP', optional: true }],
+            },
+          ],
+        }).compile();
+
+        const factoryProvider = moduleRef.get('FACTORY');
+        expect(factoryProvider).to.equal(defaultValue);
+      });
+    });
+  });
+  describe('otherwise', () => {
+    describe('and dependency is not registered', () => {
+      it('should error out', async () => {
+        try {
+          const builder = Test.createTestingModule({
+            providers: [
+              {
+                provide: 'FACTORY',
+                useFactory: () => 'RETURNED_VALUE',
+                inject: ['MISSING_DEP'],
+              },
+            ],
+          });
+          await builder.compile();
+        } catch (err) {
+          expect(err).to.be.instanceOf(UnknownDependenciesException);
+        }
+      });
+    });
+  });
+  describe('and dependency is registered but it cannot be instantiated', () => {
+    it('should error out', async () => {
+      try {
+        const builder = Test.createTestingModule({
+          providers: [
+            {
+              provide: 'POSSIBLY_MISSING_DEP',
+              useFactory: () => null,
+              inject: ['MISSING_DEP'],
+            },
+            {
+              provide: 'FACTORY',
+              useFactory: () => 'RETURNED_VALUE',
+              inject: [{ token: 'POSSIBLY_MISSING_DEP', optional: false }],
+            },
+          ],
+        });
+        await builder.compile();
+      } catch (err) {
+        expect(err).to.be.instanceOf(UnknownDependenciesException);
+        expect(err.message).to
+          .equal(`Nest can't resolve dependencies of the POSSIBLY_MISSING_DEP (?). Please make sure that the argument MISSING_DEP at index [0] is available in the RootTestModule context.
+
+Potential solutions:
+- If MISSING_DEP is a provider, is it part of the current RootTestModule?
+- If MISSING_DEP is exported from a separate @Module, is that module imported within RootTestModule?
+  @Module({
+    imports: [ /* the Module containing MISSING_DEP */ ]
+  })
+`);
+      }
+    });
+  });
+});

integration/injector/src/inject/inject-same-name.module.ts

@@ -0,0 +1,16 @@
+import { Module, Injectable, Inject } from '@nestjs/common';
+
+@Injectable()
+class CoreService {
+  constructor(@Inject(CoreService.name) private readonly coreService: any) {}
+}
+
+@Module({
+  providers: [
+    {
+      provide: CoreService.name,
+      useValue: 'anything',
+    },
+  ],
+})
+export class InjectSameNameModule {}

integration/injector/src/self-injection/self-injection-provider.module.ts

@@ -0,0 +1,40 @@
+import { Module, Injectable, Inject, forwardRef } from '@nestjs/common';
+
+@Injectable()
+class ServiceInjectingItself {
+  constructor(private readonly coreService: ServiceInjectingItself) {}
+}
+
+@Injectable()
+class ServiceInjectingItselfForwared {
+  constructor(
+    @Inject(forwardRef(() => ServiceInjectingItself))
+    private readonly coreService: ServiceInjectingItself,
+  ) {}
+}
+
+@Injectable()
+class ServiceInjectingItselfViaCustomToken {
+  constructor(@Inject('AnotherToken') private readonly coreService: any) {}
+}
+
+@Module({
+  providers: [ServiceInjectingItself],
+})
+export class SelfInjectionProviderModule {}
+
+@Module({
+  providers: [ServiceInjectingItselfForwared],
+})
+export class SelfInjectionForwardProviderModule {}
+
+@Module({
+  providers: [
+    ServiceInjectingItselfViaCustomToken,
+    {
+      provide: 'AnotherToken',
+      useClass: ServiceInjectingItselfViaCustomToken,
+    },
+  ],
+})
+export class SelfInjectionProviderCustomTokenModule {}

integration/microservices/e2e/disconnected-client.spec.ts

@@ -65,6 +65,19 @@ describe('Disconnected client', () => {
       .expect(408);
   });
 
+  it(`RMQ`, () => {
+    return request(server)
+      .post('/')
+      .send({
+        transport: Transport.RMQ,
+        options: {
+          urls: [`amqp://0.0.0.0:3333`],
+          queue: 'test',
+        },
+      })
+      .expect(408);
+  });
+
   afterEach(async () => {
     await app.close();
   });

integration/microservices/e2e/orders-grpc.spec.ts

@@ -134,7 +134,7 @@ describe('Advanced GRPC transport', () => {
     callHandler.on('error', (err: any) => {
       // We want to fail only on real errors while Cancellation error
       // is expected
-      if (String(err).toLowerCase().indexOf('cancelled') === -1) {
+      if (!String(err).toLowerCase().includes('cancelled')) {
         fail('gRPC Stream error happened, error: ' + err);
       }
     });
@@ -166,7 +166,7 @@ describe('Advanced GRPC transport', () => {
     callHandler.on('error', (err: any) => {
       // We want to fail only on real errors while Cancellation error
       // is expected
-      if (String(err).toLowerCase().indexOf('cancelled') === -1) {
+      if (!String(err).toLowerCase().includes('cancelled')) {
         fail('gRPC Stream error happened, error: ' + err);
       }
     });

integration/microservices/e2e/sum-grpc.spec.ts

@@ -48,11 +48,16 @@ describe('GRPC transport', () => {
     );
   });
 
-  it(`GRPC Sending and Receiving HTTP POST`, () => {
-    return request(server)
+  it(`GRPC Sending and Receiving HTTP POST`, async () => {
+    await request(server)
       .post('/sum')
       .send([1, 2, 3, 4, 5])
       .expect(200, { result: 15 });
+
+    await request(server)
+      .post('/upperMethod/sum')
+      .send([1, 2, 3, 4, 5])
+      .expect(200, { result: 15 });
   });
 
   it(`GRPC Sending and Receiving HTTP POST (multiple proto)`, async () => {
@@ -78,7 +83,7 @@ describe('GRPC transport', () => {
     callHandler.on('error', (err: any) => {
       // We want to fail only on real errors while Cancellation error
       // is expected
-      if (String(err).toLowerCase().indexOf('cancelled') === -1) {
+      if (!String(err).toLowerCase().includes('cancelled')) {
         fail('gRPC Stream error happened, error: ' + err);
       }
     });
@@ -100,7 +105,7 @@ describe('GRPC transport', () => {
     callHandler.on('error', (err: any) => {
       // We want to fail only on real errors while Cancellation error
       // is expected
-      if (String(err).toLowerCase().indexOf('cancelled') === -1) {
+      if (!String(err).toLowerCase().includes('cancelled')) {
         fail('gRPC Stream error happened, error: ' + err);
       }
     });

integration/microservices/e2e/sum-mqtt.spec.ts

@@ -47,7 +47,7 @@ describe('MQTT transport', () => {
       .post('/?command=streamSum')
       .send([1, 2, 3, 4, 5])
       .expect(200, '15');
-  });
+  }).timeout(5000);
 
   it(`/POST (concurrent)`, function () {
     return request(server)
@@ -72,7 +72,7 @@ describe('MQTT transport', () => {
       .post('/stream')
       .send([1, 2, 3, 4, 5])
       .expect(200, '15');
-  });
+  }).timeout(5000);
 
   it(`/POST (event notification)`, done => {
     request(server)

integration/microservices/src/disconnected.controller.ts

@@ -15,12 +15,12 @@ export class DisconnectedClientController {
   call(@Body() options): Observable<number> {
     const client = ClientProxyFactory.create(options);
     return client.send<number, number[]>({ cmd: 'none' }, [1, 2, 3]).pipe(
-      /*tap(
-          console.log.bind(console, 'data'),
-          console.error.bind(console, 'error'),
-        ),*/
+      // tap(
+      //   console.log.bind(console, 'data'),
+      //   console.error.bind(console, 'error'),
+      // ),
       catchError(error => {
-        const { code } = error || { code: 'CONN_ERR' };
+        const { code } = error?.err ?? error ?? { code: 'CONN_ERR' };
         return throwError(() =>
           code === 'ECONNREFUSED' ||
           code === 'CONN_ERR' ||

integration/microservices/src/grpc-advanced/advanced.grpc.controller.ts

@@ -134,8 +134,8 @@ export class AdvancedGrpcController {
   async streamReq(messages: Observable<any>): Promise<any> {
     const s = new Subject();
     const o = s.asObservable();
-    messages.subscribe(
-      msg => {
+    messages.subscribe({
+      next: () => {
         s.next({
           id: 1,
           itemTypes: [1],
@@ -146,9 +146,8 @@ export class AdvancedGrpcController {
           },
         });
       },
-      null,
-      () => s.complete(),
-    );
+      complete: () => s.complete(),
+    });
     return o;
   }
 

integration/microservices/src/grpc/grpc.controller.ts

@@ -40,6 +40,14 @@ export class GrpcController {
     return svc.sum({ data });
   }
 
+  // Test that getService generate both lower and uppercase method
+  @Post('upperMethod/sum')
+  @HttpCode(200)
+  callWithOptions(@Body() data: number[]): Observable<number> {
+    const svc = this.client.getService<any>('Math');
+    return svc.Sum({ data });
+  }
+
   @GrpcMethod('Math')
   async sum({ data }: { data: number[] }): Promise<any> {
     return of({
@@ -50,16 +58,16 @@ export class GrpcController {
   @GrpcStreamMethod('Math')
   async sumStream(messages: Observable<any>): Promise<any> {
     return new Promise<any>((resolve, reject) => {
-      messages.subscribe(
-        msg => {
+      messages.subscribe({
+        next: msg => {
           resolve({
             result: msg.data.reduce((a, b) => a + b),
           });
         },
-        err => {
+        error: err => {
           reject(err);
         },
-      );
+      });
     });
   }
 

integration/microservices/src/kafka-concurrent/kafka-concurrent.controller.ts

@@ -2,11 +2,11 @@ import {
   Body,
   Controller,
   HttpCode,
+  Logger,
   OnModuleDestroy,
   OnModuleInit,
   Post,
 } from '@nestjs/common';
-import { Logger } from '@nestjs/common/services/logger.service';
 import { Client, ClientKafka, Transport } from '@nestjs/microservices';
 import { PartitionerArgs } from 'kafkajs';
 import { Observable } from 'rxjs';

integration/microservices/src/kafka/kafka.controller.ts

@@ -2,11 +2,11 @@ import {
   Body,
   Controller,
   HttpCode,
+  Logger,
   OnModuleDestroy,
   OnModuleInit,
   Post,
 } from '@nestjs/common';
-import { Logger } from '@nestjs/common/services/logger.service';
 import { Client, ClientKafka, Transport } from '@nestjs/microservices';
 import { lastValueFrom, Observable } from 'rxjs';
 import { BusinessDto } from './dtos/business.dto';

integration/microservices/src/kafka/kafka.messages.controller.ts

@@ -1,5 +1,4 @@
-import { Controller } from '@nestjs/common';
-import { Logger } from '@nestjs/common/services/logger.service';
+import { Controller, Logger } from '@nestjs/common';
 import { EventPattern, MessagePattern } from '@nestjs/microservices';
 import { BusinessDto } from './dtos/business.dto';
 import { UserDto } from './dtos/user.dto';

integration/microservices/src/mqtt/mqtt.controller.ts

@@ -93,7 +93,7 @@ export class MqttController {
   @Post('record-builder-duplex')
   @HttpCode(200)
   useRecordBuilderDuplex(@Body() data: Record<string, any>) {
-    const record = new MqttRecordBuilder(data).setQoS(2).build();
+    const record = new MqttRecordBuilder(data).setQoS(1).build();
     return this.client.send('record-builder-duplex', record);
   }
 

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

@@ -1,5 +1,4 @@
-import { INestApplication } from '@nestjs/common';
-import { RequestMethod } from '@nestjs/common/enums/request-method.enum';
+import { INestApplication, RequestMethod } from '@nestjs/common';
 import { Test } from '@nestjs/testing';
 import * as request from 'supertest';
 import {

integration/scopes/src/resolve-scoped/logger.provider.ts

@@ -1,4 +1,4 @@
-import { FactoryProvider } from '@nestjs/common/interfaces';
+import { FactoryProvider } from '@nestjs/common';
 
 export const LOGGER_PROVIDER = 'LOGGER_PROVIDER';
 export const loggerProvider: FactoryProvider = {

integration/send-files/e2e/express.spec.ts

@@ -9,7 +9,8 @@ import { join } from 'path';
 import * as request from 'supertest';
 import { AppModule } from '../src/app.module';
 
-const readmeString = readFileSync(join(process.cwd(), 'Readme.md')).toString();
+const readme = readFileSync(join(process.cwd(), 'Readme.md'));
+const readmeString = readme.toString();
 
 describe('Express FileSend', () => {
   let app: NestExpressApplication;
@@ -53,12 +54,13 @@ describe('Express FileSend', () => {
         expect(res.body.toString()).to.be.eq(readmeString);
       });
   });
-  it('should return a file with correct content type and disposition', async () => {
+  it('should return a file with correct headers', async () => {
     return request(app.getHttpServer())
       .get('/file/with/headers')
       .expect(200)
       .expect('Content-Type', 'text/markdown')
       .expect('Content-Disposition', 'attachment; filename="Readme.md"')
+      .expect('Content-Length', readme.byteLength.toString())
       .expect(res => {
         expect(res.text).to.be.eq(readmeString);
       });

integration/send-files/e2e/fastify.spec.ts

@@ -8,7 +8,8 @@ import { readFileSync } from 'fs';
 import { join } from 'path';
 import { AppModule } from '../src/app.module';
 
-const readmeString = readFileSync(join(process.cwd(), 'Readme.md')).toString();
+const readme = readFileSync(join(process.cwd(), 'Readme.md'));
+const readmeString = readme.toString();
 
 describe('Fastify FileSend', () => {
   let app: NestFastifyApplication;
@@ -67,4 +68,17 @@ describe('Fastify FileSend', () => {
         expect(payload.toString()).to.be.eq(readmeString);
       });
   });
+  it('should return a file with correct headers', async () => {
+    return app
+      .inject({ url: '/file/with/headers', method: 'get' })
+      .then(({ statusCode, headers, payload }) => {
+        expect(statusCode).to.equal(200);
+        expect(headers['content-type']).to.equal('text/markdown');
+        expect(headers['content-disposition']).to.equal(
+          'attachment; filename="Readme.md"',
+        );
+        expect(headers['content-length']).to.equal(readme.byteLength);
+        expect(payload).to.equal(readmeString);
+      });
+  });
 });

integration/send-files/src/app.service.ts

@@ -25,11 +25,13 @@ export class AppService {
   }
 
   getFileWithHeaders(): StreamableFile {
+    const file = readFileSync(join(process.cwd(), 'Readme.md'));
     return new StreamableFile(
       createReadStream(join(process.cwd(), 'Readme.md')),
       {
         type: 'text/markdown',
         disposition: 'attachment; filename="Readme.md"',
+        length: file.byteLength,
       },
     );
   }

integration/versioning/e2e/custom-versioning-fastify.spec.ts

@@ -0,0 +1,967 @@
+import { INestApplication, VersioningType } from '@nestjs/common';
+import {
+  FastifyAdapter,
+  NestFastifyApplication,
+} from '@nestjs/platform-fastify';
+import { Test } from '@nestjs/testing';
+import { FastifyRequest } from 'fastify';
+import * as request from 'supertest';
+import { AppModule } from '../src/app.module';
+
+describe('Custom Versioning (fastify)', () => {
+  const extractor = (request: FastifyRequest): string | string[] => {
+    const versions = [request.headers['accept'] ?? '']
+      .flatMap(v => v.split(','))
+      .map(header => header.match(/v(\d+\.?\d*)\+json$/))
+      .filter(match => match && match.length)
+      .map(matchArray => matchArray[1])
+      .sort()
+      .reverse();
+
+    return versions;
+  };
+  let app: INestApplication;
+
+  // ======================================================================== //
+  describe('without global default version', () => {
+    before(async () => {
+      const moduleRef = await Test.createTestingModule({
+        imports: [AppModule],
+      }).compile();
+
+      app = moduleRef.createNestApplication<NestFastifyApplication>(
+        new FastifyAdapter(),
+      );
+      app.enableVersioning({
+        type: VersioningType.CUSTOM,
+        extractor,
+      });
+      await app.init();
+      await app.getHttpAdapter().getInstance().ready();
+    });
+
+    describe('GET /', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Hello World V1!');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Hello World V2!');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Hello World V2!');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Hello World V2!');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/').expect(404);
+      });
+    });
+
+    describe('GET /:param', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Parameter V1!');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Parameter V2!');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Parameter V2!');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Parameter V2!');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: '',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/').expect(404);
+      });
+    });
+
+    describe('GET /multiple', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/multiple').expect(404);
+      });
+    });
+
+    describe('GET /neutral', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .expect(200)
+          .expect('Neutral');
+      });
+    });
+
+    describe('GET /override', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Override Version 1');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Override Version 2');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Override Version 2');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Override Version 2');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/override').expect(404);
+      });
+    });
+
+    describe('GET /override-partial', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Override Partial Version 1');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Override Partial Version 2');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Override Partial Version 2');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Override Partial Version 2');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .expect(404);
+      });
+    });
+
+    describe('GET /foo/bar', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+    });
+
+    after(async () => {
+      await app.close();
+    });
+  });
+
+  // ======================================================================== //
+  describe('with the global default version: "1"', () => {
+    before(async () => {
+      const moduleRef = await Test.createTestingModule({
+        imports: [AppModule],
+      }).compile();
+
+      app = moduleRef.createNestApplication<NestFastifyApplication>(
+        new FastifyAdapter(),
+      );
+      app.enableVersioning({
+        type: VersioningType.CUSTOM,
+        extractor,
+        defaultVersion: '1',
+      });
+      await app.init();
+      await app.getHttpAdapter().getInstance().ready();
+    });
+
+    describe('GET /', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Hello World V1!');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Hello World V2!');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Hello World V2!');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Hello World V2!');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/').expect(404);
+      });
+    });
+
+    describe('GET /:param', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Parameter V1!');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Parameter V2!');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Parameter V2!');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Parameter V2!');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: '',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/').expect(404);
+      });
+    });
+
+    describe('GET /multiple', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/multiple').expect(404);
+      });
+    });
+
+    describe('GET /neutral', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .expect(200)
+          .expect('Neutral');
+      });
+    });
+
+    describe('GET /override', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Override Version 1');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Override Version 2');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Override Version 2');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Override Version 2');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/override').expect(404);
+      });
+    });
+
+    describe('GET /override-partial', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Override Partial Version 1');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Override Partial Version 2');
+      });
+
+      it('V2, if two versions are requested, select the highest version', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Override Partial Version 2');
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept:
+              'application/foo.v1+json, application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Override Partial Version 2');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .expect(404);
+      });
+    });
+
+    describe('GET /foo/bar', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(404);
+      });
+
+      it('V2, if a non-existent version is requested, select the highest supported version', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v1+json, application/foo.v2+json',
+          })
+          .expect('Hello FooBar!');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/foo/bar').expect(404);
+      });
+    });
+
+    after(async () => {
+      await app.close();
+    });
+  });
+});

integration/versioning/e2e/custom-versioning.spec.ts

@@ -0,0 +1,712 @@
+import { INestApplication, VersioningType } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { Request } from 'express';
+import * as request from 'supertest';
+import { AppModule } from '../src/app.module';
+
+describe('Custom Versioning', () => {
+  const extractor = (request: Request): string | string[] => {
+    const versions = request
+      .header('Accept')
+      ?.split(',')
+      .map(header => header.match(/v(\d+\.?\d*)\+json$/))
+      .filter(match => match && match.length)
+      .map(matchArray => matchArray[1])
+      .sort()
+      .reverse();
+
+    return versions;
+  };
+  let app: INestApplication;
+
+  // ======================================================================== //
+  describe('without global default version', () => {
+    before(async () => {
+      const moduleRef = await Test.createTestingModule({
+        imports: [AppModule],
+      }).compile();
+
+      app = moduleRef.createNestApplication();
+      app.enableVersioning({
+        type: VersioningType.CUSTOM,
+        extractor,
+      });
+      await app.init();
+    });
+
+    describe('GET /', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Hello World V1!');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Hello World V2!');
+      });
+
+      // There's a known limitation of the express-adapter, where
+      // it cannot handle selection of the highest matched version properly.
+      //
+      // it('V2, if two versions are requested, select the highest version', () => {
+      //   return request(app.getHttpServer())
+      //     .get('/')
+      //     .set({
+      //       Accept: 'application/foo.v1+json, application/foo.v2+json',
+      //     })
+      //     .expect(200)
+      //     .expect('Hello World V2!');
+      // });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/').expect(404);
+      });
+    });
+
+    describe('GET /:param', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Parameter V1!');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Parameter V2!');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: '',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/').expect(404);
+      });
+    });
+
+    describe('GET /multiple', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V2, if an unsupported version is specified, select the lower supported version', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v2+json, application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/multiple').expect(404);
+      });
+    });
+
+    describe('GET /neutral', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .expect(200)
+          .expect('Neutral');
+      });
+    });
+
+    describe('GET /override', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Override Version 1');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Override Version 2');
+      });
+
+      // There's a known limitation of the express-adapter, where
+      // it cannot handle selection of the highest matched version properly.
+      //
+      // it('V2, if two versions are requested, select the highest version', () => {
+      //   return request(app.getHttpServer())
+      //     .get('/override')
+      //     .set({
+      //       Accept: 'application/foo.v1+json, application/foo.v2+json',
+      //     })
+      //     .expect(200)
+      //     .expect('Override Version 2');
+      // });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/override').expect(404);
+      });
+    });
+
+    describe('GET /override-partial', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Override Partial Version 1');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Override Partial Version 2');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .expect(404);
+      });
+    });
+
+    describe('GET /foo/bar', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+    });
+
+    after(async () => {
+      await app.close();
+    });
+  });
+
+  // ======================================================================== //
+  describe('with the global default version: "1"', () => {
+    before(async () => {
+      const moduleRef = await Test.createTestingModule({
+        imports: [AppModule],
+      }).compile();
+
+      app = moduleRef.createNestApplication();
+      app.enableVersioning({
+        type: VersioningType.CUSTOM,
+        extractor,
+        defaultVersion: '1',
+      });
+      await app.init();
+    });
+
+    describe('GET /', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Hello World V1!');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Hello World V2!');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/').expect(404);
+      });
+    });
+
+    describe('GET /:param', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Parameter V1!');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Parameter V2!');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/param/hello')
+          .set({
+            Accept: '',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/').expect(404);
+      });
+    });
+
+    describe('GET /multiple', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Multiple Versions 1 or 2');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/multiple')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/multiple').expect(404);
+      });
+    });
+
+    describe('GET /neutral', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(200)
+          .expect('Neutral');
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer())
+          .get('/neutral')
+          .expect(200)
+          .expect('Neutral');
+      });
+    });
+
+    describe('GET /override', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Override Version 1');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Override Version 2');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/override')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/override').expect(404);
+      });
+    });
+
+    describe('GET /override-partial', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Override Partial Version 1');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(200)
+          .expect('Override Partial Version 2');
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer())
+          .get('/override-partial')
+          .expect(404);
+      });
+    });
+
+    describe('GET /foo/bar', () => {
+      it('V1', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v1+json',
+          })
+          .expect(200)
+          .expect('Hello FooBar!');
+      });
+
+      it('V2', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v2+json',
+          })
+          .expect(404);
+      });
+
+      it('V3', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/foo.v3+json',
+          })
+          .expect(404);
+      });
+
+      it('No Version', () => {
+        return request(app.getHttpServer())
+          .get('/foo/bar')
+          .set({
+            Accept: 'application/json',
+          })
+          .expect(404);
+      });
+
+      it('No Header', () => {
+        return request(app.getHttpServer()).get('/foo/bar').expect(404);
+      });
+    });
+
+    after(async () => {
+      await app.close();
+    });
+  });
+});

lerna.json

@@ -3,5 +3,5 @@
   "packages": [
     "packages/*"
   ],
-  "version": "8.2.2"
+  "version": "8.3.1"
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "8.2.1",
+  "version": "8.3.1",
   "description": "Modern, fast, powerful node.js web framework",
   "homepage": "https://nestjs.com",
   "repository": {
@@ -39,13 +39,8 @@
     "publish:beta": "npm run prerelease && npm run build:prod && ./node_modules/.bin/lerna publish --npm-tag=beta --access public -m \"chore(@nestjs) publish %s release\"",
     "publish:next": "npm run prerelease && npm run build:prod && ./node_modules/.bin/lerna publish --npm-tag=next --access public --skip-git -m \"chore(@nestjs) publish %s release\"",
     "publish:rc": "npm run prerelease && npm run build:prod && ./node_modules/.bin/lerna publish --npm-tag=rc --access public -m \"chore(@nestjs) publish %s release\"",
-    "publish:test": "npm run prerelease && npm run build:prod && ./node_modules/.bin/lerna publish --force-publish --access public --npm-tag=test --skip-git -m \"chore(@nestjs) publish %s release\""
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged",
-      "commit-msg": "commitlint -c .commitlintrc.json -E HUSKY_GIT_PARAMS"
-    }
+    "publish:test": "npm run prerelease && npm run build:prod && ./node_modules/.bin/lerna publish --force-publish --access public --npm-tag=test --skip-git -m \"chore(@nestjs) publish %s release\"",
+    "prepare": "husky install"
   },
   "lint-staged": {
     "packages/**/*.{ts,json}": [
@@ -54,79 +49,80 @@
   },
   "dependencies": {
     "@nuxtjs/opencollective": "0.3.2",
-    "axios": "0.24.0",
-    "class-transformer": "0.4.0",
-    "class-validator": "0.13.1",
+    "axios": "0.26.0",
+    "class-transformer": "0.5.1",
+    "class-validator": "0.13.2",
     "cli-color": "2.0.1",
     "cors": "2.8.5",
-    "express": "4.17.1",
-    "fast-json-stringify": "2.7.12",
+    "express": "4.17.3",
+    "fast-json-stringify": "3.0.3",
     "fast-safe-stringify": "2.1.1",
     "graphql-subscriptions": "2.0.0",
     "iterare": "1.2.1",
-    "object-hash": "2.2.0",
+    "object-hash": "3.0.0",
     "path-to-regexp": "3.2.0",
     "reflect-metadata": "0.1.13",
-    "rxjs": "7.4.0",
-    "socket.io": "4.3.2",
+    "rxjs": "7.5.4",
+    "socket.io": "4.4.1",
     "tslib": "2.3.1",
     "uuid": "8.3.2"
   },
   "devDependencies": {
     "@codechecks/client": "0.1.12",
-    "@commitlint/cli": "14.1.0",
-    "@commitlint/config-angular": "14.1.0",
-    "@grpc/grpc-js": "1.4.4",
-    "@grpc/proto-loader": "0.6.6",
-    "@nestjs/graphql": "9.1.1",
-    "@nestjs/mongoose": "9.0.1",
-    "@nestjs/typeorm": "8.0.2",
+    "@commitlint/cli": "16.2.1",
+    "@commitlint/config-angular": "16.2.1",
+    "@grpc/grpc-js": "1.5.7",
+    "@grpc/proto-loader": "0.6.9",
+    "@nestjs/apollo": "10.0.5",
+    "@nestjs/graphql": "10.0.5",
+    "@nestjs/mongoose": "9.0.2",
+    "@nestjs/typeorm": "8.0.3",
     "@types/amqplib": "0.8.2",
     "@types/bytes": "3.1.1",
-    "@types/cache-manager": "3.4.2",
-    "@types/chai": "4.2.22",
-    "@types/chai-as-promised": "7.1.4",
+    "@types/cache-manager": "3.4.3",
+    "@types/chai": "4.3.0",
+    "@types/chai-as-promised": "7.1.5",
     "@types/cors": "2.8.12",
     "@types/express": "4.17.13",
     "@types/gulp": "4.0.9",
-    "@types/http-errors": "1.8.1",
-    "@types/mocha": "9.0.0",
-    "@types/node": "16.11.7",
-    "@types/redis": "2.8.32",
+    "@types/http-errors": "1.8.2",
+    "@types/mocha": "9.1.0",
+    "@types/node": "17.0.21",
+    "@types/redis": "4.0.11",
     "@types/reflect-metadata": "0.1.0",
-    "@types/sinon": "10.0.6",
+    "@types/sinon": "10.0.11",
     "@types/socket.io": "3.0.2",
-    "@types/ws": "8.2.0",
+    "@types/ws": "8.5.1",
     "@typescript-eslint/eslint-plugin": "4.33.0",
     "@typescript-eslint/parser": "4.33.0",
-    "amqp-connection-manager": "3.7.0",
+    "amqp-connection-manager": "4.1.1",
     "amqplib": "0.8.0",
-    "apollo-server-core": "3.5.0",
-    "apollo-server-express": "3.5.0",
+    "apollo-server-core": "3.6.3",
+    "apollo-server-express": "3.6.3",
     "artillery": "1.7.9",
-    "body-parser": "1.19.0",
-    "bytes": "3.1.1",
+    "body-parser": "1.19.2",
+    "bytes": "3.1.2",
     "cache-manager": "3.6.0",
     "cache-manager-redis-store": "2.0.0",
-    "chai": "4.3.4",
+    "chai": "4.3.6",
     "chai-as-promised": "7.1.1",
     "clang-format": "1.6.0",
     "commitlint-circle": "1.0.0",
-    "concurrently": "6.4.0",
-    "conventional-changelog": "3.1.24",
-    "core-js": "3.19.1",
+    "concurrently": "7.0.0",
+    "conventional-changelog": "3.1.25",
+    "core-js": "3.21.1",
     "coveralls": "3.1.1",
     "delete-empty": "3.0.0",
     "engine.io-client": "6.1.1",
     "eslint": "7.32.0",
-    "eslint-config-prettier": "8.3.0",
-    "eslint-plugin-import": "2.25.3",
+    "eslint-config-prettier": "8.4.0",
+    "eslint-plugin-import": "2.25.4",
     "eventsource": "1.1.0",
-    "fancy-log": "1.3.3",
-    "fastify": "3.24.0",
-    "fastify-cors": "6.0.2",
+    "fancy-log": "2.0.0",
+    "fastify": "3.27.2",
+    "fastify-cors": "6.0.3",
     "fastify-formbody": "5.2.0",
-    "fastify-multipart": "5.1.0",
+    "fastify-multipart": "5.3.1",
     "fastify-static": "4.5.0",
     "graphql": "15.7.2",
     "graphql-tools": "7.0.5",
@@ -136,41 +132,41 @@
     "gulp-sourcemaps": "3.0.0",
     "gulp-typescript": "5.0.1",
     "gulp-watch": "5.0.1",
-    "http-errors": "1.8.1",
+    "http-errors": "2.0.0",
     "husky": "7.0.4",
     "imports-loader": "3.1.1",
     "json-loader": "0.5.7",
-    "kafkajs": "1.15.0",
+    "kafkajs": "1.16.0",
     "lerna": "2.11.0",
     "lerna-changelog": "2.2.0",
-    "light-my-request": "4.6.0",
-    "lint-staged": "12.0.2",
+    "light-my-request": "4.8.0",
+    "lint-staged": "12.3.4",
     "markdown-table": "2.0.0",
     "merge-graphql-schemas": "1.7.8",
-    "middie": "5.3.0",
-    "mocha": "9.1.3",
-    "mongoose": "6.0.13",
-    "mqtt": "4.2.8",
-    "multer": "1.4.3",
+    "middie": "6.0.0",
+    "mocha": "9.2.1",
+    "mongoose": "6.2.4",
+    "mqtt": "4.3.6",
+    "multer": "1.4.4",
     "mysql2": "2.3.3",
-    "nats": "2.4.0",
+    "nats": "2.6.1",
     "nodemon": "2.0.15",
     "nyc": "15.1.0",
-    "point-of-view": "4.15.2",
-    "prettier": "2.4.1",
+    "point-of-view": "5.1.0",
+    "prettier": "2.5.1",
     "redis": "3.1.2",
     "rxjs-compat": "6.6.7",
-    "sinon": "12.0.1",
+    "sinon": "13.0.1",
     "sinon-chai": "3.7.0",
-    "socket.io-client": "4.3.2",
+    "socket.io-client": "4.4.1",
     "subscriptions-transport-ws": "0.11.0",
-    "supertest": "6.1.6",
-    "ts-morph": "12.2.0",
-    "ts-node": "10.4.0",
-    "typeorm": "0.2.40",
+    "supertest": "6.2.2",
+    "ts-morph": "13.0.3",
+    "ts-node": "10.5.0",
+    "typeorm": "0.2.44",
     "typescript": "4.3.5",
     "wrk": "1.2.1",
-    "ws": "7.5.5"
+    "ws": "7.5.6"
   },
   "engines": {
     "node": ">= 10.13.0"
@@ -188,6 +184,7 @@
       "type: bug :sob:": "Bug fixes",
       "type: enhancement :wolf:": "Enhancements",
       "type: docs :page_facing_up:": "Docs",
+      "type: code style": "Code style tweaks",
       "dependencies": "Dependencies"
     }
   },

packages/common/CHANGELOG.md

@@ -1,18 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
-
-<a name="8.2.0"></a>
-# [8.2.0](https://github.com/nestjs/nest/compare/v8.1.2...v8.2.0) (2021-11-08)
-
-
-### Bug Fixes
-
-* **deps:** update dependency axios to v0.24.0 ([fc77e4f](https://github.com/nestjs/nest/commit/fc77e4f))
-
-
-### Features
-
-* **common:** add the ability to set some extra metadata about returned files ([5100573](https://github.com/nestjs/nest/commit/5100573))
-* **common:** allow to swap out class-validator and class-transformer ([2a1cc62](https://github.com/nestjs/nest/commit/2a1cc62))

packages/common/Readme.md

@@ -57,10 +57,13 @@ With official support, you can get expert help straight from Nest core team. We
 Nest is an MIT-licensed open source project. It can grow thanks to the sponsors and support by the amazing backers. If you'd like to join them, please [read more here](https://docs.nestjs.com/support).
 
 #### Principal Sponsors
-<table style="text-align:center;"><tr><td>
+<table style="text-align:center;"><tr>
+  <td><a href="https://trilon.io" target="_blank"><img src="https://nestjs.com/img/trilon.svg" width="200" valign="middle" /></a></td>
+  <td><a href="https://www.redhat.com" target="_blank"><img src="https://nestjs.com/img/red-hat-logo.svg" width="200" valign="middle" /></a></td>
+<td>
 <a href="https://github.com/Sanofi-IADC" target="_blank"><img src="https://docs.nestjs.com/assets/sponsors/sanofi.png" width="180" valign="middle" /></a></td>
 <td>
-<a href="https://trilon.io" target="_blank"><img src="https://nestjs.com/img/trilon.svg" width="200" valign="middle" /></a></td>
+<a href="https://nx.dev" target="_blank"><img src="https://nestjs.com/img/nx-logo.png" height="45" valign="middle" /></a></td>
 </tr></table>
 
 #### Gold Sponsors
@@ -78,10 +81,11 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 <table style="text-align:center;"><tr><td>
 <a href="https://neoteric.eu/" target="_blank"><img src="https://nestjs.com/img/neoteric-cut.png" width="120" valign="middle" /></a> </td><td>
   <a href="http://gojob.com" target="_blank"><img src="http://nestjs.com/img/gojob-logo.png" valign="middle" width="100" /></a> </td><td>
-<a href="http://www.leogistics.com" target="_blank"><img src="https://nestjs.com/img/leogistics-logo.jpeg" width="150" valign="middle" /></td><td>
+<a href="https://www.myleodsc.com/" target="_blank"><img src="https://nestjs.com/img/myleo-logo.png" width="180" valign="middle" /></td><td>
 <a href="https://careers.meetdandy.com/?gh_src=063ba61e3us" target="_blank"><img src="https://nestjs.com/img/dandy-roles-logo.svg" width="150" valign="middle" /></td><td>
 <a href="https://www.castlecraft.in" target="_blank"><img src="https://nestjs.com/img/castlecraft-logo.png" width="150" valign="middle" /></td>
-<td><a href="https://www.tinystacks.com" target="_blank"><img src="https://nestjs.com/img/tinystacks-logo.png#1" width="140" valign="middle" /></td></tr></table>
+<td><a href="https://www.tinystacks.com" target="_blank"><img src="https://nestjs.com/img/tinystacks-logo.png#1" width="140" valign="middle" /></td>
+<td><a href="https://n.inc" target="_blank"><img src="https://nestjs.com/img/n-inc-logo.svg" width="120" valign="middle" /></td></tr></table>
 
 #### Sponsors
 
@@ -113,6 +117,13 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
   <td align="center" valign="middle"><a href="https://studyclerk.com/pay-for-research-paper" target="_blank"><img src="https://nestjs.com/img/studyclerk-logo.png" width="125" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://xyndata.com" target="_blank"><img src="https://nestjs.com/img/xyndata-logo.png" width="125" valign="middle" /></a></td></tr><tr>
   <td align="center" valign="middle"><a href="https://www.anonymistic.com/" target="_blank"><img src="https://nestjs.com/img/anonymistic-logo.png" width="125" valign="middle" /></a></td>
 <td align="center" valign="middle"><a href="https://www.naologic.com/" target="_blank"><img src="https://nestjs.com/img/naologic-logo.svg" width="125" valign="middle" /></a></td>
+  <td align="center" valign="middle"><a href="https://messaged.com/" target="_blank"><img src="https://nestjs.com/img/messaged-logo.png" width="50" valign="middle" /></a></td>
+  <td align="center" valign="middle"><a href="https://triplecore.io" target="_blank"><img src="https://nestjs.com/img/triplecore-logo.svg" width="50" valign="middle" /></a></td>
+   <td align="center" valign="middle"><a href="https://klqc.de" target="_blank"><img src="https://nestjs.com/img/klcqcl-logo.png" width="120" valign="middle" /></a></td>
+   <td align="center" valign="middle"><a href="https://thecasinowizard.com/bonuses/no-deposit-bonuses/" target="_blank"><img src="https://nestjs.com/img/casinowizard-logo.png" width="120" valign="middle" /></a></td></tr><tr>
+     <td align="center" valign="middle"><a href="https://polygon-software.ch/" target="_blank"><img src="https://nestjs.com/img/polygon-logo.svg" width="120" valign="middle" /></a></td>
+   <td align="center" valign="middle"><a href="https://mobilereality.pl/" target="_blank"><img src="https://nestjs.com/img/mobile-reality-logo.png" width="45" valign="middle" /></a></td>
+     <td align="center" valign="middle"><a href="https://boringowl.io/" target="_blank"><img src="https://nestjs.com/img/boringowl-logo.svg" width="120" valign="middle" /></a></td>
   </tr></table>
 
 ## Backers

packages/common/constants.ts

@@ -29,3 +29,6 @@ export const REDIRECT_METADATA = '__redirect__';
 export const RESPONSE_PASSTHROUGH_METADATA = '__responsePassthrough__';
 export const SSE_METADATA = '__sse__';
 export const VERSION_METADATA = '__version__';
+export const INJECTABLE_WATERMARK = '__injectable__';
+export const CONTROLLER_WATERMARK = '__controller__';
+export const CATCH_WATERMARK = '__catch__';

packages/common/decorators/core/catch.decorator.ts

@@ -1,5 +1,5 @@
-import { FILTER_CATCH_EXCEPTIONS } from '../../constants';
-import { Type } from '../../interfaces';
+import { CATCH_WATERMARK, FILTER_CATCH_EXCEPTIONS } from '../../constants';
+import { Type, Abstract } from '../../interfaces';
 
 /**
  * Decorator that marks a class as a Nest exception filter. An exception filter
@@ -18,8 +18,11 @@ import { Type } from '../../interfaces';
  *
  * @publicApi
  */
-export function Catch(...exceptions: Type<any>[]): ClassDecorator {
+export function Catch(
+  ...exceptions: Array<Type<any> | Abstract<any>>
+): ClassDecorator {
   return (target: object) => {
+    Reflect.defineMetadata(CATCH_WATERMARK, true, target);
     Reflect.defineMetadata(FILTER_CATCH_EXCEPTIONS, exceptions, target);
   };
 }

packages/common/decorators/core/controller.decorator.ts

@@ -1,4 +1,5 @@
 import {
+  CONTROLLER_WATERMARK,
   HOST_METADATA,
   PATH_METADATA,
   SCOPE_OPTIONS_METADATA,
@@ -163,10 +164,13 @@ export function Controller(
         prefixOrOptions.path || defaultPath,
         prefixOrOptions.host,
         { scope: prefixOrOptions.scope },
-        prefixOrOptions.version,
+        Array.isArray(prefixOrOptions.version)
+          ? Array.from(new Set(prefixOrOptions.version))
+          : prefixOrOptions.version,
       ];
 
   return (target: object) => {
+    Reflect.defineMetadata(CONTROLLER_WATERMARK, true, target);
     Reflect.defineMetadata(PATH_METADATA, path, target);
     Reflect.defineMetadata(HOST_METADATA, host, target);
     Reflect.defineMetadata(SCOPE_OPTIONS_METADATA, scopeOptions, target);

packages/common/decorators/core/injectable.decorator.ts

@@ -1,5 +1,5 @@
 import { v4 as uuid } from 'uuid';
-import { SCOPE_OPTIONS_METADATA } from '../../constants';
+import { INJECTABLE_WATERMARK, SCOPE_OPTIONS_METADATA } from '../../constants';
 import { ScopeOptions } from '../../interfaces/scope-options.interface';
 import { Type } from '../../interfaces/type.interface';
 
@@ -42,6 +42,7 @@ export type InjectableOptions = ScopeOptions;
  */
 export function Injectable(options?: InjectableOptions): ClassDecorator {
   return (target: object) => {
+    Reflect.defineMetadata(INJECTABLE_WATERMARK, true, target);
     Reflect.defineMetadata(SCOPE_OPTIONS_METADATA, options, target);
   };
 }

packages/common/decorators/core/version.decorator.ts

@@ -7,6 +7,11 @@ import { VersionValue } from '../../interfaces/version-options.interface';
  * @publicApi
  */
 export function Version(version: VersionValue): MethodDecorator {
+  if (Array.isArray(version)) {
+    // Drop duplicated versions
+    version = Array.from(new Set(version));
+  }
+
   return (
     target: any,
     key: string | symbol,

packages/common/decorators/modules/module.decorator.ts

@@ -5,7 +5,7 @@ import { validateModuleKeys } from '../../utils/validate-module-keys.util';
  * Decorator that marks a class as a [module](https://docs.nestjs.com/modules).
  *
  * Modules are used by Nest to organize the application structure into scopes. Controllers
- * and Providers are scoped by the module they are declared in.  Modules and their
+ * and Providers are scoped by the module they are declared in. Modules and their
  * classes (Controllers and Providers) form a graph that determines how Nest
  * performs [Dependency Injection (DI)](https://docs.nestjs.com/providers#dependency-injection).
  *

packages/common/enums/version-type.enum.ts

@@ -5,4 +5,5 @@ export enum VersioningType {
   URI,
   HEADER,
   MEDIA_TYPE,
+  CUSTOM,
 }

packages/common/file-stream/streamable-file.ts

@@ -1,23 +1,22 @@
 import { Readable } from 'stream';
+import { types } from 'util';
+import { isFunction } from '../utils/shared.utils';
 import { StreamableFileOptions } from './streamable-options.interface';
 
 export class StreamableFile {
   private readonly stream: Readable;
 
-  constructor(buffer: Buffer, options?: StreamableFileOptions);
+  constructor(buffer: Uint8Array, options?: StreamableFileOptions);
   constructor(readable: Readable, options?: StreamableFileOptions);
   constructor(
-    bufferOrReadStream: Buffer | Readable,
+    bufferOrReadStream: Uint8Array | Readable,
     readonly options: StreamableFileOptions = {},
   ) {
-    if (Buffer.isBuffer(bufferOrReadStream)) {
+    if (types.isUint8Array(bufferOrReadStream)) {
       this.stream = new Readable();
       this.stream.push(bufferOrReadStream);
       this.stream.push(null);
-    } else if (
-      bufferOrReadStream.pipe &&
-      typeof bufferOrReadStream.pipe === 'function'
-    ) {
+    } else if (bufferOrReadStream.pipe && isFunction(bufferOrReadStream.pipe)) {
       this.stream = bufferOrReadStream;
     }
   }
@@ -27,8 +26,15 @@ export class StreamableFile {
   }
 
   getHeaders() {
-    const { type = 'application/octet-stream', disposition = null } =
-      this.options;
-    return { type, disposition };
+    const {
+      type = 'application/octet-stream',
+      disposition = undefined,
+      length = undefined,
+    } = this.options;
+    return {
+      type,
+      disposition,
+      length,
+    };
   }
 }

packages/common/file-stream/streamable-options.interface.ts

@@ -1,4 +1,5 @@
 export interface StreamableFileOptions {
   type?: string;
   disposition?: string;
-}
+  length?: number;
+}

packages/common/index.ts

@@ -31,6 +31,7 @@ export {
   INestApplication,
   INestApplicationContext,
   INestMicroservice,
+  InjectionToken,
   IntrospectionResult,
   MessageEvent,
   MiddlewareConsumer,
@@ -44,6 +45,7 @@ export {
   OnApplicationShutdown,
   OnModuleDestroy,
   OnModuleInit,
+  OptionalFactoryDependency,
   Paramtype,
   PipeTransform,
   Provider,

packages/common/interfaces/middleware/nest-middleware.interface.ts

@@ -1,3 +1,3 @@
 export interface NestMiddleware<TRequest = any, TResponse = any> {
-  use(req: TRequest, res: TResponse, next: () => void): any;
+  use(req: TRequest, res: TResponse, next: (error?: Error | any) => void): any;
 }

packages/common/interfaces/modules/index.ts

@@ -1,6 +1,8 @@
 export * from './dynamic-module.interface';
 export * from './forward-reference.interface';
+export * from './injection-token.interface';
 export * from './introspection-result.interface';
 export * from './module-metadata.interface';
 export * from './nest-module.interface';
+export * from './optional-factory-dependency.interface';
 export * from './provider.interface';

packages/common/interfaces/modules/injection-token.interface.ts

@@ -0,0 +1,9 @@
+import { Abstract } from '../abstract.interface';
+import { Type } from '../type.interface';
+
+export type InjectionToken =
+  | string
+  | symbol
+  | Type<any>
+  | Abstract<any>
+  | Function;

packages/common/interfaces/modules/optional-factory-dependency.interface.ts

@@ -0,0 +1,6 @@
+import { InjectionToken } from './injection-token.interface';
+
+export type OptionalFactoryDependency = {
+  token: InjectionToken;
+  optional: boolean;
+};

packages/common/interfaces/modules/provider.interface.ts

@@ -1,6 +1,7 @@
-import { Abstract } from '../abstract.interface';
 import { Scope } from '../scope-options.interface';
 import { Type } from '../type.interface';
+import { InjectionToken } from './injection-token.interface';
+import { OptionalFactoryDependency } from './optional-factory-dependency.interface';
 
 /**
  *
@@ -36,7 +37,7 @@ export interface ClassProvider<T = any> {
   /**
    * Injection token
    */
-  provide: string | symbol | Type<any> | Abstract<any> | Function;
+  provide: InjectionToken;
   /**
    * Type (class name) of provider (instance to be injected).
    */
@@ -66,7 +67,7 @@ export interface ValueProvider<T = any> {
   /**
    * Injection token
    */
-  provide: string | symbol | Type<any> | Abstract<any> | Function;
+  provide: InjectionToken;
   /**
    * Instance of a provider to be injected.
    */
@@ -97,7 +98,7 @@ export interface FactoryProvider<T = any> {
   /**
    * Injection token
    */
-  provide: string | symbol | Type<any> | Abstract<any> | Function;
+  provide: InjectionToken;
   /**
    * Factory function that returns an instance of the provider to be injected.
    */
@@ -105,7 +106,7 @@ export interface FactoryProvider<T = any> {
   /**
    * Optional list of providers to be injected into the context of the Factory function.
    */
-  inject?: Array<Type<any> | string | symbol | Abstract<any> | Function>;
+  inject?: Array<InjectionToken | OptionalFactoryDependency>;
   /**
    * Optional enum defining lifetime of the provider that is returned by the Factory function.
    */
@@ -131,7 +132,7 @@ export interface ExistingProvider<T = any> {
   /**
    * Injection token
    */
-  provide: string | symbol | Type<any> | Abstract<any> | Function;
+  provide: InjectionToken;
   /**
    * Provider to be aliased by the Injection token.
    */

packages/common/interfaces/nest-application-context.interface.ts

@@ -1,6 +1,5 @@
 import { ShutdownSignal } from '../enums/shutdown-signal.enum';
 import { LoggerService, LogLevel } from '../services/logger.service';
-import { Abstract } from './abstract.interface';
 import { DynamicModule } from './modules';
 import { Type } from './type.interface';
 
@@ -21,7 +20,7 @@ export interface INestApplicationContext {
    * @returns {TResult}
    */
   get<TInput = any, TResult = TInput>(
-    typeOrToken: Type<TInput> | Abstract<TInput> | string | symbol,
+    typeOrToken: Type<TInput> | Function | string | symbol,
     options?: { strict: boolean },
   ): TResult;
 
@@ -30,7 +29,7 @@ export interface INestApplicationContext {
    * @returns {Promise<TResult>}
    */
   resolve<TInput = any, TResult = TInput>(
-    typeOrToken: Type<TInput> | Abstract<TInput> | string | symbol,
+    typeOrToken: Type<TInput> | Function | string | symbol,
     contextId?: { id: number },
     options?: { strict: boolean },
   ): Promise<TResult>;
@@ -51,7 +50,8 @@ export interface INestApplicationContext {
   close(): Promise<void>;
 
   /**
-   * Sets custom logger service
+   * Sets custom logger service.
+   * Flushes buffered logs if auto flush is on.
    * @returns {void}
    */
   useLogger(logger: LoggerService | LogLevel[] | false): void;

packages/common/interfaces/version-options.interface.ts

@@ -7,7 +7,10 @@ import { VersioningType } from '../enums/version-type.enum';
  */
 export const VERSION_NEUTRAL = Symbol('VERSION_NEUTRAL');
 
-export type VersionValue = string | string[] | typeof VERSION_NEUTRAL;
+export type VersionValue =
+  | string
+  | typeof VERSION_NEUTRAL
+  | Array<string | typeof VERSION_NEUTRAL>;
 
 /**
  * @publicApi
@@ -55,6 +58,20 @@ export interface MediaTypeVersioningOptions {
   key: string;
 }
 
+export interface CustomVersioningOptions {
+  type: VersioningType.CUSTOM;
+
+  /**
+   * A function that accepts a request object (specific to the underlying platform, ie Express or Fastify)
+   * and returns a single version value or an ordered array of versions, in order from HIGHEST to LOWEST.
+   *
+   * Ex. Returned version array = ['3.1', '3.0', '2.5', '2', '1.9']
+   *
+   * Use type assertion or narrowing to identify the specific request type.
+   */
+  extractor: (request: unknown) => string | string[];
+}
+
 interface VersioningCommonOptions {
   /**
    * The default version to be used as a fallback when you did not provide some
@@ -67,4 +84,9 @@ interface VersioningCommonOptions {
  * @publicApi
  */
 export type VersioningOptions = VersioningCommonOptions &
-  (HeaderVersioningOptions | UriVersioningOptions | MediaTypeVersioningOptions);
+  (
+    | HeaderVersioningOptions
+    | UriVersioningOptions
+    | MediaTypeVersioningOptions
+    | CustomVersioningOptions
+  );

packages/common/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/common",
-  "version": "8.2.2",
+  "version": "8.3.1",
   "description": "Nest - modern, fast, powerful node.js web framework (@common)",
   "author": "Kamil Mysliwiec",
   "homepage": "https://nestjs.com",
@@ -17,7 +17,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "axios": "0.24.0",
+    "axios": "0.26.0",
     "iterare": "1.2.1",
     "tslib": "2.3.1",
     "uuid": "8.3.2"

packages/common/pipes/default-value.pipe.ts

@@ -3,7 +3,7 @@ import {
   ArgumentMetadata,
   PipeTransform,
 } from '../interfaces/features/pipe-transform.interface';
-import { isNil } from '../utils/shared.utils';
+import { isNil, isNumber } from '../utils/shared.utils';
 
 /**
  * Defines the built-in DefaultValue Pipe
@@ -21,7 +21,7 @@ export class DefaultValuePipe<T = any, R = any>
   transform(value?: T, _metadata?: ArgumentMetadata): T | R {
     if (
       isNil(value) ||
-      (typeof value === 'number' && isNaN(value as unknown as number))
+      (isNumber(value) && isNaN(value as unknown as number))
     ) {
       return this.defaultValue;
     }

packages/common/pipes/parse-array.pipe.ts

@@ -7,7 +7,7 @@ import {
   PipeTransform,
 } from '../interfaces/features/pipe-transform.interface';
 import { HttpErrorByCode } from '../utils/http-error-by-code.util';
-import { isNil, isString } from '../utils/shared.utils';
+import { isNil, isUndefined, isString } from '../utils/shared.utils';
 import { ValidationPipe, ValidationPipeOptions } from './validation.pipe';
 
 const VALIDATION_ERROR_MESSAGE = 'Validation failed (parsable array expected)';
@@ -141,21 +141,19 @@ export class ParseArrayPipe implements PipeTransform {
         originalValue !== null && originalValue !== '' ? +originalValue : NaN;
       if (isNaN(value)) {
         throw this.exceptionFactory(
-          `${
-            typeof index !== 'undefined' ? `[${index}] ` : ''
-          }item must be a number`,
+          `${isUndefined(index) ? '' : `[${index}] `}item must be a number`,
         );
       }
       return value;
     } else if (this.options.items === String) {
-      if (typeof originalValue !== 'string') {
+      if (!isString(originalValue)) {
         return `${originalValue}`;
       }
     } else if (this.options.items === Boolean) {
       if (typeof originalValue !== 'boolean') {
         throw this.exceptionFactory(
           `${
-            typeof index !== 'undefined' ? `[${index}] ` : ''
+            isUndefined(index) ? '' : `[${index}] `
           }item must be a boolean value`,
         );
       }

packages/common/pipes/parse-enum.pipe.ts

@@ -59,6 +59,6 @@ export class ParseEnumPipe<T = any> implements PipeTransform<T> {
     const enumValues = Object.keys(this.enumType).map(
       item => this.enumType[item],
     );
-    return enumValues.indexOf(value) >= 0;
+    return enumValues.includes(value);
   }
 }

packages/common/pipes/validation.pipe.ts

@@ -17,7 +17,7 @@ import {
   HttpErrorByCode,
 } from '../utils/http-error-by-code.util';
 import { loadPackage } from '../utils/load-package.util';
-import { isNil } from '../utils/shared.utils';
+import { isNil, isObject } from '../utils/shared.utils';
 
 export interface ValidationPipeOptions extends ValidatorOptions {
   transform?: boolean;
@@ -194,7 +194,7 @@ export class ValidationPipe implements PipeTransform<any> {
     delete value.__proto__;
     const keys = Object.keys(value);
     iterate(keys)
-      .filter(key => typeof value[key] === 'object' && value[key])
+      .filter(key => isObject(value[key]) && value[key])
       .forEach(key => this.stripProtoKeys(value[key]));
   }
 

packages/common/services/console-logger.service.ts

@@ -1,7 +1,7 @@
 import { Injectable } from '../decorators/core/injectable.decorator';
 import { Optional } from '../decorators/core/optional.decorator';
 import { clc, yellow } from '../utils/cli-colors.util';
-import { isPlainObject } from '../utils/shared.utils';
+import { isPlainObject, isString } from '../utils/shared.utils';
 import { LoggerService, LogLevel } from './logger.service';
 import { isLogLevelEnabled } from './utils';
 
@@ -226,7 +226,7 @@ export class ConsoleLogger implements LoggerService {
       return { messages: args, context: this.context };
     }
     const lastElement = args[args.length - 1];
-    const isContext = typeof lastElement === 'string';
+    const isContext = isString(lastElement);
     if (!isContext) {
       return { messages: args, context: this.context };
     }
@@ -242,7 +242,7 @@ export class ConsoleLogger implements LoggerService {
       return { messages, context };
     }
     const lastElement = messages[messages.length - 1];
-    const isStack = typeof lastElement === 'string';
+    const isStack = isString(lastElement);
     if (!isStack) {
       return { messages, context };
     }

packages/common/test/decorators/catch.decorator.spec.ts

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { FILTER_CATCH_EXCEPTIONS } from '../../constants';
+import { CATCH_WATERMARK, FILTER_CATCH_EXCEPTIONS } from '../../constants';
 import { Catch } from '../../decorators/core/catch.decorator';
 
 describe('@Catch', () => {
@@ -8,6 +8,12 @@ describe('@Catch', () => {
   @Catch(...exceptions)
   class Test {}
 
+  it(`should enhance component with "${CATCH_WATERMARK}" metadata`, () => {
+    const catchWatermark = Reflect.getMetadata(CATCH_WATERMARK, Test);
+
+    expect(catchWatermark).to.be.true;
+  });
+
   it('should enhance class with expected exceptions array', () => {
     const metadata = Reflect.getMetadata(FILTER_CATCH_EXCEPTIONS, Test);
     expect(metadata).to.be.eql(exceptions);

packages/common/test/decorators/controller.decorator.spec.ts

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { VERSION_METADATA } from '../../constants';
+import { VERSION_METADATA, CONTROLLER_WATERMARK } from '../../constants';
 import { Controller } from '../../decorators/core/controller.decorator';
 
 describe('@Controller', () => {
@@ -7,13 +7,15 @@ describe('@Controller', () => {
   const reflectedHost = 'api.example.com';
   const reflectedHostArray = ['api1.example.com', 'api2.example.com'];
   const reflectedVersion = '1';
-
-  @Controller(reflectedPath)
-  class Test {}
+  const reflectedVersionWithDuplicates = ['1', '2', '2', '1', '2', '1'];
+  const reflectedVersionWithoutDuplicates = ['1', '2'];
 
   @Controller()
   class EmptyDecorator {}
 
+  @Controller(reflectedPath)
+  class Test {}
+
   @Controller({ path: reflectedPath, host: reflectedHost })
   class PathAndHostDecorator {}
 
@@ -33,6 +35,18 @@ describe('@Controller', () => {
   @Controller({ version: reflectedVersion })
   class VersionOnlyDecorator {}
 
+  @Controller({ version: reflectedVersionWithDuplicates })
+  class VersionOnlyArrayDecorator {}
+
+  it(`should enhance component with "${CONTROLLER_WATERMARK}" metadata`, () => {
+    const controllerWatermark = Reflect.getMetadata(
+      CONTROLLER_WATERMARK,
+      EmptyDecorator,
+    );
+
+    expect(controllerWatermark).to.be.true;
+  });
+
   it('should enhance controller with expected path metadata', () => {
     const path = Reflect.getMetadata('path', Test);
     expect(path).to.be.eql(reflectedPath);
@@ -64,6 +78,11 @@ describe('@Controller', () => {
       VersionOnlyDecorator,
     );
     expect(version2).to.be.eql(reflectedVersion);
+    const version3 = Reflect.getMetadata(
+      VERSION_METADATA,
+      VersionOnlyArrayDecorator,
+    );
+    expect(version3).to.be.eql(reflectedVersionWithoutDuplicates);
   });
 
   it('should set default path when no object passed as param', () => {

packages/common/test/decorators/injectable.decorator.spec.ts

@@ -1,12 +1,24 @@
 import { expect } from 'chai';
+import { SCOPE_OPTIONS_METADATA, INJECTABLE_WATERMARK } from '../../constants';
 import { Injectable, mixin } from '../../index';
 
 describe('@Injectable', () => {
-  @Injectable()
+  const options = {};
+
+  @Injectable(options)
   class TestMiddleware {
-    constructor(param: number, test: string) {}
+    constructor(_param: number, _test: string) {}
   }
 
+  it(`should enhance component with "${INJECTABLE_WATERMARK}" metadata`, () => {
+    const injectableWatermark = Reflect.getMetadata(
+      INJECTABLE_WATERMARK,
+      TestMiddleware,
+    );
+
+    expect(injectableWatermark).to.be.eql(true);
+  });
+
   it('should enhance component with "design:paramtypes" metadata', () => {
     const constructorParams = Reflect.getMetadata(
       'design:paramtypes',
@@ -16,22 +28,33 @@ describe('@Injectable', () => {
     expect(constructorParams[0]).to.be.eql(Number);
     expect(constructorParams[1]).to.be.eql(String);
   });
+
+  it(`should enhance component with "${SCOPE_OPTIONS_METADATA}" metadata`, () => {
+    const constructorParams = Reflect.getMetadata(
+      SCOPE_OPTIONS_METADATA,
+      TestMiddleware,
+    );
+
+    expect(constructorParams).to.be.eql(options);
+  });
 });
 
 describe('mixin', () => {
   @Injectable()
   class Test {
-    constructor(param: number, test: string) {}
+    constructor(_param: number, _test: string) {}
   }
 
   it('should set name of metatype', () => {
     const type = mixin(Test);
+
     expect(type.name).to.not.eql('Test');
   });
 
   it('should not lost the design:parmatypes metadata', () => {
     const type = mixin(Test);
     const constructorParams = Reflect.getMetadata('design:paramtypes', type);
+
     expect(constructorParams[0]).to.be.eql(Number);
     expect(constructorParams[1]).to.be.eql(String);
   });

packages/common/test/decorators/version.decorator.spec.ts

@@ -4,14 +4,27 @@ import { Version } from '../../decorators/core/version.decorator';
 
 describe('@Version', () => {
   const version = '1';
+  const versions = ['1', '2', '2', '1', '2', '1'];
+  const versionsWithoutDuplicates = ['1', '2'];
 
   class Test {
     @Version(version)
-    public static test() {}
+    public static oneVersion() {}
+
+    @Version(versions)
+    public static multipleVersions() {}
   }
 
   it('should enhance method with expected version string', () => {
-    const metadata = Reflect.getMetadata(VERSION_METADATA, Test.test);
+    const metadata = Reflect.getMetadata(VERSION_METADATA, Test.oneVersion);
     expect(metadata).to.be.eql(version);
   });
+
+  it('should enhance method with expected version array', () => {
+    const metadata = Reflect.getMetadata(
+      VERSION_METADATA,
+      Test.multipleVersions,
+    );
+    expect(metadata).to.be.eql(versionsWithoutDuplicates);
+  });
 });

packages/common/test/file-stream/streamable-file.spec.ts

@@ -17,12 +17,48 @@ describe('StreamableFile', () => {
       expect(streamableFile.getStream()).to.equal(stream);
     });
   });
+  describe('when options is empty', () => {
+    it('should return application/octet-stream for type and undefined for others', () => {
+      const stream = new Readable();
+      const streamableFile = new StreamableFile(stream);
+      expect(streamableFile.getHeaders()).to.deep.equal({
+        type: 'application/octet-stream',
+        disposition: undefined,
+        length: undefined,
+      });
+    });
+  });
+  describe('when options is defined', () => {
+    it('should pass provided headers', () => {
+      const stream = new Readable();
+      const streamableFile = new StreamableFile(stream, {
+        type: 'application/pdf',
+        disposition: 'inline',
+        length: 100,
+      });
+      expect(streamableFile.getHeaders()).to.deep.equal({
+        type: 'application/pdf',
+        disposition: 'inline',
+        length: 100,
+      });
+    });
+  });
   describe('otherwise', () => {
-    it('should create a readable straem and push the input buffer', () => {
-      const buffer = Buffer.from('test');
-      const streamableFile = new StreamableFile(buffer);
-      const stream = streamableFile.getStream();
-      expect(stream.read()).to.equal(buffer);
+    describe('when input is a Buffer instance', () => {
+      it('should create a readable stream and push the input buffer', () => {
+        const buffer = Buffer.from('test');
+        const streamableFile = new StreamableFile(buffer);
+        const stream = streamableFile.getStream();
+        expect(stream.read()).to.equal(buffer);
+      });
+    });
+    describe('when input is a Uint8Array', () => {
+      it('should create a readable stream and push the input buffer', () => {
+        const buffer = Uint8Array.from([0xab, 0xcd, 0xef, 0x00]);
+        const streamableFile = new StreamableFile(buffer);
+        const stream = streamableFile.getStream();
+        expect(stream.read()).to.deep.equal(Buffer.from(buffer));
+      });
     });
   });
 });

packages/common/test/utils/shared.utils.spec.ts

@@ -5,9 +5,11 @@ import {
   isEmpty,
   isFunction,
   isNil,
+  isNumber,
   isObject,
   isPlainObject,
   isString,
+  isSymbol,
   isUndefined,
   normalizePath,
   stripEndSlash,
@@ -66,15 +68,44 @@ describe('Shared utils', () => {
     });
   });
   describe('isString', () => {
-    it('should return true when obj is a string', () => {
+    it('should return true when val is a string', () => {
       expect(isString('true')).to.be.true;
     });
-    it('should return false when object is not a string', () => {
+    it('should return false when val is not a string', () => {
+      expect(isString(new String('fine'))).to.be.false;
       expect(isString(false)).to.be.false;
       expect(isString(null)).to.be.false;
       expect(isString(undefined)).to.be.false;
     });
   });
+  describe('isSymbol', () => {
+    it('should return true when val is a Symbol', () => {
+      expect(isSymbol(Symbol())).to.be.true;
+    });
+    it('should return false when val is not a symbol', () => {
+      expect(isSymbol('Symbol()')).to.be.false;
+      expect(isSymbol(false)).to.be.false;
+      expect(isSymbol(null)).to.be.false;
+      expect(isSymbol(undefined)).to.be.false;
+    });
+  });
+  describe('isNumber', () => {
+    it('should return true when val is a number or NaN', () => {
+      expect(isNumber(1)).to.be.true;
+      expect(isNumber(1.23)).to.be.true; // with decimals
+      expect(isNumber(123e-5)).to.be.true; // scientific (exponent) notation
+      expect(isNumber(0o1)).to.be.true; // octal notation
+      expect(isNumber(0b1)).to.be.true; // binary notation
+      expect(isNumber(0x1)).to.be.true; // hexadecimal notation
+      expect(isNumber(NaN)).to.be.true;
+    });
+    it('should return false when val is not a number', () => {
+      // expect(isNumber(1n)).to.be.false; // big int (available on ES2020)
+      expect(isNumber('1')).to.be.false; // string
+      expect(isNumber(undefined)).to.be.false; // nullish
+      expect(isNumber(null)).to.be.false; // nullish
+    });
+  });
   describe('isConstructor', () => {
     it('should return true when string is equal to constructor', () => {
       expect(isConstructor('constructor')).to.be.true;

packages/common/utils/is-uuid.ts

@@ -1,4 +1,5 @@
 import { BadRequestException } from '../exceptions';
+import { isString } from './shared.utils';
 
 const uuid = {
   3: /^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
@@ -8,7 +9,7 @@ const uuid = {
 };
 
 export function isUUID(str: any, version = 'all') {
-  if (typeof str !== 'string') {
+  if (!isString(str)) {
     throw new BadRequestException('The value passed as UUID is not a string');
   }
   const pattern = uuid[version];

packages/common/utils/shared.utils.ts

@@ -47,10 +47,11 @@ export const normalizePath = (path?: string): string =>
 export const stripEndSlash = (path: string) =>
   path[path.length - 1] === '/' ? path.slice(0, path.length - 1) : path;
 
-export const isFunction = (fn: any): boolean => typeof fn === 'function';
-export const isString = (fn: any): fn is string => typeof fn === 'string';
-export const isConstructor = (fn: any): boolean => fn === 'constructor';
-export const isNil = (obj: any): obj is null | undefined =>
-  isUndefined(obj) || obj === null;
+export const isFunction = (val: any): boolean => typeof val === 'function';
+export const isString = (val: any): val is string => typeof val === 'string';
+export const isNumber = (val: any): val is number => typeof val === 'number';
+export const isConstructor = (val: any): boolean => val === 'constructor';
+export const isNil = (val: any): val is null | undefined =>
+  isUndefined(val) || val === null;
 export const isEmpty = (array: any): boolean => !(array && array.length > 0);
-export const isSymbol = (fn: any): fn is symbol => typeof fn === 'symbol';
+export const isSymbol = (val: any): val is symbol => typeof val === 'symbol';

packages/core/CHANGELOG.md

@@ -1,12 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
-
-<a name="8.2.0"></a>
-# [8.2.0](https://github.com/nestjs/nest/compare/v8.1.2...v8.2.0) (2021-11-08)
-
-
-
-
-**Note:** Version bump only for package @nestjs/core

packages/core/Readme.md

@@ -57,10 +57,13 @@ With official support, you can get expert help straight from Nest core team. We
 Nest is an MIT-licensed open source project. It can grow thanks to the sponsors and support by the amazing backers. If you'd like to join them, please [read more here](https://docs.nestjs.com/support).
 
 #### Principal Sponsors
-<table style="text-align:center;"><tr><td>
+<table style="text-align:center;"><tr>
+  <td><a href="https://trilon.io" target="_blank"><img src="https://nestjs.com/img/trilon.svg" width="200" valign="middle" /></a></td>
+  <td><a href="https://www.redhat.com" target="_blank"><img src="https://nestjs.com/img/red-hat-logo.svg" width="200" valign="middle" /></a></td>
+<td>
 <a href="https://github.com/Sanofi-IADC" target="_blank"><img src="https://docs.nestjs.com/assets/sponsors/sanofi.png" width="180" valign="middle" /></a></td>
 <td>
-<a href="https://trilon.io" target="_blank"><img src="https://nestjs.com/img/trilon.svg" width="200" valign="middle" /></a></td>
+<a href="https://nx.dev" target="_blank"><img src="https://nestjs.com/img/nx-logo.png" height="45" valign="middle" /></a></td>
 </tr></table>
 
 #### Gold Sponsors
@@ -78,10 +81,11 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 <table style="text-align:center;"><tr><td>
 <a href="https://neoteric.eu/" target="_blank"><img src="https://nestjs.com/img/neoteric-cut.png" width="120" valign="middle" /></a> </td><td>
   <a href="http://gojob.com" target="_blank"><img src="http://nestjs.com/img/gojob-logo.png" valign="middle" width="100" /></a> </td><td>
-<a href="http://www.leogistics.com" target="_blank"><img src="https://nestjs.com/img/leogistics-logo.jpeg" width="150" valign="middle" /></td><td>
+<a href="https://www.myleodsc.com/" target="_blank"><img src="https://nestjs.com/img/myleo-logo.png" width="180" valign="middle" /></td><td>
 <a href="https://careers.meetdandy.com/?gh_src=063ba61e3us" target="_blank"><img src="https://nestjs.com/img/dandy-roles-logo.svg" width="150" valign="middle" /></td><td>
 <a href="https://www.castlecraft.in" target="_blank"><img src="https://nestjs.com/img/castlecraft-logo.png" width="150" valign="middle" /></td>
-<td><a href="https://www.tinystacks.com" target="_blank"><img src="https://nestjs.com/img/tinystacks-logo.png#1" width="140" valign="middle" /></td></tr></table>
+<td><a href="https://www.tinystacks.com" target="_blank"><img src="https://nestjs.com/img/tinystacks-logo.png#1" width="140" valign="middle" /></td>
+<td><a href="https://n.inc" target="_blank"><img src="https://nestjs.com/img/n-inc-logo.svg" width="120" valign="middle" /></td></tr></table>
 
 #### Sponsors
 
@@ -113,6 +117,13 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
   <td align="center" valign="middle"><a href="https://studyclerk.com/pay-for-research-paper" target="_blank"><img src="https://nestjs.com/img/studyclerk-logo.png" width="125" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://xyndata.com" target="_blank"><img src="https://nestjs.com/img/xyndata-logo.png" width="125" valign="middle" /></a></td></tr><tr>
   <td align="center" valign="middle"><a href="https://www.anonymistic.com/" target="_blank"><img src="https://nestjs.com/img/anonymistic-logo.png" width="125" valign="middle" /></a></td>
 <td align="center" valign="middle"><a href="https://www.naologic.com/" target="_blank"><img src="https://nestjs.com/img/naologic-logo.svg" width="125" valign="middle" /></a></td>
+  <td align="center" valign="middle"><a href="https://messaged.com/" target="_blank"><img src="https://nestjs.com/img/messaged-logo.png" width="50" valign="middle" /></a></td>
+  <td align="center" valign="middle"><a href="https://triplecore.io" target="_blank"><img src="https://nestjs.com/img/triplecore-logo.svg" width="50" valign="middle" /></a></td>
+   <td align="center" valign="middle"><a href="https://klqc.de" target="_blank"><img src="https://nestjs.com/img/klcqcl-logo.png" width="120" valign="middle" /></a></td>
+   <td align="center" valign="middle"><a href="https://thecasinowizard.com/bonuses/no-deposit-bonuses/" target="_blank"><img src="https://nestjs.com/img/casinowizard-logo.png" width="120" valign="middle" /></a></td></tr><tr>
+     <td align="center" valign="middle"><a href="https://polygon-software.ch/" target="_blank"><img src="https://nestjs.com/img/polygon-logo.svg" width="120" valign="middle" /></a></td>
+   <td align="center" valign="middle"><a href="https://mobilereality.pl/" target="_blank"><img src="https://nestjs.com/img/mobile-reality-logo.png" width="45" valign="middle" /></a></td>
+     <td align="center" valign="middle"><a href="https://boringowl.io/" target="_blank"><img src="https://nestjs.com/img/boringowl-logo.svg" width="120" valign="middle" /></a></td>
   </tr></table>
 
 ## Backers

packages/core/application-config.ts

@@ -136,6 +136,11 @@ export class ApplicationConfig {
   }
 
   public enableVersioning(options: VersioningOptions): void {
+    if (Array.isArray(options.defaultVersion)) {
+      // Drop duplicated versions
+      options.defaultVersion = Array.from(new Set(options.defaultVersion));
+    }
+
     this.versioningOptions = options;
   }
 

packages/core/errors/exceptions/invalid-class-module.exception.ts

@@ -0,0 +1,10 @@
+import { USING_INVALID_CLASS_AS_A_MODULE_MESSAGE } from '../messages';
+import { RuntimeException } from './runtime.exception';
+
+export class InvalidClassModuleException extends RuntimeException {
+  constructor(metatypeUsedAsAModule: any, scope: any[]) {
+    super(
+      USING_INVALID_CLASS_AS_A_MODULE_MESSAGE(metatypeUsedAsAModule, scope),
+    );
+  }
+}

packages/core/errors/messages.ts

@@ -1,4 +1,4 @@
-import { ForwardReference, Type } from '@nestjs/common';
+import type { ForwardReference, Type, DynamicModule } from '@nestjs/common';
 import { isNil, isSymbol } from '@nestjs/common/utils/shared.utils';
 import {
   InjectorDependency,
@@ -7,14 +7,19 @@ import {
 import { Module } from '../injector/module';
 
 /**
- * Returns the name of an instance
+ * Returns the name of an instance or `undefined`
  * @param instance The instance which should get the name from
  */
 const getInstanceName = (instance: unknown): string => {
   if ((instance as ForwardReference)?.forwardRef) {
     return (instance as ForwardReference).forwardRef()?.name;
   }
-  return (instance as Type<any>)?.name;
+
+  if ((instance as DynamicModule)?.module) {
+    return (instance as DynamicModule).module?.name;
+  }
+
+  return (instance as Type)?.name;
 };
 
 /**
@@ -97,7 +102,7 @@ export const UNDEFINED_FORWARDREF_MESSAGE = (
 
 (Read more: https://docs.nestjs.com/fundamentals/circular-dependency)
 Scope [${stringifyScope(scope)}]
-  `;
+`;
 
 export const INVALID_MODULE_MESSAGE = (
   parentModule: any,
@@ -107,11 +112,25 @@ export const INVALID_MODULE_MESSAGE = (
   const parentModuleName = parentModule?.name || 'module';
 
   return `Nest cannot create the ${parentModuleName} instance.
-Received an unexpected value at index [${index}] of the ${parentModuleName} "imports" array. 
+Received an unexpected value at index [${index}] of the ${parentModuleName} "imports" array.
 
 Scope [${stringifyScope(scope)}]`;
 };
 
+export const USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = (
+  metatypeUsedAsAModule: Type | ForwardReference,
+  scope: any[],
+) => {
+  const metatypeName = getInstanceName(metatypeUsedAsAModule) || 'found';
+
+  // TODO(v9): Edit the message below:
+  return `In the next major version, Nest will not allow classes annotated with @Injectable(), @Catch(), and @Controller() decorators to appear in the "imports" array of a module.
+Please remove "${metatypeName}" (including forwarded occurrences, if any) from all of the "imports" arrays.
+
+Scope [${stringifyScope(scope)}]
+`;
+};
+
 export const UNDEFINED_MODULE_MESSAGE = (
   parentModule: any,
   index: number,

packages/core/helpers/context-utils.ts

@@ -50,12 +50,15 @@ export class ContextUtils {
   }
 
   public getArgumentsLength<T>(keys: string[], metadata: T): number {
-    return Math.max(...keys.map(key => metadata[key].index)) + 1;
+    return keys.length
+      ? Math.max(...keys.map(key => metadata[key].index)) + 1
+      : 0;
   }
 
   public createNullArray(length: number): any[] {
-    // eslint-disable-next-line prefer-spread
-    return Array.apply(null, { length } as any).fill(undefined);
+    const a = new Array(length);
+    for (let i = 0; i < length; ++i) a[i] = undefined;
+    return a;
   }
 
   public mergeParamsMetatypes(

packages/core/helpers/external-context-creator.ts

@@ -6,7 +6,7 @@ import {
   PipeTransform,
 } from '@nestjs/common/interfaces';
 import { isEmpty, isFunction } from '@nestjs/common/utils/shared.utils';
-import { lastValueFrom } from 'rxjs';
+import { lastValueFrom, isObservable } from 'rxjs';
 import { ExternalExceptionFilterContext } from '../exceptions/external-exception-filter-context';
 import { FORBIDDEN_MESSAGE } from '../guards/constants';
 import { GuardsConsumer } from '../guards/guards-consumer';
@@ -329,7 +329,7 @@ export class ExternalContextCreator {
   }
 
   public async transformToResult(resultOrDeferred: any) {
-    if (resultOrDeferred && isFunction(resultOrDeferred.subscribe)) {
+    if (isObservable(resultOrDeferred)) {
       return lastValueFrom(resultOrDeferred);
     }
     return resultOrDeferred;

packages/core/helpers/messages.ts

@@ -17,10 +17,12 @@ export const VERSIONED_ROUTE_MAPPED_MESSAGE = (
   method: string | number,
   version: VersionValue,
 ) => {
-  if (version === VERSION_NEUTRAL) {
-    version = 'Neutral';
-  }
-  return `Mapped {${path}, ${RequestMethod[method]}} (version: ${version}) route`;
+  const controllerVersions = Array.isArray(version) ? version : [version];
+  const versions = controllerVersions
+    .map(version => (version === VERSION_NEUTRAL ? 'Neutral' : version))
+    .join(',');
+
+  return `Mapped {${path}, ${RequestMethod[method]}} (version: ${versions}) route`;
 };
 
 export const CONTROLLER_MAPPING_MESSAGE = (name: string, path: string) =>
@@ -31,10 +33,12 @@ export const VERSIONED_CONTROLLER_MAPPING_MESSAGE = (
   path: string,
   version: VersionValue,
 ) => {
-  if (version === VERSION_NEUTRAL) {
-    version = 'Neutral';
-  }
-  return `${name} {${path}} (version: ${version}):`;
+  const controllerVersions = Array.isArray(version) ? version : [version];
+  const versions = controllerVersions
+    .map(version => (version === VERSION_NEUTRAL ? 'Neutral' : version))
+    .join(',');
+
+  return `${name} {${path}} (version: ${versions}):`;
 };
 
 export const INVALID_EXECUTION_CONTEXT = (

packages/core/injector/injector.ts

@@ -1,4 +1,9 @@
-import { Logger, LoggerService } from '@nestjs/common';
+import {
+  InjectionToken,
+  Logger,
+  LoggerService,
+  OptionalFactoryDependency,
+} from '@nestjs/common';
 import {
   OPTIONAL_DEPS_METADATA,
   OPTIONAL_PROPERTY_DEPS_METADATA,
@@ -34,7 +39,7 @@ import { InstanceToken, Module } from './module';
 /**
  * The type of an injectable dependency
  */
-export type InjectorDependency = Type<any> | Function | string | symbol;
+export type InjectorDependency = InjectionToken;
 
 /**
  * The property-based dependency
@@ -119,7 +124,7 @@ export class Injector {
       const properties = await this.resolveProperties(
         wrapper,
         moduleRef,
-        inject,
+        inject as InjectionToken[],
         contextId,
         wrapper,
         inquirer,
@@ -137,7 +142,7 @@ export class Injector {
     await this.resolveConstructorParams<T>(
       wrapper,
       moduleRef,
-      inject,
+      inject as InjectionToken[],
       callback,
       contextId,
       wrapper,
@@ -246,12 +251,11 @@ export class Injector {
       );
       return callback(deps);
     }
-    const dependencies = isNil(inject)
-      ? this.reflectConstructorParams(wrapper.metatype as Type<any>)
-      : inject;
-    const optionalDependenciesIds = isNil(inject)
-      ? this.reflectOptionalParams(wrapper.metatype as Type<any>)
-      : [];
+
+    const isFactoryProvider = !isNil(inject);
+    const [dependencies, optionalDependenciesIds] = isFactoryProvider
+      ? this.getFactoryProviderDependencies(wrapper)
+      : this.getClassDependencies(wrapper);
 
     let isResolved = true;
     const resolveParam = async (param: unknown, index: number) => {
@@ -292,6 +296,47 @@ export class Injector {
     isResolved && (await callback(instances));
   }
 
+  public getClassDependencies<T>(
+    wrapper: InstanceWrapper<T>,
+  ): [InjectorDependency[], number[]] {
+    const ctorRef = wrapper.metatype as Type<any>;
+    return [
+      this.reflectConstructorParams(ctorRef),
+      this.reflectOptionalParams(ctorRef),
+    ];
+  }
+
+  public getFactoryProviderDependencies<T>(
+    wrapper: InstanceWrapper<T>,
+  ): [InjectorDependency[], number[]] {
+    const optionalDependenciesIds = [];
+    const isOptionalFactoryDep = (
+      item: InjectionToken | OptionalFactoryDependency,
+    ): item is OptionalFactoryDependency =>
+      !isUndefined((item as OptionalFactoryDependency).token) &&
+      !isUndefined((item as OptionalFactoryDependency).optional);
+
+    const mapFactoryProviderInjectArray = (
+      item: InjectionToken | OptionalFactoryDependency,
+      index: number,
+    ): InjectionToken => {
+      if (typeof item !== 'object') {
+        return item;
+      }
+      if (isOptionalFactoryDep(item)) {
+        if (item.optional) {
+          optionalDependenciesIds.push(index);
+        }
+        return item?.token;
+      }
+      return item;
+    };
+    return [
+      wrapper.inject?.map?.(mapFactoryProviderInjectArray),
+      optionalDependenciesIds,
+    ];
+  }
+
   public reflectConstructorParams<T>(type: Type<T>): any[] {
     const paramtypes = Reflect.getMetadata(PARAMTYPES_METADATA, type) || [];
     const selfParams = this.reflectSelfParams<T>(type);
@@ -430,8 +475,9 @@ export class Injector {
     inquirer?: InstanceWrapper,
     keyOrIndex?: string | number,
   ): Promise<InstanceWrapper<T>> {
+    const token = wrapper.token || wrapper.name;
     const { name } = dependencyContext;
-    if (wrapper && wrapper.name === name) {
+    if (wrapper && token === name) {
       throw new UnknownDependenciesException(
         wrapper.name,
         dependencyContext,
@@ -778,7 +824,7 @@ export class Injector {
     return param === INQUIRER && parentInquirer;
   }
 
-  private addDependencyMetadata(
+  protected addDependencyMetadata(
     keyOrIndex: number | string,
     hostWrapper: InstanceWrapper,
     instanceWrapper: InstanceWrapper,

packages/core/injector/instance-loader.ts

@@ -8,9 +8,9 @@ import { InternalCoreModule } from './internal-core-module';
 import { Module } from './module';
 
 export class InstanceLoader {
-  private readonly injector = new Injector();
+  protected readonly injector = new Injector();
   constructor(
-    private readonly container: NestContainer,
+    protected readonly container: NestContainer,
     private readonly logger = new Logger(InstanceLoader.name, {
       timestamp: true,
     }),

packages/core/injector/instance-wrapper.ts

@@ -43,7 +43,7 @@ export class InstanceWrapper<T = any> {
 
   public scope?: Scope = Scope.DEFAULT;
   public metatype: Type<T> | Function;
-  public inject?: (string | symbol | Function | Type<any>)[];
+  public inject?: FactoryProvider['inject'];
   public forwardRef?: boolean;
 
   private readonly values = new WeakMap<ContextId, InstancePerContext<T>>();

packages/core/injector/module-ref.ts

@@ -22,11 +22,11 @@ export abstract class ModuleRef {
   constructor(protected readonly container: NestContainer) {}
 
   public abstract get<TInput = any, TResult = TInput>(
-    typeOrToken: Type<TInput> | string | symbol,
+    typeOrToken: Type<TInput> | Function | string | symbol,
     options?: { strict: boolean },
   ): TResult;
   public abstract resolve<TInput = any, TResult = TInput>(
-    typeOrToken: Type<TInput> | string | symbol,
+    typeOrToken: Type<TInput> | Function | string | symbol,
     contextId?: ContextId,
     options?: { strict: boolean },
   ): Promise<TResult>;

packages/core/injector/module-token-factory.ts

@@ -1,6 +1,7 @@
 import { DynamicModule } from '@nestjs/common';
 import { Type } from '@nestjs/common/interfaces/type.interface';
 import { randomStringGenerator } from '@nestjs/common/utils/random-string-generator.util';
+import { isFunction, isSymbol } from '@nestjs/common/utils/shared.utils';
 import stringify from 'fast-safe-stringify';
 import * as hash from 'object-hash';
 
@@ -46,7 +47,7 @@ export class ModuleTokenFactory {
   }
 
   private replacer(key: string, value: any) {
-    if (typeof value === 'function') {
+    if (isFunction(value)) {
       const funcAsString = value.toString();
       const isClass = /^class\s/.test(funcAsString);
       if (isClass) {
@@ -54,7 +55,7 @@ export class ModuleTokenFactory {
       }
       return hash(funcAsString, { ignoreUnknown: true });
     }
-    if (typeof value === 'symbol') {
+    if (isSymbol(value)) {
       return value.toString();
     }
     return value;

packages/core/injector/module.ts

@@ -1,11 +1,11 @@
 import {
-  Abstract,
   ClassProvider,
   Controller,
   DynamicModule,
   ExistingProvider,
   FactoryProvider,
   Injectable,
+  InjectionToken,
   NestModule,
   Provider,
   ValueProvider,
@@ -31,12 +31,11 @@ import { NestContainer } from './container';
 import { InstanceWrapper } from './instance-wrapper';
 import { ModuleRef } from './module-ref';
 
-export type InstanceToken =
-  | string
-  | symbol
-  | Type<any>
-  | Abstract<any>
-  | Function;
+/**
+ * @note
+ * Left for backward compatibility
+ */
+export type InstanceToken = InjectionToken;
 
 export class Module {
   private readonly _id: string;

packages/core/middleware/container.ts

@@ -1,9 +1,9 @@
-import { Scope, Type } from '@nestjs/common';
-import { SCOPE_OPTIONS_METADATA } from '@nestjs/common/constants';
+import { Type } from '@nestjs/common';
 import { MiddlewareConfiguration } from '@nestjs/common/interfaces/middleware/middleware-configuration.interface';
 import { NestContainer } from '../injector/container';
 import { InstanceWrapper } from '../injector/instance-wrapper';
 import { InstanceToken } from '../injector/module';
+import { getClassScope } from '../helpers/get-class-scope';
 
 export class MiddlewareContainer {
   private readonly middleware = new Map<
@@ -44,7 +44,7 @@ export class MiddlewareContainer {
       middleware.set(
         token,
         new InstanceWrapper({
-          scope: this.getClassScope(metatype),
+          scope: getClassScope(metatype),
           name: token,
           metatype,
           token,
@@ -66,9 +66,4 @@ export class MiddlewareContainer {
     }
     return this.configurationSets.get(moduleName);
   }
-
-  private getClassScope<T = unknown>(type: Type<T>): Scope {
-    const metadata = Reflect.getMetadata(SCOPE_OPTIONS_METADATA, type);
-    return metadata && metadata.scope;
-  }
 }

packages/core/middleware/utils.ts

@@ -81,7 +81,7 @@ export function isMiddlewareClass(middleware: any): middleware is Type<any> {
   return (
     middlewareArr[0] === 'function' &&
     /[A-Z]/.test(middlewareArr[1]?.[0]) &&
-    typeof middleware.prototype?.use === 'function'
+    isFunction(middleware.prototype?.use)
   );
 }
 

packages/core/nest-application-context.ts

@@ -35,6 +35,7 @@ export class NestApplicationContext implements INestApplicationContext {
   protected isInitialized = false;
   protected readonly injector = new Injector();
 
+  private shouldFlushLogsOnOverride = false;
   private readonly activeShutdownSignals = new Array<string>();
   private readonly moduleCompiler = new ModuleCompiler();
   private shutdownCleanupRef?: (...args: unknown[]) => unknown;
@@ -131,12 +132,23 @@ export class NestApplicationContext implements INestApplicationContext {
 
   public useLogger(logger: LoggerService | LogLevel[] | false) {
     Logger.overrideLogger(logger);
+
+    if (this.shouldFlushLogsOnOverride) {
+      this.flushLogs();
+    }
   }
 
   public flushLogs() {
     Logger.flush();
   }
 
+  /**
+   * Define that it must flush logs right after defining a custom logger.
+   */
+  public flushLogsOnOverride() {
+    this.shouldFlushLogsOnOverride = true;
+  }
+
   /**
    * Enables the usage of shutdown hooks. Will call the
    * `onApplicationShutdown` function of a provider if the

packages/core/nest-application.ts

@@ -121,8 +121,7 @@ export class NestApplication
       return undefined;
     }
     const passCustomOptions =
-      isObject(this.appOptions.cors) ||
-      typeof this.appOptions.cors === 'function';
+      isObject(this.appOptions.cors) || isFunction(this.appOptions.cors);
     if (!passCustomOptions) {
       return this.enableCors();
     }
@@ -319,13 +318,14 @@ export class NestApplication
   }
 
   private formatAddress(address: any): string {
-    if (typeof address === 'string') {
+    if (isString(address)) {
       if (platform() === 'win32') {
         return address;
       }
       const basePath = encodeURIComponent(address);
       return `${this.getProtocol()}+unix://${basePath}`;
     }
+
     let host = this.host();
     if (address && address.family === 'IPv6') {
       if (host === '::') {
@@ -410,7 +410,7 @@ export class NestApplication
   }
   private host(): string | undefined {
     const address = this.httpServer.address();
-    if (typeof address === 'string') {
+    if (isString(address)) {
       return undefined;
     }
     return address && address.address;

packages/core/nest-factory.ts

@@ -142,6 +142,9 @@ export class NestFactoryStatic {
     const context = this.createNestInstance<NestApplicationContext>(
       new NestApplicationContext(container, [], root),
     );
+    if (this.autoFlushLogs) {
+      context.flushLogsOnOverride();
+    }
     return context.init();
   }
 

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "8.2.2",
+  "version": "8.3.1",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -30,13 +30,13 @@
     "@nuxtjs/opencollective": "0.3.2",
     "fast-safe-stringify": "2.1.1",
     "iterare": "1.2.1",
-    "object-hash": "2.2.0",
+    "object-hash": "3.0.0",
     "path-to-regexp": "3.2.0",
     "tslib": "2.3.1",
     "uuid": "8.3.2"
   },
   "devDependencies": {
-    "@nestjs/common": "8.2.2"
+    "@nestjs/common": "8.3.1"
   },
   "peerDependencies": {
     "@nestjs/common": "^8.0.0",

packages/core/router/route-path-factory.ts

@@ -23,18 +23,30 @@ export class RoutePathFactory {
   ): string[] {
     let paths = [''];
 
-    const version = this.getVersion(metadata);
-    if (version && metadata.versioningOptions?.type === VersioningType.URI) {
+    const versionOrVersions = this.getVersion(metadata);
+    if (
+      versionOrVersions &&
+      metadata.versioningOptions?.type === VersioningType.URI
+    ) {
       const versionPrefix = this.getVersionPrefix(metadata.versioningOptions);
 
-      // Version Neutral - Do not include version in URL
-      if (version !== VERSION_NEUTRAL) {
-        if (Array.isArray(version)) {
-          paths = flatten(
-            paths.map(path => version.map(v => path + `/${versionPrefix}${v}`)),
+      if (Array.isArray(versionOrVersions)) {
+        paths = flatten(
+          paths.map(path =>
+            versionOrVersions.map(version =>
+              // Version Neutral - Do not include version in URL
+              version === VERSION_NEUTRAL
+                ? path
+                : `${path}/${versionPrefix}${version}`,
+            ),
+          ),
+        );
+      } else {
+        // Version Neutral - Do not include version in URL
+        if (versionOrVersions !== VERSION_NEUTRAL) {
+          paths = paths.map(
+            path => `${path}/${versionPrefix}${versionOrVersions}`,
           );
-        } else {
-          paths = paths.map(path => path + `/${versionPrefix}${version}`);
         }
       }
     }