chore(release) publish v5.0.0-beta.5

bundle/common/constants.d.ts

@@ -21,5 +21,7 @@ export declare const GUARDS_METADATA = "__guards__";
 export declare const RENDER_METADATA = "__renderTemplate__";
 export declare const INTERCEPTORS_METADATA = "__interceptors__";
 export declare const HTTP_CODE_METADATA = "__httpCode__";
-export declare const GATEWAY_MIDDLEWARES = "__gatewayMiddlewares";
+export declare const GATEWAY_MIDDLEWARES = "__gatewayMiddleware";
 export declare const MODULE_PATH = "__module_path__";
+export declare const HEADERS_METADATA = "__headers__";
+export declare const REDIRECT_METADATA = "__redirect__";

bundle/common/constants.js

@@ -23,5 +23,7 @@ exports.GUARDS_METADATA = '__guards__';
 exports.RENDER_METADATA = '__renderTemplate__';
 exports.INTERCEPTORS_METADATA = '__interceptors__';
 exports.HTTP_CODE_METADATA = '__httpCode__';
-exports.GATEWAY_MIDDLEWARES = '__gatewayMiddlewares';
+exports.GATEWAY_MIDDLEWARES = '__gatewayMiddleware';
 exports.MODULE_PATH = '__module_path__';
+exports.HEADERS_METADATA = '__headers__';
+exports.REDIRECT_METADATA = '__redirect__';

bundle/common/decorators/http/create-route-param-metadata.decorator.js

@@ -18,8 +18,8 @@ const randomString = () => Math.random()
 function createParamDecorator(factory) {
     const paramtype = randomString() + randomString();
     return (data, ...pipes) => (target, key, index) => {
-        const args = Reflect.getMetadata(constants_1.ROUTE_ARGS_METADATA, target, key) || {};
-        Reflect.defineMetadata(constants_1.ROUTE_ARGS_METADATA, assignCustomMetadata(args, paramtype, index, factory, data, ...pipes), target, key);
+        const args = Reflect.getMetadata(constants_1.ROUTE_ARGS_METADATA, target.constructor, key) || {};
+        Reflect.defineMetadata(constants_1.ROUTE_ARGS_METADATA, assignCustomMetadata(args, paramtype, index, factory, data, ...pipes), target.constructor, key);
     };
 }
 exports.createParamDecorator = createParamDecorator;

bundle/common/decorators/http/header.decorator.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+/**
+ * Sets a response header.
+ */
+export declare function Header(name: string, value: string): MethodDecorator;

bundle/common/decorators/http/header.decorator.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const constants_1 = require("../../constants");
+const extend_metadata_util_1 = require("../../utils/extend-metadata.util");
+/**
+ * Sets a response header.
+ */
+function Header(name, value) {
+    return (target, key, descriptor) => {
+        extend_metadata_util_1.extendArrayMetadata(constants_1.HEADERS_METADATA, [{ name, value }], descriptor.value);
+        return descriptor;
+    };
+}
+exports.Header = Header;

bundle/common/decorators/http/index.d.ts

@@ -3,3 +3,4 @@ export * from './route-params.decorator';
 export * from './http-code.decorator';
 export * from './create-route-param-metadata.decorator';
 export * from './render.decorator';
+export * from './header.decorator';

bundle/common/decorators/http/index.js

@@ -8,3 +8,4 @@ __export(require("./route-params.decorator"));
 __export(require("./http-code.decorator"));
 __export(require("./create-route-param-metadata.decorator"));
 __export(require("./render.decorator"));
+__export(require("./header.decorator"));

bundle/common/decorators/http/redirect.decorator.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+/**
+ * Redirects request.
+ */
+export declare function Redirect(url: string): MethodDecorator;

bundle/common/decorators/http/redirect.decorator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const constants_1 = require("../../constants");
+/**
+ * Redirects request.
+ */
+function Redirect(url) {
+    return (target, key, descriptor) => {
+        Reflect.defineMetadata(constants_1.REDIRECT_METADATA, url, descriptor.value);
+        return descriptor;
+    };
+}
+exports.Redirect = Redirect;

bundle/common/decorators/http/route-params.decorator.js

@@ -11,16 +11,16 @@ const assignMetadata = (args, paramtype, index, data, ...pipes) => (Object.assig
     } }));
 const createRouteParamDecorator = (paramtype) => {
     return (data) => (target, key, index) => {
-        const args = Reflect.getMetadata(constants_1.ROUTE_ARGS_METADATA, target, key) || {};
-        Reflect.defineMetadata(constants_1.ROUTE_ARGS_METADATA, assignMetadata(args, paramtype, index, data), target, key);
+        const args = Reflect.getMetadata(constants_1.ROUTE_ARGS_METADATA, target.constructor, key) || {};
+        Reflect.defineMetadata(constants_1.ROUTE_ARGS_METADATA, assignMetadata(args, paramtype, index, data), target.constructor, key);
     };
 };
 const createPipesRouteParamDecorator = (paramtype) => (data, ...pipes) => (target, key, index) => {
-    const args = Reflect.getMetadata(constants_1.ROUTE_ARGS_METADATA, target, key) || {};
+    const args = Reflect.getMetadata(constants_1.ROUTE_ARGS_METADATA, target.constructor, key) || {};
     const hasParamData = shared_utils_1.isNil(data) || shared_utils_1.isString(data);
     const paramData = hasParamData ? data : undefined;
     const paramPipes = hasParamData ? pipes : [data, ...pipes];
-    Reflect.defineMetadata(constants_1.ROUTE_ARGS_METADATA, assignMetadata(args, paramtype, index, paramData, ...paramPipes), target, key);
+    Reflect.defineMetadata(constants_1.ROUTE_ARGS_METADATA, assignMetadata(args, paramtype, index, paramData, ...paramPipes), target.constructor, key);
 };
 exports.Request = createRouteParamDecorator(route_paramtypes_enum_1.RouteParamtypes.REQUEST);
 exports.Response = createRouteParamDecorator(route_paramtypes_enum_1.RouteParamtypes.RESPONSE);

bundle/common/decorators/modules/module.decorator.d.ts

@@ -7,6 +7,6 @@ import { ModuleMetadata } from '../../interfaces/modules/module-metadata.interfa
  * - `providers` - the list of providers that belong to this module. They can be injected between themselves.
  * - `exports` - the set of components, which should be available for modules, which imports this module
  * - `components` - @deprecated the list of components that belong to this module. They can be injected between themselves.
- * @param obj {ModuleMetadata} Module metadata
+ * @param options {ModuleMetadata} Module metadata
  */
-export declare function Module(obj: ModuleMetadata): ClassDecorator;
+export declare function Module(metadata: ModuleMetadata): ClassDecorator;

bundle/common/decorators/modules/module.decorator.js

