ng-di-graph 0.6.0 → 0.8.0

package/README.md

@@ -6,11 +6,11 @@
 
 A command-line tool that analyzes Angular TypeScript codebases to extract dependency injection relationships.
 
-**Target Angular Versions:** 17-20
+**Target Angular Versions:** 17-21
 
 ## Prerequisites
 - Node.js 20.x (npm 10+)
-- Angular project targeting v17-20 with a `tsconfig.json` to discover or reference
+- Angular project targeting v17-21 with a `tsconfig.json` to discover or reference
 
 ## Installation
 ```bash
@@ -44,11 +44,13 @@ ng-di-graph --project ./tsconfig.json --format json
 
 - 🔍 **Dependency Analysis** - Extract DI relationships from `@Injectable`, `@Component`, and `@Directive` classes
 - 🎯 **Constructor Injection** - Analyze constructor parameters with type annotations and `@Inject()` tokens
+- ✨ **Modern DI Support** - Analyze dependencies from constructor injection and the `inject()` function
 - 🏷️ **Decorator Flags** - Capture `@Optional`, `@Self`, `@SkipSelf`, and `@Host` parameter decorators
 - 📊 **Multiple Output Formats** - Text (default), JSON (machine-readable), Mermaid (visual flowcharts)
 - 🎨 **Entry Point Filtering** - Generate sub-graphs from specific starting nodes
 - 🔄 **Bidirectional Analysis** - Explore upstream dependencies, downstream consumers, or both
 - 🔁 **Circular Detection** - Automatically detect and report circular dependencies
+- 🧹 **Angular Core Filtering** - Hide `@angular/core` nodes by default (`--include-angular-core` to show)
 
 ## Common commands
 - Full project, text output (default):  
@@ -79,6 +81,7 @@ Option | Default | Description
 `-e, --entry <symbol...>` | none | Start the graph from one or more symbols.
 `-d, --direction <dir>` | `downstream` | `downstream`, `upstream`, or `both` relative to entries.
 `--include-decorators` | `false` | Add `@Optional`, `@Self`, `@SkipSelf`, `@Host` flags to edges.
+`--include-angular-core` | `false` | Include nodes that originate from `@angular/core` imports.
 `--out <file>` | stdout | Write output to a file.
 `-v, --verbose` | `false` | Show detailed parsing and resolution logs.
 `-h, --help` | `false` | Display CLI help.

package/dist/cli/index.cjs

@@ -451,15 +451,20 @@ function buildGraph(parsedClasses, logger) {
 	let unknownNodeCount = 0;
 	for (const parsedClass of parsedClasses) for (const dependency of parsedClass.dependencies) {
 		if (!nodeMap.has(dependency.token)) {
-			nodeMap.set(dependency.token, {
+			const unknownNode = {
 				id: dependency.token,
 				kind: "unknown"
-			});
+			};
+			if (dependency.origin) unknownNode.origin = dependency.origin;
+			nodeMap.set(dependency.token, unknownNode);
 			unknownNodeCount++;
 			logger?.warn(LogCategory.GRAPH_CONSTRUCTION, `Created unknown node: ${dependency.token}`, {
 				nodeId: dependency.token,
 				referencedBy: parsedClass.name
 			});
+		} else {
+			const existingNode = nodeMap.get(dependency.token);
+			if (existingNode && existingNode.kind === "unknown" && !existingNode.origin && dependency.origin) existingNode.origin = dependency.origin;
 		}
 		const edge = {
 			from: parsedClass.name,
@@ -531,24 +536,57 @@ function validateAndTraverseEntryPoints(entryPoints, graph, adjacencyList, resul
 * @returns Filtered graph containing only nodes reachable from entry points
 */
 function filterGraph(graph, options, logger) {
-	if (!options.entry || options.entry.length === 0) return graph;
+	const baseGraph = filterGraphByOrigin(graph, options.includeAngularCore ?? false);
+	if (!options.entry || options.entry.length === 0) {
+		const includedNodeIds$1 = new Set(baseGraph.nodes.map((node) => node.id));
+		return {
+			nodes: baseGraph.nodes,
+			edges: baseGraph.edges,
+			circularDependencies: filterCircularDependencies(baseGraph, includedNodeIds$1)
+		};
+	}
 	const includedNodeIds = /* @__PURE__ */ new Set();
 	if (options.direction === "both") {
-		const upstreamAdjacencyList = buildAdjacencyList(graph, "upstream");
+		const upstreamAdjacencyList = buildAdjacencyList(baseGraph, "upstream");
 		const upstreamNodes = /* @__PURE__ */ new Set();
-		validateAndTraverseEntryPoints(options.entry, graph, upstreamAdjacencyList, upstreamNodes, options, logger);
-		const downstreamAdjacencyList = buildAdjacencyList(graph, "downstream");
+		validateAndTraverseEntryPoints(options.entry, baseGraph, upstreamAdjacencyList, upstreamNodes, options, logger);
+		const downstreamAdjacencyList = buildAdjacencyList(baseGraph, "downstream");
 		const downstreamNodes = /* @__PURE__ */ new Set();
-		validateAndTraverseEntryPoints(options.entry, graph, downstreamAdjacencyList, downstreamNodes, options, logger);
+		validateAndTraverseEntryPoints(options.entry, baseGraph, downstreamAdjacencyList, downstreamNodes, options, logger);
 		const combinedNodes = new Set([...upstreamNodes, ...downstreamNodes]);
 		for (const nodeId of combinedNodes) includedNodeIds.add(nodeId);
 	} else {
-		const adjacencyList = buildAdjacencyList(graph, options.direction);
-		validateAndTraverseEntryPoints(options.entry, graph, adjacencyList, includedNodeIds, options, logger);
+		const adjacencyList = buildAdjacencyList(baseGraph, options.direction);
+		validateAndTraverseEntryPoints(options.entry, baseGraph, adjacencyList, includedNodeIds, options, logger);
+	}
+	const filteredNodes = baseGraph.nodes.filter((node) => includedNodeIds.has(node.id));
+	const filteredEdges = baseGraph.edges.filter((edge) => includedNodeIds.has(edge.from) && includedNodeIds.has(edge.to));
+	const filteredCircularDeps = filterCircularDependencies(baseGraph, includedNodeIds);
+	if (options.verbose && logger) {
+		logger.info(LogCategory.FILTERING, "Filtered graph summary", {
+			nodeCount: filteredNodes.length,
+			edgeCount: filteredEdges.length
+		});
+		logger.debug(LogCategory.FILTERING, "Entry points applied", { entryPoints: options.entry });
 	}
-	const filteredNodes = graph.nodes.filter((node) => includedNodeIds.has(node.id));
-	const filteredEdges = graph.edges.filter((edge) => includedNodeIds.has(edge.from) && includedNodeIds.has(edge.to));
-	const filteredCircularDeps = graph.circularDependencies.filter((cycle) => {
+	return {
+		nodes: filteredNodes,
+		edges: filteredEdges,
+		circularDependencies: filteredCircularDeps
+	};
+}
+function filterGraphByOrigin(graph, includeAngularCore) {
+	if (includeAngularCore) return graph;
+	const filteredNodes = graph.nodes.filter((node) => node.origin !== "angular-core");
+	const includedNodeIds = new Set(filteredNodes.map((node) => node.id));
+	return {
+		nodes: filteredNodes,
+		edges: graph.edges.filter((edge) => includedNodeIds.has(edge.from) && includedNodeIds.has(edge.to)),
+		circularDependencies: graph.circularDependencies
+	};
+}
+function filterCircularDependencies(graph, includedNodeIds) {
+	return graph.circularDependencies.filter((cycle) => {
 		if (cycle.length < 2) return false;
 		const isSelfLoop = cycle.length === 2 && cycle[0] === cycle[1];
 		const isProperCycleWithClosing = cycle.length >= 3 && cycle[0] === cycle[cycle.length - 1];
@@ -563,18 +601,6 @@ function filterGraph(graph, options, logger) {
 		}
 		return true;
 	});
-	if (options.verbose && logger) {
-		logger.info(LogCategory.FILTERING, "Filtered graph summary", {
-			nodeCount: filteredNodes.length,
-			edgeCount: filteredEdges.length
-		});
-		logger.debug(LogCategory.FILTERING, "Entry points applied", { entryPoints: options.entry });
-	}
-	return {
-		nodes: filteredNodes,
-		edges: filteredEdges,
-		circularDependencies: filteredCircularDeps
-	};
 }
 /**
 * Traverses the graph from a starting node using DFS
@@ -650,6 +676,7 @@ var OutputHandler = class {
 * Implements FR-03: Constructor token resolution
 */
 const GLOBAL_WARNING_KEYS = /* @__PURE__ */ new Set();
+const ANGULAR_CORE_MODULE = "@angular/core";
 const formatTsDiagnostics = (diagnostics) => diagnostics.map((diagnostic) => {
 	const message = typescript.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
 	if (diagnostic.file && diagnostic.start !== void 0) {
@@ -664,6 +691,9 @@ var AngularParser = class {
 		this._logger = _logger;
 		this._typeResolutionCache = /* @__PURE__ */ new Map();
 		this._circularTypeRefs = /* @__PURE__ */ new Set();
+		this._angularCoreImportCache = /* @__PURE__ */ new Map();
+		this._angularInjectIdentifiersCache = /* @__PURE__ */ new Map();
+		this._angularCoreAliasMatchers = [];
 		this._processingStats = {
 			processedFileCount: 0,
 			skippedFileCount: 0
@@ -773,6 +803,9 @@ var AngularParser = class {
 				const message = formatTsDiagnostics(parsedConfig.errors);
 				throw ErrorHandler.createError(`TypeScript configuration error: ${message}`, "PROJECT_LOAD_FAILED", this._options.project, { diagnosticCount: parsedConfig.errors.length });
 			}
+			this.cacheAngularCoreAliases(configFile.config);
+			this._angularCoreImportCache.clear();
+			this._angularInjectIdentifiersCache.clear();
 			this._project = new ts_morph.Project({ tsConfigFilePath: tsConfigPath });
 			if (!this._project) throw ErrorHandler.createError("Failed to load TypeScript project", "PROJECT_LOAD_FAILED", this._options.project);
 		} catch (error) {
@@ -1061,15 +1094,79 @@ var AngularParser = class {
 	*/
 	resolveDecoratorAlias(sourceFile, decoratorName) {
 		const importDeclarations = sourceFile.getImportDeclarations();
-		for (const importDecl of importDeclarations) if (importDecl.getModuleSpecifierValue() === "@angular/core") {
+		for (const importDecl of importDeclarations) {
+			const moduleSpecifier = importDecl.getModuleSpecifierValue();
+			if (this.isAngularCoreModuleSpecifier(moduleSpecifier)) {
+				const namedImports = importDecl.getNamedImports();
+				for (const namedImport of namedImports) {
+					const alias = namedImport.getAliasNode();
+					if (alias && alias.getText() === decoratorName) return namedImport.getName();
+					if (!alias && namedImport.getName() === decoratorName) return decoratorName;
+				}
+			}
+		}
+		return null;
+	}
+	cacheAngularCoreAliases(tsConfig) {
+		this._angularCoreAliasMatchers = [];
+		if (!tsConfig || typeof tsConfig !== "object") return;
+		const configRecord = tsConfig;
+		const paths = (typeof configRecord.compilerOptions === "object" && configRecord.compilerOptions ? configRecord.compilerOptions : void 0)?.paths;
+		if (!paths) return;
+		for (const [alias, targets] of Object.entries(paths)) {
+			if (!Array.isArray(targets)) continue;
+			if (!targets.some((target) => this.isAngularCorePathTarget(target))) continue;
+			this._angularCoreAliasMatchers.push(this.buildAliasMatcher(alias));
+		}
+	}
+	buildAliasMatcher(alias) {
+		const pattern = alias.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, ".*");
+		return /* @__PURE__ */ new RegExp(`^${pattern}$`);
+	}
+	isAngularCorePathTarget(target) {
+		const normalized = target.replace(/\\/g, "/");
+		return normalized.includes(`${ANGULAR_CORE_MODULE}/`) || normalized.includes(ANGULAR_CORE_MODULE);
+	}
+	isAngularCoreModuleSpecifier(moduleSpecifier) {
+		if (moduleSpecifier === ANGULAR_CORE_MODULE || moduleSpecifier.startsWith(`${ANGULAR_CORE_MODULE}/`)) return true;
+		return this._angularCoreAliasMatchers.some((matcher) => matcher.test(moduleSpecifier));
+	}
+	getAngularCoreImportMap(sourceFile) {
+		const cacheKey = sourceFile.getFilePath();
+		const cached = this._angularCoreImportCache.get(cacheKey);
+		if (cached) return cached;
+		const named = /* @__PURE__ */ new Set();
+		const namespaces = /* @__PURE__ */ new Set();
+		const importDeclarations = sourceFile.getImportDeclarations();
+		for (const importDecl of importDeclarations) {
+			const moduleSpecifier = importDecl.getModuleSpecifierValue();
+			if (!this.isAngularCoreModuleSpecifier(moduleSpecifier)) continue;
 			const namedImports = importDecl.getNamedImports();
 			for (const namedImport of namedImports) {
 				const alias = namedImport.getAliasNode();
-				if (alias && alias.getText() === decoratorName) return namedImport.getName();
-				if (!alias && namedImport.getName() === decoratorName) return decoratorName;
+				named.add(alias ? alias.getText() : namedImport.getName());
 			}
+			const namespaceImport = importDecl.getNamespaceImport();
+			if (namespaceImport) namespaces.add(namespaceImport.getText());
 		}
-		return null;
+		const map = {
+			named,
+			namespaces
+		};
+		this._angularCoreImportCache.set(cacheKey, map);
+		return map;
+	}
+	resolveDependencyOrigin(token, sourceFile) {
+		const importMap = this.getAngularCoreImportMap(sourceFile);
+		const normalizedToken = this.normalizeTokenForOrigin(token);
+		if (normalizedToken.includes(".")) {
+			const namespace = normalizedToken.split(".")[0];
+			if (importMap.namespaces.has(namespace)) return "angular-core";
+		}
+		if (importMap.named.has(normalizedToken)) return "angular-core";
+	}
+	normalizeTokenForOrigin(token) {
+		return token.split("<")[0].replace(/\[\]$/, "");
 	}
 	/**
 	* Determine NodeKind from Angular decorator
@@ -1408,7 +1505,8 @@ var AngularParser = class {
 	*/
 	parseConstructorParameter(param) {
 		const parameterName = param.getName();
-		const filePath = param.getSourceFile().getFilePath();
+		const sourceFile = param.getSourceFile();
+		const filePath = sourceFile.getFilePath();
 		const lineNumber = param.getStartLineNumber();
 		const columnNumber = param.getStart() - param.getStartLinePos();
 		const startTime = performance.now();
@@ -1421,7 +1519,8 @@ var AngularParser = class {
 				if (token) return {
 					token,
 					flags,
-					parameterName
+					parameterName,
+					origin: this.resolveDependencyOrigin(token, sourceFile)
 				};
 			}
 			const initializer = param.getInitializer();
@@ -1432,7 +1531,8 @@ var AngularParser = class {
 					return {
 						token: injectResult.token,
 						flags: finalFlags,
-						parameterName
+						parameterName,
+						origin: this.resolveDependencyOrigin(injectResult.token, sourceFile)
 					};
 				}
 			}
@@ -1442,7 +1542,8 @@ var AngularParser = class {
 				if (token) return {
 					token,
 					flags,
-					parameterName
+					parameterName,
+					origin: this.resolveDependencyOrigin(token, sourceFile)
 				};
 			}
 			const type = param.getType();
@@ -1469,7 +1570,8 @@ var AngularParser = class {
 			if (resolvedToken) return {
 				token: resolvedToken,
 				flags,
-				parameterName
+				parameterName,
+				origin: this.resolveDependencyOrigin(resolvedToken, sourceFile)
 			};
 			return null;
 		} finally {
@@ -1578,8 +1680,8 @@ var AngularParser = class {
 			const callExpression = initializer;
 			const expression = callExpression.getExpression();
 			if (expression.getKind() !== ts_morph.SyntaxKind.Identifier) return null;
-			if (expression.getText() !== "inject") return null;
-			if (!this.isAngularInjectImported(property.getSourceFile())) return null;
+			const identifier = expression.getText();
+			if (!this.getAngularInjectIdentifiers(property.getSourceFile()).has(identifier)) return null;
 			const args = callExpression.getArguments();
 			if (args.length === 0) return null;
 			const token = args[0].getText().replace(/['"]/g, "");
@@ -1590,7 +1692,8 @@ var AngularParser = class {
 			return {
 				token,
 				flags,
-				parameterName: propertyName
+				parameterName: propertyName,
+				origin: this.resolveDependencyOrigin(token, property.getSourceFile())
 			};
 		} catch (error) {
 			if (this._options.verbose) {
@@ -1710,28 +1813,24 @@ var AngularParser = class {
 		}
 		return flags;
 	}
-	/**
-	* Check if inject() function is imported from @angular/core
-	* Prevents false positives from custom inject() functions
-	* @param sourceFile Source file to check imports
-	* @returns True if Angular inject is imported
-	*/
-	isAngularInjectImported(sourceFile) {
-		try {
-			const importDeclarations = sourceFile.getImportDeclarations();
-			for (const importDecl of importDeclarations) if (importDecl.getModuleSpecifierValue() === "@angular/core") {
-				const namedImports = importDecl.getNamedImports();
-				for (const namedImport of namedImports) {
-					const importName = namedImport.getName();
-					const alias = namedImport.getAliasNode();
-					if (importName === "inject" || alias && alias.getText() === "inject") return true;
-				}
+	getAngularInjectIdentifiers(sourceFile) {
+		const cacheKey = sourceFile.getFilePath();
+		const cached = this._angularInjectIdentifiersCache.get(cacheKey);
+		if (cached) return cached;
+		const identifiers = /* @__PURE__ */ new Set();
+		const importDeclarations = sourceFile.getImportDeclarations();
+		for (const importDecl of importDeclarations) {
+			const moduleSpecifier = importDecl.getModuleSpecifierValue();
+			if (!this.isAngularCoreModuleSpecifier(moduleSpecifier)) continue;
+			const namedImports = importDecl.getNamedImports();
+			for (const namedImport of namedImports) {
+				if (namedImport.getName() !== "inject") continue;
+				const alias = namedImport.getAliasNode();
+				identifiers.add(alias ? alias.getText() : "inject");
 			}
-			return false;
-		} catch (error) {
-			if (this._options.verbose) this.warn(LogCategory.ERROR_RECOVERY, `Could not verify inject() import in ${sourceFile.getFilePath()}: ${error instanceof Error ? error.message : String(error)}`, { filePath: sourceFile.getFilePath() });
-			return true;
 		}
+		this._angularInjectIdentifiersCache.set(cacheKey, identifiers);
+		return identifiers;
 	}
 	/**
 	* Analyze inject() function call expression to extract token and options
@@ -1750,9 +1849,9 @@ var AngularParser = class {
 		try {
 			const callIdentifier = callExpression.getExpression();
 			if (callIdentifier.getKind() !== ts_morph.SyntaxKind.Identifier) return null;
-			if (callIdentifier.getText() !== "inject") return null;
+			const functionName = callIdentifier.getText();
 			const sourceFile$1 = expression.getSourceFile();
-			if (!this.isAngularInjectImported(sourceFile$1)) return null;
+			if (!this.getAngularInjectIdentifiers(sourceFile$1).has(functionName)) return null;
 			const args = callExpression.getArguments();
 			if (args.length === 0) {
 				warnVerbose("inject() called without token parameter - skipping");
@@ -1937,7 +2036,11 @@ var JsonFormatter = class {
 			nodeCount: graph.nodes.length,
 			edgeCount: graph.edges.length
 		});
-		const result = JSON.stringify(graph, null, 2);
+		const sanitizedGraph = {
+			...graph,
+			nodes: graph.nodes.map(({ origin, ...node }) => node)
+		};
+		const result = JSON.stringify(sanitizedGraph, null, 2);
 		const elapsed = this._logger?.timeEnd("json-format") ?? 0;
 		this._logger?.info(LogCategory.PERFORMANCE, "JSON output complete", {
 			outputSize: result.length,
@@ -2279,7 +2382,7 @@ function enforceMinimumNodeVersion() {
 enforceMinimumNodeVersion();
 const program = new commander.Command();
 program.name("ng-di-graph").description("Angular DI dependency graph CLI tool").version("0.1.0");
-program.argument("[filePaths...]", "TypeScript files to analyze (alias for --files)").option("-p, --project <path>", "tsconfig.json path (auto-discovered if omitted)").option("--files <paths...>", "specific file paths to analyze (similar to eslint targets)").option("-f, --format <format>", "output format: text | json | mermaid", "text").option("-e, --entry <symbol...>", "starting nodes for sub-graph").option("-d, --direction <dir>", "filtering direction: upstream|downstream|both", "downstream").option("--include-decorators", "include Optional/Self/SkipSelf/Host flags", false).option("--out <file>", "output file (stdout if omitted)").option("-v, --verbose", "show detailed parsing information", false);
+program.argument("[filePaths...]", "TypeScript files to analyze (alias for --files)").option("-p, --project <path>", "tsconfig.json path (auto-discovered if omitted)").option("--files <paths...>", "specific file paths to analyze (similar to eslint targets)").option("-f, --format <format>", "output format: text | json | mermaid", "text").option("-e, --entry <symbol...>", "starting nodes for sub-graph").option("-d, --direction <dir>", "filtering direction: upstream|downstream|both", "downstream").option("--include-decorators", "include Optional/Self/SkipSelf/Host flags", false).option("--include-angular-core", "include @angular/core nodes", false).option("--out <file>", "output file (stdout if omitted)").option("-v, --verbose", "show detailed parsing information", false);
 program.action(async (filePaths = [], options) => {
 	try {
 		const mergedFiles = mergeFileTargets(filePaths, options.files);
@@ -2309,6 +2412,7 @@ program.action(async (filePaths = [], options) => {
 			entry: options.entry,
 			direction: options.direction,
 			includeDecorators: options.includeDecorators,
+			includeAngularCore: options.includeAngularCore,
 			out: options.out,
 			verbose: options.verbose
 		};
@@ -2337,10 +2441,10 @@ program.action(async (filePaths = [], options) => {
 			console.log(`✅ Graph built: ${graph.nodes.length} nodes, ${graph.edges.length} edges`);
 			if (graph.circularDependencies.length > 0) console.log(`⚠️  Detected ${graph.circularDependencies.length} circular dependencies`);
 		}
-		if (cliOptions.entry && cliOptions.entry.length > 0) {
-			if (cliOptions.verbose) console.log(`🔍 Filtering graph by entry points: ${cliOptions.entry.join(", ")}`);
+		if (cliOptions.entry && cliOptions.entry.length > 0 || !cliOptions.includeAngularCore) {
+			if (cliOptions.verbose && cliOptions.entry && cliOptions.entry.length > 0) console.log(`🔍 Filtering graph by entry points: ${cliOptions.entry.join(", ")}`);
 			graph = filterGraph(graph, cliOptions, logger);
-			if (cliOptions.verbose) console.log(`✅ Filtered graph: ${graph.nodes.length} nodes, ${graph.edges.length} edges`);
+			if (cliOptions.verbose && cliOptions.entry && cliOptions.entry.length > 0) console.log(`✅ Filtered graph: ${graph.nodes.length} nodes, ${graph.edges.length} edges`);
 		}
 		let formatter;
 		if (cliOptions.format === "mermaid") formatter = new MermaidFormatter(logger);