@nestjs/core 10.4.15 → 10.4.17

package/hooks/utils/get-instances-grouped-by-hierarchy-level.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@nestjs/common';
+import { InstanceWrapper } from '../../injector/instance-wrapper';
+export declare function getInstancesGroupedByHierarchyLevel(...collections: Array<Map<InjectionToken, InstanceWrapper> | Array<[InjectionToken, InstanceWrapper]>>): Map<number, unknown[]>;

package/hooks/utils/get-instances-grouped-by-hierarchy-level.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstancesGroupedByHierarchyLevel = getInstancesGroupedByHierarchyLevel;
+function getInstancesGroupedByHierarchyLevel(...collections) {
+    const groupedByHierarchyLevel = new Map();
+    for (const collection of collections) {
+        for (const [_, wrapper] of collection) {
+            if (!wrapper.isDependencyTreeStatic()) {
+                continue;
+            }
+            const level = wrapper.hierarchyLevel;
+            if (!groupedByHierarchyLevel.has(level)) {
+                groupedByHierarchyLevel.set(level, []);
+            }
+            const byHierarchyLevelGroup = groupedByHierarchyLevel.get(level);
+            if (wrapper.isTransient) {
+                const staticTransientInstances = wrapper
+                    .getStaticTransientInstances()
+                    .filter(i => !!i)
+                    .map(i => i.instance);
+                byHierarchyLevelGroup.push(...staticTransientInstances);
+                continue;
+            }
+            if (wrapper.instance) {
+                byHierarchyLevelGroup.push(wrapper.instance);
+            }
+        }
+    }
+    return groupedByHierarchyLevel;
+}

package/hooks/utils/get-sorted-hierarchy-levels.d.ts

@@ -0,0 +1 @@
+export declare function getSortedHierarchyLevels(groups: Map<number, unknown[]>, order?: 'ASC' | 'DESC'): number[];

package/hooks/utils/get-sorted-hierarchy-levels.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSortedHierarchyLevels = getSortedHierarchyLevels;
+function getSortedHierarchyLevels(groups, order = 'ASC') {
+    const comparator = order === 'ASC'
+        ? (a, b) => a - b
+        : (a, b) => b - a;
+    const levels = Array.from(groups.keys()).sort(comparator);
+    return levels;
+}

package/injector/opaque-key-factory/by-reference-module-opaque-key-factory.js

@@ -23,9 +23,10 @@ class ByReferenceModuleOpaqueKeyFactory {
             moduleId = this.generateRandomString();
         }
         else {
+            const delimiter = ':';
             moduleId = dynamicMetadata
-                ? `${this.generateRandomString()}:${this.hashString(moduleCls.name + JSON.stringify(dynamicMetadata))}`
-                : `${this.generateRandomString()}:${this.hashString(moduleCls.toString())}`;
+                ? `${this.generateRandomString()}${delimiter}${this.hashString(moduleCls.name + JSON.stringify(dynamicMetadata))}`
+                : `${this.generateRandomString()}${delimiter}${this.hashString(moduleCls.toString())}`;
         }
         originalRef[K_MODULE_ID] = moduleId;
         return moduleId;

package/injector/topology-tree/topology-tree.d.ts

@@ -0,0 +1,8 @@
+import { Module } from '../module';
+export declare class TopologyTree {
+    private root;
+    private links;
+    constructor(moduleRef: Module);
+    walk(callback: (value: Module, depth: number) => void): void;
+    private traverseAndMapToTree;
+}

package/injector/topology-tree/topology-tree.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologyTree = void 0;
+const tree_node_1 = require("./tree-node");
+class TopologyTree {
+    constructor(moduleRef) {
+        this.links = new Map();
+        this.root = new tree_node_1.TreeNode({
+            value: moduleRef,
+            parent: null,
+        });
+        this.links.set(moduleRef, this.root);
+        this.traverseAndMapToTree(this.root);
+    }
+    walk(callback) {
+        function walkNode(node, depth = 1) {
+            callback(node.value, depth);
+            node.children.forEach(child => walkNode(child, depth + 1));
+        }
+        walkNode(this.root);
+    }
+    traverseAndMapToTree(node, depth = 1) {
+        if (!node.value.imports) {
+            return;
+        }
+        node.value.imports.forEach(child => {
+            if (!child) {
+                return;
+            }
+            if (this.links.has(child)) {
+                const existingSubtree = this.links.get(child);
+                if (node.hasCycleWith(child)) {
+                    return;
+                }
+                const existingDepth = existingSubtree.getDepth();
+                if (existingDepth < depth) {
+                    existingSubtree.relink(node);
+                }
+                return;
+            }
+            const childNode = new tree_node_1.TreeNode({
+                value: child,
+                parent: node,
+            });
+            node.addChild(childNode);
+            this.links.set(child, childNode);
+            this.traverseAndMapToTree(childNode, depth + 1);
+        });
+    }
+}
+exports.TopologyTree = TopologyTree;

package/injector/topology-tree/tree-node.d.ts

