nx 23.0.0-beta.2 → 23.0.0-beta.4

package/dist/src/command-line/show/show-target/info.d.ts

@@ -14,6 +14,7 @@ declare function resolveTargetInfoData(t: ResolvedTarget): {
     parallelism: boolean;
     continuous: boolean;
     cache: boolean;
+    transitiveTasks?: string[];
     dependsOn?: string[];
     _depSources?: number[];
     customHasher?: boolean;

package/dist/src/command-line/show/show-target/info.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.showTargetInfoHandler = showTargetInfoHandler;
 const task_hasher_1 = require("../../../hasher/task-hasher");
+const create_task_graph_1 = require("../../../tasks-runner/create-task-graph");
 const utils_1 = require("../../../tasks-runner/utils");
 const utils_2 = require("./utils");
 // ── Handler ─────────────────────────────────────────────────────────
@@ -22,7 +23,7 @@ function resolveTargetInfoData(t) {
     const extraTargetDeps = Object.fromEntries(Object.entries(nxJson.targetDefaults ?? {})
         .filter(([, config]) => config.dependsOn)
         .map(([name, config]) => [name, config.dependsOn]));
-    const depConfigs = (0, utils_1.getDependencyConfigs)({ project: projectName, target: targetName }, extraTargetDeps, graph, [...allTargetNames]);
+    const depConfigs = (0, utils_1.getDependencyConfigs)({ project: projectName, target: targetName }, extraTargetDeps, graph, [...allTargetNames]) ?? [];
     // Determine the hoisted command value and which option key it came from
     let command;
     let commandSourceKey;
@@ -43,18 +44,7 @@ function resolveTargetInfoData(t) {
         command = targetConfig.options.script;
         commandSourceKey = 'options.script';
     }
-    const dependsOn = [];
-    const depSourceIndices = [];
-    if (depConfigs && depConfigs.length > 0) {
-        for (let i = 0; i < depConfigs.length; i++) {
-            const dep = depConfigs[i];
-            const projects = resolveDependencyProjects(dep, projectName, graph);
-            for (const p of projects) {
-                dependsOn.push(`${p}:${dep.target}`);
-                depSourceIndices.push(i);
-            }
-        }
-    }
+    const { dependsOn, depSourceIndices, transitiveTasks } = resolveTaskGraphDependencies(graph, extraTargetDeps, projectName, targetName, configuration, depConfigs);
     const configurations = Object.keys(targetConfig.configurations ?? {});
     const targetSourceMap = extractTargetSourceMap(node.data.root, targetName, sourceMaps);
     const usesCustomHasher = (0, utils_2.hasCustomHasher)(projectName, targetName, graph);
@@ -68,6 +58,7 @@ function resolveTargetInfoData(t) {
         ...(dependsOn.length > 0
             ? { dependsOn, _depSources: depSourceIndices }
             : {}),
+        ...(transitiveTasks.length > 0 ? { transitiveTasks } : {}),
         parallelism: targetConfig.parallelism ?? true,
         continuous: targetConfig.continuous ?? false,
         cache: targetConfig.cache ?? false,
@@ -110,6 +101,93 @@ function resolveDependencyProjects(dep, projectName, graph) {
     }
     return [projectName];
 }
+/**
+ * Builds a task graph rooted at the requested target and returns:
+ *   - `dependsOn`: direct task dependencies of the root, with real
+ *     project/target resolution applied.
+ *   - `depSourceIndices`: for each direct dep, the index of the original
+ *     depConfig it corresponds to (for source-map hints), or -1 if unknown.
+ *   - `transitiveTasks`: task IDs reachable through the direct deps (not
+ *     the root, not direct deps).
+ *
+ * If `createTaskGraph` throws (e.g. circular dependencies), falls back to
+ * the `depConfig`-based resolution so the output still shows the configured
+ * list rather than silently collapsing to empty.
+ */
+function resolveTaskGraphDependencies(graph, extraTargetDeps, projectName, targetName, configuration, depConfigs) {
+    try {
+        const taskGraph = (0, create_task_graph_1.createTaskGraph)(graph, extraTargetDeps, [projectName], [targetName], configuration, {});
+        const rootId = (0, utils_1.createTaskId)(projectName, targetName, configuration);
+        const directDeps = taskGraph.dependencies[rootId] ?? [];
+        const directDepSet = new Set(directDeps);
+        const depSourceIndices = directDeps.map((depTaskId) => {
+            const task = taskGraph.tasks[depTaskId];
+            if (!task)
+                return -1;
+            return findDepConfigIndex(task.target, depConfigs, projectName, graph);
+        });
+        // `Object.keys(dependencies)` gives the set of real (non-dummy) tasks
+        // in the graph — `filterDummyTasks` (called inside `createTaskGraph`)
+        // removes dummy entries from `dependencies` but leaves them in `tasks`.
+        const transitiveTasks = Object.keys(taskGraph.dependencies).filter((id) => id !== rootId && !directDepSet.has(id));
+        return { dependsOn: directDeps, depSourceIndices, transitiveTasks };
+    }
+    catch {
+        return {
+            ...resolveDependsOnFromConfigs(depConfigs, projectName, graph),
+            transitiveTasks: [],
+        };
+    }
+}
+function resolveDependsOnFromConfigs(depConfigs, projectName, graph) {
+    const dependsOn = [];
+    const depSourceIndices = [];
+    for (let i = 0; i < depConfigs.length; i++) {
+        const dep = depConfigs[i];
+        const projects = resolveDependencyProjects(dep, projectName, graph);
+        for (const p of projects) {
+            dependsOn.push(`${p}:${dep.target}`);
+            depSourceIndices.push(i);
+        }
+    }
+    return { dependsOn, depSourceIndices };
+}
+/**
+ * Builds the summary line shown beneath the direct `Depends On` list.
+ *
+ * Up to 3 unique target names: list them (`and 5 build, compile transitive tasks`).
+ * Beyond that: collapse to the count alone (`and 12 transitive tasks`).
+ */
+function formatTransitiveSummary(taskIds) {
+    const count = taskIds.length;
+    const plural = count === 1 ? 'task' : 'tasks';
+    const targetNames = uniqueTargetNames(taskIds);
+    if (targetNames.length === 0 || targetNames.length > 3) {
+        return `and ${count} transitive ${plural}`;
+    }
+    return `and ${count} ${targetNames.join(', ')} transitive ${plural}`;
+}
+function uniqueTargetNames(taskIds) {
+    const set = new Set();
+    for (const id of taskIds) {
+        // task ids are `project:target` or `project:target:config`
+        const parts = id.split(':');
+        if (parts.length >= 2)
+            set.add(parts[1]);
+    }
+    return [...set].sort();
+}
+function findDepConfigIndex(taskTarget, depConfigs, rootProject, graph) {
+    for (let i = 0; i < depConfigs.length; i++) {
+        const dep = depConfigs[i];
+        if (dep.target !== taskTarget.target)
+            continue;
+        const resolved = resolveDependencyProjects(dep, rootProject, graph);
+        if (resolved.includes(taskTarget.project))
+            return i;
+    }
+    return -1;
+}
 /**
  * Expands named inputs (e.g. "production") to their definitions while
  * tracking which original input index each expanded item came from.
@@ -216,11 +294,15 @@ function renderTargetInfo(data, args) {
     if (data.dependsOn && data.dependsOn.length > 0) {
         console.log(`${c.bold('Depends On')}:`);
         for (let i = 0; i < data.dependsOn.length; i++) {
-            const hint = data._depSources?.[i] !== undefined
-                ? sourceHint(`dependsOn.${data._depSources[i]}`, 'dependsOn')
-                : '';
+            const srcIdx = data._depSources?.[i];
+            const hint = srcIdx !== undefined && srcIdx >= 0
+                ? sourceHint(`dependsOn.${srcIdx}`, 'dependsOn')
+                : sourceHint('dependsOn');
             console.log(`  ${data.dependsOn[i]}${hint}`);
         }
+        if (data.transitiveTasks && data.transitiveTasks.length > 0) {
+            console.log(`  ${c.dim(formatTransitiveSummary(data.transitiveTasks))}`);
+        }
     }
     console.log(`${c.bold('Parallelism')}: ${data.parallelism}${sourceHint('parallelism')}`);
     console.log(`${c.bold('Continuous')}: ${data.continuous}${sourceHint('continuous')}`);