@@ -29,17 +29,17 @@ const validateKeys = (keys) => {
  * - `providers` - the list of providers that belong to this module. They can be injected between themselves.
  * - `exports` - the set of components, which should be available for modules, which imports this module
  * - `components` - @deprecated the list of components that belong to this module. They can be injected between themselves.
- * @param obj {ModuleMetadata} Module metadata
+ * @param options {ModuleMetadata} Module metadata
  */
-function Module(obj) {
-    const propsKeys = Object.keys(obj);
+function Module(metadata) {
+    const propsKeys = Object.keys(metadata);
     validateKeys(propsKeys);
-    showDeprecatedWarnings(obj);
-    overrideModuleMetadata(obj);
+    showDeprecatedWarnings(metadata);
+    overrideModuleMetadata(metadata);
     return (target) => {
-        for (const property in obj) {
-            if (obj.hasOwnProperty(property)) {
-                Reflect.defineMetadata(property, obj[property], target);
+        for (const property in metadata) {
+            if (metadata.hasOwnProperty(property)) {
+                Reflect.defineMetadata(property, metadata[property], target);
             }
         }
     };

bundle/common/http/http.service.d.ts

@@ -1,5 +1,5 @@
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 export declare class HttpService {
     request<T = any>(config: AxiosRequestConfig): Observable<AxiosResponse<T>>;
     get<T = any>(url: string, config?: AxiosRequestConfig): Observable<AxiosResponse<T>>;

bundle/common/http/http.service.js

@@ -1,28 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const axios_1 = require("axios");
-const fromPromise_1 = require("rxjs/observable/fromPromise");
+const rxjs_1 = require("rxjs");
 class HttpService {
     request(config) {
-        return fromPromise_1.fromPromise(axios_1.default.request(config));
+        return rxjs_1.from(axios_1.default.request(config));
     }
     get(url, config) {
-        return fromPromise_1.fromPromise(axios_1.default.get(url, config));
+        return rxjs_1.from(axios_1.default.get(url, config));
     }
     delete(url, config) {
-        return fromPromise_1.fromPromise(axios_1.default.delete(url, config));
+        return rxjs_1.from(axios_1.default.delete(url, config));
     }
     head(url, config) {
-        return fromPromise_1.fromPromise(axios_1.default.head(url, config));
+        return rxjs_1.from(axios_1.default.head(url, config));
     }
     post(url, data, config) {
-        return fromPromise_1.fromPromise(axios_1.default.post(url, data, config));
+        return rxjs_1.from(axios_1.default.post(url, data, config));
     }
     put(url, data, config) {
-        return fromPromise_1.fromPromise(axios_1.default.post(url, data, config));
+        return rxjs_1.from(axios_1.default.post(url, data, config));
     }
     patch(url, data, config) {
-        return fromPromise_1.fromPromise(axios_1.default.post(url, data, config));
+        return rxjs_1.from(axios_1.default.post(url, data, config));
     }
 }
 exports.HttpService = HttpService;

bundle/common/index.d.ts

@@ -1,6 +1,6 @@
 export * from './decorators';
 export * from './enums';
-export { NestModule, INestApplication, INestMicroservice, NestMiddleware, FunctionMiddleware, MiddlewaresConsumer, OnModuleInit, ExceptionFilter, WebSocketAdapter, PipeTransform, Paramtype, ArgumentMetadata, OnModuleDestroy, ExecutionContext, CanActivate, RpcExceptionFilter, WsExceptionFilter, NestInterceptor, DynamicModule, INestApplicationContext, HttpServer, HttpServerFactory, ArgumentsHost, INestExpressApplication, INestFastifyApplication } from './interfaces';
+export { NestModule, INestApplication, INestMicroservice, NestMiddleware, MiddlewareFunction, MiddlewareConsumer, OnModuleInit, ExceptionFilter, WebSocketAdapter, PipeTransform, Paramtype, ArgumentMetadata, OnModuleDestroy, ExecutionContext, CanActivate, RpcExceptionFilter, WsExceptionFilter, NestInterceptor, DynamicModule, INestApplicationContext, HttpServer, HttpServerFactory, ArgumentsHost, INestExpressApplication, INestFastifyApplication } from './interfaces';
 export * from './interceptors';
 export * from './services/logger.service';
 export * from './pipes';

bundle/common/interceptors/files.interceptor.d.ts

@@ -1,6 +1,6 @@
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 import { MulterOptions } from '../interfaces/external/multer-options.interface';
-import { ExecutionContext } from './../interfaces';
+import { ExecutionContext } from '../interfaces';
 export declare function FilesInterceptor(fieldName: string, maxCount?: number, options?: MulterOptions): {
     new (): {
         readonly upload: any;

bundle/common/interfaces/exceptions/rpc-exception-filter.interface.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 import { ArgumentsHost } from './../features/arguments-host.interface';
 export interface RpcExceptionFilter<T = any, R = any> {
     catch(exception: T, host: ArgumentsHost): Observable<R>;

bundle/common/interfaces/external/cors-options.interface.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @see https://github.com/expressjs/cors
+ */
 export declare type CustomOrigin = (requestOrigin: string, callback: (err: Error | null, allow?: boolean) => void) => void;
 export interface CorsOptions {
     origin?: boolean | string | RegExp | (string | RegExp)[] | CustomOrigin;

bundle/common/interfaces/external/mqtt-options.interface.d.ts

@@ -0,0 +1,136 @@
+/// <reference types="node" />
+/**
+ * @see https://github.com/mqttjs/MQTT.js/
+ */
+export declare type QoS = 0 | 1 | 2;
+export interface MqttClientOptions extends ISecureClientOptions {
+    port?: number;
+    host?: string;
+    hostname?: string;
+    path?: string;
+    protocol?: 'wss' | 'ws' | 'mqtt' | 'mqtts' | 'tcp' | 'ssl' | 'wx' | 'wxs';
+    wsOptions?: {
+        [x: string]: any;
+    };
+    /**
+     *  10 seconds, set to 0 to disable
+     */
+    keepalive?: number;
+    /**
+     * 'mqttjs_' + Math.random().toString(16).substr(2, 8)
+     */
+    clientId?: string;
+    /**
+     * 'MQTT'
+     */
+    protocolId?: string;
+    /**
+     * 4
+     */
+    protocolVersion?: number;
+    /**
+     * true, set to false to receive QoS 1 and 2 messages while offline
+     */
+    clean?: boolean;
+    /**
+     * 1000 milliseconds, interval between two reconnections
+     */
+    reconnectPeriod?: number;
+    /**
+     * 30 * 1000 milliseconds, time to wait before a CONNACK is received
+     */
+    connectTimeout?: number;
+    /**
+     * the username required by your broker, if any
+     */
+    username?: string;
+    /**
+     * the password required by your broker, if any
+     */
+    password?: string;
+    /**
+     * a any for the incoming packets
+     */
+    incomingStore?: any;
+    /**
+     * a any for the outgoing packets
+     */
+    outgoingStore?: any;
+    queueQoSZero?: boolean;
+    reschedulePings?: boolean;
+    servers?: Array<{
+        host: string;
+        port: number;
+    }>;
+    /**
+     * true, set to false to disable re-subscribe functionality
+     */
+    resubscribe?: boolean;
+    /**
+     * a message that will sent by the broker automatically when the client disconnect badly.
+     */
+    will?: {
+        /**
+         * the topic to publish
+         */
+        topic: string;
+        /**
+         * the message to publish
+         */
+        payload: string;
+        /**
+         * the QoS
+         */
+        qos: QoS;
+        /**
+         * the retain flag
+         */
+        retain: boolean;
+    };
+    transformWsUrl?: (url: string, options: any, client: any) => string;
+}
+export interface ISecureClientOptions {
+    /**
+     * optional private keys in PEM format
+     */
+    key?: string | string[] | Buffer | Buffer[] | Object[];
+    /**
+     * optional cert chains in PEM format
+     */
+    cert?: string | string[] | Buffer | Buffer[];
+    /**
+     * Optionally override the trusted CA certificates in PEM format
+     */
+    ca?: string | string[] | Buffer | Buffer[];
+    rejectUnauthorized?: boolean;
+}
+export interface IClientPublishOptions {
+    /**
+     * the QoS
+     */
+    qos: QoS;
+    /**
+     * the retain flag
+     */
+    retain?: boolean;
+    /**
+     * whether or not mark a message as duplicate
+     */
+    dup?: boolean;
+}
+export interface IClientSubscribeOptions {
+    /**
+     * the QoS
+     */
+    qos: QoS;
+}
+export interface IClientReconnectOptions {
+    /**
+     * a any for the incoming packets
+     */
+    incomingStore?: any;
+    /**
+     * a any for the outgoing packets
+     */
+    outgoingStore?: any;
+}

bundle/common/interfaces/external/mqtt-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

bundle/common/interfaces/external/multer-options.interface.d.ts

@@ -1,4 +1,7 @@
 /// <reference types="node" />
+/**
+ * @see https://github.com/expressjs/multer
+ */
 export interface MulterOptions {
     dest?: string;
     /** The storage engine to use for uploaded files. */

bundle/common/interfaces/external/serve-static-options.interface.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @see https://www.npmjs.com/package/@types/serve-static
+ */
 export interface ServeStaticOptions {
     /**
      * Set how "dotfiles" are treated when encountered. A dotfile is a file or directory that begins with a dot (".").

bundle/common/interfaces/external/serve-static-options.interface.js

@@ -1,3 +1,2 @@
 "use strict";
-/// Reference: https://www.npmjs.com/package/@types/serve-static
 Object.defineProperty(exports, "__esModule", { value: true });

bundle/common/interfaces/features/can-activate.interface.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 import { ExecutionContext } from './execution-context.interface';
 export interface CanActivate {
     canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean>;

bundle/common/interfaces/features/nest-interceptor.interface.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 import { ExecutionContext } from './execution-context.interface';
 export interface NestInterceptor<T = any, R = any> {
     intercept(context: ExecutionContext, call$: Observable<T>): Observable<R> | Promise<Observable<R>>;

bundle/common/interfaces/http/http-server.interface.d.ts

@@ -23,6 +23,7 @@ export interface HttpServer {
     listen(port: number | string, hostname: string, callback?: () => void): any;
     reply(response: any, body: any, statusCode: number): any;
     render(response: any, view: string, options: any): any;
+    setHeader(response: any, name: string, value: string): any;
     setErrorHandler?(handler: Function): any;
     setNotFoundHandler?(handler: Function): any;
     useStaticAssets?(...args: any[]): this;

bundle/common/interfaces/index.d.ts

@@ -12,7 +12,7 @@ export * from './nest-application-context.interface';
 export * from './modules/on-init.interface';
 export * from './modules/on-destroy.interface';
 export * from './exceptions/exception-filter.interface';
-export * from './middlewares';
+export * from './middleware';
 export * from './websockets/web-socket-adapter.interface';
 export * from './features/pipe-transform.interface';
 export * from './features/paramtype.interface';

bundle/common/interfaces/microservices/microservice-configuration.interface.d.ts

@@ -1,7 +1,6 @@
 import { Transport } from '../../enums/transport.enum';
 import { CustomTransportStrategy } from './custom-transport-strategy.interface';
-import { IClientOptions } from 'mqtt';
-import { ServerCredentials } from 'grpc';
+import { MqttClientOptions } from '../external/mqtt-options.interface';
 export declare type MicroserviceOptions = GrpcOptions | TcpOptions | RedisOptions | NatsOptions | MqttOptions | CustomStrategy;
 export interface CustomStrategy {
     strategy?: CustomTransportStrategy;
@@ -11,7 +10,7 @@ export interface GrpcOptions {
     transport?: Transport.GRPC;
     options: {
         url?: string;
-        credentials?: ServerCredentials;
+        credentials?: any;
         protoPath: string;
         package: string;
     };
@@ -35,7 +34,7 @@ export interface RedisOptions {
 }
 export interface MqttOptions {
     transport?: Transport.MQTT;
-    options?: IClientOptions & {
+    options?: MqttClientOptions & {
         url?: string;
     };
 }

bundle/common/interfaces/middleware/index.d.ts

@@ -0,0 +1,5 @@
+export * from './middleware-config-proxy.interface';
+export * from './middleware-consumer.interface';
+export * from './middleware-configuration.interface';
+export * from './nest-middleware.interface';
+export * from './middleware.interface';

bundle/common/interfaces/middleware/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

bundle/common/interfaces/middleware/middleware-config-proxy.interface.d.ts

@@ -0,0 +1,19 @@
+import { MiddlewareConsumer } from './middleware-consumer.interface';
+import { Type } from '../type.interface';
+export interface MiddlewareConfigProxy {
+    /**
+     * Passes custom arguments to `resolve()` method of the middleware.
+     *
+     * @param  {} ...data
+     * @returns {MiddlewareConfigProxy}
+     */
+    with(...data: any[]): MiddlewareConfigProxy;
+    /**
+     * Attaches passed either routes (strings) or controllers to the processed middleware(s).
+     * When you pass Controller class Nest will attach middleware to every path defined within this controller.
+     *
+     * @param  {} ...routes
+     * @returns {MiddlewareConsumer}
+     */
+    forRoutes(...routes: (string | Type<any>)[]): MiddlewareConsumer;
+}

bundle/common/interfaces/middleware/middleware-config-proxy.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

bundle/common/interfaces/middleware/middleware-configuration.interface.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '../type.interface';
+export interface MiddlewareConfiguration {
+    middleware: any;
+    forRoutes: (Type<any> | string)[];
+}

bundle/common/interfaces/middleware/middleware-configuration.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

bundle/common/interfaces/middleware/middleware-consumer.interface.d.ts

@@ -0,0 +1,11 @@
+import { MiddlewareConfigProxy } from './middleware-config-proxy.interface';
+export interface MiddlewareConsumer {
+    /**
+     * Takes single middleware class or array of classes
+     * that subsequently could be attached to the passed either routes or controllers.
+     *
+     * @param  {any|any[]} middleware
+     * @returns {MiddlewareConfigProxy}
+     */
+    apply(middleware: any | any[]): MiddlewareConfigProxy;
+}

bundle/common/interfaces/middleware/middleware-consumer.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

bundle/common/interfaces/middleware/middleware.interface.d.ts

@@ -0,0 +1 @@
+export declare type MiddlewareFunction = (req?, res?, next?) => any;

bundle/common/interfaces/middleware/middleware.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

bundle/common/interfaces/middleware/nest-middleware.interface.d.ts

@@ -0,0 +1,4 @@
+import { MiddlewareFunction } from './middleware.interface';
+export interface NestMiddleware {
+    resolve(...args: any[]): MiddlewareFunction | Promise<MiddlewareFunction>;
+}

bundle/common/interfaces/middleware/nest-middleware.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

bundle/common/interfaces/modules/nest-module.interface.d.ts

@@ -1,4 +1,4 @@
-import { MiddlewaresConsumer } from '../middlewares/middlewares-consumer.interface';
+import { MiddlewareConsumer } from '../middleware/middleware-consumer.interface';
 export interface NestModule {
-    configure(consumer: MiddlewaresConsumer): MiddlewaresConsumer | void;
+    configure(consumer: MiddlewareConsumer): MiddlewareConsumer | void;
 }

bundle/common/interfaces/websockets/web-socket-adapter.interface.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 export interface WebSocketAdapter<T = any> {
     create(port: number, options?: T): any;
     bindClientConnect(server: any, callback: (...args) => void): any;

bundle/common/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/common",
-  "version": "5.0.0-beta.4",
+  "version": "5.0.0-beta.5",
   "description": "Nest - modern, fast, powerful node.js web framework (@common)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",

bundle/common/utils/bind-resolve-values.util.d.ts

@@ -1,3 +1,3 @@
 import { Constructor } from './merge-with-values.util';
-import { NestMiddleware } from '../interfaces/middlewares/nest-middleware.interface';
+import { NestMiddleware } from '../interfaces/middleware/nest-middleware.interface';
 export declare const BindResolveMiddlewareValues: <T extends Constructor<NestMiddleware>>(data: any[]) => (Metatype: T) => any;

bundle/core/adapters/express-adapter.d.ts

@@ -24,6 +24,7 @@ export declare class ExpressAdapter implements HttpServer {
     render(response: any, view: string, options: any): any;
     setErrorHandler(handler: Function): any;
     setNotFoundHandler(handler: Function): any;
+    setHeader(response: any, name: string, value: string): any;
     getHttpServer(): any;
     close(): any;
     set(...args: any[]): any;

bundle/core/adapters/express-adapter.js

@@ -49,6 +49,9 @@ class ExpressAdapter {
     setNotFoundHandler(handler) {
         return this.use(handler);
     }
+    setHeader(response, name, value) {
+        return response.set(name, value);
+    }
     getHttpServer() {
         return this.instance;
     }

bundle/core/adapters/fastify-adapter.d.ts

@@ -36,6 +36,7 @@ export declare class FastifyAdapter {
         send?: any;
     }): any;
     setViewEngine(options: any): any;
+    setHeader(response: any, name: string, value: string): any;
     getRequestMethod(request: any): string;
     getRequestUrl(request: any): string;
 }

bundle/core/adapters/fastify-adapter.js

@@ -79,6 +79,9 @@ class FastifyAdapter {
             throw new missing_dependency_exception_1.MissingRequiredDependencyException('point-of-view', 'FastifyAdapter.setViewEngine()');
         }
     }
+    setHeader(response, name, value) {
+        return response.header(name, value);
+    }
     getRequestMethod(request) {
         return request.raw.method;
     }

bundle/core/guards/guards-consumer.d.ts

@@ -1,6 +1,6 @@
 import { Controller } from '@nestjs/common/interfaces';
 import { CanActivate } from '@nestjs/common';
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 import { ExecutionContextHost } from '../helpers/execution-context.host';
 export declare class GuardsConsumer {
     tryActivate(guards: CanActivate[], args: any[], instance: Controller, callback: (...args) => any): Promise<boolean>;

bundle/core/guards/guards-consumer.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const Observable_1 = require("rxjs/Observable");
+const rxjs_1 = require("rxjs");
 const execution_context_host_1 = require("../helpers/execution-context.host");
 class GuardsConsumer {
     tryActivate(guards, args, instance, callback) {
@@ -33,7 +33,7 @@ class GuardsConsumer {
     }
     pickResult(result) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (result instanceof Observable_1.Observable) {
+            if (result instanceof rxjs_1.Observable) {
                 return yield result.toPromise();
             }
             if (result instanceof Promise) {

bundle/core/index.d.ts

@@ -1,7 +1,7 @@
-export { MiddlewareBuilder } from './middlewares/builder';
+export { MiddlewareBuilder } from './middleware/builder';
 export { ModuleRef } from './injector/module-ref';
 export { NestFactory } from './nest-factory';
 export { APP_INTERCEPTOR, APP_FILTER, APP_GUARD, APP_PIPE } from './constants';
-export * from './services/reflector.service';
+export * from './services';
 export * from './nest-application';
 export * from './nest-application-context';

bundle/core/index.js

@@ -9,7 +9,7 @@ function __export(m) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 Object.defineProperty(exports, "__esModule", { value: true });
-var builder_1 = require("./middlewares/builder");
+var builder_1 = require("./middleware/builder");
 exports.MiddlewareBuilder = builder_1.MiddlewareBuilder;
 var module_ref_1 = require("./injector/module-ref");
 exports.ModuleRef = module_ref_1.ModuleRef;
@@ -20,6 +20,6 @@ exports.APP_INTERCEPTOR = constants_1.APP_INTERCEPTOR;
 exports.APP_FILTER = constants_1.APP_FILTER;
 exports.APP_GUARD = constants_1.APP_GUARD;
 exports.APP_PIPE = constants_1.APP_PIPE;
-__export(require("./services/reflector.service"));
+__export(require("./services"));
 __export(require("./nest-application"));
 __export(require("./nest-application-context"));

bundle/core/injector/compiler.d.ts

@@ -0,0 +1,15 @@
+import { Type, DynamicModule } from '@nestjs/common/interfaces';
+export interface ModuleFactory {
+    type: Type<any>;
+    token: string;
+    dynamicMetadata?: Partial<DynamicModule> | undefined;
+}
+export declare class ModuleCompiler {
+    private readonly moduleTokenFactory;
+    compile(metatype: Type<any> | DynamicModule, scope: Type<any>[]): ModuleFactory;
+    extractMetadata(metatype: Type<any> | DynamicModule): {
+        type: Type<any>;
+        dynamicMetadata?: Partial<DynamicModule> | undefined;
+    };
+    isDynamicModule(module: Type<any> | DynamicModule): module is DynamicModule;
+}

bundle/core/injector/compiler.js

@@ -0,0 +1,33 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
+            t[p[i]] = s[p[i]];
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const module_token_factory_1 = require("./module-token-factory");
+class ModuleCompiler {
+    constructor() {
+        this.moduleTokenFactory = new module_token_factory_1.ModuleTokenFactory();
+    }
+    compile(metatype, scope) {
+        const { type, dynamicMetadata } = this.extractMetadata(metatype);
+        const token = this.moduleTokenFactory.create(type, scope, dynamicMetadata);
+        return { type, dynamicMetadata, token };
+    }
+    extractMetadata(metatype) {
+        if (!this.isDynamicModule(metatype)) {
+            return { type: metatype };
+        }
+        const { module: type } = metatype, dynamicMetadata = __rest(metatype, ["module"]);
+        return { type, dynamicMetadata };
+    }
+    isDynamicModule(module) {
+        return !!module.module;
+    }
+}
+exports.ModuleCompiler = ModuleCompiler;

bundle/core/injector/container.d.ts

@@ -7,22 +7,17 @@ import { ApplicationConfig } from './../application-config';
 export declare class NestContainer {
     private readonly _applicationConfig;
     private readonly globalModules;
+    private readonly moduleCompiler;
     private readonly modules;
     private readonly dynamicModulesMetadata;
-    private readonly moduleTokenFactory;
     private applicationRef;
     constructor(_applicationConfig?: ApplicationConfig);
     readonly applicationConfig: ApplicationConfig | undefined;
     setApplicationRef(applicationRef: any): void;
     getApplicationRef(): any;
     addModule(metatype: Type<any> | DynamicModule, scope: Type<any>[]): void;
-    extractMetadata(metatype: Type<any> | DynamicModule): {
-        type: Type<any>;
-        dynamicMetadata?: Partial<DynamicModule> | undefined;
-    };
-    isDynamicModule(module: Type<any> | DynamicModule): module is DynamicModule;
     addDynamicMetadata(token: string, dynamicModuleMetadata: Partial<DynamicModule>, scope: Type<any>[]): any;
-    addDynamicModules(modules: any[], scope: Type<any>[]): void;
+    addDynamicModules(modules: any[], scope: Type<any>[]): any;
     isGlobalModule(metatype: Type<any>): boolean;
     addGlobalModule(module: Module): void;
     getModules(): ModulesContainer;

bundle/core/injector/container.js

@@ -1,28 +1,19 @@
 "use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
-            t[p[i]] = s[p[i]];
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const constants_1 = require("@nestjs/common/constants");
 const module_1 = require("./module");
 const unknown_module_exception_1 = require("../errors/exceptions/unknown-module.exception");
-const module_token_factory_1 = require("./module-token-factory");
 const invalid_module_exception_1 = require("./../errors/exceptions/invalid-module.exception");
 const modules_container_1 = require("./modules-container");
+const compiler_1 = require("./compiler");
 class NestContainer {
     constructor(_applicationConfig = void 0) {
         this._applicationConfig = _applicationConfig;
         this.globalModules = new Set();
+        this.moduleCompiler = new compiler_1.ModuleCompiler();
         this.modules = new modules_container_1.ModulesContainer();
         this.dynamicModulesMetadata = new Map();
-        this.moduleTokenFactory = new module_token_factory_1.ModuleTokenFactory();
     }
     get applicationConfig() {
         return this._applicationConfig;
@@ -37,8 +28,7 @@ class NestContainer {
         if (!metatype) {
             throw new invalid_module_exception_1.InvalidModuleException(scope);
         }
-        const { type, dynamicMetadata } = this.extractMetadata(metatype);
-        const token = this.moduleTokenFactory.create(type, scope, dynamicMetadata);
+        const { type, dynamicMetadata, token } = this.moduleCompiler.compile(metatype, scope);
         if (this.modules.has(token)) {
             return;
         }
@@ -47,16 +37,6 @@ class NestContainer {
         this.addDynamicMetadata(token, dynamicMetadata, [].concat(scope, type));
         this.isGlobalModule(type) && this.addGlobalModule(module);
     }
-    extractMetadata(metatype) {
-        if (!this.isDynamicModule(metatype)) {
-            return { type: metatype };
-        }
-        const { module: type } = metatype, dynamicMetadata = __rest(metatype, ["module"]);
-        return { type, dynamicMetadata };
-    }
-    isDynamicModule(module) {
-        return !!module.module;
-    }
     addDynamicMetadata(token, dynamicModuleMetadata, scope) {
         if (!dynamicModuleMetadata) {
             return undefined;
@@ -68,7 +48,7 @@ class NestContainer {
     }
     addDynamicModules(modules, scope) {
         if (!modules) {
-            return;
+            return undefined;
         }
         modules.map(module => this.addModule(module, scope));
     }
@@ -86,8 +66,8 @@ class NestContainer {
             return;
         const module = this.modules.get(token);
         const parent = module.metatype;
-        const { type, dynamicMetadata } = this.extractMetadata(relatedModule);
-        const relatedModuleToken = this.moduleTokenFactory.create(type, [].concat(module.scope, parent), dynamicMetadata);
+        const scope = [].concat(module.scope, parent);
+        const { type, dynamicMetadata, token: relatedModuleToken, } = this.moduleCompiler.compile(relatedModule, scope);
         const related = this.modules.get(relatedModuleToken);
         module.addRelatedModule(related);
     }

bundle/core/injector/injector.d.ts

@@ -4,7 +4,7 @@ import { Module } from './module';
 import { Type } from '@nestjs/common/interfaces/type.interface';
 import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
 import { Injectable } from '@nestjs/common/interfaces/injectable.interface';
-import { MiddlewareWrapper } from '../middlewares/container';
+import { MiddlewareWrapper } from '../middleware/container';
 export declare class Injector {
     loadInstanceOfMiddleware(wrapper: MiddlewareWrapper, collection: Map<string, MiddlewareWrapper>, module: Module): Promise<void>;
     loadInstanceOfRoute(wrapper: InstanceWrapper<Controller>, module: Module): Promise<void>;

bundle/core/interceptors/interceptors-consumer.d.ts

@@ -1,6 +1,6 @@
 import { Controller } from '@nestjs/common/interfaces';
 import { NestInterceptor } from '@nestjs/common';
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 import { ExecutionContextHost } from '../helpers/execution-context.host';
 export declare class InterceptorsConsumer {
     intercept(interceptors: NestInterceptor[], args: any[], instance: Controller, callback: (...args) => any, next: () => Promise<any>): Promise<any>;

bundle/core/interceptors/interceptors-consumer.js

@@ -9,9 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const Observable_1 = require("rxjs/Observable");
-const defer_1 = require("rxjs/observable/defer");
-const fromPromise_1 = require("rxjs/observable/fromPromise");
+const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const execution_context_host_1 = require("../helpers/execution-context.host");
 class InterceptorsConsumer {
@@ -21,7 +19,7 @@ class InterceptorsConsumer {
                 return yield yield next();
             }
             const context = this.createContext(args, instance, callback);
-            const start$ = defer_1.defer(() => this.transformDeffered(next));
+            const start$ = rxjs_1.defer(() => this.transformDeffered(next));
             const result$ = yield interceptors.reduce((stream$, interceptor) => __awaiter(this, void 0, void 0, function* () { return yield interceptor.intercept(context, yield stream$); }), Promise.resolve(start$));
             return yield result$.toPromise();
         });
@@ -30,8 +28,8 @@ class InterceptorsConsumer {
         return new execution_context_host_1.ExecutionContextHost(args, instance.constructor, callback);
     }
     transformDeffered(next) {
-        return fromPromise_1.fromPromise(next()).pipe(operators_1.switchMap(res => {
-            const isDeffered = res instanceof Promise || res instanceof Observable_1.Observable;
+        return rxjs_1.from(next()).pipe(operators_1.switchMap(res => {
+            const isDeffered = res instanceof Promise || res instanceof rxjs_1.Observable;
             return isDeffered ? res : Promise.resolve(res);
         }));
     }

bundle/core/middleware/builder.d.ts

@@ -0,0 +1,14 @@
+import { MiddlewareConfiguration } from '@nestjs/common/interfaces/middleware/middleware-configuration.interface';
+import { Type, MiddlewareConsumer } from '@nestjs/common/interfaces';
+import { MiddlewareConfigProxy } from '@nestjs/common/interfaces/middleware';
+import { RoutesMapper } from './routes-mapper';
+export declare class MiddlewareBuilder implements MiddlewareConsumer {
+    private readonly routesMapper;
+    private readonly middlewareCollection;
+    private readonly logger;
+    constructor(routesMapper: RoutesMapper);
+    apply(...middleware: Array<Type<any> | Function | any>): MiddlewareConfigProxy;
+    build(): MiddlewareConfiguration[];
+    private bindValuesToResolve(middleware, resolveParams);
+    private static ConfigProxy;
+}

bundle/core/middleware/builder.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const bind_resolve_values_util_1 = require("@nestjs/common/utils/bind-resolve-values.util");
+const logger_service_1 = require("@nestjs/common/services/logger.service");
+const utils_1 = require("./utils");
+const dependencies_decorator_1 = require("@nestjs/common/decorators/core/dependencies.decorator");
+class MiddlewareBuilder {
+    constructor(routesMapper) {
+        this.routesMapper = routesMapper;
+        this.middlewareCollection = new Set();
+        this.logger = new logger_service_1.Logger(MiddlewareBuilder.name);
+    }
+    apply(...middleware) {
+        return new MiddlewareBuilder.ConfigProxy(this, dependencies_decorator_1.flatten(middleware));
+    }
+    build() {
+        return [...this.middlewareCollection];
+    }
+    bindValuesToResolve(middleware, resolveParams) {
+        if (shared_utils_1.isNil(resolveParams)) {
+            return middleware;
+        }
+        const bindArgs = bind_resolve_values_util_1.BindResolveMiddlewareValues(resolveParams);
+        return [].concat(middleware).map(bindArgs);
+    }
+}
+MiddlewareBuilder.ConfigProxy = class {
+    constructor(builder, middleware) {
+        this.builder = builder;
+        this.contextParameters = null;
+        this.includedRoutes = utils_1.filterMiddleware(middleware);
+    }
+    with(...args) {
+        this.contextParameters = args;
+        return this;
+    }
+    forRoutes(...routes) {
+        const { middlewareCollection, bindValuesToResolve, routesMapper, } = this.builder;
+        const forRoutes = this.mapRoutesToFlatList(routes.map(route => routesMapper.mapRouteToRouteProps(route)));
+        const configuration = {
+            middleware: bindValuesToResolve(this.includedRoutes, this.contextParameters),
+            forRoutes,
+        };
+        middlewareCollection.add(configuration);
+        return this.builder;
+    }
+    mapRoutesToFlatList(forRoutes) {
+        return forRoutes.reduce((a, b) => a.concat(b));
+    }
+};
+exports.MiddlewareBuilder = MiddlewareBuilder;

bundle/core/middleware/container.d.ts

@@ -0,0 +1,16 @@
+import { MiddlewareConfiguration } from '@nestjs/common/interfaces/middleware/middleware-configuration.interface';
+import { NestMiddleware } from '@nestjs/common/interfaces/middleware/nest-middleware.interface';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+export declare class MiddlewareContainer {
+    private readonly middleware;
+    private readonly configurationSets;
+    getMiddleware(module: string): Map<string, MiddlewareWrapper>;
+    getConfigs(): Map<string, Set<MiddlewareConfiguration>>;
+    addConfig(configList: MiddlewareConfiguration[], module: string): void;
+    private getCurrentMiddleware(module);
+    private getCurrentConfig(module);
+}
+export interface MiddlewareWrapper {
+    instance: NestMiddleware;
+    metatype: Type<NestMiddleware>;
+}

bundle/core/middleware/container.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MiddlewareContainer {
+    constructor() {
+        this.middleware = new Map();
+        this.configurationSets = new Map();
+    }
+    getMiddleware(module) {
+        return this.middleware.get(module) || new Map();
+    }
+    getConfigs() {
+        return this.configurationSets;
+    }
+    addConfig(configList, module) {
+        const middleware = this.getCurrentMiddleware(module);
+        const currentConfig = this.getCurrentConfig(module);
+        const configurations = configList || [];
+        configurations.map(config => {
+            [].concat(config.middleware).map(metatype => {
+                const token = metatype.name;
+                middleware.set(token, {
+                    instance: null,
+                    metatype,
+                });
+            });
+            currentConfig.add(config);
+        });
+    }
+    getCurrentMiddleware(module) {
+        if (!this.middleware.has(module)) {
+            this.middleware.set(module, new Map());
+        }
+        return this.middleware.get(module);
+    }
+    getCurrentConfig(module) {
+        if (!this.configurationSets.has(module)) {
+            this.configurationSets.set(module, new Set());
+        }
+        return this.configurationSets.get(module);
+    }
+}
+exports.MiddlewareContainer = MiddlewareContainer;

bundle/core/middleware/middleware-module.d.ts

@@ -0,0 +1,21 @@
+import { NestContainer } from '../injector/container';
+import { MiddlewareContainer } from './container';
+import { NestModule } from '@nestjs/common/interfaces/modules/nest-module.interface';
+import { MiddlewareConfiguration } from '@nestjs/common/interfaces/middleware/middleware-configuration.interface';
+import { Module } from '../injector/module';
+import { ApplicationConfig } from '../application-config';
+export declare class MiddlewareModule {
+    private readonly routerProxy;
+    private readonly routerMethodFactory;
+    private routerExceptionFilter;
+    private routesMapper;
+    private resolver;
+    register(middlewareContainer: MiddlewareContainer, container: NestContainer, config: ApplicationConfig): Promise<void>;
+    resolveMiddleware(middlewareContainer: MiddlewareContainer, modules: Map<string, Module>): Promise<void>;
+    loadConfiguration(middlewareContainer: MiddlewareContainer, instance: NestModule, module: string): void;
+    registerMiddleware(middlewareContainer: MiddlewareContainer, applicationRef: any): Promise<void>;
+    registerMiddlewareConfig(middlewareContainer: MiddlewareContainer, config: MiddlewareConfiguration, module: string, applicationRef: any): Promise<void>;
+    registerRouteMiddleware(middlewareContainer: MiddlewareContainer, routePath: string, config: MiddlewareConfiguration, module: string, applicationRef: any): Promise<void>;
+    private bindHandler(instance, metatype, applicationRef, method, path);
+    private bindHandlerWithProxy(exceptionsHandler, router, middleware, path);
+}

bundle/core/middleware/middleware-module.js

@@ -0,0 +1,112 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const builder_1 = require("./builder");
+const resolver_1 = require("./resolver");
+const invalid_middleware_exception_1 = require("../errors/exceptions/invalid-middleware.exception");
+const request_method_enum_1 = require("@nestjs/common/enums/request-method.enum");
+const routes_mapper_1 = require("./routes-mapper");
+const router_proxy_1 = require("../router/router-proxy");
+const router_method_factory_1 = require("../helpers/router-method-factory");
+const runtime_exception_1 = require("../errors/exceptions/runtime.exception");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const router_exception_filters_1 = require("../router/router-exception-filters");
+class MiddlewareModule {
+    constructor() {
+        this.routerProxy = new router_proxy_1.RouterProxy();
+        this.routerMethodFactory = new router_method_factory_1.RouterMethodFactory();
+    }
+    register(middlewareContainer, container, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const appRef = container.getApplicationRef();
+            this.routerExceptionFilter = new router_exception_filters_1.RouterExceptionFilters(container, config, appRef);
+            this.routesMapper = new routes_mapper_1.RoutesMapper(container);
+            this.resolver = new resolver_1.MiddlewareResolver(middlewareContainer);
+            const modules = container.getModules();
+            yield this.resolveMiddleware(middlewareContainer, modules);
+        });
+    }
+    resolveMiddleware(middlewareContainer, modules) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([...modules.entries()].map(([name, module]) => __awaiter(this, void 0, void 0, function* () {
+                const instance = module.instance;
+                this.loadConfiguration(middlewareContainer, instance, name);
+                yield this.resolver.resolveInstances(module, name);
+            })));
+        });
+    }
+    loadConfiguration(middlewareContainer, instance, module) {
+        if (!instance.configure)
+            return;
+        const middlewareBuilder = new builder_1.MiddlewareBuilder(this.routesMapper);
+        instance.configure(middlewareBuilder);
+        if (!(middlewareBuilder instanceof builder_1.MiddlewareBuilder))
+            return;
+        const config = middlewareBuilder.build();
+        middlewareContainer.addConfig(config, module);
+    }
+    registerMiddleware(middlewareContainer, applicationRef) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const configs = middlewareContainer.getConfigs();
+            const registerAllConfigs = (module, middlewareConfig) => middlewareConfig.map((config) => __awaiter(this, void 0, void 0, function* () {
+                yield this.registerMiddlewareConfig(middlewareContainer, config, module, applicationRef);
+            }));
+            yield Promise.all([...configs.entries()].map(([module, moduleConfigs]) => __awaiter(this, void 0, void 0, function* () {
+                yield Promise.all(registerAllConfigs(module, [...moduleConfigs]));
+            })));
+        });
+    }
+    registerMiddlewareConfig(middlewareContainer, config, module, applicationRef) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { forRoutes } = config;
+            yield Promise.all(forRoutes.map((routePath) => __awaiter(this, void 0, void 0, function* () {
+                yield this.registerRouteMiddleware(middlewareContainer, routePath, config, module, applicationRef);
+            })));
+        });
+    }
+    registerRouteMiddleware(middlewareContainer, routePath, config, module, applicationRef) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const middlewareCollection = [].concat(config.middleware);
+            yield Promise.all(middlewareCollection.map((metatype) => __awaiter(this, void 0, void 0, function* () {
+                const collection = middlewareContainer.getMiddleware(module);
+                const middleware = collection.get(metatype.name);
+                if (shared_utils_1.isUndefined(middleware)) {
+                    throw new runtime_exception_1.RuntimeException();
+                }
+                const { instance } = middleware;
+                yield this.bindHandler(instance, metatype, applicationRef, request_method_enum_1.RequestMethod.ALL, routePath);
+            })));
+        });
+    }
+    bindHandler(instance, metatype, applicationRef, method, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (shared_utils_1.isUndefined(instance.resolve)) {
+                throw new invalid_middleware_exception_1.InvalidMiddlewareException(metatype.name);
+            }
+            const exceptionsHandler = this.routerExceptionFilter.create(instance, instance.resolve, undefined);
+            const router = this.routerMethodFactory
+                .get(applicationRef, method)
+                .bind(applicationRef);
+            const bindWithProxy = obj => this.bindHandlerWithProxy(exceptionsHandler, router, obj, path);
+            const resolve = instance.resolve();
+            if (!(resolve instanceof Promise)) {
+                bindWithProxy(resolve);
+                return;
+            }
+            const middleware = yield resolve;
+            bindWithProxy(middleware);
+        });
+    }
+    bindHandlerWithProxy(exceptionsHandler, router, middleware, path) {
+        const proxy = this.routerProxy.createProxy(middleware, exceptionsHandler);
+        router(path, proxy);
+    }
+}
+exports.MiddlewareModule = MiddlewareModule;

bundle/core/middleware/resolver.d.ts

@@ -0,0 +1,9 @@
+import { MiddlewareContainer } from './container';
+import { Module } from '../injector/module';
+export declare class MiddlewareResolver {
+    private readonly middlewareContainer;
+    private readonly instanceLoader;
+    constructor(middlewareContainer: MiddlewareContainer);
+    resolveInstances(module: Module, moduleName: string): Promise<void>;
+    private resolveMiddlewareInstance(wrapper, middleware, module);
+}

bundle/core/middleware/resolver.js

@@ -0,0 +1,29 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const injector_1 = require("../injector/injector");
+class MiddlewareResolver {
+    constructor(middlewareContainer) {
+        this.middlewareContainer = middlewareContainer;
+        this.instanceLoader = new injector_1.Injector();
+    }
+    resolveInstances(module, moduleName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const middleware = this.middlewareContainer.getMiddleware(moduleName);
+            yield Promise.all([...middleware.values()].map((wrapper) => __awaiter(this, void 0, void 0, function* () { return yield this.resolveMiddlewareInstance(wrapper, middleware, module); })));
+        });
+    }
+    resolveMiddlewareInstance(wrapper, middleware, module) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.instanceLoader.loadInstanceOfMiddleware(wrapper, middleware, module);
+        });
+    }
+}
+exports.MiddlewareResolver = MiddlewareResolver;

bundle/core/middleware/routes-mapper.d.ts

@@ -0,0 +1,11 @@
+import 'reflect-metadata';
+import { NestContainer } from '../injector/container';
+import { Type } from '@nestjs/common/interfaces';
+export declare class RoutesMapper {
+    private readonly routerExplorer;
+    constructor(container: NestContainer);
+    mapRouteToRouteProps(route: Type<any> | any | string): string[];
+    private mapObjectToPath(routeOrPath);
+    private validateGlobalPath(path);
+    private validateRoutePath(path);
+}

bundle/core/middleware/routes-mapper.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const router_explorer_1 = require("../router/router-explorer");
+const unknown_request_mapping_exception_1 = require("../errors/exceptions/unknown-request-mapping.exception");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const constants_1 = require("@nestjs/common/constants");
+const metadata_scanner_1 = require("../metadata-scanner");
+class RoutesMapper {
+    constructor(container) {
+        this.routerExplorer = new router_explorer_1.RouterExplorer(new metadata_scanner_1.MetadataScanner(), container);
+    }
+    mapRouteToRouteProps(route) {
+        if (shared_utils_1.isString(route)) {
+            return [route];
+        }
+        const routePath = Reflect.getMetadata(constants_1.PATH_METADATA, route);
+        if (shared_utils_1.isUndefined(routePath)) {
+            return [this.mapObjectToPath(route)];
+        }
+        const paths = this.routerExplorer.scanForPaths(Object.create(route), route.prototype);
+        const uniquePathsSet = new Set(paths.map(item => this.validateGlobalPath(routePath) +
+            this.validateRoutePath(item.path)));
+        return [...uniquePathsSet.values()];
+    }
+    mapObjectToPath(routeOrPath) {
+        if (shared_utils_1.isString(routeOrPath)) {
+            return this.validateRoutePath(routeOrPath);
+        }
+        const { path } = routeOrPath;
+        if (shared_utils_1.isUndefined(path)) {
+            throw new unknown_request_mapping_exception_1.UnknownRequestMappingException();
+        }
+        return this.validateRoutePath(path);
+    }
+    validateGlobalPath(path) {
+        const prefix = shared_utils_1.validatePath(path);
+        return prefix === '/' ? '' : prefix;
+    }
+    validateRoutePath(path) {
+        return shared_utils_1.validatePath(path);
+    }
+}
+exports.RoutesMapper = RoutesMapper;

bundle/core/middleware/utils.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@nestjs/common/interfaces';
+export declare const filterMiddleware: (middleware: any) => any[];
+export declare const mapToClass: (middleware: any) => any;
+export declare const isClass: (middleware: any) => boolean;
+export declare const assignToken: (metatype: any) => Type<any>;

bundle/core/middleware/utils.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+exports.filterMiddleware = middleware => {
+    return []
+        .concat(middleware)
+        .filter(shared_utils_1.isFunction)
+        .map(ware => exports.mapToClass(ware));
+};
+exports.mapToClass = middleware => {
+    if (this.isClass(middleware)) {
+        return middleware;
+    }
+    return exports.assignToken(class {
+        constructor() {
+            this.resolve = (...args) => (...params) => middleware(...params);
+        }
+    });
+};
+exports.isClass = middleware => {
+    return middleware.toString().substring(0, 5) === 'class';
+};
+exports.assignToken = (metatype) => {
+    this.id = this.id || 1;
+    Object.defineProperty(metatype, 'name', { value: ++this.id });
+    return metatype;
+};

bundle/core/nest-application.d.ts

@@ -17,8 +17,8 @@ export declare class NestApplication extends NestApplicationContext implements I
     private readonly config;
     private readonly appOptions;
     private readonly logger;
-    private readonly middlewaresModule;
-    private readonly middlewaresContainer;
+    private readonly middlewareModule;
+    private readonly middlewareContainer;
     private readonly microservicesModule;
     private readonly socketModule;
     private readonly routesResolver;
@@ -32,7 +32,7 @@ export declare class NestApplication extends NestApplicationContext implements I
     getUnderlyingHttpServer(): any;
     registerModules(): Promise<void>;
     init(): Promise<this>;
-    registerParserMiddlewares(): any;
+    registerParserMiddleware(): any;
     isMiddlewareApplied(httpAdapter: HttpServer, name: string): boolean;
     registerRouter(): Promise<void>;
     connectMicroservice(options: MicroserviceOptions): INestMicroservice;
@@ -63,7 +63,7 @@ export declare class NestApplication extends NestApplicationContext implements I
     setBaseViewsDir(path: string): this;
     setViewEngine(engineOrOptions: any): this;
     private loadPackage(name, ctx);
-    private registerMiddlewares(instance);
+    private registerMiddleware(instance);
     private isExpress();
     private listenToPromise(microservice);
     private callDestroyHook();

bundle/core/nest-application.js

@@ -18,10 +18,10 @@ const logger_service_1 = require("@nestjs/common/services/logger.service");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const application_config_1 = require("./application-config");
 const constants_1 = require("./constants");
-const middlewares_module_1 = require("./middlewares/middlewares-module");
+const middleware_module_1 = require("./middleware/middleware-module");
 const routes_resolver_1 = require("./router/routes-resolver");
 const microservices_package_not_found_exception_1 = require("./errors/exceptions/microservices-package-not-found.exception");
-const container_1 = require("./middlewares/container");
+const container_1 = require("./middleware/container");
 const nest_application_context_1 = require("./nest-application-context");
 const express_adapter_1 = require("./adapters/express-adapter");
 const fastify_adapter_1 = require("./adapters/fastify-adapter");
@@ -37,8 +37,8 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
         this.config = config;
         this.appOptions = appOptions;
         this.logger = new logger_service_1.Logger(NestApplication.name, true);
-        this.middlewaresModule = new middlewares_module_1.MiddlewaresModule();
-        this.middlewaresContainer = new container_1.MiddlewaresContainer();
+        this.middlewareModule = new middleware_module_1.MiddlewareModule();
+        this.middlewareContainer = new container_1.MiddlewareContainer();
         this.microservicesModule = MicroservicesModule
             ? new MicroservicesModule()
             : null;
@@ -90,13 +90,13 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
                 this.microservicesModule.register(this.container, this.config);
                 this.microservicesModule.setupClients(this.container);
             }
-            yield this.middlewaresModule.register(this.middlewaresContainer, this.container, this.config);
+            yield this.middlewareModule.register(this.middlewareContainer, this.container, this.config);
         });
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             const useBodyParser = this.appOptions && this.appOptions.bodyParser !== false;
-            useBodyParser && this.registerParserMiddlewares();
+            useBodyParser && this.registerParserMiddleware();
             yield this.registerModules();
             yield this.registerRouter();
             yield this.callInitHook();
@@ -105,20 +105,20 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
             return this;
         });
     }
