chore(@nestjs) publish v7.6.14 release

feat(core): support route injection

.eslintrc.js

@@ -9,7 +9,6 @@ module.exports = {
     'plugin:@typescript-eslint/eslint-recommended',
     'plugin:@typescript-eslint/recommended',
     'prettier',
-    'prettier/@typescript-eslint',
   ],
   root: true,
   env: {

LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2020 Kamil Mysliwiec <https://kamilmysliwiec.com>
+Copyright (c) 2017-2021 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

@@ -37,6 +37,7 @@ Nest is a framework for building efficient, scalable <a href="http://nodejs.org"
 
 * To check out the [guide](https://docs.nestjs.com), visit [docs.nestjs.com](https://docs.nestjs.com). :books:
 * 要查看中文 [指南](readme_zh.md), 请访问 [docs.nestjs.cn](https://docs.nestjs.cn). :books:
+* [가이드](readme_kr.md)를 확인하려면, [docs.nestjs.com](https://docs.nestjs.com)를 방문하세요.:books: 
 
 ## Questions
 
@@ -56,16 +57,21 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 
 #### Principal Sponsors
 <table style="text-align:center;"><tr><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://valor-software.com/" target="_blank"><img src="https://docs.nestjs.com/assets/sponsors/valor-software.png" width="180" valign="middle" /></a></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>
 </tr></table>
 
+#### Gold Sponsors
+
+<table style="text-align:center;"><tr><td>
+<a href="https://valor-software.com/" target="_blank"><img src="https://docs.nestjs.com/assets/sponsors/valor-software.png" width="170" valign="middle" /></a></td></tr></table>
+
 #### Silver 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="https://trilon.io" target="_blank"><img src="https://nestjs.com/img/trilon.svg" width="170" valign="middle" /></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="http://www.meetdandy.com" target="_blank"><img src="https://nestjs.com/img/dandy-wide-logo.png" width="150" valign="middle" /></td></tr></table>
 
@@ -90,6 +96,11 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
   <td align="center" valign="middle">
   <a href="https://genuinebee.com/" target="_blank"><img src="https://nestjs.com/img/genuinebee.svg" width="97" valign="middle" /></a> </td>
 <td align="center" valign="middle"><a href="https://sanyodigital.com/" target="_blank"><img src="https://nestjs.com/img/sanyo-digital.png" width="130" valign="middle" /></a></td></tr><tr><td align="center" valign="middle"><a href="https://vpn-review.com/vpn-for-torrenting" target="_blank"><img src="https://nestjs.com/img/vpn-review-logo.png" width="85" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://lambda-it.ch/" target="_blank"><img src="https://nestjs.com/img/lambda-it-logo.svg" width="115" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://pickwriters.com/top-10-translation-services" target="_blank"><img src="https://nestjs.com/img/pickwriters-logo.png" width="40" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://thewordpoint.com/services/localization" target="_blank"><img src="https://nestjs.com/img/thewordpoint-logo.png" width="40" valign="middle" /></a></td>
+<td align="center" valign="middle"><a href="https://meercode.io/" target="_blank"><img src="https://nestjs.com/img/meercode-logo.png" width="60" valign="middle" /></a></td>
+  <td align="center" valign="middle"><a href="https://www.najlepszeplatformyforex.pl/blog/broker-xtb/" target="_blank"><img src="https://nestjs.com/img/npf-logo.jpg" width="200" valign="middle" /></a></td></tr><tr>
+<td align="center" valign="middle"><a href="https://thestandarddaily.com/" target="_blank"><img src="https://nestjs.com/img/the-standard-daily-logo.png" width="180" valign="middle" /></a></td>
+<td align="center" valign="middle"><a href="https://houseofangular.io/" target="_blank"><img src="https://nestjs.com/img/house-of-angular.png" width="100" valign="middle" /></a></td>
+<td align="center" valign="middle"><a href="https://rocketech.it/cases/?utm_source=google&utm_medium=badge&utm_campaign=nestjs" target="_blank"><img src="https://nestjs.com/img/rocketech-logo.svg" width="110" valign="middle" /></a></td>
   </tr></table>
 
 ## Backers

benchmarks/all_output.txt

@@ -2,47 +2,87 @@
 express
 -----------------------
 Running 10s test @ http://localhost:3000
-  8 threads and 1024 connections
-  Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency    47.78ms   19.09ms 212.47ms   66.94%
-    Req/Sec     1.31k   268.90     2.07k    72.38%
-  104687 requests in 10.02s, 21.47MB read
-  Socket errors: connect 0, read 877, write 0, timeout 0
-Requests/sec:  10444.24
-Transfer/sec:      2.14MB
+1024 connections
+
+┌─────────┬───────┬───────┬───────┬────────┬──────────┬──────────┬────────┐
+│ Stat    │ 2.5%  │ 50%   │ 97.5% │ 99%    │ Avg      │ Stdev    │ Max    │
+├─────────┼───────┼───────┼───────┼────────┼──────────┼──────────┼────────┤
+│ Latency │ 55 ms │ 58 ms │ 91 ms │ 138 ms │ 61.88 ms │ 23.95 ms │ 747 ms │
+└─────────┴───────┴───────┴───────┴────────┴──────────┴──────────┴────────┘
+┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬─────────┬─────────┐
+│ Stat      │ 1%      │ 2.5%    │ 50%     │ 97.5%   │ Avg      │ Stdev   │ Min     │
+├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼─────────┼─────────┤
+│ Req/Sec   │ 8407    │ 8407    │ 17407   │ 17743   │ 16454.41 │ 2716.94 │ 8402    │
+├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼─────────┼─────────┤
+│ Bytes/Sec │ 1.81 MB │ 1.81 MB │ 3.74 MB │ 3.81 MB │ 3.54 MB  │ 584 kB  │ 1.81 MB │
+└───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴─────────┴─────────┘
+
+Req/Bytes counts sampled once per second.
+
+165k requests in 10.17s, 35.4 MB read
+-----------------------
+nest (with "@nestjs/platform-express")
+-----------------------
+Running 10s test @ http://localhost:3000
+1024 connections
+
+┌─────────┬───────┬───────┬───────┬───────┬──────────┬──────────┬────────┐
+│ Stat    │ 2.5%  │ 50%   │ 97.5% │ 99%   │ Avg      │ Stdev    │ Max    │
+├─────────┼───────┼───────┼───────┼───────┼──────────┼──────────┼────────┤
+│ Latency │ 61 ms │ 64 ms │ 71 ms │ 94 ms │ 65.44 ms │ 17.35 ms │ 325 ms │
+└─────────┴───────┴───────┴───────┴───────┴──────────┴──────────┴────────┘
+┌───────────┬─────────┬─────────┬─────────┬─────────┬─────────┬────────┬─────────┐
+│ Stat      │ 1%      │ 2.5%    │ 50%     │ 97.5%   │ Avg     │ Stdev  │ Min     │
+├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼────────┼─────────┤
+│ Req/Sec   │ 14183   │ 14183   │ 15767   │ 15991   │ 15640   │ 501.13 │ 14182   │
+├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼────────┼─────────┤
+│ Bytes/Sec │ 3.06 MB │ 3.06 MB │ 3.41 MB │ 3.45 MB │ 3.38 MB │ 108 kB │ 3.06 MB │
+└───────────┴─────────┴─────────┴─────────┴─────────┴─────────┴────────┴─────────┘
+
+Req/Bytes counts sampled once per second.
+
+156k requests in 10.24s, 33.8 MB read
 -----------------------
 fastify
 -----------------------
 Running 10s test @ http://localhost:3000
-  8 threads and 1024 connections
-  Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency    21.80ms    8.73ms  78.12ms   55.78%
-    Req/Sec     2.99k     0.92k    5.67k    68.88%
-  238550 requests in 10.02s, 31.17MB read
-  Socket errors: connect 0, read 862, write 0, timeout 0
-Requests/sec:  23795.79
-Transfer/sec:      3.11MB
+1024 connections
+
+┌─────────┬───────┬───────┬───────┬───────┬──────────┬──────────┬─────────┐
+│ Stat    │ 2.5%  │ 50%   │ 97.5% │ 99%   │ Avg      │ Stdev    │ Max     │
+├─────────┼───────┼───────┼───────┼───────┼──────────┼──────────┼─────────┤
+│ Latency │ 27 ms │ 30 ms │ 39 ms │ 78 ms │ 31.62 ms │ 26.59 ms │ 1232 ms │
+└─────────┴───────┴───────┴───────┴───────┴──────────┴──────────┴─────────┘
+┌───────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐
+│ Stat      │ 1%      │ 2.5%    │ 50%     │ 97.5%   │ Avg     │ Stdev   │ Min     │
+├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
+│ Req/Sec   │ 19935   │ 19935   │ 33247   │ 34111   │ 32030.4 │ 4103.84 │ 19931   │
+├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
+│ Bytes/Sec │ 3.03 MB │ 3.03 MB │ 5.05 MB │ 5.19 MB │ 4.87 MB │ 624 kB  │ 3.03 MB │
+└───────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘
+
+Req/Bytes counts sampled once per second.
+
+320k requests in 10.18s, 48.7 MB read
 -----------------------
-nest
+nest (with "@nestjs/platform-fastify")
 -----------------------
 Running 10s test @ http://localhost:3000
-  8 threads and 1024 connections
-  Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency    54.00ms   22.33ms 200.25ms   62.23%
-    Req/Sec     1.15k   338.60     1.88k    66.12%
-  91348 requests in 10.05s, 18.82MB read
-  Socket errors: connect 0, read 983, write 0, timeout 0
-Requests/sec:   9093.64
-Transfer/sec:      1.87MB
------------------------
-nest-fastify
------------------------
-Running 10s test @ http://localhost:3000
-  8 threads and 1024 connections
-  Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency    29.31ms   11.71ms 101.96ms   70.03%
-    Req/Sec     2.17k     0.93k    4.12k    63.13%
-  173241 requests in 10.05s, 22.80MB read
-  Socket errors: connect 0, read 934, write 0, timeout 0
-Requests/sec:  17233.87
-Transfer/sec:      2.27MB
+1024 connections
+
+┌─────────┬───────┬───────┬───────┬───────┬──────────┬──────────┬────────┐
+│ Stat    │ 2.5%  │ 50%   │ 97.5% │ 99%   │ Avg      │ Stdev    │ Max    │
+├─────────┼───────┼───────┼───────┼───────┼──────────┼──────────┼────────┤
+│ Latency │ 31 ms │ 33 ms │ 38 ms │ 52 ms │ 34.41 ms │ 11.73 ms │ 245 ms │
+└─────────┴───────┴───────┴───────┴───────┴──────────┴──────────┴────────┘
+┌───────────┬─────────┬─────────┬────────┬─────────┬─────────┬─────────┬─────────┐
+│ Stat      │ 1%      │ 2.5%    │ 50%    │ 97.5%   │ Avg     │ Stdev   │ Min     │
+├───────────┼─────────┼─────────┼────────┼─────────┼─────────┼─────────┼─────────┤
+│ Req/Sec   │ 24911   │ 24911   │ 30031  │ 30335   │ 29470.4 │ 1564.48 │ 24907   │
+├───────────┼─────────┼─────────┼────────┼─────────┼─────────┼─────────┼─────────┤
+│ Bytes/Sec │ 3.81 MB │ 3.81 MB │ 4.6 MB │ 4.64 MB │ 4.51 MB │ 239 kB  │ 3.81 MB │
+└───────────┴─────────┴─────────┴────────┴─────────┴─────────┴─────────┴─────────┘
+
+Req/Bytes counts sampled once per second.
+
+295k requests in 10.17s, 45.1 MB read

integration/cors/e2e/express.spec.ts

@@ -0,0 +1,177 @@
+import { NestFastifyApplication } from '@nestjs/platform-fastify';
+import { Test } from '@nestjs/testing';
+import * as request from 'supertest';
+import { AppModule } from '../src/app.module';
+
+describe('Express Cors', () => {
+  let app: NestFastifyApplication;
+  const configs = [
+    {
+      origin: 'example.com',
+      methods: 'GET',
+      credentials: true,
+      exposedHeaders: ['foo', 'bar'],
+      allowedHeaders: ['baz', 'woo'],
+      maxAge: 123,
+    },
+    {
+      origin: 'sample.com',
+      methods: 'GET',
+      credentials: true,
+      exposedHeaders: ['zoo', 'bar'],
+      allowedHeaders: ['baz', 'foo'],
+      maxAge: 321,
+    },
+  ];
+  describe('Dynamic config', () => {
+    describe('enableCors', () => {
+      before(async () => {
+        const module = await Test.createTestingModule({
+          imports: [AppModule],
+        }).compile();
+
+        app = module.createNestApplication<NestFastifyApplication>();
+
+        let requestId = 0;
+        const configDelegation = function (req, cb) {
+          const config = configs[requestId];
+          requestId++;
+          cb(null, config);
+        };
+        app.enableCors(configDelegation);
+
+        await app.init();
+      });
+
+      it(`Should add cors headers based on the first config`, async () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .expect('access-control-allow-origin', 'example.com')
+          .expect('vary', 'Origin')
+          .expect('access-control-allow-credentials', 'true')
+          .expect('access-control-expose-headers', 'foo,bar')
+          .expect('content-length', '0');
+      });
+
+      it(`Should add cors headers based on the second config`, async () => {
+        return request(app.getHttpServer())
+          .options('/')
+          .expect('access-control-allow-origin', 'sample.com')
+          .expect('vary', 'Origin')
+          .expect('access-control-allow-credentials', 'true')
+          .expect('access-control-expose-headers', 'zoo,bar')
+          .expect('access-control-allow-methods', 'GET')
+          .expect('access-control-allow-headers', 'baz,foo')
+          .expect('access-control-max-age', '321')
+          .expect('content-length', '0');
+      });
+
+      after(async () => {
+        await app.close();
+      });
+    });
+
+    describe('Application Options', () => {
+      before(async () => {
+        const module = await Test.createTestingModule({
+          imports: [AppModule],
+        }).compile();
+
+        let requestId = 0;
+        const configDelegation = function (req, cb) {
+          const config = configs[requestId];
+          requestId++;
+          cb(null, config);
+        };
+
+        app = module.createNestApplication<NestFastifyApplication>(null, {
+          cors: configDelegation,
+        });
+
+        await app.init();
+      });
+
+      it(`Should add cors headers based on the first config`, async () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .expect('access-control-allow-origin', 'example.com')
+          .expect('vary', 'Origin')
+          .expect('access-control-allow-credentials', 'true')
+          .expect('access-control-expose-headers', 'foo,bar')
+          .expect('content-length', '0');
+      });
+
+      it(`Should add cors headers based on the second config`, async () => {
+        return request(app.getHttpServer())
+          .options('/')
+          .expect('access-control-allow-origin', 'sample.com')
+          .expect('vary', 'Origin')
+          .expect('access-control-allow-credentials', 'true')
+          .expect('access-control-expose-headers', 'zoo,bar')
+          .expect('access-control-allow-methods', 'GET')
+          .expect('access-control-allow-headers', 'baz,foo')
+          .expect('access-control-max-age', '321')
+          .expect('content-length', '0');
+      });
+
+      after(async () => {
+        await app.close();
+      });
+    });
+  });
+  describe('Static config', () => {
+    describe('enableCors', () => {
+      before(async () => {
+        const module = await Test.createTestingModule({
+          imports: [AppModule],
+        }).compile();
+
+        app = module.createNestApplication<NestFastifyApplication>();
+        app.enableCors(configs[0]);
+
+        await app.init();
+      });
+
+      it(`CORS headers`, async () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .expect('access-control-allow-origin', 'example.com')
+          .expect('vary', 'Origin')
+          .expect('access-control-allow-credentials', 'true')
+          .expect('access-control-expose-headers', 'foo,bar')
+          .expect('content-length', '0');
+      });
+    });
+
+    after(async () => {
+      await app.close();
+    });
+
+    describe('Application Options', () => {
+      before(async () => {
+        const module = await Test.createTestingModule({
+          imports: [AppModule],
+        }).compile();
+
+        app = module.createNestApplication<NestFastifyApplication>(null, {
+          cors: configs[0],
+        });
+        await app.init();
+      });
+
+      it(`CORS headers`, async () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .expect('access-control-allow-origin', 'example.com')
+          .expect('vary', 'Origin')
+          .expect('access-control-allow-credentials', 'true')
+          .expect('access-control-expose-headers', 'foo,bar')
+          .expect('content-length', '0');
+      });
+
+      after(async () => {
+        await app.close();
+      });
+    });
+  });
+});

integration/cors/e2e/fastify.spec.ts

