nx 23.0.0-beta.21 → 23.0.0-beta.22

package/dist/src/plugins/js/lock-file/lock-file.d.ts

@@ -8,6 +8,7 @@ import { RawProjectGraphDependency } from '../../../project-graph/project-graph-
 import { PackageJson } from '../../../utils/package-json';
 import { PackageManager } from '../../../utils/package-manager';
 export declare const LOCKFILES: string[];
+export declare const AUTO_AFFECTED_LOCK_FILES: readonly ["yarn.lock", "package-lock.json", "pnpm-lock.yaml", "pnpm-lock.yml", "bun.lockb", "bun.lock"];
 /**
  * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
  */
@@ -15,6 +16,10 @@ export declare function getLockFileNodes(packageManager: PackageManager, content
     nodes: Record<string, ProjectGraphExternalNode>;
     keyMap: Map<string, any>;
 };
+export declare function getLockFileNodesForName(lockFile: string, contents: string, lockFileHash: string, packageJson?: PackageJson): {
+    nodes: Record<string, ProjectGraphExternalNode>;
+    keyMap: Map<string, any>;
+};
 /**
  * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
  */

package/dist/src/plugins/js/lock-file/lock-file.js

@@ -4,8 +4,9 @@
  * It encapsulates the package manager specific logic and implementation details.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOCKFILES = void 0;
+exports.AUTO_AFFECTED_LOCK_FILES = exports.LOCKFILES = void 0;
 exports.getLockFileNodes = getLockFileNodes;
+exports.getLockFileNodesForName = getLockFileNodesForName;
 exports.getLockFileDependencies = getLockFileDependencies;
 exports.lockFileExists = lockFileExists;
 exports.getLockFileName = getLockFileName;
@@ -28,6 +29,7 @@ const yarn_parser_1 = require("./yarn-parser");
 const YARN_LOCK_FILE = 'yarn.lock';
 const NPM_LOCK_FILE = 'package-lock.json';
 const PNPM_LOCK_FILE = 'pnpm-lock.yaml';