@@ -0,0 +1,14 @@
+export declare class TreeNode<T> {
+    readonly value: T;
+    readonly children: Set<TreeNode<T>>;
+    private parent;
+    constructor({ value, parent }: {
+        value: T;
+        parent: TreeNode<T> | null;
+    });
+    addChild(child: TreeNode<T>): void;
+    removeChild(child: TreeNode<T>): void;
+    relink(parent: TreeNode<T>): void;
+    getDepth(): number;
+    hasCycleWith(target: T): boolean;
+}

package/injector/topology-tree/tree-node.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeNode = void 0;
+class TreeNode {
+    constructor({ value, parent }) {
+        this.children = new Set();
+        this.value = value;
+        this.parent = parent;
+    }
+    addChild(child) {
+        this.children.add(child);
+    }
+    removeChild(child) {
+        this.children.delete(child);
+    }
+    relink(parent) {
+        this.parent?.removeChild(this);
+        this.parent = parent;
+        this.parent.addChild(this);
+    }
+    getDepth() {
+        const visited = new Set();
+        let depth = 0;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let current = this;
+        while (current) {
+            depth++;
+            current = current.parent;
+            // Stop on cycle
+            if (visited.has(current)) {
+                return -1;
+            }
+            visited.add(current);
+        }
+        return depth;
+    }
+    hasCycleWith(target) {
+        const visited = new Set();
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let current = this;
+        while (current) {
+            if (current.value === target) {
+                return true;
+            }
+            current = current.parent;
+            if (visited.has(current)) {
+                return false;
+            }
+            visited.add(current);
+        }
+        return false;
+    }
+}
+exports.TreeNode = TreeNode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "10.4.15",
+  "version": "10.4.17",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -36,7 +36,7 @@
     "uid": "2.0.2"
   },
   "devDependencies": {
-    "@nestjs/common": "10.4.15"
+    "@nestjs/common": "10.4.17"
   },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0",

package/router/legacy-route-converter.d.ts

@@ -5,9 +5,12 @@ export declare class LegacyRouteConverter {
      * path-to-regexp used by Express>=v5 and @fastify/middie>=v9 no longer support unnamed wildcards.
      * This method attempts to convert the old syntax to the new one, and logs an error if it fails.
      * @param route The route to convert.
+     * @param options Options object.
      * @returns The converted route, or the original route if it cannot be converted.
      */
-    static tryConvert(route: string): string;
+    static tryConvert(route: string, options?: {
+        logs?: boolean;
+    }): string;
     static printError(route: string): void;
     static printWarning(route: string): void;
 }

package/router/legacy-route-converter.js

@@ -9,39 +9,52 @@ class LegacyRouteConverter {
      * path-to-regexp used by Express>=v5 and @fastify/middie>=v9 no longer support unnamed wildcards.
      * This method attempts to convert the old syntax to the new one, and logs an error if it fails.
      * @param route The route to convert.
+     * @param options Options object.
      * @returns The converted route, or the original route if it cannot be converted.
      */
-    static tryConvert(route) {
-        // Normalize path to eliminate additional conditions.
+    static tryConvert(route, options) {
+        // Normalize path to eliminate additional if statements.
         const routeWithLeadingSlash = route.startsWith('/') ? route : `/${route}`;
         const normalizedRoute = route.endsWith('/')
             ? routeWithLeadingSlash
             : `${routeWithLeadingSlash}/`;
+        const loggingEnabled = options?.logs ?? true;
+        const printWarning = loggingEnabled
+            ? this.printWarning.bind(this)
+            : () => { };
         if (normalizedRoute.endsWith('/(.*)/')) {
             // Skip printing warning for the "all" wildcard.
             if (normalizedRoute !== '/(.*)/') {
-                this.printWarning(route);
+                printWarning(route);
             }
             return route.replace('(.*)', '{*path}');
         }
         if (normalizedRoute.endsWith('/*/')) {
             // Skip printing warning for the "all" wildcard.
             if (normalizedRoute !== '/*/') {
-                this.printWarning(route);
+                printWarning(route);
             }
             return route.replace('*', '{*path}');
         }
         if (normalizedRoute.endsWith('/+/')) {
-            this.printWarning(route);
+            printWarning(route);
             return route.replace('/+', '/*path');
         }
+        // When route includes any wildcard segments in the middle.
+        if (normalizedRoute.includes('/*/')) {
+            printWarning(route);
+            // Replace each /*/ segment with a named parameter using different name for each segment.
+            return route.replaceAll('/*/', (match, offset) => {
+                return `/*path${offset}/`;
+            });
+        }
         return route;
     }
     static printError(route) {
         this.logger.error(UNSUPPORTED_PATH_MESSAGE `${route}`);
     }
     static printWarning(route) {
-        this.logger.warn(UNSUPPORTED_PATH_MESSAGE `${route}` + ' Attempting to convert...');
+        this.logger.warn(UNSUPPORTED_PATH_MESSAGE `${route}` + ' Attempting to auto-convert...');
     }
 }
 exports.LegacyRouteConverter = LegacyRouteConverter;