@@ -0,0 +1,177 @@
+import { NestFastifyApplication } from '@nestjs/platform-fastify';
+import { Test } from '@nestjs/testing';
+import * as request from 'supertest';
+import { AppModule } from '../src/app.module';
+
+describe('Fastify Cors', () => {
+  let app: NestFastifyApplication;
+  const configs = [
+    {
+      origin: 'example.com',
+      methods: 'GET',
+      credentials: true,
+      exposedHeaders: ['foo', 'bar'],
+      allowedHeaders: ['baz', 'woo'],
+      maxAge: 123,
+    },
+    {
+      origin: 'sample.com',
+      methods: 'GET',
+      credentials: true,
+      exposedHeaders: ['zoo', 'bar'],
+      allowedHeaders: ['baz', 'foo'],
+      maxAge: 321,
+    },
+  ];
+  describe('Dynamic config', () => {
+    describe('enableCors', () => {
+      before(async () => {
+        const module = await Test.createTestingModule({
+          imports: [AppModule],
+        }).compile();
+
+        app = module.createNestApplication<NestFastifyApplication>();
+
+        let requestId = 0;
+        const configDelegation = function (req, cb) {
+          const config = configs[requestId];
+          requestId++;
+          cb(null, config);
+        };
+        app.enableCors(configDelegation);
+
+        await app.init();
+      });
+
+      it(`Should add cors headers based on the first config`, async () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .expect('access-control-allow-origin', 'example.com')
+          .expect('vary', 'Origin')
+          .expect('access-control-allow-credentials', 'true')
+          .expect('access-control-expose-headers', 'foo,bar')
+          .expect('content-length', '0');
+      });
+
+      it(`Should add cors headers based on the second config`, async () => {
+        return request(app.getHttpServer())
+          .options('/')
+          .expect('access-control-allow-origin', 'sample.com')
+          .expect('vary', 'Origin')
+          .expect('access-control-allow-credentials', 'true')
+          .expect('access-control-expose-headers', 'zoo,bar')
+          .expect('access-control-allow-methods', 'GET')
+          .expect('access-control-allow-headers', 'baz,foo')
+          .expect('access-control-max-age', '321')
+          .expect('content-length', '0');
+      });
+
+      after(async () => {
+        await app.close();
+      });
+    });
+
+    describe('Application Options', () => {
+      before(async () => {
+        const module = await Test.createTestingModule({
+          imports: [AppModule],
+        }).compile();
+
+        let requestId = 0;
+        const configDelegation = function (req, cb) {
+          const config = configs[requestId];
+          requestId++;
+          cb(null, config);
+        };
+
+        app = module.createNestApplication<NestFastifyApplication>(null, {
+          cors: configDelegation,
+        });
+
+        await app.init();
+      });
+
+      it(`Should add cors headers based on the first config`, async () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .expect('access-control-allow-origin', 'example.com')
+          .expect('vary', 'Origin')
+          .expect('access-control-allow-credentials', 'true')
+          .expect('access-control-expose-headers', 'foo,bar')
+          .expect('content-length', '0');
+      });
+
+      it(`Should add cors headers based on the second config`, async () => {
+        return request(app.getHttpServer())
+          .options('/')
+          .expect('access-control-allow-origin', 'sample.com')
+          .expect('vary', 'Origin')
+          .expect('access-control-allow-credentials', 'true')
+          .expect('access-control-expose-headers', 'zoo,bar')
+          .expect('access-control-allow-methods', 'GET')
+          .expect('access-control-allow-headers', 'baz,foo')
+          .expect('access-control-max-age', '321')
+          .expect('content-length', '0');
+      });
+
+      after(async () => {
+        await app.close();
+      });
+    });
+  });
+
+  describe('Static config', () => {
+    describe('enableCors', () => {
+      before(async () => {
+        const module = await Test.createTestingModule({
+          imports: [AppModule],
+        }).compile();
+
+        app = module.createNestApplication<NestFastifyApplication>();
+        app.enableCors(configs[0]);
+
+        await app.init();
+      });
+
+      it(`CORS headers`, async () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .expect('access-control-allow-origin', 'example.com')
+          .expect('vary', 'Origin')
+          .expect('access-control-allow-credentials', 'true')
+          .expect('access-control-expose-headers', 'foo,bar')
+          .expect('content-length', '0');
+      });
+    });
+
+    after(async () => {
+      await app.close();
+    });
+    describe('Application Options', () => {
+      before(async () => {
+        const module = await Test.createTestingModule({
+          imports: [AppModule],
+        }).compile();
+
+        app = module.createNestApplication<NestFastifyApplication>(null, {
+          cors: configs[0],
+        });
+        await app.init();
+      });
+
+      it(`CORS headers`, async () => {
+        return request(app.getHttpServer())
+          .get('/')
+          .expect('access-control-allow-origin', 'example.com')
+          .expect('vary', 'Origin')
+          .expect('access-control-allow-credentials', 'true')
+          .expect('access-control-expose-headers', 'foo,bar')
+          .expect('content-length', '0');
+      });
+    });
+
+    after(async () => {
+      await app.close();
+    });
+  });
+});

integration/cors/src/app.controller.ts

@@ -0,0 +1,9 @@
+import { Controller, Get } from '@nestjs/common';
+
+@Controller()
+export class AppController {
+  @Get()
+  getGlobals() {
+    return '';
+  }
+}

integration/cors/src/app.module.ts

@@ -0,0 +1,7 @@
+import { Module } from '@nestjs/common';
+import { AppController } from './app.controller';
+
+@Module({
+  controllers: [AppController],
+})
+export class AppModule {}

integration/cors/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

@@ -23,7 +23,7 @@ services:
       - "9001:9001"
     restart: always
   mysql:
-    image: mysql:5.7.32
+    image: mysql:5.7.33
     environment:
       MYSQL_ROOT_PASSWORD: root
       MYSQL_DATABASE: test
@@ -48,7 +48,7 @@ services:
   zookeeper:
     container_name: test-zookeeper
     hostname: zookeeper
-    image: confluentinc/cp-zookeeper:5.5.2
+    image: confluentinc/cp-zookeeper:5.5.3
     ports:
       - "2181:2181"
     environment:
@@ -57,7 +57,7 @@ services:
   kafka:
     container_name: test-kafka
     hostname: kafka
-    image: confluentinc/cp-kafka:5.5.2
+    image: confluentinc/cp-kafka:5.5.3
     depends_on:
       - zookeeper
     ports:
@@ -70,3 +70,4 @@ services:
       KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:29092,PLAINTEXT_HOST://localhost:9092
       KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
       KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
+      KAFKA_DELETE_TOPIC_ENABLE: 'true'

integration/hello-world/e2e/fastify-adapter.spec.ts

@@ -63,6 +63,22 @@ describe('Hello world (fastify adapter)', () => {
       });
   });
 