-    registerParserMiddlewares() {
+    registerParserMiddleware() {
         if (this.httpAdapter instanceof fastify_adapter_1.FastifyAdapter) {
             return this.httpAdapter.register(this.loadPackage('fastify-formbody', 'FastifyAdapter'));
         }
         if (!this.isExpress()) {
-            return void 0;
+            return undefined;
         }
-        const parserMiddlewares = {
+        const parserMiddleware = {
             jsonParser: bodyParser.json(),
             urlencodedParser: bodyParser.urlencoded({ extended: true }),
         };
-        Object.keys(parserMiddlewares)
+        Object.keys(parserMiddleware)
             .filter(parser => !this.isMiddlewareApplied(this.httpAdapter, parser))
-            .forEach(parserKey => this.httpAdapter.use(parserMiddlewares[parserKey]));
+            .forEach(parserKey => this.httpAdapter.use(parserMiddleware[parserKey]));
     }
     isMiddlewareApplied(httpAdapter, name) {
         const app = this.httpAdapter.getHttpServer();
@@ -129,7 +129,7 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
     }
     registerRouter() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.registerMiddlewares(this.httpAdapter);
+            yield this.registerMiddleware(this.httpAdapter);
             const prefix = this.config.getGlobalPrefix();
             const basePath = prefix ? shared_utils_1.validatePath(prefix) : '';
             this.routesResolver.resolve(this.httpAdapter, basePath);
@@ -274,9 +274,9 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
             throw new missing_dependency_exception_1.MissingRequiredDependencyException(name, ctx);
         }
     }
