@nestjs/core 11.0.8 → 11.0.10

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": "11.0.8",
+  "version": "11.0.10",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -39,7 +39,7 @@
     "uid": "2.0.2"
   },
   "devDependencies": {
-    "@nestjs/common": "11.0.8"
+    "@nestjs/common": "11.0.10"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",

package/scanner.js

@@ -13,6 +13,7 @@ const invalid_module_exception_1 = require("./errors/exceptions/invalid-module.e
 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/internal-core-module-factory");
+const topology_tree_1 = require("./injector/topology-tree/topology-tree");
 const uuid_factory_1 = require("./inspector/uuid-factory");
 class DependenciesScanner {
     constructor(container, metadataScanner, graphInspector, applicationConfig = new application_config_1.ApplicationConfig()) {
@@ -199,27 +200,21 @@ class DependenciesScanner {
     }
     calculateModulesDistance() {
         const modulesGenerator = this.container.getModules().values();
-        // Skip "InternalCoreModule" from calculating distance
+        // Skip "InternalCoreModule"
+        // The second element is the actual root module
         modulesGenerator.next();
-        const calculateDistance = (moduleRef, distance = 1, modulesStack = []) => {
-            const localModulesStack = [...modulesStack];
-            if (!moduleRef || localModulesStack.includes(moduleRef)) {
+        const rootModule = modulesGenerator.next().value;
+        if (!rootModule) {
+            return;
+        }
+        // Convert modules to an acyclic connected graph
+        const tree = new topology_tree_1.TopologyTree(rootModule);
+        tree.walk((moduleRef, depth) => {
+            if (moduleRef.isGlobal) {
                 return;
             }
-            localModulesStack.push(moduleRef);
-            const moduleImports = moduleRef.imports;
-            moduleImports.forEach(importedModuleRef => {
-                if (importedModuleRef) {
-                    if (distance > importedModuleRef.distance &&
-                        !importedModuleRef.isGlobal) {
-                        importedModuleRef.distance = distance;
-                    }
-                    calculateDistance(importedModuleRef, distance + 1, localModulesStack);
-                }
-            });
-        };
-        const rootModule = modulesGenerator.next().value;
-        calculateDistance(rootModule);
+            moduleRef.distance = depth;
+        });
     }
     async insertImport(related, token, context) {
         if ((0, shared_utils_1.isUndefined)(related)) {