+const PNPM_LOCK_FILE_LEGACY = 'pnpm-lock.yml';
 exports.LOCKFILES = [
     YARN_LOCK_FILE,
     NPM_LOCK_FILE,
@@ -35,6 +37,14 @@ exports.LOCKFILES = [
     bun_parser_1.BUN_LOCK_FILE,
     bun_parser_1.BUN_TEXT_LOCK_FILE,
 ];
+exports.AUTO_AFFECTED_LOCK_FILES = [
+    YARN_LOCK_FILE,
+    NPM_LOCK_FILE,
+    PNPM_LOCK_FILE,
+    PNPM_LOCK_FILE_LEGACY,
+    bun_parser_1.BUN_LOCK_FILE,
+    bun_parser_1.BUN_TEXT_LOCK_FILE,
+];
 const YARN_LOCK_PATH = (0, node_path_1.join)(workspace_root_1.workspaceRoot, YARN_LOCK_FILE);
 const NPM_LOCK_PATH = (0, node_path_1.join)(workspace_root_1.workspaceRoot, NPM_LOCK_FILE);
 const PNPM_LOCK_PATH = (0, node_path_1.join)(workspace_root_1.workspaceRoot, PNPM_LOCK_FILE);
@@ -45,29 +55,10 @@ const BUN_TEXT_LOCK_PATH = (0, node_path_1.join)(workspace_root_1.workspaceRoot,
  */
 function getLockFileNodes(packageManager, contents, lockFileHash, context) {
     try {
-        if (packageManager === 'yarn') {
-            const packageJson = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(context.workspaceRoot, 'package.json'));
-            return (0, yarn_parser_1.getYarnLockfileNodes)(contents, lockFileHash, packageJson);
-        }
-        if (packageManager === 'pnpm') {
-            return (0, pnpm_parser_1.getPnpmLockfileNodes)(contents, lockFileHash);
-        }
-        if (packageManager === 'npm') {
-            return (0, npm_parser_1.getNpmLockfileNodes)(contents, lockFileHash);
-        }
-        if (packageManager === 'bun') {
-            const lockFilePath = getLockFilePath(packageManager);
-            if (lockFilePath.endsWith(bun_parser_1.BUN_TEXT_LOCK_FILE)) {
-                // Use new text-based parser
-                const nodes = (0, bun_parser_1.getBunTextLockfileNodes)(contents, lockFileHash);
-                return { nodes, keyMap: new Map() };
-            }
-            else {
-                // Fallback to yarn parser for binary format
-                const packageJson = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(context.workspaceRoot, 'package.json'));
-                return (0, yarn_parser_1.getYarnLockfileNodes)(contents, lockFileHash, packageJson);
-            }
-        }
+        const packageJson = packageManager === 'yarn' || packageManager === 'bun'
+            ? (0, fileutils_1.readJsonFile)((0, node_path_1.join)(context.workspaceRoot, 'package.json'))
+            : undefined;
+        return getLockFileNodesForName(getLockFileName(packageManager), contents, lockFileHash, packageJson);
     }
     catch (e) {
         if (!isPostInstallProcess()) {
@@ -80,6 +71,25 @@ function getLockFileNodes(packageManager, contents, lockFileHash, context) {
     }
     throw new Error(`Unknown package manager: ${packageManager}`);
 }
+function getLockFileNodesForName(lockFile, contents, lockFileHash, packageJson) {
+    if (lockFile === YARN_LOCK_FILE || lockFile === bun_parser_1.BUN_LOCK_FILE) {
+        // yarn-parser only reads optional fields plus an unused `name` for the
+        // synthetic root workspace node, which is identical across base/head and
+        // therefore irrelevant for affected diffing.
+        return (0, yarn_parser_1.getYarnLockfileNodes)(contents, lockFileHash, packageJson ?? {});
+    }
+    if (lockFile === PNPM_LOCK_FILE || lockFile === PNPM_LOCK_FILE_LEGACY) {
+        return (0, pnpm_parser_1.getPnpmLockfileNodes)(contents, lockFileHash);
+    }
+    if (lockFile === NPM_LOCK_FILE) {
+        return (0, npm_parser_1.getNpmLockfileNodes)(contents, lockFileHash);
+    }
+    if (lockFile === bun_parser_1.BUN_TEXT_LOCK_FILE) {
+        const nodes = (0, bun_parser_1.getBunTextLockfileNodes)(contents, lockFileHash);
+        return { nodes, keyMap: new Map() };
+    }
+    throw new Error(`Unknown lock file: ${lockFile}`);
+}
 /**
  * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
  */

package/dist/src/plugins/js/project-graph/affected/lock-file-changes.d.ts

@@ -1,5 +1,3 @@
 import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
-import { WholeFileChange } from '../../../../project-graph/file-utils';
-import { JsonChange } from '../../../../utils/json-diff';
-export declare const PNPM_LOCK_FILES: string[];
-export declare const getTouchedProjectsFromLockFile: TouchedProjectLocator<WholeFileChange | JsonChange>;
+import { LockFileChange, WholeFileChange } from '../../../../project-graph/file-utils';
+export declare const getTouchedProjectsFromLockFile: TouchedProjectLocator<WholeFileChange | LockFileChange>;

package/dist/src/plugins/js/project-graph/affected/lock-file-changes.js

@@ -1,26 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTouchedProjectsFromLockFile = exports.PNPM_LOCK_FILES = void 0;
-const configuration_1 = require("../../../../config/configuration");
-const json_diff_1 = require("../../../../utils/json-diff");
+exports.getTouchedProjectsFromLockFile = void 0;
+const file_utils_1 = require("../../../../project-graph/file-utils");
 const config_1 = require("../../utils/config");
 const find_matching_projects_1 = require("../../../../utils/find-matching-projects");
-exports.PNPM_LOCK_FILES = ['pnpm-lock.yaml', 'pnpm-lock.yml'];
-const ALL_LOCK_FILES = [
-    ...exports.PNPM_LOCK_FILES,
-    'package-lock.json',
-    'yarn.lock',
-    'bun.lockb',
-    'bun.lock',
-];
-const getTouchedProjectsFromLockFile = (fileChanges, projectGraphNodes) => {
-    const nxJson = (0, configuration_1.readNxJson)();
+const file_hasher_1 = require("../../../../hasher/file-hasher");
+const output_1 = require("../../../../utils/output");
+const lock_file_1 = require("../../lock-file/lock-file");
+const getTouchedProjectsFromLockFile = (fileChanges, projectGraphNodes, nxJson, packageJson, projectGraph) => {
     const { projectsAffectedByDependencyUpdates } = (0, config_1.jsPluginConfig)(nxJson);
-    const changedLockFile = fileChanges.find((f) => ALL_LOCK_FILES.includes(f.file));
+    const changedLockFile = fileChanges.find((f) => lock_file_1.AUTO_AFFECTED_LOCK_FILES.includes(f.file));
     if (projectsAffectedByDependencyUpdates === 'auto') {
-        const changedProjectPaths = getProjectPathsAffectedByDependencyUpdates(changedLockFile);
-        const changedProjectNames = getProjectsNamesFromPaths(projectGraphNodes, changedProjectPaths);
-        return changedProjectNames;
+        return getAutoAffected(changedLockFile, projectGraphNodes, projectGraph, packageJson);
     }
     else if (Array.isArray(projectsAffectedByDependencyUpdates)) {
         return (0, find_matching_projects_1.findMatchingProjects)(projectsAffectedByDependencyUpdates, projectGraphNodes);
@@ -32,41 +23,128 @@ const getTouchedProjectsFromLockFile = (fileChanges, projectGraphNodes) => {
 };
 exports.getTouchedProjectsFromLockFile = getTouchedProjectsFromLockFile;
 /**
- * For pnpm projects, check lock file for changes to importers and return the project paths that have changes.
+ * In auto mode, parse the lock file at the base and head revisions
+ * using Nx's existing lock file parsers, then diff the resulting
+ * external-node maps to determine which packages actually changed.
+ *
+ * Returns external node names (e.g. "npm:lodash@4.17.21") so the
+ * graph reversal in filterAffected can walk back to workspace projects.
  */
-const getProjectPathsAffectedByDependencyUpdates = (changedLockFile) => {
+function getAutoAffected(changedLockFile, projectGraphNodes, projectGraph, packageJson) {
+    const allProjectNames = Object.values(projectGraphNodes).map((p) => p.name);
     if (!changedLockFile) {
         return [];
     }
-    const changedProjectPaths = new Set();
-    if (exports.PNPM_LOCK_FILES.includes(changedLockFile.file)) {
-        for (const change of changedLockFile.getChanges()) {
-            if ((0, json_diff_1.isJsonChange)(change) &&
-                change.path[0] === 'importers' &&
-                change.path[1] !== undefined) {
-                changedProjectPaths.add(change.path[1]);
+    const changes = changedLockFile.getChanges();
+    // A WholeFileChange means we were unable to read both revisions of
+    // the lock file (e.g. missing base revision, git error). Fall back
+    // to marking all projects affected.
+    if (!changes.every(file_utils_1.isLockFileChange)) {
+        return allProjectNames;
+    }
+    const changedPackageNames = getChangedPackageNames(changedLockFile.file, changes, packageJson);
+    if (changedPackageNames === null) {
+        return allProjectNames;
+    }
+    if (changedPackageNames.size === 0) {
+        return [];
+    }
+    // Look up the changed packages in the project graph's external nodes
+    // and return the external node names. The graph reversal in
+    // filterAffected walks from these nodes to workspace projects.
+    const { touchedNodeNames, missingPackageNames } = findExternalNodesByPackageName(changedPackageNames, projectGraph.externalNodes ?? {});
+    if (missingPackageNames.size > 0) {
+        return allProjectNames;
+    }
+    return touchedNodeNames;
+}
+/**
+ * Parse the base and head revisions of the lock file with Nx's
+ * existing parsers and diff the resulting package -> version maps.
+ *
+ * Returns the set of changed package names, or null if parsing
+ * failed (in which case the caller should fall back to all projects).
+ */
+function getChangedPackageNames(file, changes, packageJson) {
+    try {
+        const changed = new Set();
+        // calculateFileChanges emits a single LockFileChange per lock file, but
+        // the iteration keeps the contract open in case multiple ranges are ever
+        // emitted for the same file.
+        for (const change of changes) {
+            const baseFingerprints = collectPackageFingerprints((0, lock_file_1.getLockFileNodesForName)(file, change.baseContent, (0, file_hasher_1.hashArray)([change.baseContent]), packageJson).nodes);
+            const headFingerprints = collectPackageFingerprints((0, lock_file_1.getLockFileNodesForName)(file, change.headContent, (0, file_hasher_1.hashArray)([change.headContent]), packageJson).nodes);
+            for (const [name, fingerprints] of headFingerprints) {
+                const baseSet = baseFingerprints.get(name);
+                if (!baseSet || !setsEqual(baseSet, fingerprints)) {
+                    changed.add(name);
+                }
+            }
+            for (const name of baseFingerprints.keys()) {
+                if (!headFingerprints.has(name)) {
+                    changed.add(name);
+                }
             }
         }
+        return changed;
     }
-    return Array.from(changedProjectPaths);
-};
-const getProjectsNamesFromPaths = (projectGraphNodes, projectPaths) => {
-    if (!projectPaths.length) {
-        return [];
+    catch (e) {
+        output_1.output.warn({
+            title: `Failed to parse "${file}" for projectsAffectedByDependencyUpdates "auto" mode. All projects will be marked as affected.`,
+            bodyLines: [e instanceof Error ? e.message : String(e)],
+        });
+        return null;
     }
-    const lookup = new RootPathLookup(projectGraphNodes);
-    return projectPaths
-        .map((path) => lookup.findNodeNameByRoot(path))
-        .filter(Boolean);
-};
-class RootPathLookup {
-    constructor(nodes) {
-        this.rootToNameMap = new Map();
-        Object.entries(nodes).forEach(([name, node]) => {
-            this.rootToNameMap.set(node.data.root, name);
+}
+/**
+ * Build a map of packageName -> set of versions present in the
+ * external-node record returned by a lock-file parser. We include both
+ * version and hash so patched/tarball/integrity-only changes still
+ * count as lockfile changes even when the semver stays the same.
+ */
+function collectPackageFingerprints(nodes) {
+    const fingerprints = new Map();
+    for (const node of Object.values(nodes ?? {})) {
+        const name = node.data?.packageName;
+        if (!name)
+            continue;
+        const fingerprint = JSON.stringify({
+            version: node.data.version ?? '',
+            hash: node.data.hash ?? '',
         });
+        let set = fingerprints.get(name);
+        if (!set) {
+            set = new Set();
+            fingerprints.set(name, set);
+        }
+        set.add(fingerprint);
     }
-    findNodeNameByRoot(root) {
-        return this.rootToNameMap.get(root);
+    return fingerprints;
+}
+function setsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const value of a) {
+        if (!b.has(value))
+            return false;
+    }
+    return true;
+}
+/**
+ * Given a set of package names, find all matching external node names
+ * in the project graph.
+ */
+function findExternalNodesByPackageName(packageNames, externalNodes) {
+    const touchedNodeNames = [];
+    const matchedPackageNames = new Set();
+    for (const [name, node] of Object.entries(externalNodes)) {
+        if (packageNames.has(node.data.packageName)) {
+            touchedNodeNames.push(name);
+            matchedPackageNames.add(node.data.packageName);
+        }
     }
+    return {
+        touchedNodeNames,
+        missingPackageNames: new Set(Array.from(packageNames).filter((name) => !matchedPackageNames.has(name))),
+    };
 }

package/dist/src/project-graph/file-utils.d.ts

@@ -13,8 +13,15 @@ export declare class WholeFileChange implements Change {
 export declare class DeletedFileChange implements Change {
     type: string;
 }
+export declare class LockFileChange implements Change {
+    baseContent: string;
+    headContent: string;
+    type: string;
+    constructor(baseContent: string, headContent: string);
+}
 export declare function isWholeFileChange(change: Change): change is WholeFileChange;
 export declare function isDeletedFileChange(change: Change): change is DeletedFileChange;
+export declare function isLockFileChange(change: Change): change is LockFileChange;
 export declare function calculateFileChanges(files: string[], nxArgs?: NxArgs, readFileAtRevision?: {
     (f: string, r: string | void): string;
 }, ignore?: ReturnType<typeof ignore>): FileChange[];

package/dist/src/project-graph/file-utils.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TEN_MEGABYTES = exports.DeletedFileChange = exports.WholeFileChange = void 0;
+exports.TEN_MEGABYTES = exports.LockFileChange = exports.DeletedFileChange = exports.WholeFileChange = void 0;
 exports.isWholeFileChange = isWholeFileChange;
 exports.isDeletedFileChange = isDeletedFileChange;
+exports.isLockFileChange = isLockFileChange;
 exports.calculateFileChanges = calculateFileChanges;
 exports.defaultFileRead = defaultFileRead;
 exports.readPackageJson = readPackageJson;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
+const os_1 = require("os");
 const path_1 = require("path");
 const fileutils_1 = require("../utils/fileutils");
 const ignore_1 = require("../utils/ignore");
@@ -25,16 +27,36 @@ class DeletedFileChange {
     }
 }
 exports.DeletedFileChange = DeletedFileChange;
+class LockFileChange {
+    constructor(baseContent, headContent) {
+        this.baseContent = baseContent;
+        this.headContent = headContent;
+        this.type = 'LockFileChange';
+    }
+}
+exports.LockFileChange = LockFileChange;
 function isWholeFileChange(change) {
     return change.type === 'WholeFileChange';
 }
 function isDeletedFileChange(change) {
     return change.type === 'WholeFileDeleted';
 }
+function isLockFileChange(change) {
+    return change.type === 'LockFileChange';
+}
+const TEXT_LOCK_FILES = new Set([
+    'yarn.lock',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'pnpm-lock.yml',
+    'bun.lock',
+]);
+const BINARY_LOCK_FILES = new Set(['bun.lockb']);
 function calculateFileChanges(files, nxArgs, readFileAtRevision = defaultReadFileAtRevision, ignore = (0, ignore_1.getIgnoreObject)()) {
     files = files.filter((f) => !ignore.ignores(f));
     return files.map((f) => {
         const ext = (0, path_1.extname)(f);
+        const basename = f.split('/').pop() ?? f;
         return {
             file: f,
             getChanges: () => {
@@ -47,6 +69,16 @@ function calculateFileChanges(files, nxArgs, readFileAtRevision = defaultReadFil
                 if (nxArgs.files && nxArgs.files.includes(f)) {
                     return [new WholeFileChange()];
                 }
+                if (TEXT_LOCK_FILES.has(basename) || BINARY_LOCK_FILES.has(basename)) {
+                    try {
+                        const atBase = readLockFileAtRevision(f, basename, nxArgs.base, readFileAtRevision);
+                        const atHead = readLockFileAtRevision(f, basename, nxArgs.head, readFileAtRevision);
+                        return [new LockFileChange(atBase, atHead)];
+                    }
+                    catch {
+                        return [new WholeFileChange()];
+                    }
+                }
                 switch (ext) {
                     case '.json':
                         try {
@@ -75,18 +107,17 @@ function calculateFileChanges(files, nxArgs, readFileAtRevision = defaultReadFil
         };
     });
 }
+function readLockFileAtRevision(file, lockFileName, revision, readFileAtRevision) {
+    if (lockFileName === 'bun.lockb' &&
+        readFileAtRevision === defaultReadFileAtRevision) {
+        return defaultReadBunLockFileAtRevision(file, revision);
+    }
+    return readFileAtRevision(file, revision);
+}
 exports.TEN_MEGABYTES = 1024 * 10000;
 function defaultReadFileAtRevision(file, revision) {
     try {
-        const fileFullPath = `${workspace_root_1.workspaceRoot}${path_1.sep}${file}`;
-        const gitRepositoryPath = (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
-            windowsHide: true,
-        })
-            .toString()
-            .trim();
-        const filePathInGitRepository = (0, path_1.relative)(gitRepositoryPath, fileFullPath)
-            .split(path_1.sep)
-            .join('/');
+        const filePathInGitRepository = getFilePathInGitRepository(file);
         return !revision
             ? (0, fs_1.readFileSync)(file, 'utf-8')
             : (0, child_process_1.execSync)(`git show ${revision}:${filePathInGitRepository}`, {
@@ -101,6 +132,43 @@ function defaultReadFileAtRevision(file, revision) {
         return '';
     }
 }
+function defaultReadBunLockFileAtRevision(file, revision) {
+    if (!revision) {
+        return (0, child_process_1.execFileSync)('bun', [(0, path_1.join)(workspace_root_1.workspaceRoot, file)], {
+            encoding: 'utf-8',
+            maxBuffer: exports.TEN_MEGABYTES,
+            windowsHide: true,
+        }).trim();
+    }
+    const filePathInGitRepository = getFilePathInGitRepository(file);
+    const tempDirectory = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'nx-bun-lock-'));
+    const tempLockfilePath = (0, path_1.join)(tempDirectory, 'bun.lockb');
+    try {
+        const lockFileContents = (0, child_process_1.execFileSync)('git', ['show', `${revision}:${filePathInGitRepository}`], {
+            maxBuffer: exports.TEN_MEGABYTES,
+            stdio: ['pipe', 'pipe', 'ignore'],
+            windowsHide: true,
+        });
+        (0, fs_1.writeFileSync)(tempLockfilePath, lockFileContents);
+        return (0, child_process_1.execFileSync)('bun', [tempLockfilePath], {
+            encoding: 'utf-8',
+            maxBuffer: exports.TEN_MEGABYTES,
+            windowsHide: true,
+        }).trim();
+    }
+    finally {
+        (0, fs_1.rmSync)(tempDirectory, { force: true, recursive: true });
+    }
+}
+function getFilePathInGitRepository(file) {
+    const fileFullPath = `${workspace_root_1.workspaceRoot}${path_1.sep}${file}`;
+    const gitRepositoryPath = (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+        windowsHide: true,
+    })
+        .toString()
+        .trim();
+    return (0, path_1.relative)(gitRepositoryPath, fileFullPath).split(path_1.sep).join('/');
+}
 function defaultFileRead(filePath) {
     return (0, fs_1.readFileSync)((0, path_1.join)(workspace_root_1.workspaceRoot, filePath), 'utf-8');
 }

package/dist/src/tasks-runner/init-tasks-runner.d.ts

@@ -3,5 +3,5 @@ import { Task, TaskGraph } from '../config/task-graph';
 import { LifeCycle, TaskResult } from './life-cycle';
 import type { ProjectGraph } from '../config/project-graph';
 import { RunningTask } from './running-tasks/running-task';
-export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Array<Promise<TaskResult[]>>>;
-export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Record<string, Promise<RunningTask>>>;
+export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Array<Promise<TaskResult[]>>>;
+export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Record<string, Promise<RunningTask>>>;

package/dist/src/tasks-runner/init-tasks-runner.js

@@ -10,7 +10,7 @@ const task_orchestrator_1 = require("./task-orchestrator");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const client_1 = require("../daemon/client/client");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
-async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
+async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle) {
     (0, dotenv_1.loadRootEnvFiles)();
     const invokeRunnerTerminalLifecycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(tasks);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
@@ -42,13 +42,13 @@ async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJs
         lifeCycle: compositedLifeCycle,
     };
     (0, run_command_1.setEnvVarsBasedOnArgs)(nxArgs, true);
-    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, tasks, projectGraph, taskGraph, nxJson, nxArgs, false, client_1.daemonClient, undefined, taskGraphForHashing);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, tasks, projectGraph, taskGraph, nxJson, nxArgs, false, client_1.daemonClient, undefined, fullTaskGraph);
     await orchestrator.init();
     orchestrator.processAllScheduledTasks();
     return orchestrator;
 }
-async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
-    const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
+async function runDiscreteTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle);
     let groupId = 0;
     let nextBatch = orchestrator.nextBatch();
     const batchResults = [];
@@ -77,8 +77,8 @@ async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson
     });
     return [...batchResults, ...taskResults];
 }
-async function runContinuousTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
-    const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
+async function runContinuousTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle);
     return tasks.reduce((current, task, index) => {
         current[task.id] = orchestrator.startContinuousTask(task, index);
         return current;

package/dist/src/tasks-runner/task-orchestrator.d.ts

@@ -21,7 +21,7 @@ export declare class TaskOrchestrator {
     private readonly bail;
     private readonly daemon;
     private readonly outputStyle;
-    private readonly taskGraphForHashing;
+    private readonly fullTaskGraph;
     private taskDetails;
     private cache;
     private readonly tuiEnabled;
@@ -49,7 +49,7 @@ export declare class TaskOrchestrator {
     private discreteTaskExitHandled;
     private continuousTaskExitHandled;
     private cleanupPromise;
-    constructor(hasher: TaskHasher, initiatingProject: string | undefined, initiatingTasks: Task[], projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string, taskGraphForHashing?: TaskGraph);
+    constructor(hasher: TaskHasher, initiatingProject: string | undefined, initiatingTasks: Task[], projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string, fullTaskGraph?: TaskGraph);
     init(): Promise<void>;
     run(): Promise<{
         [k: string]: TaskStatus;

package/dist/src/tasks-runner/task-orchestrator.js

@@ -39,7 +39,7 @@ function resolveBatchTaskStatus(result) {
 }
 class TaskOrchestrator {
     // endregion internal state
-    constructor(hasher, initiatingProject, initiatingTasks, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle, taskGraphForHashing = taskGraph) {
+    constructor(hasher, initiatingProject, initiatingTasks, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle, fullTaskGraph = taskGraph) {
         this.hasher = hasher;
         this.initiatingProject = initiatingProject;
         this.initiatingTasks = initiatingTasks;
@@ -50,7 +50,7 @@ class TaskOrchestrator {
         this.bail = bail;
         this.daemon = daemon;
         this.outputStyle = outputStyle;
-        this.taskGraphForHashing = taskGraphForHashing;
+        this.fullTaskGraph = fullTaskGraph;
         this.taskDetails = (0, hash_task_1.getTaskDetails)();
         this.cache = (0, cache_1.getCache)(this.options);
         this.tuiEnabled = (0, is_tui_enabled_1.isTuiEnabled)();
@@ -185,7 +185,7 @@ class TaskOrchestrator {
                     for (const task of unhashed) {
                         perTaskEnvs[task.id] = (0, task_env_1.getTaskSpecificEnv)(task, this.projectGraph);
                     }
-                    await (0, hash_task_1.hashTasks)(this.hasher, this.projectGraph, this.taskGraphForHashing, perTaskEnvs, this.taskDetails, unhashed);
+                    await (0, hash_task_1.hashTasks)(this.hasher, this.projectGraph, this.fullTaskGraph, perTaskEnvs, this.taskDetails, unhashed);
                 }
             }
             // 2. Bulk-resolve cache hits before processTask — avoids N
@@ -257,7 +257,7 @@ class TaskOrchestrator {
         const task = this.taskGraph.tasks[taskId];
         const taskSpecificEnv = (0, task_env_1.getTaskSpecificEnv)(task, this.projectGraph);
         if (!task.hash) {
-            await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraphForHashing, task, taskSpecificEnv, this.taskDetails);
+            await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.fullTaskGraph, task, taskSpecificEnv, this.taskDetails);
         }
         await this.options.lifeCycle.scheduleTask(task);
         return taskSpecificEnv;
@@ -474,7 +474,7 @@ class TaskOrchestrator {
         for (const task of tasks) {
             perTaskEnvs[task.id] = (0, task_env_1.getTaskSpecificEnv)(task, this.projectGraph);
         }
-        await (0, hash_task_1.hashTasks)(this.hasher, this.projectGraph, this.taskGraphForHashing, perTaskEnvs, this.taskDetails, tasks);
+        await (0, hash_task_1.hashTasks)(this.hasher, this.projectGraph, this.fullTaskGraph, perTaskEnvs, this.taskDetails, tasks);
     }
     async applyFromCacheOrRunBatch(doNotSkipCache, batch, groupId) {
         const applyFromCacheOrRunBatchStart = perf_hooks_1.performance.mark('TaskOrchestrator-apply-from-cache-or-run-batch:start');
@@ -542,7 +542,7 @@ class TaskOrchestrator {
     async runBatch(batch, env, groupId) {
         const runBatchStart = perf_hooks_1.performance.mark('TaskOrchestrator-run-batch:start');
         try {
-            const batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.projectGraph, this.taskGraph, env);
+            const batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.projectGraph, this.fullTaskGraph, env);
             // Stream output from batch process to the batch
             batchProcess.onOutput((output) => {
                 this.options.lifeCycle.appendBatchOutput?.(batch.id, output);