+  it(`/GET { host: [":tenant.example1.com", ":tenant.example2.com"] } not matched`, () => {
+    return app
+      .inject({
+        method: 'GET',
+        url: '/host-array',
+      })
+      .then(({ payload }) => {
+        expect(JSON.parse(payload)).to.be.eql({
+          error: 'Internal Server Error',
+          message:
+            'HTTP adapter does not support filtering on hosts: [":tenant.example1.com", ":tenant.example2.com"]',
+          statusCode: 500,
+        });
+      });
+  });
+
   it(`/GET inject with LightMyRequest chaining API`, () => {
     return app
       .inject()

integration/hello-world/e2e/hello-world.spec.ts

@@ -28,6 +28,16 @@ describe('Hello world (default adapter)', () => {
       path: '/host',
       greeting: 'Host Greeting! tenant=acme',
     },
+    {
+      host: 'acme.example1.com',
+      path: '/host-array',
+      greeting: 'Host Greeting! tenant=acme',
+    },
+    {
+      host: 'acme.example2.com',
+      path: '/host-array',
+      greeting: 'Host Greeting! tenant=acme',
+    },
   ].forEach(({ host, path, greeting }) => {
     describe(`host=${host}`, () => {
       describe('/GET', () => {

integration/hello-world/src/app.module.ts

@@ -1,8 +1,9 @@
 import { Module } from '@nestjs/common';
 import { HelloModule } from './hello/hello.module';
+import { HostArrayModule } from './host-array/host-array.module';
 import { HostModule } from './host/host.module';
 
 @Module({
-  imports: [HelloModule, HostModule],
+  imports: [HelloModule, HostModule, HostArrayModule],
 })
 export class ApplicationModule {}

integration/hello-world/src/host-array/dto/test.dto.ts

@@ -0,0 +1,10 @@
+import { IsString, IsNotEmpty, IsNumber } from 'class-validator';
+
+export class TestDto {
+  @IsString()
+  @IsNotEmpty()
+  string: string;
+
+  @IsNumber()
+  number: number;
+}

integration/hello-world/src/host-array/host-array.controller.ts

@@ -0,0 +1,37 @@
+import { Controller, Get, Header, HostParam, Param } from '@nestjs/common';
+import { Observable, of } from 'rxjs';
+import { HostArrayService } from './host-array.service';
+import { UserByIdPipe } from './users/user-by-id.pipe';
+
+@Controller({
+  path: 'host-array',
+  host: [':tenant.example1.com', ':tenant.example2.com'],
+})
+export class HostArrayController {
+  constructor(private readonly hostService: HostArrayService) {}
+
+  @Get()
+  @Header('Authorization', 'Bearer')
+  greeting(@HostParam('tenant') tenant: string): string {
+    return `${this.hostService.greeting()} tenant=${tenant}`;
+  }
+
+  @Get('async')
+  async asyncGreeting(@HostParam('tenant') tenant: string): Promise<string> {
+    return `${await this.hostService.greeting()} tenant=${tenant}`;
+  }
+
+  @Get('stream')
+  streamGreeting(@HostParam('tenant') tenant: string): Observable<string> {
+    return of(`${this.hostService.greeting()} tenant=${tenant}`);
+  }
+
+  @Get('local-pipe/:id')
+  localPipe(
+    @Param('id', UserByIdPipe)
+    user: any,
+    @HostParam('tenant') tenant: string,
+  ): any {
+    return { ...user, tenant };
+  }
+}

integration/hello-world/src/host-array/host-array.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { HostArrayController } from './host-array.controller';
+import { HostArrayService } from './host-array.service';
+import { UsersService } from './users/users.service';
+
+@Module({
+  controllers: [HostArrayController],
+  providers: [HostArrayService, UsersService],
+})
+export class HostArrayModule {}

integration/hello-world/src/host-array/host-array.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class HostArrayService {
+  greeting(): string {
+    return 'Host Greeting!';
+  }
+}

integration/hello-world/src/host-array/users/user-by-id.pipe.ts

@@ -0,0 +1,11 @@
+import { PipeTransform, Injectable, ArgumentMetadata } from '@nestjs/common';
+import { UsersService } from './users.service';
+
+@Injectable()
+export class UserByIdPipe implements PipeTransform<string> {
+  constructor(private readonly usersService: UsersService) {}
+
+  transform(value: string, metadata: ArgumentMetadata) {
+    return this.usersService.findById(value);
+  }
+}

integration/hello-world/src/host-array/users/users.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class UsersService {
+  findById(id: string) {
+    return { id, host: true };
+  }
+}

integration/hooks/src/enable-shutdown-hooks-main.ts

@@ -26,7 +26,7 @@ class TestInjectable
 class AppModule {}
 
 async function bootstrap() {
-  const app = await NestFactory.create(AppModule, { logger: true });
+  const app = await NestFactory.create(AppModule, { logger: false });
 
   if (SIGNAL_TO_LISTEN && SIGNAL_TO_LISTEN !== 'NONE') {
     app.enableShutdownHooks([SIGNAL_TO_LISTEN]);

integration/microservices/e2e/concurrent-kafka.spec.ts

@@ -0,0 +1,291 @@
+import { INestApplication, Logger } from '@nestjs/common';
+import { Transport } from '@nestjs/microservices';
+import { Test } from '@nestjs/testing';
+import { Admin, ITopicMetadata, Kafka } from 'kafkajs';
+import * as request from 'supertest';
+import * as util from 'util';
+import { KafkaConcurrentController } from '../src/kafka-concurrent/kafka-concurrent.controller';
+import { KafkaConcurrentMessagesController } from '../src/kafka-concurrent/kafka-concurrent.messages.controller';
+
+describe('Kafka concurrent', function () {
+  const numbersOfServers = 3;
+
+  const requestTopic = 'math.sum.sync.number.wait';
+  const responseTopic = 'math.sum.sync.number.wait.reply';
+
+  let admin: Admin;
+  const servers: any[] = [];
+  const apps: INestApplication[] = [];
+
+  const logger = new Logger('concurrent-kafka.spec.ts');
+
+  // set timeout to be longer (especially for the after hook)
+  this.timeout(30000);
+
+  const startServer = async () => {
+    const module = await Test.createTestingModule({
+      controllers: [
+        KafkaConcurrentController,
+        KafkaConcurrentMessagesController,
+      ],
+    }).compile();
+
+    // use our own logger for a little
+    // Logger.overrideLogger(new Logger());
+
+    const app = module.createNestApplication();
+
+    const server = app.getHttpAdapter().getInstance();
+
+    app.connectMicroservice({
+      transport: Transport.KAFKA,
+      options: {
+        client: {
+          brokers: ['localhost:9092'],
+        },
+        run: {
+          partitionsConsumedConcurrently: numbersOfServers,
+        },
+      },
+    });
+
+    // enable these for clean shutdown
+    app.enableShutdownHooks();
+
+    // push to the collection
+    servers.push(server);
+    apps.push(app);
+
+    // await the start
+    await app.startAllMicroservicesAsync();
+    await app.init();
+  };
+
+  it(`Create kafka topics/partitions`, async () => {
+    const kafka = new Kafka({
+      clientId: 'concurrent-test-admin',
+      brokers: ['localhost:9092'],
+    });
+
+    admin = kafka.admin();
+    await admin.connect();
+
+    let topicMetadata: {
+      topics: ITopicMetadata[];
+    };
+
+    try {
+      topicMetadata = await admin.fetchTopicMetadata({
+        topics: [requestTopic, responseTopic],
+      });
+    } catch (e) {
+      // create with number of servers
+      try {
+        await admin.createTopics({
+          topics: [
+            {
+              topic: requestTopic,
+              numPartitions: numbersOfServers,
+              replicationFactor: 1,
+            },
+            {
+              topic: responseTopic,
+              numPartitions: numbersOfServers,
+              replicationFactor: 1,
+            },
+          ],
+        });
+      } catch (e) {
+        logger.error(util.format('Create topics error: %o', e));
+      }
+    }
+
+    if (topicMetadata && topicMetadata.topics.length > 0) {
+      // we have topics, how many partitions do they have?
+      for (const topic of topicMetadata.topics) {
+        if (topic.partitions.length < numbersOfServers) {
+          try {
+            await admin.createPartitions({
+              topicPartitions: [
+                {
+                  topic: topic.name,
+                  count: numbersOfServers,
+                },
+              ],
+            });
+          } catch (e) {
+            logger.error(util.format('Create partitions error: %o', e));
+          }
+        }
+      }
+    }
+
+    // create with number of servers
+    try {
+      await admin.createTopics({
+        topics: [
+          {
+            topic: requestTopic,
+            numPartitions: numbersOfServers,
+            replicationFactor: 1,
+          },
+          {
+            topic: responseTopic,
+            numPartitions: numbersOfServers,
+            replicationFactor: 1,
+          },
+        ],
+      });
+    } catch (e) {
+      logger.error(util.format('Create topics error: %o', e));
+    }
+
+    // disconnect
+    await admin.disconnect();
+  });
+
+  it(`Start Kafka apps`, async () => {
+    // start all at once
+    await Promise.all(
+      Array(numbersOfServers)
+        .fill(1)
+        .map(async (v, i) => {
+          // return startServer();
+
+          // wait in intervals so the consumers start in order
+          return new Promise<void>(resolve => {
+            setTimeout(async () => {
+              await startServer();
+
+              return resolve();
+            }, 1000 * i);
+          });
+        }),
+    );
+  }).timeout(30000);
+
+  it(`Concurrent messages without forcing a rebalance.`, async () => {
+    // wait a second before notifying the servers to respond
+    setTimeout(async () => {
+      // notify the other servers that it is time to respond
+      await Promise.all(
+        servers.map(async server => {
+          // send to all servers since indexes don't necessarily align with server consumers
+          return request(server).post('/go').send();
+        }),
+      );
+    }, 1000);
+
+    await Promise.all(
+      servers.map(async (server, index) => {
+        // send requests
+        const payload = {
+          key: index,
+          numbers: [1, index],
+        };
+        const result = (1 + index).toString();
+
+        return request(server)
+          .post('/mathSumSyncNumberWait')
+          .send(payload)
+          .expect(200)
+          .expect(200, result);
+      }),
+    );
+  });
+
+  it(`Close kafka client consumer while waiting for message pattern response.`, async () => {
+    await Promise.all(
+      servers.map(async (server, index) => {
+        // shut off and delete the leader
+        if (index === 0) {
+          return new Promise<void>(resolve => {
+            // wait a second before closing so the producers can send the message to the server consumers
+            setTimeout(async () => {
+              // get the controller
+              const controller = apps[index].get(KafkaConcurrentController);
+
+              // close the controller clients
+              await controller.client.close();
+
+              // notify the other servers that we have stopped
+              await Promise.all(
+                servers.map(async server => {
+                  // send to all servers since indexes don't necessarily align with server consumers
+                  return request(server).post('/go').send();
+                }),
+              );
+
+              return resolve();
+            }, 1000);
+          });
+        }
+
+        // send requests
+        const payload = {
+          key: index,
+          numbers: [1, index],
+        };
+        const result = (1 + index).toString();
+
+        return request(server)
+          .post('/mathSumSyncNumberWait')
+          .send(payload)
+          .expect(200)
+          .expect(200, result);
+      }),
+    );
+  });
+
+  it(`Start kafka client consumer while waiting for message pattern response.`, async () => {
+    await Promise.all(
+      servers.map(async (server, index) => {
+        // shut off and delete the leader
+        if (index === 0) {
+          return new Promise<void>(resolve => {
+            // wait a second before closing so the producers can send the message to the server consumers
+            setTimeout(async () => {
+              // get the controller
+              const controller = apps[index].get(KafkaConcurrentController);
+
+              // connect the controller client
+              await controller.client.connect();
+
+              // notify the servers that we have started
+              await Promise.all(
+                servers.map(async server => {
+                  // send to all servers since indexes don't necessarily align with server consumers
+                  return request(server).post('/go').send();
+                }),
+              );
+
+              return resolve();
+            }, 1000);
+          });
+        }
+
+        // send requests
+        const payload = {
+          key: index,
+          numbers: [1, index],
+        };
+        const result = (1 + index).toString();
+
+        return request(server)
+          .post('/mathSumSyncNumberWait')
+          .send(payload)
+          .expect(200)
+          .expect(200, result);
+      }),
+    );
+  });
+
+  after(`Stopping Kafka app`, async () => {
+    // close all concurrently
+    return Promise.all(
+      apps.map(async app => {
+        return app.close();
+      }),
+    );
+  });
+});

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

@@ -113,6 +113,5 @@ describe('GRPC transport', () => {
 
   after(async () => {
     await app.close();
-    client.close();
   });
 });

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

@@ -9,10 +9,13 @@ import { UserEntity } from '../src/kafka/entities/user.entity';
 import { KafkaController } from '../src/kafka/kafka.controller';
 import { KafkaMessagesController } from '../src/kafka/kafka.messages.controller';
 
-describe('Kafka transport', () => {
+describe('Kafka transport', function () {
   let server;
   let app: INestApplication;
 
+  // set timeout to be longer (especially for the after hook)
+  this.timeout(30000);
+
   it(`Start Kafka app`, async () => {
     const module = await Test.createTestingModule({
       controllers: [KafkaController, KafkaMessagesController],
@@ -29,6 +32,7 @@ describe('Kafka transport', () => {
         },
       },
     });
+    app.enableShutdownHooks();
     await app.startAllMicroservicesAsync();
     await app.init();
   }).timeout(30000);

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

@@ -105,6 +105,22 @@ describe('RPC transport', () => {
       });
   });
 
+  it('/POST (custom client)', () => {
+    return request(server)
+      .post('/error?client=custom')
+      .send({})
+      .expect(200)
+      .expect('true');
+  });
+
+  it('/POST (standard client)', () => {
+    return request(server)
+      .post('/error?client=standard')
+      .send({})
+      .expect(200)
+      .expect('false');
+  });
+
   afterEach(async () => {
     await app.close();
   });

integration/microservices/src/app.controller.ts

@@ -12,15 +12,17 @@ import {
   EventPattern,
   MessagePattern,
   Transport,
+  RpcException,
 } from '@nestjs/microservices';
-import { from, Observable, of } from 'rxjs';
-import { scan } from 'rxjs/operators';
+import { from, Observable, of, throwError } from 'rxjs';
+import { catchError, scan } from 'rxjs/operators';
 
 @Controller()
 export class AppController {
   constructor(
     @Inject('USE_CLASS_CLIENT') private useClassClient: ClientProxy,
     @Inject('USE_FACTORY_CLIENT') private useFactoryClient: ClientProxy,
+    @Inject('CUSTOM_PROXY_CLIENT') private customClient: ClientProxy,
   ) {}
   static IS_NOTIFIED = false;
 
@@ -75,6 +77,17 @@ export class AppController {
       .reduce(async (a, b) => (await a) && b);
   }
 
+  @Post('error')
+  @HttpCode(200)
+  serializeError(@Query('client') query: 'custom' | 'standard' = 'standard', @Body() body: Record<string, any>): Observable<boolean> {
+    const client = query === 'custom' ? this.customClient : this.client;
+    return client.send({ cmd: 'err' }, {}).pipe(
+      catchError((err) => {
+        return of(err instanceof RpcException);
+      })
+    )
+  }
+
   @MessagePattern({ cmd: 'sum' })
   sum(data: number[]): number {
     return (data || []).reduce((a, b) => a + b);
@@ -95,6 +108,11 @@ export class AppController {
     return from(data);
   }
 
+  @MessagePattern({ cmd: 'err' })
+  throwAnError() {
+    return throwError(new Error('err'));
+  }
+
   @Post('notify')
   async sendNotification(): Promise<any> {
     return this.client.emit<number>('notification', true);

integration/microservices/src/app.module.ts

@@ -5,8 +5,16 @@ import {
   Transport,
   ClientsModuleOptionsFactory,
   ClientOptions,
+  ClientTCP,
+  RpcException,
 } from '@nestjs/microservices';
 
+class ErrorHandlingProxy extends ClientTCP {
+  serializeError(err) {
+    return new RpcException(err);
+  }
+}
+
 @Injectable()
 class ConfigService {
   private readonly config = {
@@ -51,7 +59,14 @@ class ClientOptionService implements ClientsModuleOptionsFactory {
         name: 'USE_CLASS_CLIENT',
         useClass: ClientOptionService,
         inject: [ConfigService],
-      },
+      }, {
+        imports: [ConfigModule],
+        inject: [ConfigService],
+        name: 'CUSTOM_PROXY_CLIENT',
+        useFactory: (config: ConfigService) => ({
+          customClass: ErrorHandlingProxy
+        })
+      }
     ]),
   ],
   controllers: [AppController],

integration/microservices/src/kafka-concurrent/dto/sum.dto.ts

@@ -0,0 +1,4 @@
+export class SumDto {
+  key: string;
+  numbers: number[];
+}

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

@@ -0,0 +1,70 @@
+import {
+  Body,
+  Controller,
+  HttpCode,
+  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';
+import { SumDto } from './dto/sum.dto';
+
+/**
+ * The following function explicity sends messages to the key representing the partition.
+ */
+const explicitPartitioner = () => {
+  return ({ message }: PartitionerArgs) => {
+    return parseFloat(message.headers.toPartition.toString());
+  };
+};
+
+@Controller()
+export class KafkaConcurrentController
+  implements OnModuleInit, OnModuleDestroy {
+  protected readonly logger = new Logger(KafkaConcurrentController.name);
+
+  @Client({
+    transport: Transport.KAFKA,
+    options: {
+      client: {
+        brokers: ['localhost:9092'],
+      },
+      run: {
+        partitionsConsumedConcurrently: 3,
+      },
+      producer: {
+        createPartitioner: explicitPartitioner,
+      },
+    },
+  })
+  public readonly client: ClientKafka;
+
+  async onModuleInit() {
+    const requestPatterns = ['math.sum.sync.number.wait'];
+
+    requestPatterns.forEach(pattern => {
+      this.client.subscribeToResponseOf(pattern);
+    });
+
+    await this.client.connect();
+  }
+
+  async onModuleDestroy() {
+    await this.client.close();
+  }
+
+  @Post('mathSumSyncNumberWait')
+  @HttpCode(200)
+  public mathSumSyncNumberWait(@Body() data: SumDto): Observable<string> {
+    return this.client.send('math.sum.sync.number.wait', {
+      headers: {
+        toPartition: data.key.toString(),
+      },
+      key: data.key.toString(),
+      value: data.numbers,
+    });
+  }
+}

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

@@ -0,0 +1,37 @@
+import { Controller, HttpCode, Post } from '@nestjs/common';
+import { MessagePattern } from '@nestjs/microservices';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { first, map, skipWhile } from 'rxjs/operators';
+
+@Controller()
+export class KafkaConcurrentMessagesController {
+  public waiting = new BehaviorSubject<boolean>(false);
+
+  @Post('go')
+  @HttpCode(200)
+  async go() {
+    // no longer waiting
+    this.waiting.next(false);
+
+    return;
+  }
+
+  @MessagePattern('math.sum.sync.number.wait')
+  public mathSumSyncNumberWait(data: any): Observable<number> {
+    // start waiting
+    this.waiting.next(true);
+
+    // find sum
+    const sum = data.value[0] + data.value[1];
+
+    return this.waiting.asObservable().pipe(
+      skipWhile(isWaiting => {
+        return isWaiting;
+      }),
+      map(() => {
+        return sum;
+      }),
+      first(),
+    );
+  }
+}

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

@@ -1,4 +1,11 @@
-import { Body, Controller, HttpCode, OnModuleInit, Post } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  HttpCode,
+  OnModuleInit,
+  Post,
+  OnModuleDestroy,
+} from '@nestjs/common';
 import { Logger } from '@nestjs/common/services/logger.service';
 import { Client, ClientKafka, Transport } from '@nestjs/microservices';
 import { Observable } from 'rxjs';
@@ -6,7 +13,7 @@ import { BusinessDto } from './dtos/business.dto';
 import { UserDto } from './dtos/user.dto';
 
 @Controller()
-export class KafkaController implements OnModuleInit {
+export class KafkaController implements OnModuleInit, OnModuleDestroy {
   protected readonly logger = new Logger(KafkaController.name);
   static IS_NOTIFIED = false;
   static MATH_SUM = 0;
@@ -21,7 +28,7 @@ export class KafkaController implements OnModuleInit {
   })
   private readonly client: ClientKafka;
 
-  onModuleInit() {
+  async onModuleInit() {
     const requestPatterns = [
       'math.sum.sync.kafka.message',
       'math.sum.sync.without.key',
@@ -36,6 +43,12 @@ export class KafkaController implements OnModuleInit {
     requestPatterns.forEach(pattern => {
       this.client.subscribeToResponseOf(pattern);
     });
+
+    await this.client.connect();
+  }
+
+  async onModuleDestroy() {
+    await this.client.close();
   }
 
   // sync send kafka message

integration/websockets/e2e/error-gateway.spec.ts

@@ -20,7 +20,7 @@ describe('ErrorGateway', () => {
     ws.emit('push', {
       test: 'test',
     });
-    await new Promise(resolve =>
+    await new Promise<void>(resolve =>
       ws.on('exception', data => {
         expect(data).to.be.eql({
           status: 'error',

integration/websockets/e2e/gateway-ack.spec.ts

@@ -20,7 +20,7 @@ describe('WebSocketGateway (ack)', () => {
     await app.listenAsync(3000);
 
     ws = io.connect('http://localhost:8080');
-    await new Promise(resolve =>
+    await new Promise<void>(resolve =>
       ws.emit('push', { test: 'test' }, data => {
         expect(data).to.be.eql('pong');
         resolve();
@@ -33,7 +33,7 @@ describe('WebSocketGateway (ack)', () => {
     await app.listenAsync(3000);
 
     ws = io.connect('http://localhost:8080');
-    await new Promise(resolve =>
+    await new Promise<void>(resolve =>
       ws.emit('push', data => {
         expect(data).to.be.eql('pong');
         resolve();

integration/websockets/e2e/gateway.spec.ts

@@ -25,7 +25,7 @@ describe('WebSocketGateway', () => {
     ws.emit('push', {
       test: 'test',
     });
-    await new Promise(resolve =>
+    await new Promise<void>(resolve =>
       ws.on('pop', data => {
         expect(data.test).to.be.eql('test');
         resolve();
@@ -41,7 +41,7 @@ describe('WebSocketGateway', () => {
     ws.emit('push', {
       test: 'test',
     });
-    await new Promise(resolve =>
+    await new Promise<void>(resolve =>
       ws.on('pop', data => {
         expect(data.test).to.be.eql('test');
         resolve();
@@ -58,7 +58,7 @@ describe('WebSocketGateway', () => {
     ws.emit('push', {
       test: 'test',
     });
-    await new Promise(resolve =>
+    await new Promise<void>(resolve =>
       ws.on('pop', data => {
         expect(data.test).to.be.eql('test');
         resolve();

integration/websockets/e2e/ws-gateway.spec.ts

@@ -34,7 +34,7 @@ describe('WebSocketGateway (WsAdapter)', () => {
         },
       }),
     );
-    await new Promise(resolve =>
+    await new Promise<void>(resolve =>
       ws.on('message', data => {
         expect(JSON.parse(data).data.test).to.be.eql('test');
         resolve();
@@ -57,7 +57,7 @@ describe('WebSocketGateway (WsAdapter)', () => {
         },
       }),
     );
-    await new Promise(resolve =>
+    await new Promise<void>(resolve =>
       ws.on('message', data => {
         expect(JSON.parse(data).data.test).to.be.eql('test');
         resolve();
@@ -77,7 +77,7 @@ describe('WebSocketGateway (WsAdapter)', () => {
     ws = new WebSocket('ws://localhost:8080');
     ws2 = new WebSocket('ws://localhost:8090');
 
-    await new Promise(resolve =>
+    await new Promise<void>(resolve =>
       ws.on('open', () => {
         ws.on('message', data => {
           expect(JSON.parse(data).data.test).to.be.eql('test');
@@ -94,7 +94,7 @@ describe('WebSocketGateway (WsAdapter)', () => {
       }),
     );
 
-    await new Promise(resolve => {
+    await new Promise<void>(resolve => {
       ws2.on('message', data => {
         expect(JSON.parse(data).data.test).to.be.eql('test');
         resolve();

lerna.json

@@ -3,5 +3,5 @@
   "packages": [
     "packages/*"
   ],
-  "version": "7.5.5"
+  "version": "7.6.14"
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "7.5.3",
+  "version": "7.6.8",
   "description": "Modern, fast, powerful node.js web framework",
   "homepage": "https://nestjs.com",
   "repository": {
@@ -29,9 +29,10 @@
     "test:docker:up": "docker-compose -f integration/docker-compose.yml up -d",
     "test:docker:down": "docker-compose -f integration/docker-compose.yml down",
     "lint": "concurrently 'npm run lint:packages' 'npm run lint:integration' 'npm run lint:spec'",
-    "lint:integration": "eslint 'integration/*/{,!(node_modules)/**/}/*.ts' -c '.eslintrc.spec.js' --fix",
-    "lint:packages": "eslint 'packages/**/**.ts' --fix --ignore-pattern 'packages/**/*.spec.ts'",
-    "lint:spec": "eslint 'packages/**/**.spec.ts' -c '.eslintrc.spec.js' --fix",
+    "lint:fix": "concurrently 'npm run lint:packages -- --fix' 'npm run lint:integration -- --fix' 'npm run lint:spec -- --fix'",
+    "lint:integration": "eslint 'integration/*/{,!(node_modules)/**/}/*.ts' -c '.eslintrc.spec.js'",
+    "lint:packages": "eslint 'packages/**/**.ts' --ignore-pattern 'packages/**/*.spec.ts'",
+    "lint:spec": "eslint 'packages/**/**.spec.ts' -c '.eslintrc.spec.js'",
     "prerelease": "gulp copy-misc && gulp build --dist node_modules/@nestjs",
     "publish": "npm run prerelease && npm run build:prod && ./node_modules/.bin/lerna publish --force-publish --access public --exact -m \"chore(@nestjs) publish %s release\"",
     "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\"",
@@ -52,119 +53,119 @@
   },
   "dependencies": {
     "@nuxtjs/opencollective": "0.3.2",
-    "axios": "0.21.0",
-    "class-transformer": "0.3.1",
-    "class-validator": "0.12.2",
+    "axios": "0.21.1",
+    "class-transformer": "0.4.0",
+    "class-validator": "0.13.1",
     "cli-color": "2.0.0",
     "cors": "2.8.5",
     "express": "4.17.1",
-    "fast-json-stringify": "2.2.10",
+    "fast-json-stringify": "2.5.1",
     "fast-safe-stringify": "2.0.7",
     "iterare": "1.2.1",
-    "object-hash": "2.0.3",
+    "object-hash": "2.1.1",
     "path-to-regexp": "3.2.0",
     "reflect-metadata": "0.1.13",
-    "rxjs": "6.6.3",
-    "socket.io": "2.3.0",
-    "uuid": "8.3.1",
-    "tslib": "2.0.3"
+    "rxjs": "6.6.6",
+    "socket.io": "2.4.1",
+    "tslib": "2.1.0",
+    "uuid": "8.3.2"
   },
   "devDependencies": {
     "@codechecks/client": "0.1.10",
-    "@commitlint/cli": "11.0.0",
-    "@commitlint/config-angular": "11.0.0",
-    "@grpc/proto-loader": "0.5.5",
-    "@nestjs/graphql": "7.9.1",
-    "@nestjs/mongoose": "7.1.2",
+    "@commitlint/cli": "12.0.1",
+    "@commitlint/config-angular": "12.0.1",
+    "@grpc/proto-loader": "0.5.6",
+    "@nestjs/graphql": "7.9.11",
+    "@nestjs/mongoose": "7.2.4",
     "@nestjs/typeorm": "7.1.5",
-    "@types/amqplib": "0.5.16",
+    "@types/amqplib": "0.5.17",
     "@types/bytes": "3.1.0",
-    "@types/cache-manager": "2.10.3",
-    "@types/chai": "4.2.14",
+    "@types/cache-manager": "3.4.0",
+    "@types/chai": "4.2.15",
     "@types/chai-as-promised": "7.1.3",
-    "@types/cors": "2.8.8",
-    "@types/express": "4.17.9",
-    "@types/gulp": "4.0.7",
-    "@types/mocha": "8.0.4",
-    "@types/mongoose": "5.10.2",
-    "@types/node": "14.14.10",
+    "@types/cors": "2.8.10",
+    "@types/express": "4.17.11",
+    "@types/gulp": "4.0.8",
+    "@types/mocha": "8.2.1",
+    "@types/mongoose": "5.10.3",
+    "@types/node": "14.14.33",
     "@types/redis": "2.8.28",
     "@types/reflect-metadata": "0.1.0",
-    "@types/sinon": "9.0.9",
-    "@types/socket.io": "2.1.12",
+    "@types/sinon": "9.0.11",
+    "@types/socket.io": "2.1.13",
     "@types/ws": "7.4.0",
-    "@typescript-eslint/eslint-plugin": "4.9.1",
-    "@typescript-eslint/parser": "4.9.0",
-    "amqp-connection-manager": "3.2.1",
-    "amqplib": "0.6.0",
-    "apollo-server-express": "2.19.0",
-    "artillery": "1.6.1",
+    "@typescript-eslint/eslint-plugin": "4.17.0",
+    "@typescript-eslint/parser": "4.17.0",
+    "amqp-connection-manager": "3.2.2",
+    "amqplib": "0.7.1",
+    "apollo-server-express": "2.21.1",
+    "artillery": "1.6.2",
     "awesome-typescript-loader": "5.2.1",
     "body-parser": "1.19.0",
     "bytes": "3.1.0",
-    "cache-manager": "3.4.0",
-    "chai": "4.2.0",
+    "cache-manager": "3.4.1",
+    "chai": "4.3.3",
     "chai-as-promised": "7.1.1",
-    "clang-format": "1.4.0",
+    "clang-format": "1.5.0",
     "commitlint-circle": "1.0.0",
-    "concurrently": "5.3.0",
+    "concurrently": "6.0.0",
     "conventional-changelog": "3.1.24",
-    "core-js": "3.8.1",
+    "core-js": "3.9.1",
     "coveralls": "3.1.0",
     "delete-empty": "3.0.0",
-    "engine.io-client": "4.0.4",
-    "eslint": "7.15.0",
-    "eslint-config-prettier": "7.0.0",
+    "engine.io-client": "5.0.0",
+    "eslint": "7.21.0",
+    "eslint-config-prettier": "8.1.0",
     "eslint-plugin-import": "2.22.1",
     "eventsource": "1.0.7",
     "fancy-log": "1.3.3",
-    "fastify": "3.9.1",
-    "fastify-cors": "5.0.0",
+    "fastify": "3.14.0",
+    "fastify-cors": "5.2.0",
     "fastify-formbody": "5.0.0",
-    "fastify-multipart": "3.3.1",
-    "fastify-static": "3.3.0",
-    "graphql": "15.4.0",
-    "graphql-tools": "7.0.2",
-    "grpc": "1.24.4",
+    "fastify-multipart": "4.0.1",
+    "fastify-static": "4.0.1",
+    "graphql": "15.5.0",
+    "graphql-tools": "7.0.4",
+    "grpc": "1.24.6",
     "gulp": "4.0.2",
     "gulp-clang-format": "1.0.27",
     "gulp-clean": "0.4.0",
     "gulp-sourcemaps": "3.0.0",
     "gulp-typescript": "5.0.1",
     "gulp-watch": "5.0.1",
-    "husky": "4.3.5",
-    "imports-loader": "1.2.0",
+    "husky": "5.1.3",
+    "imports-loader": "2.0.0",
     "json-loader": "0.5.7",
-    "kafkajs": "1.12.0",
+    "kafkajs": "1.15.0",
     "lerna": "2.11.0",
-    "light-my-request": "4.3.0",
-    "lint-staged": "10.5.3",
+    "light-my-request": "4.4.1",
+    "lint-staged": "10.5.4",
     "markdown-table": "2.0.0",
     "merge-graphql-schemas": "1.7.8",
     "middie": "5.2.0",
-    "mocha": "8.2.1",
-    "mongoose": "5.11.5",
+    "mocha": "8.3.1",
+    "mongoose": "5.12.0",
     "mqtt": "4.2.6",
     "multer": "1.4.2",
     "mysql": "2.18.1",
     "nats": "1.4.12",
-    "nodemon": "2.0.6",
+    "nodemon": "2.0.7",
     "nyc": "15.1.0",
-    "point-of-view": "4.7.0",
+    "point-of-view": "4.14.0",
     "prettier": "2.2.1",
     "redis": "3.0.2",
-    "rxjs-compat": "6.6.3",
-    "sinon": "9.2.1",
+    "rxjs-compat": "6.6.6",
+    "sinon": "9.2.4",
     "sinon-chai": "3.5.0",
-    "socket.io-client": "2.3.1",
+    "socket.io-client": "2.4.0",
     "subscriptions-transport-ws": "0.9.18",
-    "supertest": "6.0.1",
-    "ts-morph": "9.1.0",
+    "supertest": "6.1.3",
+    "ts-morph": "10.0.1",
     "ts-node": "9.1.1",
-    "typeorm": "0.2.29",
-    "typescript": "4.0.3",
+    "typeorm": "0.2.31",
+    "typescript": "4.2.3",
     "wrk": "1.2.1",
-    "ws": "7.4.1"
+    "ws": "7.4.4"
   },
   "engines": {
     "node": ">= 10.13.0"

packages/common/Readme.md

@@ -56,16 +56,21 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 
 #### Principal Sponsors
 <table style="text-align:center;"><tr><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://valor-software.com/" target="_blank"><img src="https://docs.nestjs.com/assets/sponsors/valor-software.png" width="180" valign="middle" /></a></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>
 </tr></table>
 
+#### Gold Sponsors
+
+<table style="text-align:center;"><tr><td>
+<a href="https://valor-software.com/" target="_blank"><img src="https://docs.nestjs.com/assets/sponsors/valor-software.png" width="170" valign="middle" /></a></td></tr></table>
+
 #### Silver 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="https://trilon.io" target="_blank"><img src="https://nestjs.com/img/trilon.svg" width="170" valign="middle" /></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="http://www.meetdandy.com" target="_blank"><img src="https://nestjs.com/img/dandy-wide-logo.png" width="150" valign="middle" /></td></tr></table>
 
@@ -90,6 +95,11 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
   <td align="center" valign="middle">
   <a href="https://genuinebee.com/" target="_blank"><img src="https://nestjs.com/img/genuinebee.svg" width="97" valign="middle" /></a> </td>
 <td align="center" valign="middle"><a href="https://sanyodigital.com/" target="_blank"><img src="https://nestjs.com/img/sanyo-digital.png" width="130" valign="middle" /></a></td></tr><tr><td align="center" valign="middle"><a href="https://vpn-review.com/vpn-for-torrenting" target="_blank"><img src="https://nestjs.com/img/vpn-review-logo.png" width="85" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://lambda-it.ch/" target="_blank"><img src="https://nestjs.com/img/lambda-it-logo.svg" width="115" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://pickwriters.com/top-10-translation-services" target="_blank"><img src="https://nestjs.com/img/pickwriters-logo.png" width="40" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://thewordpoint.com/services/localization" target="_blank"><img src="https://nestjs.com/img/thewordpoint-logo.png" width="40" valign="middle" /></a></td>
+<td align="center" valign="middle"><a href="https://streamat.se/" target="_blank"><img src="https://nestjs.com/img/streamat-logo.png" width="120" valign="middle" /></a></td>
+<td align="center" valign="middle"><a href="https://filmen.nu/" target="_blank"><img src="https://nestjs.com/img/filmen-logo.png" width="120" valign="middle" /></a></td></tr><tr>
+<td align="center" valign="middle"><a href="https://meercode.io/" target="_blank"><img src="https://nestjs.com/img/meercode-logo.png" width="60" valign="middle" /></a></td>
+  <td align="center" valign="middle"><a href="https://www.najlepszeplatformyforex.pl/blog/broker-xtb/" target="_blank"><img src="https://nestjs.com/img/npf-logo.jpg" width="200" valign="middle" /></a></td>
+    <td align="center" valign="middle"><a href="https://thestandarddaily.com/" target="_blank"><img src="https://nestjs.com/img/the-standard-daily-logo.png" width="180" valign="middle" /></a></td>
   </tr></table>
 
 ## Backers

packages/common/cache/interceptors/cache.interceptor.ts

@@ -37,8 +37,7 @@ export class CacheInterceptor implements NestInterceptor {
     next: CallHandler,
   ): Promise<Observable<any>> {
     const key = this.trackBy(context);
-    const ttlValueOrFactory =
-      this.reflector.get(CACHE_TTL_METADATA, context.getHandler()) || null;
+    const ttlValueOrFactory = this.reflector.get(CACHE_TTL_METADATA, context.getHandler()) ?? null;
 
     if (!key) {
       return next.handle();

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

@@ -27,7 +27,7 @@ export interface ControllerOptions extends ScopeOptions {
    *
    * @see [Routing](https://docs.nestjs.com/controllers#routing)
    */
-  host?: string;
+  host?: string | string[];
 }
 
 /**

packages/common/decorators/http/route-params.decorator.ts

@@ -167,7 +167,7 @@ export const Session: () => ParameterDecorator = createRouteParamDecorator(
  * Route handler parameter decorator. Extracts the `file` object
  * and populates the decorated parameter with the value of `file`.
  * Used in conjunction with
- * [multer middleware](https://github.com/expressjs/multer).
+ * [multer middleware](https://github.com/expressjs/multer) for Express-based applications.
  *
  * For example:
  * ```typescript
@@ -179,15 +179,78 @@ export const Session: () => ParameterDecorator = createRouteParamDecorator(
  *
  * @publicApi
  */
-export const UploadedFile: (
+export function UploadedFile(): ParameterDecorator;
+/**
+ * Route handler parameter decorator. Extracts the `file` object
+ * and populates the decorated parameter with the value of `file`.
+ * Used in conjunction with
+ * [multer middleware](https://github.com/expressjs/multer) for Express-based applications.
+ *
+ * For example:
+ * ```typescript
+ * uploadFile(@UploadedFile() file) {
+ *   console.log(file);
+ * }
+ * ```
+ * @see [Request object](https://docs.nestjs.com/techniques/file-upload)
+ *
+ * @publicApi
+ */
+export function UploadedFile(
+  ...pipes: (Type<PipeTransform> | PipeTransform)[]
+): ParameterDecorator;
+
+/**
+ * Route handler parameter decorator. Extracts the `file` object
+ * and populates the decorated parameter with the value of `file`.
+ * Used in conjunction with
+ * [multer middleware](https://github.com/expressjs/multer) for Express-based applications.
+ *
+ * For example:
+ * ```typescript
+ * uploadFile(@UploadedFile() file) {
+ *   console.log(file);
+ * }
+ * ```
+ * @see [Request object](https://docs.nestjs.com/techniques/file-upload)
+ *
+ * @publicApi
+ */
+export function UploadedFile(
   fileKey?: string,
-) => ParameterDecorator = createRouteParamDecorator(RouteParamtypes.FILE);
+  ...pipes: (Type<PipeTransform> | PipeTransform)[]
+): ParameterDecorator;
+/**
+ * Route handler parameter decorator. Extracts the `file` object
+ * and populates the decorated parameter with the value of `file`.
+ * Used in conjunction with
+ * [multer middleware](https://github.com/expressjs/multer) for Express-based applications.
+ *
+ * For example:
+ * ```typescript
+ * uploadFile(@UploadedFile() file) {
+ *   console.log(file);
+ * }
+ * ```
+ * @see [Request object](https://docs.nestjs.com/techniques/file-upload)
+ *
+ * @publicApi
+ */
+export function UploadedFile(
+  fileKey?: string | (Type<PipeTransform> | PipeTransform),
+  ...pipes: (Type<PipeTransform> | PipeTransform)[]
+): ParameterDecorator {
+  return createPipesRouteParamDecorator(RouteParamtypes.FILE)(
+    fileKey,
+    ...pipes,
+  );
+}
 
 /**
  * Route handler parameter decorator. Extracts the `files` object
  * and populates the decorated parameter with the value of `files`.
  * Used in conjunction with
- * [multer middleware](https://github.com/expressjs/multer).
+ * [multer middleware](https://github.com/expressjs/multer) for Express-based applications.
  *
  * For example:
  * ```typescript
@@ -199,9 +262,51 @@ export const UploadedFile: (
  *
  * @publicApi
  */
-export const UploadedFiles: () => ParameterDecorator = createRouteParamDecorator(
-  RouteParamtypes.FILES,
-);
+export function UploadedFiles(): ParameterDecorator;
+/**
+ * Route handler parameter decorator. Extracts the `files` object
+ * and populates the decorated parameter with the value of `files`.
+ * Used in conjunction with
+ * [multer middleware](https://github.com/expressjs/multer) for Express-based applications.
+ *
+ * For example:
+ * ```typescript
+ * uploadFile(@UploadedFiles() files) {
+ *   console.log(files);
+ * }
+ * ```
+ * @see [Request object](https://docs.nestjs.com/techniques/file-upload)
+ *
+ * @publicApi
+ */
+export function UploadedFiles(
+  ...pipes: (Type<PipeTransform> | PipeTransform)[]
+): ParameterDecorator;
+/**
+ * Route handler parameter decorator. Extracts the `files` object
+ * and populates the decorated parameter with the value of `files`.
+ * Used in conjunction with
+ * [multer middleware](https://github.com/expressjs/multer) for Express-based applications.
+ *
+ * For example:
+ * ```typescript
+ * uploadFile(@UploadedFiles() files) {
+ *   console.log(files);
+ * }
+ * ```
+ * @see [Request object](https://docs.nestjs.com/techniques/file-upload)
+ *
+ * @publicApi
+ */
+export function UploadedFiles(
+  ...pipes: (Type<PipeTransform> | PipeTransform)[]
+): ParameterDecorator {
+  return createPipesRouteParamDecorator(RouteParamtypes.FILES)(
+    undefined,
+    ...pipes,
+  );
+}
+
 /**
  * Route handler parameter decorator. Extracts the `headers`
  * property from the `req` object and populates the decorated

packages/common/exceptions/http.exception.ts

@@ -78,4 +78,3 @@ export class HttpException extends Error {
       : { statusCode, message: objectOrError, error: description };
   }
 }
-

packages/common/interfaces/external/class-transform-options.interface.ts

@@ -50,4 +50,16 @@ export interface ClassTransformOptions {
    * and exposing all class properties (with undefined, if nothing else is given)
    */
   excludeExtraneousValues?: boolean;
+  /**
+   * If set to true then class transformer will take default values for unprovided fields.
+   * This is useful when you convert a plain object to a class and have an optional field with a default value.
+   */
+  exposeDefaultValues?: boolean;
+  /**
+   * When set to true, fields with `undefined` as value will be included in class to plain transformation. Otherwise
+   * those fields will be omitted from the result.
+   *
+   * DEFAULT: `true`
+   */
+  exposeUnsetFields?: boolean;
 }

packages/common/interfaces/external/cors-options.interface.ts

@@ -1,3 +1,5 @@
+type StaticOrigin = boolean | string | RegExp | (string | RegExp)[];
+
 /**
  * Set origin to a function implementing some custom logic. The function takes the
  * request origin as the first parameter and a callback (which expects the signature
@@ -9,7 +11,7 @@
  */
 export type CustomOrigin = (
   requestOrigin: string,
-  callback: (err: Error | null, allow?: boolean) => void,
+  callback: (err: Error | null, origin?: StaticOrigin) => void,
 ) => void;
 
 /**
@@ -22,7 +24,7 @@ export interface CorsOptions {
   /**
    * Configures the `Access-Control-Allow-Origins` CORS header.  See [here for more detail.](https://github.com/expressjs/cors#configuration-options)
    */
-  origin?: boolean | string | RegExp | (string | RegExp)[] | CustomOrigin;
+  origin?: StaticOrigin | CustomOrigin;
   /**
    * Configures the Access-Control-Allow-Methods CORS header.
    */
@@ -52,3 +54,10 @@ export interface CorsOptions {
    */
   optionsSuccessStatus?: number;
 }
+
+export interface CorsOptionsCallback {
+  (error: Error, options: CorsOptions): void;
+}
+export interface CorsOptionsDelegate<T> {
+  (req: T, cb: CorsOptionsCallback): void;
+}

packages/common/interfaces/external/validation-error.interface.ts

@@ -2,29 +2,41 @@
  * Validation error description.
  * @see https://github.com/typestack/class-validator
  *
+ * class-validator@0.13.0
+ *
  * @publicApi
  */
 export interface ValidationError {
   /**
    * Object that was validated.
+   *
+   * OPTIONAL - configurable via the ValidatorOptions.validationError.target option
    */
-  target: Record<string, any>;
+  target?: Record<string, any>;
   /**
    * Object's property that hasn't passed validation.
    */
   property: string;
   /**
-   * Value that hasn't passed validation.
+   * Value that haven't pass a validation.
+   *
+   * OPTIONAL - configurable via the ValidatorOptions.validationError.value option
    */
-  value: any;
+  value?: any;
   /**
    * Constraints that failed validation with error messages.
    */
-  constraints: {
+  constraints?: {
     [type: string]: string;
   };
   /**
    * Contains all nested validation errors of the property.
    */
-  children: ValidationError[];
+  children?: ValidationError[];
+  /**
+   * A transient set of data passed through to the validation result for response mapping
+   */
+  contexts?: {
+    [type: string]: any;
+  };
 }

packages/common/interfaces/external/validator-options.interface.ts

@@ -2,11 +2,15 @@
  * Options passed to validator during validation.
  * @see https://github.com/typestack/class-validator
  *
- * class-validator@0.10.1
+ * class-validator@0.13.0
  *
  * @publicApi
  */
 export interface ValidatorOptions {
+  /**
+   * If set to true then class-validator will print extra warning messages to the console when something is not right.
+   */
+  enableDebugMessages?: boolean;
   /**
    * If set to true then validator will skip validation of all properties that are undefined in the validating object.
    */
@@ -33,6 +37,15 @@ export interface ValidatorOptions {
    * Groups to be used during validation of the object.
    */
   groups?: string[];
+  /**
+   * Set default for `always` option of decorators. Default can be overridden in decorator options.
+   */
+  always?: boolean;
+  /**
+   * If [groups]{@link ValidatorOptions#groups} is not given or is empty,
+   * ignore decorators with at least one group.
+   */
+  strictGroups?: boolean;
   /**
    * If set to true, the validation will not use default messages.
    * Error message always will be undefined if its not explicitly set.
@@ -55,4 +68,8 @@ export interface ValidatorOptions {
    * Settings true will cause fail validation of unknown objects.
    */
   forbidUnknownValues?: boolean;
+  /**
+   * When set to true, validation of the given property will stop after encountering the first error. Defaults to false.
+   */
+  stopAtFirstError?: boolean;
 }

packages/common/interfaces/http/http-server.interface.ts

@@ -1,5 +1,8 @@
 import { RequestMethod } from '../../enums';
-import { CorsOptions } from '../../interfaces/external/cors-options.interface';
+import {
+  CorsOptions,
+  CorsOptionsDelegate,
+} from '../../interfaces/external/cors-options.interface';
 import { NestApplicationOptions } from '../../interfaces/nest-application-options.interface';
 
 export type ErrorHandler<TRequest = any, TResponse = any> = (
@@ -59,10 +62,10 @@ export interface HttpServer<TRequest = any, TResponse = any> {
     | Promise<(path: string, callback: Function) => any>;
   getRequestHostname?(request: TRequest): string;
   getRequestMethod?(request: TRequest): string;
-  getRequestUrl?(request: TResponse): string;
+  getRequestUrl?(request: TRequest): string;
   getInstance(): any;
   registerParserMiddleware(): any;
-  enableCors(options: CorsOptions): any;
+  enableCors(options: CorsOptions | CorsOptionsDelegate<TRequest>): any;
   getHttpServer(): any;
   initHttpServer(options: NestApplicationOptions): void;
   close(): any;

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

@@ -1,6 +1,7 @@
 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';
 
 /**
@@ -13,7 +14,7 @@ export interface INestApplicationContext {
    * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
    * @returns {INestApplicationContext}
    */
-  select<T>(module: Type<T>): INestApplicationContext;
+  select<T>(module: Type<T> | DynamicModule): INestApplicationContext;
 
   /**
    * Retrieves an instance of either injectable or controller, otherwise, throws exception.

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

@@ -1,4 +1,7 @@
-import { CorsOptions } from './external/cors-options.interface';
+import {
+  CorsOptions,
+  CorsOptionsDelegate,
+} from './external/cors-options.interface';
 import { HttpsOptions } from './external/https-options.interface';
 import { NestApplicationContextOptions } from './nest-application-context-options.interface';
 
@@ -9,7 +12,7 @@ export interface NestApplicationOptions extends NestApplicationContextOptions {
   /**
    * CORS options from [CORS package](https://github.com/expressjs/cors#configuration-options)
    */
-  cors?: boolean | CorsOptions;
+  cors?: boolean | CorsOptions | CorsOptionsDelegate<any>;
   /**
    * Whether to use underlying platform body parser.
    */

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

@@ -1,4 +1,7 @@
-import { CorsOptions } from './external/cors-options.interface';
+import {
+  CorsOptions,
+  CorsOptionsDelegate,
+} from './external/cors-options.interface';
 import { CanActivate } from './features/can-activate.interface';
 import { NestInterceptor } from './features/nest-interceptor.interface';
 import { HttpServer } from './http/http-server.interface';
@@ -30,7 +33,7 @@ export interface INestApplication extends INestApplicationContext {
    *
    * @returns {void}
    */
-  enableCors(options?: CorsOptions): void;
+  enableCors(options?: CorsOptions | CorsOptionsDelegate<any>): void;
 
   /**
    * Starts the application.

packages/common/interfaces/type.interface.ts

@@ -1,3 +1,3 @@
-export interface Type<T> extends Function {
+export interface Type<T = any> extends Function {
   new (...args: any[]): T;
 }

packages/common/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/common",
-  "version": "7.5.5",
+  "version": "7.6.14",
   "description": "Nest - modern, fast, powerful node.js web framework (@common)",
   "author": "Kamil Mysliwiec",
   "homepage": "https://nestjs.com",
@@ -17,13 +17,27 @@
   },
   "license": "MIT",
   "dependencies": {
-    "axios": "0.21.0",
+    "axios": "0.21.1",
     "iterare": "1.2.1",
-    "tslib": "2.0.3",
-    "uuid": "8.3.1"
+    "tslib": "2.1.0",
+    "uuid": "8.3.2"
   },
   "peerDependencies": {
+    "cache-manager": "*",
+    "class-transformer": "*",
+    "class-validator": "*",
     "reflect-metadata": "^0.1.12",
     "rxjs": "^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "cache-manager": {
+      "optional": true
+    },
+    "class-validator": {
+      "optional": true
+    },
+    "class-transformer": {
+      "optional": true
+    }
   }
 }

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

@@ -1,4 +1,5 @@
-import { ArgumentMetadata, Injectable, PipeTransform } from '../index';
+import { Injectable } from '../decorators/core/injectable.decorator';
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface';
 import { isNil } from '../utils/shared.utils';
 
 /**

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

@@ -1,6 +1,8 @@
-import { ArgumentMetadata, HttpStatus, Injectable, Optional } from '../index';
+import { Injectable } from '../decorators/core/injectable.decorator';
+import { Optional } from '../decorators/core/optional.decorator';
+import { HttpStatus } from '../enums/http-status.enum';
 import { Type } from '../interfaces';
-import { PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface';
 import { HttpErrorByCode } from '../utils/http-error-by-code.util';
 import { isNil, isString } from '../utils/shared.utils';
 import { ValidationPipe, ValidationPipeOptions } from './validation.pipe';
@@ -86,7 +88,39 @@ export class ParseArrayPipe implements PipeTransform {
         } catch {}
         return this.validationPipe.transform(item, validationMetadata);
       };
-      value = await Promise.all(value.map(toClassInstance));
+      if (this.options.stopAtFirstError === false) {
+        // strict compare to "false" to make sure
+        // that this option is disabled by default
+        let errors = [];
+
+        const targetArray = value as Array<unknown>;
+        for (let i = 0; i < targetArray.length; i++) {
+          try {
+            targetArray[i] = await toClassInstance(targetArray[i]);
+          } catch (err) {
+            let message: string[] | unknown;
+            if (err.getResponse) {
+              const response = err.getResponse();
+              if (Array.isArray(response.message)) {
+                message = response.message.map(
+                  (item: string) => `[${i}] ${item}`,
+                );
+              } else {
+                message = `[${i}] ${response.message}`;
+              }
+            } else {
+              message = err;
+            }
+            errors = errors.concat(message);
+          }
+        }
+        if (errors.length > 0) {
+          throw this.exceptionFactory(errors as any);
+        }
+        return targetArray;
+      } else {
+        value = await Promise.all(value.map(toClassInstance));
+      }
     }
     return value;
   }

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

@@ -1,5 +1,7 @@
-import { ArgumentMetadata, HttpStatus, Injectable, Optional } from '../index';
-import { PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { Injectable } from '../decorators/core/injectable.decorator';
+import { Optional } from '../decorators/core/optional.decorator';
+import { HttpStatus } from '../enums/http-status.enum';
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface';
 import {
   ErrorHttpStatusCode,
   HttpErrorByCode,

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

@@ -1,5 +1,7 @@
-import { ArgumentMetadata, HttpStatus, Injectable, Optional } from '../index';
-import { PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { Injectable } from '../decorators/core/injectable.decorator';
+import { Optional } from '../decorators/core/optional.decorator';
+import { HttpStatus } from '../enums/http-status.enum';
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface';
 import {
   ErrorHttpStatusCode,
   HttpErrorByCode,

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

@@ -1,6 +1,7 @@
-import { Optional } from '../decorators';
-import { ArgumentMetadata, HttpStatus, Injectable } from '../index';
-import { PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { Injectable } from '../decorators/core/injectable.decorator';
+import { Optional } from '../decorators/core/optional.decorator';
+import { HttpStatus } from '../enums/http-status.enum';
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface';
 import {
   ErrorHttpStatusCode,
   HttpErrorByCode,

packages/common/pipes/validation.pipe.ts

@@ -2,10 +2,10 @@ import { iterate } from 'iterare';
 import { Optional } from '../decorators';
 import { Injectable } from '../decorators/core';
 import { HttpStatus } from '../enums/http-status.enum';
-import { ArgumentMetadata, ValidationError } from '../index';
 import { ClassTransformOptions } from '../interfaces/external/class-transform-options.interface';
+import { ValidationError } from '../interfaces/external/validation-error.interface';
 import { ValidatorOptions } from '../interfaces/external/validator-options.interface';
-import { PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface';
 import { Type } from '../interfaces/type.interface';
 import {
   ErrorHttpStatusCode,
@@ -199,27 +199,35 @@ export class ValidationPipe implements PipeTransform<any> {
 
   protected mapChildrenToValidationErrors(
     error: ValidationError,
+    parentPath?: string,
   ): ValidationError[] {
     if (!(error.children && error.children.length)) {
       return [error];
     }
     const validationErrors = [];
+    parentPath = parentPath
+      ? `${parentPath}.${error.property}`
+      : error.property;
     for (const item of error.children) {
       if (item.children && item.children.length) {
-        validationErrors.push(...this.mapChildrenToValidationErrors(item));
+        validationErrors.push(
+          ...this.mapChildrenToValidationErrors(item, parentPath),
+        );
       }
-      validationErrors.push(this.prependConstraintsWithParentProp(error, item));
+      validationErrors.push(
+        this.prependConstraintsWithParentProp(parentPath, item),
+      );
     }
     return validationErrors;
   }
 
   protected prependConstraintsWithParentProp(
-    parentError: ValidationError,
+    parentPath: string,
     error: ValidationError,
   ): ValidationError {
     const constraints = {};
     for (const key in error.constraints) {
-      constraints[key] = `${parentError.property}.${error.constraints[key]}`;
+      constraints[key] = `${parentPath}.${error.constraints[key]}`;
     }
     return {
       ...error,

packages/common/serializer/class-serializer.interceptor.ts

@@ -71,7 +71,7 @@ export class ClassSerializerInterceptor implements NestInterceptor {
       : plainOrClass;
   }
 
-  private getContextOptions(
+  protected getContextOptions(
     context: ExecutionContext,
   ): ClassTransformOptions | undefined {
     return (

packages/common/services/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 { isObject } from '../utils/shared.utils';
+import { isObject, isPlainObject } from '../utils/shared.utils';
 
 declare const process: any;
 
@@ -83,7 +83,7 @@ export class Logger implements LoggerService {
     context = '',
     isTimeDiffEnabled = true,
   ) {
-    this.printMessage(message, clc.red, context, isTimeDiffEnabled);
+    this.printMessage(message, clc.red, context, isTimeDiffEnabled, 'stderr');
     this.printStackTrace(trace);
   }
 
@@ -108,7 +108,10 @@ export class Logger implements LoggerService {
       day: '2-digit',
       month: '2-digit',
     };
-    return new Date(Date.now()).toLocaleString(undefined, localeStringOptions);
+    return new Date(Date.now()).toLocaleString(
+      undefined,
+      localeStringOptions as Intl.DateTimeFormatOptions,
+    );
   }
 
   private callFunction(
@@ -144,18 +147,22 @@ export class Logger implements LoggerService {
     color: (message: string) => string,
     context = '',
     isTimeDiffEnabled?: boolean,
+    writeStreamType?: 'stdout' | 'stderr',
   ) {
-    const output = isObject(message)
+    const output = isPlainObject(message)
       ? `${color('Object:')}\n${JSON.stringify(message, null, 2)}\n`
       : color(message);
 
     const pidMessage = color(`[Nest] ${process.pid}   - `);
     const contextMessage = context ? yellow(`[${context}] `) : '';
     const timestampDiff = this.updateAndGetTimestampDiff(isTimeDiffEnabled);
-    const instance = this.instance as typeof Logger;
-    process.stdout.write(
-      `${pidMessage}${instance.getTimestamp()}   ${contextMessage}${output}${timestampDiff}\n`,
-    );
+    const instance = (this.instance as typeof Logger) ?? Logger;
+    const timestamp = instance.getTimestamp
+      ? instance.getTimestamp()
+      : Logger.getTimestamp?.();
+    const computedMessage = `${pidMessage}${timestamp}   ${contextMessage}${output}${timestampDiff}\n`;
+
+    process[writeStreamType ?? 'stdout'].write(computedMessage);
   }
 
   private static updateAndGetTimestampDiff(
@@ -173,6 +180,6 @@ export class Logger implements LoggerService {
     if (!trace) {
       return;
     }
-    process.stdout.write(`${trace}\n`);
+    process.stderr.write(`${trace}\n`);
   }
 }

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

@@ -4,6 +4,7 @@ import { Controller } from '../../decorators/core/controller.decorator';
 describe('@Controller', () => {
   const reflectedPath = 'test';
   const reflectedHost = 'api.example.com';
+  const reflectedHostArray = ['api1.example.com', 'api2.example.com'];
 
   @Controller(reflectedPath)
   class Test {}
@@ -14,6 +15,9 @@ describe('@Controller', () => {
   @Controller({ path: reflectedPath, host: reflectedHost })
   class PathAndHostDecorator {}
 
+  @Controller({ path: reflectedPath, host: reflectedHostArray })
+  class PathAndHostArrayDecorator {}
+
   @Controller({ host: reflectedHost })
   class HostOnlyDecorator {}
 
@@ -29,6 +33,8 @@ describe('@Controller', () => {
     expect(host).to.be.eql(reflectedHost);
     const host2 = Reflect.getMetadata('host', HostOnlyDecorator);
     expect(host2).to.be.eql(reflectedHost);
+    const host3 = Reflect.getMetadata('host', PathAndHostArrayDecorator);
+    expect(host3).to.be.eql(reflectedHostArray);
   });
 
   it('should set default path when no object passed as param', () => {

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

@@ -1,7 +1,19 @@
+import * as chai from 'chai';
 import { expect } from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
+import { Type } from 'class-transformer';
+import {
+  IsBoolean,
+  IsDate,
+  IsDefined,
+  IsNumber,
+  IsString,
+  ValidateNested,
+} from 'class-validator';
 import { BadRequestException } from '../../exceptions';
 import { ArgumentMetadata } from '../../interfaces/features/pipe-transform.interface';
 import { ParseArrayPipe } from '../../pipes/parse-array.pipe';
+chai.use(chaiAsPromised);
 
 describe('ParseArrayPipe', () => {
   let target: ParseArrayPipe;
@@ -102,6 +114,153 @@ describe('ParseArrayPipe', () => {
           expect(item).to.be.instanceOf(ArrItem);
         });
       });
+      describe('when "stopAtFirstError" is explicitly turned off', () => {
+        it('should validate each item and concat errors', async () => {
+          class ArrItemWithProp {
+            @IsNumber()
+            number: number;
+          }
+          const pipe = new ParseArrayPipe({
+            items: ArrItemWithProp,
+            stopAtFirstError: false,
+          });
+          try {
+            await pipe.transform(
+              [
+                { number: '1' },
+                { number: '1' },
+                { number: 1 },
+              ] as ArrItemWithProp[],
+              {} as ArgumentMetadata,
+            );
+          } catch (err) {
+            expect(err).to.be.instanceOf(BadRequestException);
+            expect(err.getResponse().message).to.deep.equal([
+              '[0] number must be a number conforming to the specified constraints',
+              '[1] number must be a number conforming to the specified constraints',
+            ]);
+          }
+        });
+
+        it('should validate each nested object and concat errors', async () => {
+          class RandomObject {
+            @IsDefined()
+            @IsBoolean()
+            isEnabled: boolean;
+
+            @IsString()
+            title: string;
+
+            @IsDate()
+            createdAt: Date;
+
+            constructor(partial: Partial<any>) {
+              Object.assign(this, partial);
+            }
+          }
+          class ArrItemObject {
+            @ValidateNested()
+            random: RandomObject;
+          }
+          const pipe = new ParseArrayPipe({
+            items: ArrItemObject,
+            stopAtFirstError: false,
+          });
+          try {
+            await pipe.transform(
+              [
+                {
+                  random: new RandomObject({
+                    isEnabled: true,
+                    title: true,
+                    createdAt: new Date(),
+                  }),
+                },
+                {
+                  random: new RandomObject({
+                    title: 'ok',
+                    createdAt: false,
+                  }),
+                },
+              ] as any[],
+              {} as ArgumentMetadata,
+            );
+          } catch (err) {
+            expect(err).to.be.instanceOf(BadRequestException);
+            expect(err.getResponse().message).to.deep.equal([
+              '[0] random.title must be a string',
+              '[1] random.isEnabled should not be null or undefined',
+              '[1] random.isEnabled must be a boolean value',
+              '[1] random.createdAt must be a Date instance',
+            ]);
+          }
+        });
+
+        it('should validate each nested array and concat errors', async () => {
+          class RandomObject {
+            @IsDefined()
+            @IsBoolean()
+            isEnabled: boolean;
+
+            @IsString()
+            title: string;
+
+            @IsDate()
+            createdAt: Date;
+
+            constructor(partial: Partial<any>) {
+              Object.assign(this, partial);
+            }
+          }
+          class ArrItemObject {
+            @Type(() => RandomObject)
+            @ValidateNested({ each: true })
+            random: RandomObject[];
+          }
+          const pipe = new ParseArrayPipe({
+            items: ArrItemObject,
+            stopAtFirstError: false,
+          });
+          try {
+            await pipe.transform(
+              [
+                {
+                  random: [
+                    new RandomObject({
+                      isEnabled: true,
+                      title: true,
+                      createdAt: new Date(),
+                    }),
+                    new RandomObject({
+                      isEnabled: true,
+                      title: true,
+                      createdAt: new Date(),
+                    }),
+                  ],
+                },
+                {
+                  random: [
+                    new RandomObject({
+                      title: 'ok',
+                      createdAt: false,
+                    }),
+                  ],
+                },
+              ] as any[],
+              {} as ArgumentMetadata,
+            );
+          } catch (err) {
+            expect(err).to.be.instanceOf(BadRequestException);
+            expect(err.getResponse().message).to.deep.equal([
+              '[0] random.0.title must be a string',
+              '[0] random.1.title must be a string',
+              '[1] random.0.isEnabled should not be null or undefined',
+              '[1] random.0.isEnabled must be a boolean value',
+              '[1] random.0.createdAt must be a Date instance',
+            ]);
+          }
+        });
+      });
     });
   });
 });

packages/common/test/pipes/validation.pipe.spec.ts

@@ -8,6 +8,7 @@ import {
   IsOptional,
   IsString,
   ValidateNested,
+  IsArray,
 } from 'class-validator';
 import { HttpStatus } from '../../enums';
 import { UnprocessableEntityException } from '../../exceptions';
@@ -156,6 +157,32 @@ describe('ValidationPipe', () => {
           ]);
         }
       });
+
+      class TestModelForNestedArrayValidation {
+        @IsString()
+        public prop: string;
+
+        @IsArray()
+        @ValidateNested()
+        @Type(() => TestModel2)
+        public test: TestModel2[];
+      }
+      it('should provide complete path for nested errors', async () => {
+        try {
+          const model = new TestModelForNestedArrayValidation();
+          model.test = [new TestModel2()];
+          await target.transform(model, {
+            type: 'body',
+            metatype: TestModelForNestedArrayValidation,
+          });
+        } catch (err) {
+          expect(err.getResponse().message).to.be.eql([
+            'prop must be a string',
+            'test.0.prop1 must be a string',
+            'test.0.prop2 must be a boolean value',
+          ]);
+        }
+      });
     });
     describe('when validation transforms', () => {
       it('should return a TestModel instance', async () => {

packages/common/utils/shared.utils.ts

@@ -27,6 +27,12 @@ export const isPlainObject = (fn: any): fn is object => {
 export const addLeadingSlash = (path?: string): string =>
   path ? (path.charAt(0) !== '/' ? '/' + path : path) : '';
 
+/**
+ * Deprecated. Use the "addLeadingSlash" function instead.
+ * @deprecated
+ */
+export const validatePath = addLeadingSlash;
+
 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';

packages/core/Readme.md

@@ -56,16 +56,21 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 
 #### Principal Sponsors
 <table style="text-align:center;"><tr><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://valor-software.com/" target="_blank"><img src="https://docs.nestjs.com/assets/sponsors/valor-software.png" width="180" valign="middle" /></a></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>
 </tr></table>
 
+#### Gold Sponsors
+
+<table style="text-align:center;"><tr><td>
+<a href="https://valor-software.com/" target="_blank"><img src="https://docs.nestjs.com/assets/sponsors/valor-software.png" width="170" valign="middle" /></a></td></tr></table>
+
 #### Silver 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="https://trilon.io" target="_blank"><img src="https://nestjs.com/img/trilon.svg" width="170" valign="middle" /></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="http://www.meetdandy.com" target="_blank"><img src="https://nestjs.com/img/dandy-wide-logo.png" width="150" valign="middle" /></td></tr></table>
 
@@ -90,6 +95,11 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
   <td align="center" valign="middle">
   <a href="https://genuinebee.com/" target="_blank"><img src="https://nestjs.com/img/genuinebee.svg" width="97" valign="middle" /></a> </td>
 <td align="center" valign="middle"><a href="https://sanyodigital.com/" target="_blank"><img src="https://nestjs.com/img/sanyo-digital.png" width="130" valign="middle" /></a></td></tr><tr><td align="center" valign="middle"><a href="https://vpn-review.com/vpn-for-torrenting" target="_blank"><img src="https://nestjs.com/img/vpn-review-logo.png" width="85" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://lambda-it.ch/" target="_blank"><img src="https://nestjs.com/img/lambda-it-logo.svg" width="115" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://pickwriters.com/top-10-translation-services" target="_blank"><img src="https://nestjs.com/img/pickwriters-logo.png" width="40" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://thewordpoint.com/services/localization" target="_blank"><img src="https://nestjs.com/img/thewordpoint-logo.png" width="40" valign="middle" /></a></td>
+<td align="center" valign="middle"><a href="https://streamat.se/" target="_blank"><img src="https://nestjs.com/img/streamat-logo.png" width="120" valign="middle" /></a></td>
+<td align="center" valign="middle"><a href="https://filmen.nu/" target="_blank"><img src="https://nestjs.com/img/filmen-logo.png" width="120" valign="middle" /></a></td></tr><tr>
+<td align="center" valign="middle"><a href="https://meercode.io/" target="_blank"><img src="https://nestjs.com/img/meercode-logo.png" width="60" valign="middle" /></a></td>
+  <td align="center" valign="middle"><a href="https://www.najlepszeplatformyforex.pl/blog/broker-xtb/" target="_blank"><img src="https://nestjs.com/img/npf-logo.jpg" width="200" valign="middle" /></a></td>
+    <td align="center" valign="middle"><a href="https://thestandarddaily.com/" target="_blank"><img src="https://nestjs.com/img/the-standard-daily-logo.png" width="180" valign="middle" /></a></td>
   </tr></table>
 
 ## Backers

packages/core/adapters/http-adapter.ts

@@ -1,6 +1,9 @@
 import { HttpServer, RequestMethod } from '@nestjs/common';
 import { RequestHandler } from '@nestjs/common/interfaces';
-import { CorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface';
+import {
+  CorsOptions,
+  CorsOptionsDelegate,
+} from '@nestjs/common/interfaces/external/cors-options.interface';
 import { NestApplicationOptions } from '@nestjs/common/interfaces/nest-application-options.interface';
 
 /**
@@ -14,6 +17,14 @@ export abstract class AbstractHttpAdapter<
   protected httpServer: TServer;
 
   constructor(protected readonly instance: any) {}
+  all(path: string, handler: RequestHandler<TRequest, TResponse>);
+  all(handler: RequestHandler<TRequest, TResponse>);
+  all(path: any, handler?: any) {
+    throw new Error('Method not implemented.');
+  }
+  setBaseViewsDir?(path: string | string[]): this {
+    throw new Error('Method not implemented.');
+  }
 
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   public async init() {}
@@ -97,7 +108,10 @@ export abstract class AbstractHttpAdapter<
   abstract setNotFoundHandler(handler: Function, prefix?: string);
   abstract setHeader(response, name: string, value: string);
   abstract registerParserMiddleware(prefix?: string);
-  abstract enableCors(options: CorsOptions, prefix?: string);
+  abstract enableCors(
+    options: CorsOptions | CorsOptionsDelegate<TRequest>,
+    prefix?: string,
+  );
   abstract createMiddlewareFactory(
     requestMethod: RequestMethod,
   ):

packages/core/application-config.ts

@@ -14,12 +14,8 @@ export class ApplicationConfig {
   private globalInterceptors: NestInterceptor[] = [];
   private globalGuards: CanActivate[] = [];
   private readonly globalRequestPipes: InstanceWrapper<PipeTransform>[] = [];
-  private readonly globalRequestFilters: InstanceWrapper<
-    ExceptionFilter
-  >[] = [];
-  private readonly globalRequestInterceptors: InstanceWrapper<
-    NestInterceptor
-  >[] = [];
+  private readonly globalRequestFilters: InstanceWrapper<ExceptionFilter>[] = [];
+  private readonly globalRequestInterceptors: InstanceWrapper<NestInterceptor>[] = [];
   private readonly globalRequestGuards: InstanceWrapper<CanActivate>[] = [];
 
   constructor(private ioAdapter: WebSocketAdapter | null = null) {}

packages/core/errors/messages.ts

@@ -1,4 +1,4 @@
-import { Type } from '@nestjs/common';
+import { ForwardReference, Type } from '@nestjs/common';
 import { isNil, isSymbol } from '@nestjs/common/utils/shared.utils';
 import {
   InjectorDependency,
@@ -10,8 +10,12 @@ import { Module } from '../injector/module';
  * Returns the name of an instance
  * @param instance The instance which should get the name from
  */
-const getInstanceName = (instance: unknown): string =>
-  instance && (instance as Type<any>).name;
+const getInstanceName = (instance: unknown): string => {
+  if ((instance as ForwardReference)?.forwardRef) {
+    return (instance as ForwardReference).forwardRef()?.name;
+  }
+  return (instance as Type<any>)?.name;
+};
 
 /**
  * Returns the name of the dependency

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

@@ -38,9 +38,7 @@ export interface ExternalContextOptions {
 export class ExternalContextCreator {
   private readonly contextUtils = new ContextUtils();
   private readonly externalErrorProxy = new ExternalErrorProxy();
-  private readonly handlerMetadataStorage = new HandlerMetadataStorage<
-    ExternalHandlerMetadata
-  >();
+  private readonly handlerMetadataStorage = new HandlerMetadataStorage<ExternalHandlerMetadata>();
   private container: NestContainer;
 
   constructor(

packages/core/injector/compiler.ts

@@ -13,18 +13,17 @@ export class ModuleCompiler {
   public async compile(
     metatype: Type<any> | DynamicModule | Promise<DynamicModule>,
   ): Promise<ModuleFactory> {
-    const { type, dynamicMetadata } = await this.extractMetadata(metatype);
+    const { type, dynamicMetadata } = this.extractMetadata(await metatype);
     const token = this.moduleTokenFactory.create(type, dynamicMetadata);
     return { type, dynamicMetadata, token };
   }
 
-  public async extractMetadata(
-    metatype: Type<any> | DynamicModule | Promise<DynamicModule>,
-  ): Promise<{
+  public extractMetadata(
+    metatype: Type<any> | DynamicModule,
+  ): {
     type: Type<any>;
     dynamicMetadata?: Partial<DynamicModule> | undefined;
-  }> {
-    metatype = await metatype;
+  } {
     if (!this.isDynamicModule(metatype)) {
       return { type: metatype };
     }

packages/core/injector/injector.ts

@@ -69,82 +69,6 @@ export interface InjectorDependencyContext {
 }
 
 export class Injector {
-  public async loadMiddleware(
-    wrapper: InstanceWrapper,
-    collection: Map<string, InstanceWrapper>,
-    moduleRef: Module,
-    contextId = STATIC_CONTEXT,
-    inquirer?: InstanceWrapper,
-  ) {
-    const { metatype } = wrapper;
-    const targetWrapper = collection.get(metatype.name);
-    if (!isUndefined(targetWrapper.instance)) {
-      return;
-    }
-    const loadInstance = (instances: any[]) => {
-      targetWrapper.instance = targetWrapper.isDependencyTreeStatic()
-        ? new (metatype as Type<any>)(...instances)
-        : Object.create(metatype.prototype);
-    };
-    await this.resolveConstructorParams(
-      wrapper,
-      moduleRef,
-      null,
-      loadInstance,
-      contextId,
-      inquirer,
-    );
-  }
-
-  public async loadController(
-    wrapper: InstanceWrapper<Controller>,
-    moduleRef: Module,
-    contextId = STATIC_CONTEXT,
-  ) {
-    const controllers = moduleRef.controllers;
-    await this.loadInstance<Controller>(
-      wrapper,
-      controllers,
-      moduleRef,
-      contextId,
-      wrapper,
-    );
-    await this.loadEnhancersPerContext(wrapper, contextId, wrapper);
-  }
-
-  public async loadInjectable<T = any>(
-    wrapper: InstanceWrapper<T>,
-    moduleRef: Module,
-    contextId = STATIC_CONTEXT,
-    inquirer?: InstanceWrapper,
-  ) {
-    const injectables = moduleRef.injectables;
-    await this.loadInstance<T>(
-      wrapper,
-      injectables,
-      moduleRef,
-      contextId,
-      inquirer,
-    );
-  }
-
-  public async loadProvider(
-    wrapper: InstanceWrapper<Injectable>,
-    moduleRef: Module,
-    contextId = STATIC_CONTEXT,
-    inquirer?: InstanceWrapper,
-  ) {
-    const providers = moduleRef.providers;
-    await this.loadInstance<Injectable>(
-      wrapper,
-      providers,
-      moduleRef,
-      contextId,
-      inquirer,
-    );
-    await this.loadEnhancersPerContext(wrapper, contextId, wrapper);
-  }
-
   public loadPrototype<T>(
     { name }: InstanceWrapper<T>,
     collection: Map<string, InstanceWrapper<T>>,
@@ -164,15 +88,6 @@ export class Injector {
     }
   }
 
-  public applyDoneHook<T>(wrapper: InstancePerContext<T>): () => void {
-    let done: () => void;
-    wrapper.donePromise = new Promise<void>((resolve, reject) => {
-      done = resolve;
-    });
-    wrapper.isPending = true;
-    return done;
-  }
-
   public async loadInstance<T>(
     wrapper: InstanceWrapper<T>,
     collection: Map<string, InstanceWrapper>,
@@ -225,11 +140,91 @@ export class Injector {
     );
   }
 
+  public async loadMiddleware(
+    wrapper: InstanceWrapper,
+    collection: Map<string, InstanceWrapper>,
+    moduleRef: Module,
+    contextId = STATIC_CONTEXT,
+    inquirer?: InstanceWrapper,
+  ) {
+    const { metatype } = wrapper;
+    const targetWrapper = collection.get(metatype.name);
+    if (!isUndefined(targetWrapper.instance)) {
+      return;
+    }
+    targetWrapper.instance = Object.create(metatype.prototype);
+    await this.loadInstance(
+      wrapper,
+      collection,
+      moduleRef,
+      contextId,
+      inquirer || wrapper,
+    );
+  }
+
+  public async loadController(
+    wrapper: InstanceWrapper<Controller>,
+    moduleRef: Module,
+    contextId = STATIC_CONTEXT,
+  ) {
+    const controllers = moduleRef.controllers;
+    await this.loadInstance<Controller>(
+      wrapper,
+      controllers,
+      moduleRef,
+      contextId,
+      wrapper,
+    );
+    await this.loadEnhancersPerContext(wrapper, contextId, wrapper);
+  }
+
+  public async loadInjectable<T = any>(
+    wrapper: InstanceWrapper<T>,
+    moduleRef: Module,
+    contextId = STATIC_CONTEXT,
+    inquirer?: InstanceWrapper,
+  ) {
+    const injectables = moduleRef.injectables;
+    await this.loadInstance<T>(
+      wrapper,
+      injectables,
+      moduleRef,
+      contextId,
+      inquirer,
+    );
+  }
+
+  public async loadProvider(
+    wrapper: InstanceWrapper<Injectable>,
+    moduleRef: Module,
+    contextId = STATIC_CONTEXT,
+    inquirer?: InstanceWrapper,
+  ) {
+    const providers = moduleRef.providers;
+    await this.loadInstance<Injectable>(
+      wrapper,
+      providers,
+      moduleRef,
+      contextId,
+      inquirer,
+    );
+    await this.loadEnhancersPerContext(wrapper, contextId, wrapper);
+  }
+
+  public applyDoneHook<T>(wrapper: InstancePerContext<T>): () => void {
+    let done: () => void;
+    wrapper.donePromise = new Promise<void>((resolve, reject) => {
+      done = resolve;
+    });
+    wrapper.isPending = true;
+    return done;
+  }
+
   public async resolveConstructorParams<T>(
     wrapper: InstanceWrapper<T>,
     moduleRef: Module,
     inject: InjectorDependency[],
-    callback: (args: unknown[]) => void,
+    callback: (args: unknown[]) => void | Promise<void>,
     contextId = STATIC_CONTEXT,
     inquirer?: InstanceWrapper,
     parentInquirer?: InstanceWrapper,
@@ -274,7 +269,7 @@ export class Injector {
         if (!instanceHost.isResolved && !paramWrapper.forwardRef) {
           isResolved = false;
         }
-        return instanceHost && instanceHost.instance;
+        return instanceHost?.instance;
       } catch (err) {
         const isOptional = optionalDependenciesIds.includes(index);
         if (!isOptional) {
@@ -372,7 +367,7 @@ export class Injector {
 
   public async resolveComponentHost<T>(
     moduleRef: Module,
-    instanceWrapper: InstanceWrapper<T>,
+    instanceWrapper: InstanceWrapper<T | Promise<T>>,
     contextId = STATIC_CONTEXT,
     inquirer?: InstanceWrapper,
   ): Promise<InstanceWrapper> {

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

@@ -47,11 +47,15 @@ export class ModuleTokenFactory {
 
   private replacer(key: string, value: any) {
     if (typeof value === 'function') {
-      const isClass = /^class\s/.test(Function.prototype.toString.call(value));
+      const funcAsString = value.toString();
+      const isClass = /^class\s/.test(funcAsString);
       if (isClass) {
         return value.name;
       }
-      return hash(value.toString(), { ignoreUnknown: true });
+      return hash(funcAsString, { ignoreUnknown: true });
+    }
+    if (typeof value === 'symbol') {
+      return value.toString();
     }
     return value;
   }

packages/core/middleware/middleware-module.ts

@@ -168,6 +168,9 @@ export class MiddlewareModule {
       if (isUndefined(instanceWrapper)) {
         throw new RuntimeException();
       }
+      if (instanceWrapper.isTransient) {
+        return;
+      }
       await this.bindHandler(
         instanceWrapper,
         applicationRef,

packages/core/middleware/routes-mapper.ts

@@ -28,8 +28,11 @@ export class RoutesMapper {
         },
       ];
     }
-    const routePath: string = Reflect.getMetadata(PATH_METADATA, route);
-    if (this.isRouteInfo(routePath, route)) {
+    const routePathOrPaths: string | string[] = Reflect.getMetadata(
+      PATH_METADATA,
+      route,
+    );
+    if (this.isRouteInfo(routePathOrPaths, route)) {
       return [
         {
           path: this.validateRoutePath(route.path),
@@ -43,21 +46,28 @@ export class RoutesMapper {
     );
     const concatPaths = <T>(acc: T[], currentValue: T[]) =>
       acc.concat(currentValue);
-    return paths
-      .map(
-        item =>
-          item.path &&
-          item.path.map(p => ({
-            path:
-              this.validateGlobalPath(routePath) + this.validateRoutePath(p),
-            method: item.requestMethod,
-          })),
+
+    return []
+      .concat(routePathOrPaths)
+      .map(routePath =>
+        paths
+          .map(
+            item =>
+              item.path &&
+              item.path.map(p => ({
+                path:
+                  this.validateGlobalPath(routePath) +
+                  this.validateRoutePath(p),
+                method: item.requestMethod,
+              })),
+          )
+          .reduce(concatPaths, []),
       )
       .reduce(concatPaths, []);
   }
 
   private isRouteInfo(
-    path: string | undefined,
+    path: string | string[] | undefined,
     objectOrClass: Function | RouteInfo,
   ): objectOrClass is RouteInfo {
     return isUndefined(path);

packages/core/middleware/utils.ts

@@ -29,7 +29,7 @@ export const mapToClass = <T extends Function | Type<any>>(
   excludedRoutes: RouteInfoRegex[],
   httpAdapter: HttpServer,
 ) => {
-  if (isClass(middleware)) {
+  if (isMiddlewareClass(middleware)) {
     if (excludedRoutes.length <= 0) {
       return middleware;
     }
@@ -59,8 +59,17 @@ export const mapToClass = <T extends Function | Type<any>>(
   );
 };
 
-export function isClass(middleware: any): middleware is Type<any> {
-  return middleware.toString().substring(0, 5) === 'class';
+export function isMiddlewareClass(middleware: any): middleware is Type<any> {
+  const middlewareStr = middleware.toString();
+  if (middlewareStr.substring(0, 5) === 'class') {
+    return true;
+  }
+  const middlewareArr = middlewareStr.split(' ');
+  return (
+    middlewareArr[0] === 'function' &&
+    /[A-Z]/.test(middlewareArr[1]?.[0]) &&
+    typeof middleware.prototype?.use === 'function'
+  );
 }
 
 export function assignToken(metatype: Type<any>, token = uuid()): Type<any> {

packages/core/nest-application-context.ts

@@ -5,7 +5,7 @@ import {
   LogLevel,
   ShutdownSignal,
 } from '@nestjs/common';
-import { Abstract, Scope } from '@nestjs/common/interfaces';
+import { Abstract, DynamicModule, Scope } from '@nestjs/common/interfaces';
 import { Type } from '@nestjs/common/interfaces/type.interface';
 import { isEmpty } from '@nestjs/common/utils/shared.utils';
 import { iterate } from 'iterare';
@@ -22,6 +22,7 @@ import {
   callModuleInitHook,
 } from './hooks';
 import { ContextId } from './injector';
+import { ModuleCompiler } from './injector/compiler';
 import { NestContainer } from './injector/container';
 import { Injector } from './injector/injector';
 import { InstanceLinksHost } from './injector/instance-links-host';
@@ -33,8 +34,10 @@ import { Module } from './injector/module';
 export class NestApplicationContext implements INestApplicationContext {
   protected isInitialized = false;
   protected readonly injector = new Injector();
-  private shutdownCleanupRef?: (...args: unknown[]) => unknown;
+
   private readonly activeShutdownSignals = new Array<string>();
+  private readonly moduleCompiler = new ModuleCompiler();
+  private shutdownCleanupRef?: (...args: unknown[]) => unknown;
   private _instanceLinksHost: InstanceLinksHost;
 
   private get instanceLinksHost() {
@@ -55,14 +58,20 @@ export class NestApplicationContext implements INestApplicationContext {
     this.contextModule = modules.next().value;
   }
 
-  public select<T>(moduleType: Type<T>): INestApplicationContext {
-    const modules = this.container.getModules();
-    const moduleMetatype = this.contextModule.metatype;
-    const scope = this.scope.concat(moduleMetatype);
-    const moduleTokenFactory = this.container.getModuleTokenFactory();
+  public select<T>(
+    moduleType: Type<T> | DynamicModule,
+  ): INestApplicationContext {
+    const modulesContainer = this.container.getModules();
+    const contextModuleCtor = this.contextModule.metatype;
+    const scope = this.scope.concat(contextModuleCtor);
 
-    const token = moduleTokenFactory.create(moduleType);
-    const selectedModule = modules.get(token);
+    const moduleTokenFactory = this.container.getModuleTokenFactory();
+    const { type, dynamicMetadata } = this.moduleCompiler.extractMetadata(
+      moduleType,
+    );
+    const token = moduleTokenFactory.create(type, dynamicMetadata);
+
+    const selectedModule = modulesContainer.get(token);
     if (!selectedModule) {
       throw new UnknownModuleException();
     }

packages/core/nest-application.ts

@@ -9,7 +9,10 @@ import {
   PipeTransform,
   WebSocketAdapter,
 } from '@nestjs/common';
-import { CorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface';
+import {
+  CorsOptions,
+  CorsOptionsDelegate,
+} from '@nestjs/common/interfaces/external/cors-options.interface';
 import { NestApplicationOptions } from '@nestjs/common/interfaces/nest-application-options.interface';
 import { Logger } from '@nestjs/common/services/logger.service';
 import { loadPackage } from '@nestjs/common/utils/load-package.util';
@@ -76,6 +79,7 @@ export class NestApplication
 
   protected async dispose(): Promise<void> {
     this.socketModule && (await this.socketModule.close());
+    this.microservicesModule && (await this.microservicesModule.close());
     this.httpAdapter && (await this.httpAdapter.close());
 
     await Promise.all(
@@ -102,11 +106,15 @@ export class NestApplication
     if (!this.appOptions || !this.appOptions.cors) {
       return undefined;
     }
-    const isCorsOptionsObj = isObject(this.appOptions.cors);
-    if (!isCorsOptionsObj) {
+    const passCustomOptions =
+      isObject(this.appOptions.cors) ||
+      typeof this.appOptions.cors === 'function';
+    if (!passCustomOptions) {
       return this.enableCors();
     }
-    return this.enableCors(this.appOptions.cors as CorsOptions);
+    return this.enableCors(
+      this.appOptions.cors as CorsOptions | CorsOptionsDelegate<any>,
+    );
   }
 
   public createServer<T = any>(): T {
@@ -224,7 +232,7 @@ export class NestApplication
     return this;
   }
 
-  public enableCors(options?: CorsOptions): void {
+  public enableCors(options?: CorsOptions | CorsOptionsDelegate<any>): void {
     this.httpAdapter.enableCors(options);
   }
 
@@ -348,7 +356,7 @@ export class NestApplication
   }
 
   private listenToPromise(microservice: INestMicroservice) {
-    return new Promise(async resolve => {
+    return new Promise<void>(async resolve => {
       await microservice.listen(resolve);
     });
   }

packages/core/nest-factory.ts

@@ -215,10 +215,10 @@ export class NestFactoryStatic {
   }
 
   private applyLogger(options: NestApplicationContextOptions | undefined) {
-    if (!options) {
+    if (!options || options?.logger === true || isNil(options?.logger)) {
       return;
     }
-    !isNil(options.logger) && Logger.overrideLogger(options.logger);
+    Logger.overrideLogger(options.logger);
   }
 
   private createHttpAdapter<T = any>(httpServer?: T): AbstractHttpAdapter {
@@ -248,14 +248,29 @@ export class NestFactoryStatic {
   }
 
   private createAdapterProxy<T>(app: NestApplication, adapter: HttpServer): T {
-    return (new Proxy(app, {
+    const proxy = new Proxy(app, {
       get: (receiver: Record<string, any>, prop: string) => {
         if (!(prop in receiver) && prop in adapter) {
-          return this.createExceptionZone(adapter, prop);
+          return (...args: unknown[]) => {
+            this.createExceptionZone(adapter, prop)(...args);
+            return proxy;
+          };
+        }
+        if (isFunction(receiver[prop])) {
+          const mapToProxy = (result: unknown) =>
+            result instanceof NestApplication ? proxy : result;
+
+          return (...args: unknown[]) => {
+            const result = receiver[prop](...args);
+            return result instanceof Promise
+              ? result.then(mapToProxy)
+              : mapToProxy(result);
+          };
         }
         return receiver[prop];
       },
-    }) as unknown) as T;
+    });
+    return (proxy as unknown) as T;
   }
 }
 

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "7.5.5",
+  "version": "7.6.14",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -30,17 +30,31 @@
     "@nuxtjs/opencollective": "0.3.2",
     "fast-safe-stringify": "2.0.7",
     "iterare": "1.2.1",
-    "object-hash": "2.0.3",
+    "object-hash": "2.1.1",
     "path-to-regexp": "3.2.0",
-    "tslib": "2.0.3",
-    "uuid": "8.3.1"
+    "tslib": "2.1.0",
+    "uuid": "8.3.2"
   },
   "devDependencies": {
-    "@nestjs/common": "7.5.5"
+    "@nestjs/common": "7.6.14"
   },
   "peerDependencies": {
     "@nestjs/common": "^7.0.0",
+    "@nestjs/microservices": "^7.0.0",
+    "@nestjs/platform-express": "^7.0.0",
+    "@nestjs/websockets": "^7.0.0",
     "reflect-metadata": "^0.1.12",
     "rxjs": "^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@nestjs/websockets": {
+      "optional": true
+    },
+    "@nestjs/microservices": {
+      "optional": true
+    },
+    "@nestjs/platform-express": {
+      "optional": true
+    }
   }
 }

packages/core/router/router-execution-context.ts

@@ -413,7 +413,11 @@ export class RouterExecutionContext {
     const renderTemplate = this.reflectRenderTemplate(callback);
     if (renderTemplate) {
       return async <TResult, TResponse>(result: TResult, res: TResponse) => {
-        await this.responseController.render(result, res, renderTemplate);
+        return await this.responseController.render(
+          result,
+          res,
+          renderTemplate,
+        );
       };
     }
     if (redirectResponse && typeof redirectResponse.url === 'string') {

packages/core/router/router-explorer.ts

@@ -73,7 +73,7 @@ export class RouterExplorer {
     module: string,
     applicationRef: T,
     basePath: string,
-    host: string,
+    host: string | string[],
   ) {
     const { instance } = instanceWrapper;
     const routerPaths = this.scanForPaths(instance);
@@ -124,14 +124,15 @@ export class RouterExplorer {
     prototype: object,
     methodName: string,
   ): RoutePathProperties {
-    const targetCallback = prototype[methodName];
-    const routePath = Reflect.getMetadata(PATH_METADATA, targetCallback);
+    const instanceCallback = instance[methodName];
+    const prototypeCallback = prototype[methodName];
+    const routePath = Reflect.getMetadata(PATH_METADATA, prototypeCallback);
     if (isUndefined(routePath)) {
       return null;
     }
     const requestMethod: RequestMethod = Reflect.getMetadata(
       METHOD_METADATA,
-      targetCallback,
+      prototypeCallback,
     );
     const path = isString(routePath)
       ? [addLeadingSlash(routePath)]
@@ -139,7 +140,7 @@ export class RouterExplorer {
     return {
       path,
       requestMethod,
-      targetCallback,
+      targetCallback: instanceCallback,
       methodName,
     };
   }
@@ -150,7 +151,7 @@ export class RouterExplorer {
     instanceWrapper: InstanceWrapper,
     moduleKey: string,
     basePath: string,
-    host: string,
+    host: string | string[],
   ) {
     (routePaths || []).forEach(pathProperties => {
       const { path, requestMethod } = pathProperties;
@@ -179,7 +180,7 @@ export class RouterExplorer {
     instanceWrapper: InstanceWrapper,
     moduleKey: string,
     basePath: string,
-    host: string,
+    host: string | string[],
   ) {
     const {
       path: paths,
@@ -216,14 +217,24 @@ export class RouterExplorer {
     });
   }
 
-  private applyHostFilter(host: string, handler: Function) {
+  private applyHostFilter(host: string | string[], handler: Function) {
     if (!host) {
       return handler;
     }
 
     const httpAdapterRef = this.container.getHttpAdapterRef();
-    const keys = [];
-    const re = pathToRegexp(host, keys);
+    const hosts = Array.isArray(host) ? host : [host];
+    const hostRegExps = hosts.map((host: string) => {
+      const keys = [];
+      const regexp = pathToRegexp(host, keys);
+      return { regexp, keys };
+    });
+
+    const unsupportedFilteringErrorMessage = Array.isArray(host)
+      ? `HTTP adapter does not support filtering on hosts: ["${host.join(
+          '", "',
+        )}"]`
+      : `HTTP adapter does not support filtering on host: "${host}"`;
 
     return <TRequest extends Record<string, any> = any, TResponse = any>(
       req: TRequest,
@@ -232,14 +243,17 @@ export class RouterExplorer {
     ) => {
       (req as Record<string, any>).hosts = {};
       const hostname = httpAdapterRef.getRequestHostname(req) || '';
-      const match = hostname.match(re);
-      if (match) {
-        keys.forEach((key, i) => (req.hosts[key.name] = match[i + 1]));
-        return handler(req, res, next);
+
+      for (const exp of hostRegExps) {
+        const match = hostname.match(exp.regexp);
+        if (match) {
+          exp.keys.forEach((key, i) => (req.hosts[key.name] = match[i + 1]));
+          return handler(req, res, next);
+        }
       }
       if (!next) {
         throw new InternalServerErrorException(
-          `HTTP adapter does not support filtering on host: "${host}"`,
+          unsupportedFilteringErrorMessage,
         );
       }
       return next();

packages/core/router/router-response-controller.ts

@@ -48,7 +48,7 @@ export class RouterResponseController {
     template: string,
   ) {
     const result = await this.transformToResult(resultOrDeferred);
-    this.applicationRef.render(response, template, result);
+    return this.applicationRef.render(response, template, result);
   }
 
   public async transformToResult(resultOrDeferred: any) {

packages/core/router/routes-resolver.ts

@@ -132,7 +132,7 @@ export class RoutesResolver implements Resolver {
 
   private getHostMetadata(
     metatype: Type<unknown> | Function,
-  ): string | undefined {
+  ): string | string[] | undefined {
     return Reflect.getMetadata(HOST_METADATA, metatype);
   }
 }

packages/core/test/injector/injector.spec.ts

@@ -189,28 +189,28 @@ describe('Injector', () => {
   });
 
   describe('loadMiddleware', () => {
-    let resolveConstructorParams: sinon.SinonSpy;
+    let loadInstanceSpy: sinon.SinonSpy;
 
     beforeEach(() => {
-      resolveConstructorParams = sinon.spy();
-      injector.resolveConstructorParams = resolveConstructorParams;
+      loadInstanceSpy = sinon.spy();
+      injector.loadInstance = loadInstanceSpy;
     });
 
-    it('should call "resolveConstructorParams" when instance is not resolved', () => {
+    it('should call "loadInstance" when instance is not resolved', () => {
       const collection = {
         get: (...args) => ({}),
         set: (...args) => {},
       };
 
       injector.loadMiddleware(
-        { metatype: { name: '' } } as any,
+        { metatype: { name: '', prototype: {} } } as any,
         collection as any,
         null,
       );
-      expect(resolveConstructorParams.called).to.be.true;
+      expect(loadInstanceSpy.called).to.be.true;
     });
 
-    it('should not call "resolveConstructorParams" when instance is not resolved', () => {
+    it('should not call "loadInstanceSpy" when instance is not resolved', () => {
       const collection = {
         get: (...args) => ({
           instance: {},
@@ -223,7 +223,7 @@ describe('Injector', () => {
         collection as any,
         null,
       );
-      expect(resolveConstructorParams.called).to.be.false;
+      expect(loadInstanceSpy.called).to.be.false;
     });
   });
 

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

@@ -30,6 +30,7 @@ describe('ModuleTokenFactory', () => {
       const token = factory.create(type, {
         providers: [{}],
       } as any);
+
       expect(token).to.be.deep.eq(
         hash({
           id: moduleId,
@@ -62,6 +63,24 @@ describe('ModuleTokenFactory', () => {
           '{"providers":["Provider"],"exports":["Provider"]}',
         );
       });
+      it('should serialize symbols in a dynamic metadata object', () => {
+        const metadata = {
+          providers: [
+            {
+              provide: Symbol('a'),
+              useValue: 'a',
+            },
+            {
+              provide: Symbol('b'),
+              useValue: 'b',
+            },
+          ],
+        };
+
+        expect(factory.getDynamicMetadataToken(metadata)).to.be.eql(
+          '{"providers":[{"provide":"Symbol(a)","useValue":"a"},{"provide":"Symbol(b)","useValue":"b"}]}',
+        );
+      });
     });
     describe('when metadata does not exist', () => {
       it('should return empty string', () => {

packages/core/test/middleware/routes-mapper.spec.ts

@@ -34,4 +34,32 @@ describe('RoutesMapper', () => {
       { path: '/test/another', method: RequestMethod.DELETE },
     ]);
   });
+  @Controller(['test', 'test2'])
+  class TestRouteWithMultiplePaths {
+    @RequestMapping({ path: 'test' })
+    public getTest() {}
+
+    @RequestMapping({ path: 'another', method: RequestMethod.DELETE })
+    public getAnother() {}
+  }
+
+  it('should map a controller with multiple paths to "ControllerMetadata" in forRoutes', () => {
+    const config = {
+      middleware: 'Test',
+      forRoutes: [
+        { path: 'test', method: RequestMethod.GET },
+        TestRouteWithMultiplePaths,
+      ],
+    };
+
+    expect(mapper.mapRouteToRouteInfo(config.forRoutes[0])).to.deep.equal([
+      { path: '/test', method: RequestMethod.GET },
+    ]);
+    expect(mapper.mapRouteToRouteInfo(config.forRoutes[1])).to.deep.equal([
+      { path: '/test/test', method: RequestMethod.GET },
+      { path: '/test/another', method: RequestMethod.DELETE },
+      { path: '/test2/test', method: RequestMethod.GET },
+      { path: '/test2/another', method: RequestMethod.DELETE },
+    ]);
+  });
 });

packages/core/test/middleware/utils.spec.ts

@@ -5,7 +5,7 @@ import * as sinon from 'sinon';
 import {
   assignToken,
   filterMiddleware,
-  isClass,
+  isMiddlewareClass,
   isRouteExcluded,
   mapToClass,
 } from '../../middleware/utils';
@@ -63,15 +63,15 @@ describe('middleware utils', () => {
       });
     });
   });
-  describe('isClass', () => {
+  describe('isMiddlewareClass', () => {
     describe('when middleware is a class', () => {
       it('should returns true', () => {
-        expect(isClass(Test)).to.be.true;
+        expect(isMiddlewareClass(Test)).to.be.true;
       });
     });
     describe('when middleware is a function', () => {
       it('should returns false', () => {
-        expect(isClass(fnMiddleware)).to.be.false;
+        expect(isMiddlewareClass(fnMiddleware)).to.be.false;
       });
     });
   });

packages/core/test/router/router-explorer.spec.ts

@@ -109,13 +109,14 @@ describe('RouterExplorer', () => {
       const instanceProto = Object.getPrototypeOf(instance);
 
       const route = routerBuilder.exploreMethodMetadata(
-        new TestRoute(),
+        instance,
         instanceProto,
         'getTest',
       );
 
       expect(route.path).to.eql(['/test']);
       expect(route.requestMethod).to.eql(RequestMethod.GET);
+      expect(route.targetCallback).to.eq(instance.getTest);
     });
 
     it('should method return expected object which represent single route with alias', () => {
@@ -123,13 +124,14 @@ describe('RouterExplorer', () => {
       const instanceProto = Object.getPrototypeOf(instance);
 
       const route = routerBuilder.exploreMethodMetadata(
-        new TestRouteAlias(),
+        instance,
         instanceProto,
         'getTest',
       );
 
       expect(route.path).to.eql(['/test']);
       expect(route.requestMethod).to.eql(RequestMethod.GET);
+      expect(route.targetCallback).to.eq(instance.getTest);
     });
 
     it('should method return expected object which represent multiple routes', () => {
@@ -137,13 +139,14 @@ describe('RouterExplorer', () => {
       const instanceProto = Object.getPrototypeOf(instance);
 
       const route = routerBuilder.exploreMethodMetadata(
-        new TestRoute(),
+        instance,
         instanceProto,
         'getTestUsingArray',
       );
 
       expect(route.path).to.eql(['/foo', '/bar']);
       expect(route.requestMethod).to.eql(RequestMethod.GET);
+      expect(route.targetCallback).to.eq(instance.getTestUsingArray);
     });
 
     it('should method return expected object which represent multiple routes with alias', () => {
@@ -151,13 +154,88 @@ describe('RouterExplorer', () => {
       const instanceProto = Object.getPrototypeOf(instance);
 
       const route = routerBuilder.exploreMethodMetadata(
-        new TestRouteAlias(),
+        instance,
         instanceProto,
         'getTestUsingArray',
       );
 
       expect(route.path).to.eql(['/foo', '/bar']);
       expect(route.requestMethod).to.eql(RequestMethod.GET);
+      expect(route.targetCallback).to.eq(instance.getTestUsingArray);
+    });
+
+    describe('when new implementation is injected into router', () => {
+      it('should method return changed impl of single route', () => {
+        const instance = new TestRoute();
+        const instanceProto = Object.getPrototypeOf(instance);
+
+        const newImpl = function () {};
+        instance.getTest = newImpl;
+
+        const route = routerBuilder.exploreMethodMetadata(
+          instance,
+          instanceProto,
+          'getTest',
+        );
+
+        expect(route.targetCallback).to.eq(newImpl);
+        expect(route.path).to.eql(['/test']);
+        expect(route.requestMethod).to.eql(RequestMethod.GET);
+      });
+
+      it('should method return changed impl of single route which alias applied', () => {
+        const instance = new TestRouteAlias();
+        const instanceProto = Object.getPrototypeOf(instance);
+
+        const newImpl = function () {};
+        instance.getTest = newImpl;
+
+        const route = routerBuilder.exploreMethodMetadata(
+          instance,
+          instanceProto,
+          'getTest',
+        );
+
+        expect(route.targetCallback).to.eq(newImpl);
+        expect(route.path).to.eql(['/test']);
+        expect(route.requestMethod).to.eql(RequestMethod.GET);
+      });
+
+      it('should method return changed impl of multiple routes', () => {
+        const instance = new TestRoute();
+        const instanceProto = Object.getPrototypeOf(instance);
+
+        const newImpl = function () {};
+        instance.getTestUsingArray = newImpl;
+
+        const route = routerBuilder.exploreMethodMetadata(
+          instance,
+          instanceProto,
+          'getTestUsingArray',
+        );
+
+        expect(route.targetCallback).to.eq(newImpl);
+        expect(route.path).to.eql(['/foo', '/bar']);
+        expect(route.requestMethod).to.eql(RequestMethod.GET);
+      });
+
+      it('should method return changed impl of multiple routes which alias applied', () => {
+        const instance = new TestRouteAlias();
+        const instanceProto = Object.getPrototypeOf(instance);
+
+        const newImpl = function () {};
+        instance.getTestUsingArray = newImpl;
+
+        const route = routerBuilder.exploreMethodMetadata(
+          instance,
+          instanceProto,
+          'getTestUsingArray',
+        );
+
+        expect(route.targetCallback).to.eq(newImpl);
+        expect(route.path).to.eql(['/foo', '/bar']);
+        expect(route.requestMethod).to.eql(RequestMethod.GET);
+      });
     });
   });
 

packages/core/test/router/sse-stream.spec.ts

@@ -125,7 +125,7 @@ data: hello
         'Content-Type': 'text/event-stream',
         Connection: 'keep-alive',
         'Cache-Control':
-          'private, no-cache, no-store, must-revalidate, max-age=0',
+          'private, no-cache, no-store, must-revalidate, max-age=0, no-transform',
         'Transfer-Encoding': 'identity',
         Pragma: 'no-cache',
         Expire: '0',

packages/microservices/Readme.md

@@ -56,16 +56,21 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 
 #### Principal Sponsors
 <table style="text-align:center;"><tr><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://valor-software.com/" target="_blank"><img src="https://docs.nestjs.com/assets/sponsors/valor-software.png" width="180" valign="middle" /></a></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>
 </tr></table>
 
+#### Gold Sponsors
+
+<table style="text-align:center;"><tr><td>
+<a href="https://valor-software.com/" target="_blank"><img src="https://docs.nestjs.com/assets/sponsors/valor-software.png" width="170" valign="middle" /></a></td></tr></table>
+
 #### Silver 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="https://trilon.io" target="_blank"><img src="https://nestjs.com/img/trilon.svg" width="170" valign="middle" /></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="http://www.meetdandy.com" target="_blank"><img src="https://nestjs.com/img/dandy-wide-logo.png" width="150" valign="middle" /></td></tr></table>
 
@@ -90,6 +95,11 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
   <td align="center" valign="middle">
   <a href="https://genuinebee.com/" target="_blank"><img src="https://nestjs.com/img/genuinebee.svg" width="97" valign="middle" /></a> </td>
 <td align="center" valign="middle"><a href="https://sanyodigital.com/" target="_blank"><img src="https://nestjs.com/img/sanyo-digital.png" width="130" valign="middle" /></a></td></tr><tr><td align="center" valign="middle"><a href="https://vpn-review.com/vpn-for-torrenting" target="_blank"><img src="https://nestjs.com/img/vpn-review-logo.png" width="85" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://lambda-it.ch/" target="_blank"><img src="https://nestjs.com/img/lambda-it-logo.svg" width="115" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://pickwriters.com/top-10-translation-services" target="_blank"><img src="https://nestjs.com/img/pickwriters-logo.png" width="40" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://thewordpoint.com/services/localization" target="_blank"><img src="https://nestjs.com/img/thewordpoint-logo.png" width="40" valign="middle" /></a></td>
+<td align="center" valign="middle"><a href="https://streamat.se/" target="_blank"><img src="https://nestjs.com/img/streamat-logo.png" width="120" valign="middle" /></a></td>
+<td align="center" valign="middle"><a href="https://filmen.nu/" target="_blank"><img src="https://nestjs.com/img/filmen-logo.png" width="120" valign="middle" /></a></td></tr><tr>
+<td align="center" valign="middle"><a href="https://meercode.io/" target="_blank"><img src="https://nestjs.com/img/meercode-logo.png" width="60" valign="middle" /></a></td>
+  <td align="center" valign="middle"><a href="https://www.najlepszeplatformyforex.pl/blog/broker-xtb/" target="_blank"><img src="https://nestjs.com/img/npf-logo.jpg" width="200" valign="middle" /></a></td>
+    <td align="center" valign="middle"><a href="https://thestandarddaily.com/" target="_blank"><img src="https://nestjs.com/img/the-standard-daily-logo.png" width="180" valign="middle" /></a></td>
   </tr></table>
 
 ## Backers

packages/microservices/client/client-grpc.ts

@@ -305,7 +305,9 @@ export class ClientGrpcProxy extends ClientProxy implements ClientGrpc {
   }
 
   public close() {
-    this.grpcClients.forEach(client => client.close());
+    this.grpcClients
+      .filter(client => client && isFunction(client.close))
+      .forEach(client => client.close());
     this.grpcClients = [];
   }
 

packages/microservices/client/client-kafka.ts

@@ -8,7 +8,6 @@ import {
 } from '../constants';
 import { KafkaResponseDeserializer } from '../deserializers/kafka-response.deserializer';
 import { KafkaHeaders } from '../enums';
-import { InvalidKafkaClientTopicPartitionException } from '../errors/invalid-kafka-client-topic-partition.exception';
 import { InvalidKafkaClientTopicException } from '../errors/invalid-kafka-client-topic.exception';
 import {
   BrokersFunction,
@@ -24,7 +23,7 @@ import {
 import {
   KafkaLogger,
   KafkaParser,
-  KafkaRoundRobinPartitionAssigner,
+  KafkaReplyPartitionAssigner,
 } from '../helpers';
 import {
   KafkaOptions,
@@ -46,7 +45,7 @@ export class ClientKafka extends ClientProxy {
   protected producer: Producer = null;
   protected logger = new Logger(ClientKafka.name);
   protected responsePatterns: string[] = [];
-  protected consumerAssignments: { [key: string]: number[] } = {};
+  protected consumerAssignments: { [key: string]: number } = {};
 
   protected brokers: string[] | BrokersFunction;
   protected clientId: string;
@@ -59,17 +58,16 @@ export class ClientKafka extends ClientProxy {
       this.getOptionsProp(this.options, 'client') || ({} as KafkaConfig);
     const consumerOptions =
       this.getOptionsProp(this.options, 'consumer') || ({} as ConsumerConfig);
+    const postfixId =
+      this.getOptionsProp(this.options, 'postfixId') || '-client';
 
     this.brokers = clientOptions.brokers || [KAFKA_DEFAULT_BROKER];
 
     // Append a unique id to the clientId and groupId
     // so they don't collide with a microservices client
     this.clientId =
-      (clientOptions.clientId || KAFKA_DEFAULT_CLIENT) +
-      (clientOptions.clientIdPostfix || '-client');
-    this.groupId =
-      (consumerOptions.groupId || KAFKA_DEFAULT_GROUP) +
-      (clientOptions.clientIdPostfix || '-client');
+      (clientOptions.clientId || KAFKA_DEFAULT_CLIENT) + postfixId;
+    this.groupId = (consumerOptions.groupId || KAFKA_DEFAULT_GROUP) + postfixId;
 
     kafkaPackage = loadPackage('kafkajs', ClientKafka.name, () =>
       require('kafkajs'),
@@ -99,11 +97,8 @@ export class ClientKafka extends ClientProxy {
     this.client = this.createClient();
 
     const partitionAssigners = [
-      (
-        config: ConstructorParameters<
-          typeof KafkaRoundRobinPartitionAssigner
-        >[0],
-      ) => new KafkaRoundRobinPartitionAssigner(config),
+      (config: ConstructorParameters<typeof KafkaReplyPartitionAssigner>[1]) =>
+        new KafkaReplyPartitionAssigner(this, config),
     ] as any[];
 
     const consumerOptions = Object.assign(
@@ -188,6 +183,10 @@ export class ClientKafka extends ClientProxy {
     };
   }
 
+  public getConsumerAssignments() {
+    return this.consumerAssignments;
+  }
+
   protected dispatchEvent(packet: OutgoingEvent): Promise<any> {
     const pattern = this.normalizePattern(packet.pattern);
     const outgoingEvent = this.serializer.serialize(packet.data);
@@ -202,17 +201,13 @@ export class ClientKafka extends ClientProxy {
   }
 
   protected getReplyTopicPartition(topic: string): string {
-    const topicAssignments = this.consumerAssignments[topic];
-    if (isUndefined(topicAssignments)) {
+    const minimumPartition = this.consumerAssignments[topic];
+    if (isUndefined(minimumPartition)) {
       throw new InvalidKafkaClientTopicException(topic);
     }
 
-    // if the current member isn't listening to
-    // any partitions on the topic then throw an error.
-    if (isUndefined(topicAssignments[0])) {
-      throw new InvalidKafkaClientTopicPartitionException(topic);
-    }
-    return topicAssignments[0].toString();
+    // get the minimum partition
+    return minimumPartition.toString();
   }
 
   protected publish(
@@ -241,7 +236,7 @@ export class ClientKafka extends ClientProxy {
         },
         this.options.send || {},
       );
-      this.producer.send(message);
+      this.producer.send(message).catch(err => callback({ err }));
 
       return () => this.routingMap.delete(packet.id);
     } catch (err) {
@@ -254,7 +249,18 @@ export class ClientKafka extends ClientProxy {
   }
 
   protected setConsumerAssignments(data: ConsumerGroupJoinEvent): void {
-    this.consumerAssignments = data.payload.memberAssignment;
+    const consumerAssignments: { [key: string]: number } = {};
+
+    // only need to set the minimum
+    Object.keys(data.payload.memberAssignment).forEach(memberId => {
+      const minimumPartition = Math.min(
+        ...data.payload.memberAssignment[memberId],
+      );
+
+      consumerAssignments[memberId] = minimumPartition;
+    });
+
+    this.consumerAssignments = consumerAssignments;
   }
 
   protected initializeSerializer(options: KafkaOptions['options']) {

packages/microservices/client/client-mqtt.ts

@@ -157,7 +157,7 @@ export class ClientMqtt extends ClientProxy {
     const pattern = this.normalizePattern(packet.pattern);
     const serializedPacket = this.serializer.serialize(packet);
 
-    return new Promise((resolve, reject) =>
+    return new Promise<void>((resolve, reject) =>
       this.mqttClient.publish(pattern, JSON.stringify(serializedPacket), err =>
         err ? reject(err) : resolve(),
       ),

packages/microservices/client/client-nats.ts

@@ -111,7 +111,7 @@ export class ClientNats extends ClientProxy {
     const pattern = this.normalizePattern(packet.pattern);
     const serializedPacket = this.serializer.serialize(packet);
 
-    return new Promise((resolve, reject) =>
+    return new Promise<void>((resolve, reject) =>
       this.natsClient.publish(pattern, serializedPacket as any, err =>
         err ? reject(err) : resolve(),
       ),

packages/microservices/client/client-proxy-factory.ts

@@ -1,6 +1,7 @@
 import { Transport } from '../enums/transport.enum';
 import {
   ClientOptions,
+  CustomClientOptions,
   TcpClientOptions,
 } from '../interfaces/client-metadata.interface';
 import { Closeable } from '../interfaces/closeable.interface';
@@ -30,7 +31,16 @@ export class ClientProxyFactory {
     clientOptions: { transport: Transport.GRPC } & ClientOptions,
   ): ClientGrpcProxy;
   public static create(clientOptions: ClientOptions): ClientProxy & Closeable;
-  public static create(clientOptions: ClientOptions): ClientProxy & Closeable {
+  public static create(
+    clientOptions: CustomClientOptions,
+  ): ClientProxy & Closeable;
+  public static create(
+    clientOptions: ClientOptions | CustomClientOptions,
+  ): ClientProxy & Closeable {
+    if (this.isCustomClientOptions(clientOptions)) {
+      const { customClass, options } = clientOptions;
+      return new customClass(options);
+    }
     const { transport, options } = clientOptions;
     switch (transport) {
       case Transport.REDIS:
@@ -49,4 +59,10 @@ export class ClientProxyFactory {
         return new ClientTCP(options as TcpClientOptions['options']);
     }
   }
+
+  private static isCustomClientOptions(
+    options: ClientOptions | CustomClientOptions,
+  ): options is CustomClientOptions {
+    return !!(options as CustomClientOptions).customClass;
+  }
 }

packages/microservices/client/client-proxy.ts

@@ -84,17 +84,25 @@ export abstract class ClientProxy {
   ): (packet: WritePacket) => void {
     return ({ err, response, isDisposed }: WritePacket) => {
       if (err) {
-        return observer.error(err);
+        return observer.error(this.serializeError(err));
       } else if (response !== undefined && isDisposed) {
-        observer.next(response);
+        observer.next(this.serializeResponse(response));
         return observer.complete();
       } else if (isDisposed) {
         return observer.complete();
       }
-      observer.next(response);
+      observer.next(this.serializeResponse(response));
     };
   }
 
+  protected serializeError(err: any): any {
+    return err;
+  }
+
+  protected serializeResponse(response: any): any {
+    return response;
+  }
+
   protected assignPacketId(packet: ReadPacket): ReadPacket & PacketId {
     const id = randomStringGenerator();
     return Object.assign(packet, { id });

packages/microservices/client/client-redis.ts

@@ -190,7 +190,7 @@ export class ClientRedis extends ClientProxy {
     const pattern = this.normalizePattern(packet.pattern);
     const serializedPacket = this.serializer.serialize(packet);
 
-    return new Promise((resolve, reject) =>
+    return new Promise<void>((resolve, reject) =>
       this.pubClient.publish(pattern, JSON.stringify(serializedPacket), err =>
         err ? reject(err) : resolve(),
       ),

packages/microservices/client/client-rmq.ts

@@ -16,9 +16,9 @@ import {
   RQM_DEFAULT_QUEUE_OPTIONS,
   RQM_DEFAULT_URL,
 } from '../constants';
+import { RmqUrl } from '../external/rmq-url.interface';
 import { ReadPacket, RmqOptions, WritePacket } from '../interfaces';
 import { ClientProxy } from './client-proxy';
-import { RmqUrl } from '../external/rmq-url.interface';
 
 let rqmPackage: any = {};
 
@@ -204,14 +204,14 @@ export class ClientRMQ extends ClientProxy {
   protected dispatchEvent(packet: ReadPacket): Promise<any> {
     const serializedPacket = this.serializer.serialize(packet);
 
-    return new Promise((resolve, reject) =>
+    return new Promise<void>((resolve, reject) =>
       this.channel.sendToQueue(
         this.queue,
         Buffer.from(JSON.stringify(serializedPacket)),
         {
           persistent: this.persistent,
         },
-        err => (err ? reject(err) : resolve()),
+        (err: unknown) => (err ? reject(err) : resolve()),
       ),
     );
   }

packages/microservices/context/rpc-context-creator.ts

@@ -41,9 +41,7 @@ export interface RpcHandlerMetadata {
 export class RpcContextCreator {
   private readonly contextUtils = new ContextUtils();
   private readonly rpcParamsFactory = new RpcParamsFactory();
-  private readonly handlerMetadataStorage = new HandlerMetadataStorage<
-    RpcHandlerMetadata
-  >();
+  private readonly handlerMetadataStorage = new HandlerMetadataStorage<RpcHandlerMetadata>();
 
   constructor(
     private readonly rpcProxy: RpcProxy,

packages/microservices/errors/invalid-kafka-client-topic-partition.exception.ts

@@ -1,9 +0,0 @@
-import { RuntimeException } from '@nestjs/core/errors/exceptions/runtime.exception';
-
-export class InvalidKafkaClientTopicPartitionException extends RuntimeException {
-  constructor(topic?: string) {
-    super(
-      `The client consumer subscribed to the topic (${topic}) which is not assigned to any partitions.`,
-    );
-  }
-}