@nestjs/core 8.2.3 → 8.3.0

package/router/router-execution-context.js

@@ -67,7 +67,7 @@ class RouterExecutionContext {
             ? httpCode
             : this.responseController.getStatusByMethod(requestMethod);
         const responseHeaders = this.reflectResponseHeaders(callback);
-        const hasCustomHeaders = !shared_utils_1.isEmpty(responseHeaders);
+        const hasCustomHeaders = !(0, shared_utils_1.isEmpty)(responseHeaders);
         const handlerMetadata = {
             argsLength,
             fnHandleResponse,
@@ -116,7 +116,7 @@ class RouterExecutionContext {
         });
     }
     async getParamValue(value, { metatype, type, data, }, pipes) {
-        if (!shared_utils_1.isEmpty(pipes)) {
+        if (!(0, shared_utils_1.isEmpty)(pipes)) {
             return this.pipesConsumer.apply(value, { metatype, type, data }, pipes);
         }
         return value;
@@ -127,7 +127,7 @@ class RouterExecutionContext {
             type === route_paramtypes_enum_1.RouteParamtypes.PARAM ||
             type === route_paramtypes_enum_1.RouteParamtypes.FILE ||
             type === route_paramtypes_enum_1.RouteParamtypes.FILES ||
-            shared_utils_1.isString(type));
+            (0, shared_utils_1.isString)(type));
     }
     createGuardsFn(guards, instance, callback, contextType) {
         const canActivateFn = async (args) => {
@@ -158,15 +158,16 @@ class RouterExecutionContext {
                 return await this.responseController.render(result, res, renderTemplate);
             };
         }
-        if (redirectResponse && typeof redirectResponse.url === 'string') {
+        if (redirectResponse && (0, shared_utils_1.isString)(redirectResponse.url)) {
             return async (result, res) => {
                 await this.responseController.redirect(result, res, redirectResponse);
             };
         }
         const isSseHandler = !!this.reflectSse(callback);
         if (isSseHandler) {
-            return async (result, res, req) => {
-                await this.responseController.sse(result, res.raw || res, req.raw || req);
+            return (result, res, req) => {
+                var _a;
+                this.responseController.sse(result, res.raw || res, req.raw || req, { additionalHeaders: (_a = res.getHeaders) === null || _a === void 0 ? void 0 : _a.call(res) });
             };
         }
         return async (result, res) => {

package/router/router-explorer.js

@@ -53,16 +53,16 @@ class RouterExplorer {
     }
     extractRouterPath(metatype) {
         const path = Reflect.getMetadata(constants_1.PATH_METADATA, metatype);
-        if (shared_utils_1.isUndefined(path)) {
+        if ((0, shared_utils_1.isUndefined)(path)) {
             throw new unknown_request_mapping_exception_1.UnknownRequestMappingException();
         }
         if (Array.isArray(path)) {
-            return path.map(p => shared_utils_1.addLeadingSlash(p));
+            return path.map(p => (0, shared_utils_1.addLeadingSlash)(p));
         }
-        return [shared_utils_1.addLeadingSlash(path)];
+        return [(0, shared_utils_1.addLeadingSlash)(path)];
     }
     scanForPaths(instance, prototype) {
-        const instancePrototype = shared_utils_1.isUndefined(prototype)
+        const instancePrototype = (0, shared_utils_1.isUndefined)(prototype)
             ? Object.getPrototypeOf(instance)
             : prototype;
         return this.metadataScanner.scanFromPrototype(instance, instancePrototype, method => this.exploreMethodMetadata(instance, instancePrototype, method));
@@ -71,14 +71,14 @@ class RouterExplorer {
         const instanceCallback = instance[methodName];
         const prototypeCallback = prototype[methodName];
         const routePath = Reflect.getMetadata(constants_1.PATH_METADATA, prototypeCallback);
-        if (shared_utils_1.isUndefined(routePath)) {
+        if ((0, shared_utils_1.isUndefined)(routePath)) {
             return null;
         }
         const requestMethod = Reflect.getMetadata(constants_1.METHOD_METADATA, prototypeCallback);
         const version = Reflect.getMetadata(constants_1.VERSION_METADATA, prototypeCallback);
-        const path = shared_utils_1.isString(routePath)
-            ? [shared_utils_1.addLeadingSlash(routePath)]
-            : routePath.map((p) => shared_utils_1.addLeadingSlash(p));
+        const path = (0, shared_utils_1.isString)(routePath)
+            ? [(0, shared_utils_1.addLeadingSlash)(routePath)]
+            : routePath.map((p) => (0, shared_utils_1.addLeadingSlash)(p));
         return {
             path,
             requestMethod,
@@ -121,10 +121,10 @@ class RouterExplorer {
             pathsToLog.forEach(path => {
                 if (isVersioned) {
                     const version = this.routePathFactory.getVersion(routePathMetadata);
-                    this.logger.log(messages_1.VERSIONED_ROUTE_MAPPED_MESSAGE(path, requestMethod, version));
+                    this.logger.log((0, messages_1.VERSIONED_ROUTE_MAPPED_MESSAGE)(path, requestMethod, version));
                 }
                 else {
-                    this.logger.log(messages_1.ROUTE_MAPPED_MESSAGE(path, requestMethod));
+                    this.logger.log((0, messages_1.ROUTE_MAPPED_MESSAGE)(path, requestMethod));
                 }
             });
         });
@@ -193,7 +193,7 @@ class RouterExplorer {
                             return handler(req, res, next);
                         }
                     }
-                    else if (shared_utils_1.isString(version)) {
+                    else if ((0, shared_utils_1.isString)(version)) {
                         if (version === headerVersion) {
                             return handler(req, res, next);
                         }
@@ -210,7 +210,7 @@ class RouterExplorer {
                             return handler(req, res, next);
                         }
                     }
-                    else if (shared_utils_1.isString(version)) {
+                    else if ((0, shared_utils_1.isString)(version)) {
                         if (version === customHeaderVersionParameter) {
                             return handler(req, res, next);
                         }

package/router/router-module.js

@@ -43,9 +43,9 @@ let RouterModule = RouterModule_1 = class RouterModule {
         });
     }
     initialize() {
-        const flattenedRoutes = utils_1.flattenRoutePaths(this.routes);
+        const flattenedRoutes = (0, utils_1.flattenRoutePaths)(this.routes);
         flattenedRoutes.forEach(route => {
-            const modulePath = shared_utils_1.normalizePath(route.path);
+            const modulePath = (0, shared_utils_1.normalizePath)(route.path);
             this.registerModulePathMetadata(route.module, modulePath);
             this.updateTargetModulesCache(route.module);
         });
@@ -69,9 +69,9 @@ let RouterModule = RouterModule_1 = class RouterModule {
         moduleClassSet.add(moduleRef);
     }
 };
-RouterModule = RouterModule_1 = tslib_1.__decorate([
-    common_1.Module({}),
-    tslib_1.__param(1, common_1.Inject(exports.ROUTES)),
-    tslib_1.__metadata("design:paramtypes", [modules_container_1.ModulesContainer, Array])
+RouterModule = RouterModule_1 = (0, tslib_1.__decorate)([
+    (0, common_1.Module)({}),
+    (0, tslib_1.__param)(1, (0, common_1.Inject)(exports.ROUTES)),
+    (0, tslib_1.__metadata)("design:paramtypes", [modules_container_1.ModulesContainer, Array])
 ], RouterModule);
 exports.RouterModule = RouterModule;

package/router/router-response-controller.d.ts

@@ -2,7 +2,7 @@
 import { HttpServer, RequestMethod } from '@nestjs/common';
 import { IncomingMessage } from 'http';
 import { Observable } from 'rxjs';
-import { HeaderStream } from './sse-stream';
+import { AdditionalHeaders, WritableHeaderStream } from './sse-stream';
 export interface CustomHeader {
     name: string;
     value: string;
@@ -13,6 +13,7 @@ export interface RedirectResponse {
 }
 export declare class RouterResponseController {
     private readonly applicationRef;
+    private readonly logger;
     constructor(applicationRef: HttpServer);
     apply<TInput = any, TResponse = any>(result: TInput, response: TResponse, httpStatusCode?: number): Promise<any>;
     redirect<TInput = any, TResponse = any>(resultOrDeferred: TInput, response: TResponse, redirectResponse: RedirectResponse): Promise<void>;
@@ -21,6 +22,8 @@ export declare class RouterResponseController {
     getStatusByMethod(requestMethod: RequestMethod): number;
     setHeaders<TResponse = unknown>(response: TResponse, headers: CustomHeader[]): void;
     setStatus<TResponse = unknown>(response: TResponse, statusCode: number): void;
-    sse<TInput extends Observable<unknown> = any, TResponse extends HeaderStream = any, TRequest extends IncomingMessage = any>(result: TInput, response: TResponse, request: TRequest): Promise<void>;
+    sse<TInput extends Observable<unknown> = any, TResponse extends WritableHeaderStream = any, TRequest extends IncomingMessage = any>(result: TInput, response: TResponse, request: TRequest, options?: {
+        additionalHeaders: AdditionalHeaders;
+    }): void;
     private assertObservable;
 }

package/router/router-response-controller.js

@@ -9,6 +9,7 @@ const sse_stream_1 = require("./sse-stream");
 class RouterResponseController {
     constructor(applicationRef) {
         this.applicationRef = applicationRef;
+        this.logger = new common_1.Logger(RouterResponseController.name);
     }
     async apply(result, response, httpStatusCode) {
         return this.applicationRef.reply(response, result, httpStatusCode);
@@ -28,8 +29,8 @@ class RouterResponseController {
         return this.applicationRef.render(response, template, result);
     }
     async transformToResult(resultOrDeferred) {
-        if (resultOrDeferred && shared_utils_1.isFunction(resultOrDeferred.subscribe)) {
-            return rxjs_1.lastValueFrom(resultOrDeferred);
+        if (resultOrDeferred && (0, shared_utils_1.isFunction)(resultOrDeferred.subscribe)) {
+            return (0, rxjs_1.lastValueFrom)(resultOrDeferred);
         }
         return resultOrDeferred;
     }
@@ -47,21 +48,29 @@ class RouterResponseController {
     setStatus(response, statusCode) {
         this.applicationRef.status(response, statusCode);
     }
-    async sse(result, response, request) {
+    sse(result, response, request, options) {
         // It's possible that we sent headers already so don't use a stream
         if (response.writableEnded) {
             return;
         }
         this.assertObservable(result);
         const stream = new sse_stream_1.SseStream(request);
-        stream.pipe(response);
+        stream.pipe(response, options);
         const subscription = result
-            .pipe(operators_1.debounce((message) => new Promise(resolve => {
-            if (!shared_utils_1.isObject(message)) {
-                message = { data: message };
+            .pipe((0, operators_1.map)((message) => {
+            if ((0, shared_utils_1.isObject)(message)) {
+                return message;
             }
-            stream.writeMessage(message, resolve);
-        })))
+            return { data: message };
+        }), (0, operators_1.debounce)(message => new Promise(resolve => stream.writeMessage(message, () => resolve()))), (0, operators_1.catchError)(err => {
+            const data = err instanceof Error ? err.message : err;
+            stream.writeMessage({ type: 'error', data }, writeError => {
+                if (writeError) {
+                    this.logger.error(writeError);
+                }
+            });
+            return rxjs_1.EMPTY;
+        }))
             .subscribe({
             complete: () => {
                 response.end();
@@ -72,7 +81,7 @@ class RouterResponseController {
         });
     }
     assertObservable(result) {
-        if (!shared_utils_1.isFunction(result.subscribe)) {
+        if (!(0, shared_utils_1.isFunction)(result.subscribe)) {
             throw new ReferenceError('You must return an Observable stream to use Server-Sent Events (SSE).');
         }
     }

package/router/routes-resolver.js

@@ -47,13 +47,13 @@ class RoutesResolver {
                 });
                 if (!controllerVersion) {
                     pathsToLog.forEach(path => {
-                        const logMessage = messages_1.CONTROLLER_MAPPING_MESSAGE(controllerName, path);
+                        const logMessage = (0, messages_1.CONTROLLER_MAPPING_MESSAGE)(controllerName, path);
                         this.logger.log(logMessage);
                     });
                 }
                 else {
                     pathsToLog.forEach(path => {
-                        const logMessage = messages_1.VERSIONED_CONTROLLER_MAPPING_MESSAGE(controllerName, path, controllerVersion);
+                        const logMessage = (0, messages_1.VERSIONED_CONTROLLER_MAPPING_MESSAGE)(controllerName, path, controllerVersion);
                         this.logger.log(logMessage);
                     });
                 }
@@ -93,7 +93,10 @@ class RoutesResolver {
     }
     mapExternalException(err) {
         switch (true) {
-            case err instanceof SyntaxError:
+            // SyntaxError is thrown by Express body-parser when given invalid JSON (#422, #430)
+            // URIError is thrown by Express when given a path parameter with an invalid percentage
+            // encoding, e.g. '%FF' (#8915)
+            case err instanceof SyntaxError || err instanceof URIError:
                 return new common_1.BadRequestException(err.message);
             default:
                 return err;

package/router/sse-stream.d.ts

@@ -2,13 +2,18 @@
 import { MessageEvent } from '@nestjs/common/interfaces';
 import { IncomingMessage, OutgoingHttpHeaders } from 'http';
 import { Transform } from 'stream';
+export declare type AdditionalHeaders = Record<string, string[] | string | number | undefined>;
+interface ReadHeaders {
+    getHeaders?(): AdditionalHeaders;
+}
 interface WriteHeaders {
     writableEnded?: boolean;
     writeHead?(statusCode: number, reasonPhrase?: string, headers?: OutgoingHttpHeaders): void;
     writeHead?(statusCode: number, headers?: OutgoingHttpHeaders): void;
     flushHeaders?(): void;
 }
-export declare type HeaderStream = NodeJS.WritableStream & WriteHeaders;
+export declare type WritableHeaderStream = NodeJS.WritableStream & WriteHeaders;
+export declare type HeaderStream = WritableHeaderStream & ReadHeaders;
 /**
  * Adapted from https://raw.githubusercontent.com/EventSource/node-ssestream
  * Transforms "messages" to W3C event stream content.
@@ -25,7 +30,8 @@ export declare type HeaderStream = NodeJS.WritableStream & WriteHeaders;
 export declare class SseStream extends Transform {
     private lastEventId;
     constructor(req?: IncomingMessage);
-    pipe<T extends HeaderStream>(destination: T, options?: {
+    pipe<T extends WritableHeaderStream>(destination: T, options?: {
+        additionalHeaders?: AdditionalHeaders;
         end?: boolean;
     }): T;
     _transform(message: MessageEvent, encoding: string, callback: (error?: Error | null, data?: any) => void): void;

package/router/sse-stream.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SseStream = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
 const stream_1 = require("stream");
 function toDataString(data) {
-    if (typeof data === 'object') {
+    if ((0, shared_utils_1.isObject)(data)) {
         return toDataString(JSON.stringify(data));
     }
     return data
@@ -36,20 +37,16 @@ class SseStream extends stream_1.Transform {
     }
     pipe(destination, options) {
         if (destination.writeHead) {
-            destination.writeHead(200, {
+            destination.writeHead(200, Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.additionalHeaders), { 
                 // See https://github.com/dunglas/mercure/blob/master/hub/subscribe.go#L124-L130
-                'Content-Type': 'text/event-stream',
-                Connection: 'keep-alive',
+                'Content-Type': 'text/event-stream', Connection: 'keep-alive', 
                 // Disable cache, even for old browsers and proxies
-                'Cache-Control': 'private, no-cache, no-store, must-revalidate, max-age=0, no-transform',
-                Pragma: 'no-cache',
-                Expire: '0',
+                'Cache-Control': 'private, no-cache, no-store, must-revalidate, max-age=0, no-transform', Pragma: 'no-cache', Expire: '0', 
                 // NGINX support https://www.nginx.com/resources/wiki/start/topics/examples/x-accel/#x-accel-buffering
-                'X-Accel-Buffering': 'no',
-            });
+                'X-Accel-Buffering': 'no' }));
             destination.flushHeaders();
         }
-        destination.write(':\n');
+        destination.write('\n');
         return super.pipe(destination, options);
     }
     _transform(message, encoding, callback) {

package/router/utils/exclude-route.util.js

@@ -8,7 +8,7 @@ const isRequestMethodAll = (method) => {
 exports.isRequestMethodAll = isRequestMethodAll;
 function isRouteExcluded(excludedRoutes, path, requestMethod) {
     return excludedRoutes.some(route => {
-        if (exports.isRequestMethodAll(route.requestMethod) ||
+        if ((0, exports.isRequestMethodAll)(route.requestMethod) ||
             route.requestMethod === requestMethod) {
             return route.pathRegex.exec(path);
         }

package/router/utils/flatten-route-paths.util.js

@@ -11,8 +11,8 @@ function flattenRoutePaths(routes) {
         if (item.children) {
             const childrenRef = item.children;
             childrenRef.forEach(child => {
-                if (typeof child !== 'string' && child.path) {
-                    child.path = shared_utils_1.normalizePath(shared_utils_1.normalizePath(item.path) + shared_utils_1.normalizePath(child.path));
+                if (!(0, shared_utils_1.isString)(child) && child.path) {
+                    child.path = (0, shared_utils_1.normalizePath)((0, shared_utils_1.normalizePath)(item.path) + (0, shared_utils_1.normalizePath)(child.path));
                 }
                 else {
                     result.push({ path: item.path, module: child });

package/router/utils/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./exclude-route.util"), exports);
-tslib_1.__exportStar(require("./flatten-route-paths.util"), exports);
+(0, tslib_1.__exportStar)(require("./exclude-route.util"), exports);
+(0, tslib_1.__exportStar)(require("./flatten-route-paths.util"), exports);

package/scanner.d.ts

@@ -11,11 +11,12 @@ export declare class DependenciesScanner {
     private readonly container;
     private readonly metadataScanner;
     private readonly applicationConfig;
+    private readonly logger;
     private readonly applicationProvidersApplyMap;
     constructor(container: NestContainer, metadataScanner: MetadataScanner, applicationConfig?: ApplicationConfig);
     scan(module: Type<any>): Promise<void>;
     scanForModules(moduleDefinition: ForwardReference | Type<unknown> | DynamicModule | Promise<DynamicModule>, scope?: Type<unknown>[], ctxRegistry?: (ForwardReference | DynamicModule | Type<unknown>)[]): Promise<Module[]>;
-    insertModule(module: any, scope: Type<unknown>[]): Promise<Module | undefined>;
+    insertModule(moduleDefinition: any, scope: Type<unknown>[]): Promise<Module | undefined>;
     scanModulesForDependencies(modules?: Map<string, Module>): Promise<void>;
     reflectImports(module: Type<unknown>, token: string, context: string): Promise<void>;
     reflectProviders(module: Type<any>, token: string): void;
@@ -47,7 +48,22 @@ export declare class DependenciesScanner {
         [type: string]: Function;
     };
     isDynamicModule(module: Type<any> | DynamicModule): module is DynamicModule;
-    isForwardReference(module: Type<any> | DynamicModule | ForwardReference): module is ForwardReference;
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Injectable()` decorator.
+     */
+    private isInjectable;
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Controller()` decorator.
+     */
+    private isController;
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Catch()` decorator.
+     */
+    private isExceptionFilter;
+    private isForwardReference;
     private flatten;
     private isRequestOrTransient;
 }

package/scanner.js

@@ -11,6 +11,7 @@ const application_config_1 = require("./application-config");
 const constants_2 = require("./constants");
 const circular_dependency_exception_1 = require("./errors/exceptions/circular-dependency.exception");
 const invalid_module_exception_1 = require("./errors/exceptions/invalid-module.exception");
+const invalid_class_module_exception_1 = require("./errors/exceptions/invalid-class-module.exception");
 const undefined_module_exception_1 = require("./errors/exceptions/undefined-module.exception");
 const get_class_scope_1 = require("./helpers/get-class-scope");
 const internal_core_module_factory_1 = require("./injector/internal-core-module-factory");
@@ -19,6 +20,7 @@ class DependenciesScanner {
         this.container = container;
         this.metadataScanner = metadataScanner;
         this.applicationConfig = applicationConfig;
+        this.logger = new common_1.Logger(DependenciesScanner.name);
         this.applicationProvidersApplyMap = [];
     }
     async scan(module) {
@@ -65,11 +67,17 @@ class DependenciesScanner {
         }
         return [moduleInstance].concat(registeredModuleRefs);
     }
-    async insertModule(module, scope) {
-        if (module && module.forwardRef) {
-            return this.container.addModule(module.forwardRef(), scope);
+    async insertModule(moduleDefinition, scope) {
+        const moduleToAdd = this.isForwardReference(moduleDefinition)
+            ? moduleDefinition.forwardRef()
+            : moduleDefinition;
+        if (this.isInjectable(moduleToAdd) ||
+            this.isController(moduleToAdd) ||
+            this.isExceptionFilter(moduleToAdd)) {
+            // TODO(v9): Throw the exception instead of printing a warning
+            this.logger.warn(new invalid_class_module_exception_1.InvalidClassModuleException(moduleDefinition, scope).message);
         }
-        return this.container.addModule(module, scope);
+        return this.container.addModule(moduleToAdd, scope);
     }
     async scanModulesForDependencies(modules = this.container.getModules()) {
         for (const [token, { metatype }] of modules) {
@@ -138,8 +146,8 @@ class DependenciesScanner {
     }
     reflectParamInjectables(component, token, metadataKey) {
         const paramsMetadata = this.metadataScanner.scanFromPrototype(null, component.prototype, method => Reflect.getMetadata(metadataKey, component, method));
-        const paramsInjectables = this.flatten(paramsMetadata).map((param) => common_1.flatten(Object.keys(param).map(k => param[k].pipes)).filter(shared_utils_1.isFunction));
-        common_1.flatten(paramsInjectables).forEach((injectable) => this.insertInjectable(injectable, token, component));
+        const paramsInjectables = this.flatten(paramsMetadata).map((param) => (0, common_1.flatten)(Object.keys(param).map(k => param[k].pipes)).filter(shared_utils_1.isFunction));
+        (0, common_1.flatten)(paramsInjectables).forEach((injectable) => this.insertInjectable(injectable, token, component));
     }
     reflectKeyMetadata(component, key, method) {
         let prototype = component.prototype;
@@ -176,16 +184,16 @@ class DependenciesScanner {
         calculateDistance(rootModule);
     }
     async insertImport(related, token, context) {
-        if (shared_utils_1.isUndefined(related)) {
+        if ((0, shared_utils_1.isUndefined)(related)) {
             throw new circular_dependency_exception_1.CircularDependencyException(context);
         }
-        if (related && related.forwardRef) {
+        if (this.isForwardReference(related)) {
             return this.container.addImport(related.forwardRef(), token);
         }
         await this.container.addImport(related, token);
     }
     isCustomProvider(provider) {
-        return provider && !shared_utils_1.isNil(provider.provide);
+        return provider && !(0, shared_utils_1.isNil)(provider.provide);
     }
     insertProvider(provider, token) {
         const isCustomProvider = this.isCustomProvider(provider);
@@ -198,10 +206,10 @@ class DependenciesScanner {
         if (!providersKeys.includes(type)) {
             return this.container.addProvider(provider, token);
         }
-        const providerToken = `${type} (UUID: ${random_string_generator_util_1.randomStringGenerator()})`;
+        const providerToken = `${type} (UUID: ${(0, random_string_generator_util_1.randomStringGenerator)()})`;
         let scope = provider.scope;
-        if (shared_utils_1.isNil(scope) && provider.useClass) {
-            scope = get_class_scope_1.getClassScope(provider.useClass);
+        if ((0, shared_utils_1.isNil)(scope) && provider.useClass) {
+            scope = (0, get_class_scope_1.getClassScope)(provider.useClass);
         }
         this.applicationProvidersApplyMap.push({
             type,
@@ -238,13 +246,13 @@ class DependenciesScanner {
      * to all controllers metadata storage
      */
     addScopedEnhancersMetadata() {
-        iterare_1.iterate(this.applicationProvidersApplyMap)
+        (0, iterare_1.iterate)(this.applicationProvidersApplyMap)
             .filter(wrapper => this.isRequestOrTransient(wrapper.scope))
             .forEach(({ moduleKey, providerKey }) => {
             const modulesContainer = this.container.getModules();
             const { injectables } = modulesContainer.get(moduleKey);
             const instanceWrapper = injectables.get(providerKey);
-            iterare_1.iterate(modulesContainer.values())
+            (0, iterare_1.iterate)(modulesContainer.values())
                 .map(module => module.controllers.values())
                 .flatten()
                 .forEach(controller => controller.addEnhancerMetadata(instanceWrapper));
@@ -288,6 +296,27 @@ class DependenciesScanner {
     isDynamicModule(module) {
         return module && !!module.module;
     }
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Injectable()` decorator.
+     */
+    isInjectable(metatype) {
+        return !!Reflect.getMetadata(constants_1.INJECTABLE_WATERMARK, metatype);
+    }
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Controller()` decorator.
+     */
+    isController(metatype) {
+        return !!Reflect.getMetadata(constants_1.CONTROLLER_WATERMARK, metatype);
+    }
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Catch()` decorator.
+     */
+    isExceptionFilter(metatype) {
+        return !!Reflect.getMetadata(constants_1.CATCH_WATERMARK, metatype);
+    }
     isForwardReference(module) {
         return module && !!module.forwardRef;
     }

package/services/index.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./reflector.service"), exports);
+(0, tslib_1.__exportStar)(require("./reflector.service"), exports);

package/services/reflector.service.js

@@ -42,14 +42,14 @@ class Reflector {
      */
     getAllAndMerge(metadataKey, targets) {
         const metadataCollection = this.getAll(metadataKey, targets).filter(item => item !== undefined);
-        if (shared_utils_1.isEmpty(metadataCollection)) {
+        if ((0, shared_utils_1.isEmpty)(metadataCollection)) {
             return metadataCollection;
         }
         return metadataCollection.reduce((a, b) => {
             if (Array.isArray(a)) {
                 return a.concat(b);
             }
-            if (shared_utils_1.isObject(a) && shared_utils_1.isObject(b)) {
+            if ((0, shared_utils_1.isObject)(a) && (0, shared_utils_1.isObject)(b)) {
                 return Object.assign(Object.assign({}, a), b);
             }
             return [a, b];