-    registerMiddlewares(instance) {
+    registerMiddleware(instance) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.middlewaresModule.registerMiddlewares(this.middlewaresContainer, instance);
+            yield this.middlewareModule.registerMiddleware(this.middlewareContainer, instance);
         });
     }
     isExpress() {

bundle/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "5.0.0-beta.4",
+  "version": "5.0.0-beta.5",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",

bundle/core/router/router-execution-context.d.ts

@@ -8,6 +8,7 @@ import { PipesConsumer } from './../pipes/pipes-consumer';
 import { ParamData, PipeTransform, RequestMethod, HttpServer } from '@nestjs/common';
 import { GuardsContextCreator } from '../guards/guards-context-creator';
 import { GuardsConsumer } from '../guards/guards-consumer';
+import { CustomHeader } from './router-response-controller';
 import { InterceptorsContextCreator } from '../interceptors/interceptors-context-creator';
 import { InterceptorsConsumer } from '../interceptors/interceptors-consumer';
 export interface ParamProperties {
@@ -34,6 +35,7 @@ export declare class RouterExecutionContext {
     reflectCallbackParamtypes(instance: Controller, methodName: string): any[];
     reflectHttpStatusCode(callback: (...args) => any): number;
     reflectRenderTemplate(callback: any): string;
+    reflectResponseHeaders(callback: any): CustomHeader[];
     getArgumentsLength(keys: string[], metadata: RouteParamsMetadata): number;
     createNullArray(length: number): any[];
     exchangeKeysForValues(keys: string[], metadata: RouteParamsMetadata, moduleContext: string): ParamProperties[];
@@ -46,9 +48,9 @@ export declare class RouterExecutionContext {
         type: any;
         data: any;
     }, transforms: Transform<any>[]): Promise<any>;
-    createGuardsFn(guards: any[], instance: Controller, callback: (...args) => any): (args: any[]) => Promise<boolean>;
+    createGuardsFn(guards: any[], instance: Controller, callback: (...args) => any): (args: any[]) => Promise<void>;
     createPipesFn(pipes: any[], paramsOptions: (ParamProperties & {
         metatype?: any;
     })[]): (args: any, req: any, res: any, next: any) => Promise<void>;
-    createHandleResponseFn(callback: any, isResponseHandled: boolean, httpStatusCode: number): (result: any, res: any) => Promise<any>;
+    createHandleResponseFn(callback: any, isResponseHandled: boolean, httpStatusCode: number): (result: any, res: any) => Promise<void>;
 }

bundle/core/router/router-execution-context.js

@@ -12,7 +12,9 @@ require("reflect-metadata");
 const constants_1 = require("@nestjs/common/constants");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const route_paramtypes_enum_1 = require("@nestjs/common/enums/route-paramtypes.enum");
+const common_1 = require("@nestjs/common");
 const router_response_controller_1 = require("./router-response-controller");
+const constants_2 = require("../guards/constants");
 class RouterExecutionContext {
     constructor(paramsFactory, pipesContextCreator, pipesConsumer, guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, applicationRef) {
         this.paramsFactory = paramsFactory;
@@ -59,7 +61,7 @@ class RouterExecutionContext {
         return keyPair[0];
     }
     reflectCallbackMetadata(instance, methodName) {
-        return Reflect.getMetadata(constants_1.ROUTE_ARGS_METADATA, instance, methodName);
+        return Reflect.getMetadata(constants_1.ROUTE_ARGS_METADATA, instance.constructor, methodName);
     }
     reflectCallbackParamtypes(instance, methodName) {
         return Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, instance, methodName);
@@ -70,6 +72,9 @@ class RouterExecutionContext {
     reflectRenderTemplate(callback) {
         return Reflect.getMetadata(constants_1.RENDER_METADATA, callback);
     }
+    reflectResponseHeaders(callback) {
+        return Reflect.getMetadata(constants_1.HEADERS_METADATA, callback) || [];
+    }
     getArgumentsLength(keys, metadata) {
         return Math.max(...keys.map(key => metadata[key].index)) + 1;
     }
@@ -118,7 +123,7 @@ class RouterExecutionContext {
         const canActivateFn = (args) => __awaiter(this, void 0, void 0, function* () {
             const canActivate = yield this.guardsConsumer.tryActivate(guards, args, instance, callback);
             if (!canActivate) {
-                return false;
+                throw new common_1.HttpException(constants_2.FORBIDDEN_MESSAGE, common_1.HttpStatus.FORBIDDEN);
             }
         });
         return guards.length ? canActivateFn : null;
@@ -128,18 +133,23 @@ class RouterExecutionContext {
             yield Promise.all(paramsOptions.map((param) => __awaiter(this, void 0, void 0, function* () {
                 const { index, extractValue, type, data, metatype, pipes: paramPipes, } = param;
                 const value = extractValue(req, res, next);
-                args[index] = yield this.getParamValue(value, { metatype, type, data }, pipes.concat(this.pipesContextCreator.createConcreteContext(paramPipes)));
+                args[index] = yield this.getParamValue(value, { metatype, type, data }, pipes.concat(paramPipes));
             })));
         });
         return paramsOptions.length ? pipesFn : null;
     }
     createHandleResponseFn(callback, isResponseHandled, httpStatusCode) {
         const renderTemplate = this.reflectRenderTemplate(callback);
-        if (!!renderTemplate) {
-            return (result, res) => __awaiter(this, void 0, void 0, function* () { return yield this.responseController.render(result, res, renderTemplate); });
+        const responseHeaders = this.reflectResponseHeaders(callback);
+        if (renderTemplate) {
+            return (result, res) => __awaiter(this, void 0, void 0, function* () {
+                this.responseController.setHeaders(res, responseHeaders);
+                yield this.responseController.render(result, res, renderTemplate);
+            });
         }
         return (result, res) => __awaiter(this, void 0, void 0, function* () {
-            return !isResponseHandled &&
+            this.responseController.setHeaders(res, responseHeaders);
+            !isResponseHandled &&
                 (yield this.responseController.apply(result, res, httpStatusCode));
         });
     }

bundle/core/router/router-response-controller.d.ts

@@ -1,4 +1,8 @@
 import { RequestMethod, HttpServer } from '@nestjs/common';
+export interface CustomHeader {
+    name: string;
+    value: string;
+}
 export declare class RouterResponseController {
     private readonly applicationRef;
     constructor(applicationRef: HttpServer);
@@ -6,4 +10,5 @@ export declare class RouterResponseController {
     render(resultOrDeffered: any, response: any, template: string): Promise<void>;
     transformToResult(resultOrDeffered: any): Promise<any>;
     getStatusByMethod(requestMethod: RequestMethod): number;
+    setHeaders(response: any, headers: CustomHeader[]): void;
 }

bundle/core/router/router-response-controller.js

@@ -45,5 +45,8 @@ class RouterResponseController {
                 return common_1.HttpStatus.OK;
         }
     }
+    setHeaders(response, headers) {
+        headers.forEach(({ name, value }) => this.applicationRef.setHeader(response, name, value));
+    }
 }
 exports.RouterResponseController = RouterResponseController;

bundle/core/scanner.d.ts

@@ -22,8 +22,9 @@ export declare class DependenciesScanner {
     reflectControllers(module: Type<any>, token: string): void;
     reflectDynamicMetadata(obj: Type<Injectable>, token: string): void;
     reflectExports(module: Type<any>, token: string): void;
-    reflectGatewaysMiddlewares(component: Type<Injectable>, token: string): void;
+    reflectGatewaysMiddleware(component: Type<Injectable>, token: string): void;
     reflectInjectables(component: Type<Injectable>, token: string, metadataKey: string): void;
+    reflectParamInjectables(component: Type<Injectable>, token: string, metadataKey: string): void;
     reflectKeyMetadata(component: Type<Injectable>, key: string, method: string): any;
     storeRelatedModule(related: any, token: string, context: string): void;
     storeComponent(component: any, token: string): string;

bundle/core/scanner.js

@@ -20,8 +20,8 @@ class DependenciesScanner {
     }
     scanForModules(module, scope = []) {
         this.storeModule(module, scope);
-        const importedModules = this.reflectMetadata(module, constants_1.metadata.MODULES);
-        importedModules.map(innerModule => {
+        const modules = this.reflectMetadata(module, constants_1.metadata.MODULES);
+        modules.map(innerModule => {
             this.scanForModules(innerModule, [].concat(scope, module));
         });
     }
@@ -61,7 +61,7 @@ class DependenciesScanner {
         });
     }
     reflectComponentMetadata(component, token) {
-        this.reflectGatewaysMiddlewares(component, token);
+        this.reflectGatewaysMiddleware(component, token);
     }
     reflectControllers(module, token) {
         const routes = [
@@ -81,6 +81,7 @@ class DependenciesScanner {
         this.reflectInjectables(obj, token, constants_1.INTERCEPTORS_METADATA);
         this.reflectInjectables(obj, token, constants_1.EXCEPTION_FILTERS_METADATA);
         this.reflectInjectables(obj, token, constants_1.PIPES_METADATA);
+        this.reflectParamInjectables(obj, token, constants_1.ROUTE_ARGS_METADATA);
     }
     reflectExports(module, token) {
         const exports = [
@@ -89,19 +90,25 @@ class DependenciesScanner {
         ];
         exports.map(exportedComponent => this.storeExportedComponent(exportedComponent, token));
     }
-    reflectGatewaysMiddlewares(component, token) {
-        const middlewares = this.reflectMetadata(component, constants_1.GATEWAY_MIDDLEWARES);
-        middlewares.map(middleware => this.storeComponent(middleware, token));
+    reflectGatewaysMiddleware(component, token) {
+        const middleware = this.reflectMetadata(component, constants_1.GATEWAY_MIDDLEWARES);
+        middleware.map(ware => this.storeComponent(ware, token));
     }
     reflectInjectables(component, token, metadataKey) {
         const controllerInjectables = this.reflectMetadata(component, metadataKey);
         const methodsInjectables = this.metadataScanner.scanFromPrototype(null, component.prototype, this.reflectKeyMetadata.bind(this, component, metadataKey));
         const flattenMethodsInjectables = methodsInjectables.reduce((a, b) => a.concat(b), []);
-        const mergedInjectableConstructors = [
+        const mergedInjectables = [
             ...controllerInjectables,
             ...flattenMethodsInjectables,
         ].filter(shared_utils_1.isFunction);
-        mergedInjectableConstructors.map(injectable => this.storeInjectable(injectable, token));
+        mergedInjectables.map(injectable => this.storeInjectable(injectable, token));
+    }
+    reflectParamInjectables(component, token, metadataKey) {
+        const paramsMetadata = this.metadataScanner.scanFromPrototype(null, component.prototype, method => Reflect.getMetadata(metadataKey, component, method));
+        const flatten = arr => arr.reduce((a, b) => a.concat(b), []);
+        const paramsInjectables = flatten(paramsMetadata).map(param => flatten(Object.keys(param).map(k => param[k].pipes)).filter(shared_utils_1.isFunction));
+        flatten(paramsInjectables).map(injectable => this.storeInjectable(injectable, token));
     }
     reflectKeyMetadata(component, key, method) {
         const descriptor = Reflect.getOwnPropertyDescriptor(component.prototype, method);

bundle/core/services/index.d.ts

@@ -0,0 +1 @@
+export * from './reflector.service';

bundle/core/services/index.js

@@ -0,0 +1,6 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./reflector.service"));

bundle/microservices/client/client-grpc.d.ts

@@ -1,8 +1,7 @@
-import { GrpcObject } from 'grpc';
 import { ClientProxy } from './client-proxy';
 import { ClientOptions } from '../interfaces/client-metadata.interface';
 import { ClientGrpc } from './../interfaces';
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 export declare class ClientGrpcProxy extends ClientProxy implements ClientGrpc {
     private readonly options;
     private readonly logger;
@@ -14,7 +13,7 @@ export declare class ClientGrpcProxy extends ClientProxy implements ClientGrpc {
     createStreamServiceMethod(client: any, methodName: string): (...args) => Observable<any>;
     createUnaryServiceMethod(client: any, methodName: string): (...args) => Observable<any>;
     createClient(): any;
-    loadProto(): GrpcObject;
+    loadProto(): any;
     lookupPackage(root: any, packageName: string): any;
     close(): void;
     protected publish(partialPacket: any, callback: (packet) => any): Promise<void>;

bundle/microservices/client/client-grpc.js

@@ -11,7 +11,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const client_proxy_1 = require("./client-proxy");
 const logger_service_1 = require("@nestjs/common/services/logger.service");
 const constants_1 = require("./../constants");
-const Observable_1 = require("rxjs/Observable");
+const rxjs_1 = require("rxjs");
 const invalid_grpc_service_exception_1 = require("../exceptions/invalid-grpc-service.exception");
 const invalid_grpc_package_exception_1 = require("../exceptions/invalid-grpc-package.exception");
 const invalid_proto_definition_exception_1 = require("../exceptions/invalid-proto-definition.exception");
@@ -47,7 +47,7 @@ class ClientGrpcProxy extends client_proxy_1.ClientProxy {
     }
     createStreamServiceMethod(client, methodName) {
         return (...args) => {
-            return new Observable_1.Observable(observer => {
+            return new rxjs_1.Observable(observer => {
                 const call = client[methodName](...args);
                 call.on('data', (data) => observer.next(data));
                 call.on('error', (error) => observer.error(error));
@@ -57,7 +57,7 @@ class ClientGrpcProxy extends client_proxy_1.ClientProxy {
     }
     createUnaryServiceMethod(client, methodName) {
         return (...args) => {
-            return new Observable_1.Observable(observer => {
+            return new rxjs_1.Observable(observer => {
                 client[methodName](...args, (error, data) => {
                     if (error) {
                         return observer.error(error);

bundle/microservices/client/client-mqtt.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
-import { MqttClient } from 'mqtt';
 import { ClientProxy } from './client-proxy';
 import { ClientOptions } from '../interfaces/client-metadata.interface';
 import { WritePacket } from './../interfaces';
 import { ReadPacket } from './../interfaces';
+import { MqttClient } from '../external/mqtt-client.interface';
 export declare class ClientMqtt extends ClientProxy {
     private readonly options;
     private readonly logger;

bundle/microservices/client/client-mqtt.js

@@ -23,7 +23,7 @@ class ClientMqtt extends client_proxy_1.ClientProxy {
         const responseCallback = (channel, buffer) => {
             const { err, response, isDisposed, id } = JSON.parse(buffer.toString());
             if (id !== packet.id) {
-                return void 0;
+                return undefined;
             }
             if (isDisposed || err) {
                 callback({

bundle/microservices/client/client-nats.d.ts

@@ -1,7 +1,7 @@
-import { Client } from 'nats';
 import { ClientProxy } from './client-proxy';
 import { ClientOptions } from '../interfaces/client-metadata.interface';
 import { WritePacket, ReadPacket, PacketId } from './../interfaces';
+import { Client } from '../external/nats-client.interface';
 export declare class ClientNats extends ClientProxy {
     private readonly options;
     private readonly logger;

bundle/microservices/client/client-nats.js

@@ -31,7 +31,7 @@ class ClientNats extends client_proxy_1.ClientProxy {
             const responseChannel = this.getResPatternName(pattern);
             const subscriptionHandler = (message) => {
                 if (message.id !== packet.id) {
-                    return void 0;
+                    return undefined;
                 }
                 const { err, response, isDisposed } = message;
                 if (isDisposed || err) {

bundle/microservices/client/client-proxy.d.ts

@@ -1,10 +1,9 @@
-import { Observable } from 'rxjs/Observable';
-import { Observer } from 'rxjs/Observer';
+import { Observable, Observer } from 'rxjs';
 import { ReadPacket, PacketId, WritePacket, ClientOptions } from './../interfaces';
 export declare abstract class ClientProxy {
     abstract close(): any;
     protected abstract publish(packet: ReadPacket, callback: (packet: WritePacket) => void): any;
-    send<T>(pattern: any, data: any): Observable<T>;
+    send<T = any>(pattern: any, data: any): Observable<T>;
     protected loadPackage(name: string, ctx: string): any;
     protected createObserver<T>(observer: Observer<T>): (packet: WritePacket) => void;
     protected assignPacketId(packet: ReadPacket): ReadPacket & PacketId;

bundle/microservices/client/client-proxy.js

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const Observable_1 = require("rxjs/Observable");
+const rxjs_1 = require("rxjs");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const invalid_message_exception_1 = require("../exceptions/invalid-message.exception");
-const throw_1 = require("rxjs/observable/throw");
 const missing_dependency_exception_1 = require("@nestjs/core/errors/exceptions/missing-dependency.exception");
 class ClientProxy {
     send(pattern, data) {
         if (shared_utils_1.isNil(pattern) || shared_utils_1.isNil(data)) {
-            return throw_1._throw(new invalid_message_exception_1.InvalidMessageException());
+            return rxjs_1.throwError(new invalid_message_exception_1.InvalidMessageException());
         }
-        return new Observable_1.Observable((observer) => {
+        return new rxjs_1.Observable((observer) => {
             this.publish({ pattern, data }, this.createObserver(observer));
         });
     }

bundle/microservices/client/client-redis.d.ts

@@ -1,7 +1,7 @@
-import { ClientOpts, RetryStrategyOptions, RedisClient } from 'redis';
 import { ClientProxy } from './client-proxy';
 import { ClientOptions } from '../interfaces/client-metadata.interface';
 import { WritePacket, ReadPacket } from './../interfaces';
+import { RedisClient, ClientOpts, RetryStrategyOptions } from '../external/redis.interface';
 export declare class ClientRedis extends ClientProxy {
     private readonly options;
     private readonly logger;

bundle/microservices/client/client-redis.js

@@ -33,7 +33,7 @@ class ClientRedis extends client_proxy_1.ClientProxy {
             const responseCallback = (channel, buffer) => {
                 const { err, response, isDisposed, id } = JSON.parse(buffer);
                 if (id !== packet.id) {
-                    return void 0;
+                    return undefined;
                 }
                 if (isDisposed || err) {
                     callback({
@@ -55,7 +55,7 @@ class ClientRedis extends client_proxy_1.ClientProxy {
             yield new Promise(resolve => {
                 const handler = channel => {
                     if (channel && channel !== responseChannel) {
-                        return void 0;
+                        return undefined;
                     }
                     this.subClient.removeListener(constants_1.SUBSCRIBE, handler);
                     resolve();

bundle/microservices/client/client-tcp.js

@@ -43,7 +43,7 @@ class ClientTCP extends client_proxy_1.ClientProxy {
                 jsonSocket.sendMessage(packet);
                 const listener = (buffer) => {
                     if (buffer.id !== packet.id) {
-                        return void 0;
+                        return undefined;
                     }
                     this.handleResponse(jsonSocket, callback, buffer, listener);
                 };

bundle/microservices/context/exception-filters-context.d.ts

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
 import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 import { RpcExceptionsHandler } from '../exceptions/rpc-exceptions-handler';
 import { BaseExceptionFilterContext } from '@nestjs/core/exceptions/base-exception-filter-context';
 import { ApplicationConfig } from '@nestjs/core/application-config';

bundle/microservices/context/rpc-context-creator.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 import { RpcProxy } from './rpc-proxy';
 import { ExceptionFiltersContext } from './exception-filters-context';
 import { Controller } from '@nestjs/common/interfaces';

bundle/microservices/context/rpc-proxy.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 import { RpcExceptionsHandler } from '../exceptions/rpc-exceptions-handler';
 export declare class RpcProxy {
     create(targetCallback: (...args) => Promise<Observable<any>>, exceptionsHandler: RpcExceptionsHandler): (...args) => Promise<Observable<any>>;

bundle/microservices/exceptions/invalid-message.exception.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const runtime_exception_1 = require("@nestjs/core/errors/exceptions/runtime.exception");
 class InvalidMessageException extends runtime_exception_1.RuntimeException {
     constructor() {
-        super(`Invalid data or message pattern (undefined / null)`);
+        super(`Invalid data or message pattern (undefined/null)`);
     }
 }
 exports.InvalidMessageException = InvalidMessageException;

bundle/microservices/exceptions/rpc-exceptions-handler.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs/Observable';
+import { Observable } from 'rxjs';
 import { RpcException } from './rpc-exception';
 import { RpcExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions';
 import { ArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';

bundle/microservices/exceptions/rpc-exceptions-handler.js

@@ -4,8 +4,8 @@ const common_1 = require("@nestjs/common");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const invalid_exception_filter_exception_1 = require("@nestjs/core/errors/exceptions/invalid-exception-filter.exception");
 const constants_1 = require("@nestjs/core/constants");
+const rxjs_1 = require("rxjs");
 const rpc_exception_1 = require("./rpc-exception");
-const throw_1 = require("rxjs/observable/throw");
 class RpcExceptionsHandler {
     constructor() {
         this.filters = [];
@@ -24,11 +24,11 @@ class RpcExceptionsHandler {
                 : [exception];
             const logger = RpcExceptionsHandler.logger;
             logger.error.apply(logger, loggerArgs);
-            return throw_1._throw({ status, message: errorMessage });
+            return rxjs_1.throwError({ status, message: errorMessage });
         }
         const res = exception.getError();
         const message = shared_utils_1.isObject(res) ? res : { status, message: res };
-        return throw_1._throw(message);
+        return rxjs_1.throwError(message);
     }
     setCustomFilters(filters) {
         if (!Array.isArray(filters)) {

bundle/microservices/external/mqtt-client.interface.d.ts

@@ -0,0 +1,122 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+/**
+ * @see https://github.com/mqttjs/MQTT.js/
+ */
+export declare class MqttClient extends EventEmitter {
+    connected: boolean;
+    disconnecting: boolean;
+    disconnected: boolean;
+    reconnecting: boolean;
+    incomingStore: any;
+    outgoingStore: any;
+    options: any;
+    queueQoSZero: boolean;
+    constructor(streamBuilder: (client: MqttClient) => any, options: any);
+    on(event: 'message', cb: any): this;
+    on(event: 'packetsend' | 'packetreceive', cb: any): this;
+    on(event: 'error', cb: any): this;
+    on(event: string, cb: Function): this;
+    once(event: 'message', cb: any): this;
+    once(event: 'packetsend' | 'packetreceive', cb: any): this;
+    once(event: 'error', cb: any): this;
+    once(event: string, cb: Function): this;
+    /**
+     * publish - publish <message> to <topic>
+     *
+     * @param {String} topic - topic to publish to
+     * @param {(String|Buffer)} message - message to publish
+     *
+     * @param {Object}    [opts] - publish options, includes:
+     *   @param {Number}  [opts.qos] - qos level to publish on
+     *   @param {Boolean} [opts.retain] - whether or not to retain the message
+     *
+     * @param {Function} [callback] - function(err){}
+     *    called when publish succeeds or fails
+     * @returns {Client} this - for chaining
+     * @api public
+     *
+     * @example client.publish('topic', 'message')
+     * @example
+     *     client.publish('topic', 'message', {qos: 1, retain: true})
+     * @example client.publish('topic', 'message', console.log)
+     */
+    publish(topic: string, message: string | Buffer, opts: any, callback?: any): this;
+    publish(topic: string, message: string | Buffer, callback?: any): this;
+    /**
+     * subscribe - subscribe to <topic>
+     *
+     * @param {String, Array, Object} topic - topic(s) to subscribe to, supports objects in the form {'topic': qos}
+     * @param {Object} [opts] - optional subscription options, includes:
+     * @param  {Number} [opts.qos] - subscribe qos level
+     * @param {Function} [callback] - function(err, granted){} where:
+     *    {Error} err - subscription error (none at the moment!)
+     *    {Array} granted - array of {topic: 't', qos: 0}
+     * @returns {MqttClient} this - for chaining
+     * @api public
+     * @example client.subscribe('topic')
+     * @example client.subscribe('topic', {qos: 1})
+     * @example client.subscribe({'topic': 0, 'topic2': 1}, console.log)
+     * @example client.subscribe('topic', console.log)
+     */
+    subscribe(topic: string | string[], opts: any, callback?: any): this;
+    subscribe(topic: string | string[] | any, callback?: any): this;
+    /**
+     * unsubscribe - unsubscribe from topic(s)
+     *
+     * @param {String, Array} topic - topics to unsubscribe from
+     * @param {Function} [callback] - callback fired on unsuback
+     * @returns {MqttClient} this - for chaining
+     * @api public
+     * @example client.unsubscribe('topic')
+     * @example client.unsubscribe('topic', console.log)
+     */
+    unsubscribe(topic: string | string[], callback?: any): this;
+    /**
+     * end - close connection
+     *
+     * @returns {MqttClient} this - for chaining
+     * @param {Boolean} force - do not wait for all in-flight messages to be acked
+     * @param {Function} cb - called when the client has been closed
+     *
+     * @api public
+     */
+    end(force?: boolean, cb?: any): this;
+    /**
+     * removeOutgoingMessage - remove a message in outgoing store
+     * the outgoing callback will be called withe Error('Message removed') if the message is removed
+     *
+     * @param {Number} mid - messageId to remove message
+     * @returns {MqttClient} this - for chaining
+     * @api public
+     *
+     * @example client.removeOutgoingMessage(client.getLastMessageId());
+     */
+    removeOutgoingMessage(mid: number): this;
+    /**
+     * reconnect - connect again using the same options as connect()
+     *
+     * @param {Object} [opts] - optional reconnect options, includes:
+     *    {any} incomingStore - a store for the incoming packets
+     *    {any} outgoingStore - a store for the outgoing packets
+     *    if opts is not given, current stores are used
+     *
+     * @returns {MqttClient} this - for chaining
+     *
+     * @api public
+     */
+    reconnect(opts?: any): this;
+    /**
+     * Handle messages with backpressure support, one at a time.
+     * Override at will.
+     *
+     * @param packet packet the packet
+     * @param callback callback call when finished
+     * @api public
+     */
+    handleMessage(packet: any, callback: any): void;
+    /**
+     * getLastMessageId
+     */
+    getLastMessageId(): number;
+}