@nestjs/core 8.2.6 → 8.3.0

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 (!shared_utils_1.isString(child) && 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.js

@@ -146,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;
@@ -184,7 +184,7 @@ 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 (this.isForwardReference(related)) {
@@ -193,7 +193,7 @@ class DependenciesScanner {
         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);
@@ -206,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,
@@ -246,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));

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];