nx 23.3.0-beta.4 → 23.3.0-beta.6

package/dist/src/project-graph/affected/affected-tasks.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectsAffectedTasks = selectsAffectedTasks;
+exports.computeAffectedTasks = computeAffectedTasks;
+exports.selectAffectedTasks = selectAffectedTasks;
+const native_1 = require("../../native");
+const outputs_1 = require("../../io-snapshots/outputs");
+const overrides_1 = require("../../io-snapshots/overrides");
+const store_1 = require("../../io-snapshots/store");
+const create_task_graph_1 = require("../../tasks-runner/create-task-graph");
+const project_graph_utils_1 = require("../../utils/project-graph-utils");
+const utils_1 = require("../../tasks-runner/utils");
+const project_graph_1 = require("../project-graph");
+const file_utils_1 = require("../file-utils");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
+const logger_1 = require("../../utils/logger");
+const error_types_1 = require("../error-types");
+const workspace_root_1 = require("../../utils/workspace-root");
+const task_planning_context_1 = require("../../hasher/task-planning-context");
+const client_1 = require("../../daemon/client/client");
+const is_on_daemon_1 = require("../../daemon/is-on-daemon");
+const affected_projects_1 = require("./affected-projects");
+const lock_file_changes_1 = require("../../plugins/js/project-graph/affected/lock-file-changes");
+const npm_packages_1 = require("../../plugins/js/project-graph/affected/npm-packages");
+/**
+ * Whether `nx affected` selects the individual tasks whose inputs a change
+ * reaches, rather than whole projects. Off by default while the task path
+ * settles.
+ *
+ * Env-var only, so `nx show projects --affected` and `nx affected` in one CI
+ * script agree. The run also executes the selected tasks' dependencies.
+ */
+function selectsAffectedTasks() {
+    return process.env.NX_LEGACY_AFFECTED === 'false';
+}
+/**
+ * Selects the tasks a change reaches, rather than the projects that own a
+ * changed file.
+ *
+ * With the daemon on, the daemon selects: it hashes the run's tasks, so its
+ * planner is the one that remembers the plans. It returns the graph it selected
+ * against, which the command must run with.
+ */
+async function computeAffectedTasks(opts) {
+    const request = {
+        targets: opts.targets,
+        changedFiles: opts.touchedFiles.map((f) => f.file),
+        fileChangeArgs: opts.fileChangeArgs,
+        configuration: opts.configuration,
+        overrides: opts.overrides ?? {},
+        extraTargetDependencies: opts.extraTargetDependencies ?? {},
+        excludeTaskDependencies: opts.excludeTaskDependencies ?? false,
+        exclude: opts.exclude ?? [],
+        selectivelyHashTsConfig: opts.selectivelyHashTsConfig,
+    };
+    const ioSnapshots = (0, store_1.snapshotsOf)(opts.ioSnapshotOutcome ?? null);
+    if (ioSnapshots) {
+        request.ioSnapshots = {
+            commit: ioSnapshots.commit,
+            fetchedAt: ioSnapshots.resolution.fetchedAt,
+        };
+    }
+    if (!(0, is_on_daemon_1.isOnDaemon)() && client_1.daemonClient.enabled()) {
+        try {
+            const selection = await client_1.daemonClient.selectAffectedTasks(request);
+            return {
+                ...selection,
+                affectedTaskIds: new Set(selection.affectedTaskIds),
+                taskSelection: {
+                    ...selection.taskSelection,
+                    ioSnapshotOutcome: opts.ioSnapshotOutcome,
+                },
+            };
+        }
+        catch (e) {
+            if (e?.name === error_types_1.DaemonProjectGraphError.name) {
+                throw error_types_1.ProjectGraphError.fromDaemonProjectGraphError(e);
+            }
+            // Not rethrown: the graph fetch handles an unreachable daemon, and a
+            // selection error recurs in-process below.
+            logger_1.logger.verbose(`Selecting affected tasks in the daemon failed: ${e}`);
+        }
+    }
+    const projectGraph = opts.projectGraph ?? (await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true }));
+    const planningContext = (0, task_planning_context_1.createTaskPlanningContext)(projectGraph, opts.nxJson);
+    const selection = await selectAffectedTasks(projectGraph, opts.nxJson, planningContext, request, {
+        touchedFiles: opts.touchedFiles,
+        packageJson: opts.packageJson,
+        ioSnapshots,
+    });
+    return {
+        projectGraph,
+        affectedTaskIds: selection.affectedTaskIds,
+        taskGraph: selection.taskGraph,
+        taskSelection: {
+            ...selection.taskSelection,
+            // The planner remembers what selection planned, so the run's hashing reuses it.
+            planningContext,
+            ioSnapshotOutcome: opts.ioSnapshotOutcome,
+        },
+    };
+}
+/**
+ * Plans the targets' full task graph and matches the changed paths against
+ * every plan. No project-level prefilter: under an I/O snapshot a task can read
+ * files no affected project owns. Shared by the client and the daemon.
+ */
+async function selectAffectedTasks(projectGraph, nxJson, planningContext, request, { touchedFiles = (0, file_utils_1.calculateFileChanges)(request.changedFiles, request.fileChangeArgs), packageJson, ioSnapshots, } = {}) {
+    const { targets } = request;
+    // Only projects that have one of the targets: with a single target,
+    // createTaskGraph tries to create a task for projects that lack it and
+    // createTask throws.
+    const candidates = [...(0, project_graph_utils_1.runnableForTarget)(projectGraph.nodes, targets)];
+    if (!candidates.length) {
+        const empty = {
+            roots: [],
+            tasks: {},
+            dependencies: {},
+            continuousDependencies: {},
+        };
+        return {
+            affectedTaskIds: new Set(),
+            taskGraph: empty,
+            taskSelection: { taskGraph: empty, initiatingTaskIds: [], taskIds: [] },
+        };
+    }
+    const { taskGraph, dependencyOverrides } = (0, create_task_graph_1.createTaskGraphWithDependencyOverrides)(projectGraph, request.extraTargetDependencies, candidates, targets, request.configuration, request.overrides, 
+    // Dependencies carry a change even when they won't run; `keep` drops them.
+    false);
+    const taskIds = Object.keys(taskGraph.tasks);
+    // As the run hashes: observed outputs carry output reads, observed inputs match changes.
+    if (ioSnapshots) {
+        (0, outputs_1.applyIoSnapshotOutputs)(projectGraph, taskGraph, ioSnapshots);
+    }
+    const plans = ioSnapshots
+        ? planningContext.planner.getPlansReference(taskIds, taskGraph, ioSnapshots, (0, overrides_1.ioSnapshotEligibilityOptions)(projectGraph, taskGraph))
+        : planningContext.planner.getPlansReference(taskIds, taskGraph);
+    const dependencies = dependencyChanges(projectGraph, touchedFiles, nxJson, packageJson);
+    const namedProjects = new Set(dependencies.projects);
+    const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
+    const selection = (0, native_1.affectedTasks)(planningContext.projectGraphRef, plans, taskGraph, request.changedFiles, {
+        projectGlobPatterns: await (0, affected_projects_1.getProjectGlobPatterns)(nxJson),
+        workspaceRoot: workspace_root_1.workspaceRoot,
+        alwaysTouchedTaskIds: taskIds.filter((id) => namedProjects.has(taskGraph.tasks[id].target.project) ||
+            hasCustomHasher(taskGraph.tasks[id], projects)),
+        changedExternals: dependencies.externals,
+        changedExternalTypes: dependencies.changedExternalTypes,
+        excludedProjects: request.exclude.length
+            ? (0, find_matching_projects_1.findMatchingProjects)(request.exclude, projectGraph.nodes)
+            : [],
+        targets,
+        revisions: fileRevisions(request.fileChangeArgs),
+        selectivelyHashTsConfig: request.selectivelyHashTsConfig ?? false,
+    });
+    // The run builds from the owning projects, so only their requested tasks
+    // take the CLI overrides there; every other task is a dependency.
+    const owning = new Set(selection.affected.map((id) => taskGraph.tasks[id].target.project));
+    const initial = new Set(taskIds.filter((id) => {
+        const { project, target } = taskGraph.tasks[id].target;
+        return owning.has(project) && targets.includes(target);
+    }));
+    // Without dependencies the run builds its initial tasks and nothing else.
+    const keep = request.excludeTaskDependencies
+        ? selection.required.filter((id) => initial.has(id))
+        : selection.required;
+    return {
+        affectedTaskIds: new Set(selection.affected),
+        taskGraph,
+        taskSelection: {
+            // Edges that disagree on a dependency's overrides leave it to a build
+            // from the owning projects, which settles them the way the run always has.
+            taskGraph: (0, create_task_graph_1.filterTaskGraphToSelection)(projectGraph, taskGraph, dependencyOverrides, initial, new Set(keep)) ??
+                (0, utils_1.pruneToSelectedTasks)((0, create_task_graph_1.createTaskGraph)(projectGraph, request.extraTargetDependencies, [...owning], targets, request.configuration, request.overrides, request.excludeTaskDependencies), keep),
+            initiatingTaskIds: keep.filter((id) => initial.has(id)),
+            taskIds: keep,
+        },
+    };
+}
+/** Unset for `--files`, which names files without a diff to compare. */
+function fileRevisions(args) {
+    return args?.base && !args.files?.length
+        ? { base: args.base, head: args.head }
+        : undefined;
+}
+/**
+ * A custom hasher hashes outside the task's plan, so no instruction says what
+ * reaches it and the task is always selected. An executor that cannot be
+ * resolved cannot run either, so it is left to the plan.
+ */
+function hasCustomHasher(task, projects) {
+    try {
+        return !!(0, utils_1.getExecutorForTask)(task, projects).hasherFactory;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A lockfile or package.json change reaches a hash as `External(name)`, a
+ * package rather than a path, so it is handed to the plans as package names.
+ */
+function dependencyChanges(projectGraph, touchedFiles, nxJson, packageJson = (0, file_utils_1.readPackageJson)()) {
+    const changes = [
+        (0, lock_file_changes_1.lockFileDependencyChanges)(touchedFiles, projectGraph.nodes, nxJson, packageJson, projectGraph),
+        (0, npm_packages_1.packageJsonDependencyChanges)(touchedFiles, nxJson, projectGraph),
+    ];
+    return {
+        externals: [...new Set(changes.flatMap((c) => c.externals))],
+        changedExternalTypes: [
+            ...new Set(changes.flatMap((c) => c.changedExternalTypes)),
+        ],
+        projects: [...new Set(changes.flatMap((c) => c.projects))],
+    };
+}

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

@@ -15,6 +15,7 @@ const path_1 = require("path");
 const fileutils_1 = require("../utils/fileutils");
 const git_revision_1 = require("../utils/git-revision");
 const ignore_1 = require("../utils/ignore");
+const native_1 = require("../native");
 const json_diff_1 = require("../utils/json-diff");
 const workspace_root_1 = require("../utils/workspace-root");
 class WholeFileChange {
@@ -90,7 +91,10 @@ function calculateFileChanges(files, nxArgs, readFileAtRevision = defaultReadFil
                         try {
                             const atBase = readFileAtRevision(f, nxArgs.base);
                             const atHead = readFileAtRevision(f, nxArgs.head);
-                            return (0, json_diff_1.jsonDiff)(JSON.parse(atBase), JSON.parse(atHead));
+                            // Unset when either side is not strict JSON.
+                            return ((0, native_1.diffJson)(atBase, atHead) ?? [
+                                new WholeFileChange(),
+                            ]);
                         }
                         catch (e) {
                             return [new WholeFileChange()];
@@ -128,7 +132,7 @@ function defaultReadFileAtRevision(file, revision) {
     try {
         const filePathInGitRepository = getFilePathInGitRepository(file);
         return !revision
-            ? (0, fs_1.readFileSync)(file, 'utf-8')
+            ? (0, fs_1.readFileSync)((0, path_1.join)(workspace_root_1.workspaceRoot, file), 'utf-8')
             : (0, child_process_1.execFileSync)('git', ['show', `${revision}:${filePathInGitRepository}`], {
                 maxBuffer: exports.TEN_MEGABYTES,
                 stdio: ['pipe', 'pipe', 'ignore'],

package/dist/src/project-graph/utils/project-configuration/target-merging.js

@@ -139,6 +139,60 @@ function mergeConfigurationValue(newConfig, baseConfig, projectConfigSourceMap,
     }
     return merged;
 }
+// `ultracache` keeps replace-unless-`'...'` semantics at the object level, but its
+// values still have to be merged per key: neither the wholesale replace nor
+// `mergeObjectWithSpread` recurses, so an `ignoredReads: ['...', 'tmp/**']`
+// would otherwise reach the task graph with `'...'` intact — a glob matching
+// nothing, silently dropping the inherited patterns.
+function mergeUltracache(newUltracache, baseUltracache, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase) {
+    if (newUltracache === undefined) {
+        return baseUltracache;
+    }
+    const sourceMapContext = projectConfigSourceMap
+        ? {
+            sourceMap: projectConfigSourceMap,
+            key: `${targetIdentifier}.ultracache`,
+            sourceInformation,
+        }
+        : undefined;
+    // Object level first: this settles which keys survive, their order, and
+    // their source-map attribution.
+    const merged = (0, utils_1.getMergeValueResult)(baseUltracache, newUltracache, sourceMapContext, deferSpreadsWithoutBase);
+    if (!merged || typeof merged !== 'object' || Array.isArray(merged)) {
+        return merged;
+    }
+    // Copy before resolving: with no object-level spread `getMergeValueResult`
+    // returns `newUltracache` itself, and writing through it would edit the
+    // caller's target in place, corrupting later merge layers.
+    const resolved = { ...merged };
+    // Keys authored before `'...'` let the base win, exactly as they do at the
+    // target level. Re-resolving those would overwrite the object-level merge's
+    // decision and make authored position meaningless for array keys while
+    // still honouring it for scalar ones.
+    const authoredKeys = Object.keys(newUltracache);
+    const spreadPosition = authoredKeys.indexOf(utils_1.NX_SPREAD_TOKEN);
+    const keysBeforeSpread = spreadPosition >= 0
+        ? new Set(authoredKeys.slice(0, spreadPosition))
+        : new Set();
+    // Then re-resolve any key the target authored as an array, so a nested
+    // `'...'` expands against the inherited value rather than surviving as a
+    // literal element.
+    for (const key of Object.keys(resolved)) {
+        if (!Array.isArray(newUltracache[key]))
+            continue;
+        if (keysBeforeSpread.has(key) && baseUltracache && key in baseUltracache) {
+            continue;
+        }
+        resolved[key] = (0, utils_1.getMergeValueResult)(baseUltracache?.[key], newUltracache[key], projectConfigSourceMap
+            ? {
+                sourceMap: projectConfigSourceMap,
+                key: `${targetIdentifier}.ultracache.${key}`,
+                sourceInformation,
+            }
+            : undefined, deferSpreadsWithoutBase);
+    }
+    return resolved;
+}
 function mergeConfigurations(newConfigurations, baseConfigurations, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase) {
     const mergedConfigurations = {};
     // Keys before '...' let base win for shared names; keys after '...'
@@ -305,6 +359,7 @@ function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, s
     const skipForOwnMerge = new Set([
         'options',
         'configurations',
+        'ultracache',
         utils_1.NX_SPREAD_TOKEN,
     ]);
     const processKey = (key) => {
@@ -428,6 +483,18 @@ function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, s
                 sourceInformation;
         }
     }
+    // merge ultracache if either side declares one
+    // as with options, an incompatible target discards the base.
+    // `ultracache` is in `skipForOwnMerge` so the key-by-key pass leaves it to
+    // this block; removing it from that set would change only the key's position
+    // in the result, since this overwrites whatever the generic pass produced.
+    if ('ultracache' in target ||
+        (isCompatible && baseTarget && 'ultracache' in baseTarget)) {
+        const mergedUltracache = mergeUltracache(target.ultracache, isCompatible ? baseTarget?.ultracache : undefined, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase);
+        if (mergedUltracache !== undefined) {
+            result.ultracache = mergedUltracache;
+        }
+    }
     if (target.metadata) {
         result.metadata = mergeMetadata(projectConfigSourceMap, sourceInformation, `${targetIdentifier}.metadata`, target.metadata, baseTarget?.metadata);
     }

package/dist/src/project-graph/utils/project-configuration/target-normalization.js

@@ -10,6 +10,7 @@ const output_1 = require("../../../utils/output");
 const to_project_name_1 = require("../../../config/to-project-name");
 const error_types_1 = require("../../error-types");
 const target_merging_1 = require("./target-merging");
+const utils_1 = require("./utils");
 const node_fs_1 = require("node:fs");
 const git_worktrees_1 = require("../../../utils/git-worktrees");
 const path_1 = require("path");
@@ -176,6 +177,87 @@ function warnAboutLegacyCachedTargets(legacyCacheReads) {
         bodyLines,
     });
 }
+/**
+ * Nothing downstream rejects a key it does not know — the Rust hasher drops it,
+ * the Cloud runner reads only the keys it reads, and the Kotlin API decodes with
+ * `ignoreUnknownKeys`. So a typo is silent everywhere else, and this is the only
+ * place a misspelled option can be reported at all. `'...'` is listed because a
+ * spread with no base to resolve against survives merging.
+ */
+const KNOWN_ULTRACACHE_KEYS = new Set([
+    'mode',
+    'ignoredReads',
+    'ignoredWrites',
+    utils_1.NX_SPREAD_TOKEN,
+]);
+const ULTRACACHE_MODES = ['on', 'warn', 'error', 'off'];
+function describeUltracacheValue(value) {
+    if (Array.isArray(value))
+        return 'an array';
+    if (value === null)
+        return 'null';
+    return `a ${typeof value}`;
+}
+/**
+ * Describes every way an `ultracache` violates the shape the schema forbids.
+ *
+ * The schema is editor-only, and everything downstream — the Rust task hasher,
+ * the cloud runner's Go and Kotlin deserializers — is strict. A bad value that
+ * gets this far is reported far from its source, or silently drops the task's
+ * tracking, so it is worth reporting here where the project, target and file
+ * are all still in hand.
+ *
+ * Returns messages rather than throwing: only a WorkspaceValidityError is
+ * collected by `validateAndNormalizeProjectRootMap`, and anything else escapes
+ * as far as the daemon, which exits on an error it cannot classify.
+ */
+function validateTargetUltracache(ultracache, projectName, projectRoot, targetName, sourceMaps) {
+    if (ultracache === undefined) {
+        return [];
+    }
+    const targetSourceMaps = sourceMaps?.[projectRoot];
+    const [file, plugin] = targetSourceMaps?.[`targets.${targetName}.ultracache`] ??
+        targetSourceMaps?.[`targets.${targetName}`] ??
+        [];
+    const origin = file
+        ? ` (defined in ${file})`
+        : plugin
+            ? ` (defined by ${plugin})`
+            : '';
+    const where = `"${targetName}" in project "${projectName}"${origin}`;
+    if (!(0, utils_1.isObject)(ultracache)) {
+        return [
+            `The "ultracache" configuration for target ${where} must be an object, but it is ${describeUltracacheValue(ultracache)}.`,
+        ];
+    }
+    const errors = [];
+    for (const key of Object.keys(ultracache)) {
+        if (!KNOWN_ULTRACACHE_KEYS.has(key)) {
+            errors.push(`"ultracache.${key}" for target ${where} is not an ultracache option. Supported options are "mode", "ignoredReads" and "ignoredWrites".`);
+        }
+    }
+    if (ultracache.mode !== undefined &&
+        !ULTRACACHE_MODES.includes(ultracache.mode)) {
+        const supported = ULTRACACHE_MODES.map((mode) => `"${mode}"`).join(', ');
+        errors.push(`"ultracache.mode" for target ${where} must be one of ${supported}, but it is ${typeof ultracache.mode === 'string'
+            ? `"${ultracache.mode}"`
+            : describeUltracacheValue(ultracache.mode)}.`);
+    }
+    for (const key of ['ignoredReads', 'ignoredWrites']) {
+        const value = ultracache[key];
+        if (value === undefined)
+            continue;
+        if (!Array.isArray(value)) {
+            errors.push(`"ultracache.${key}" for target ${where} must be an array of glob patterns, but it is ${describeUltracacheValue(value)}.`);
+            continue;
+        }
+        const badIndex = value.findIndex((glob) => typeof glob !== 'string');
+        if (badIndex !== -1) {
+            errors.push(`"ultracache.${key}[${badIndex}]" for target ${where} must be a glob pattern string, but it is ${describeUltracacheValue(value[badIndex])}.`);
+        }
+    }
+    return errors;
+}
 function normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, 
 /**
  * Project configurations keyed by project name
@@ -190,6 +272,7 @@ legacyCacheReads) {
     for (const targetName in project.targets) {
         project.targets[targetName] = normalizeTarget(project.targets[targetName], project, workspaceRoot, projects, [project.root, targetName].join(':'));
         const target = project.targets[targetName];
+        targetErrorMessage.push(...validateTargetUltracache(target.ultracache, project.name ?? project.root, project.root, targetName, sourceMaps).map((message) => `- ${message}`));
         const targetDefaults = nxJsonConfiguration.targetDefaults;
         if (isLegacyCachedTarget(targetName, targetDefaults, target)) {
             target.cache = true;

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

@@ -35,4 +35,5 @@ type SourceMapContext = {
  * preserved so a later merge layer can expand it.
  */
 export declare function getMergeValueResult<T>(baseValue: unknown, newValue: T | undefined, sourceMapContext?: SourceMapContext, deferSpreadsWithoutBase?: boolean): T | undefined;
+export declare function isObject(value: unknown): value is Record<string, unknown>;
 export {};

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

@@ -4,6 +4,7 @@ exports.IntegerLikeSpreadKeyError = exports.INTEGER_LIKE_KEY_PATTERN = exports.N
 exports.uniqueKeysInObjects = uniqueKeysInObjects;
 exports.assertNoIntegerLikeSpreadKey = assertNoIntegerLikeSpreadKey;
 exports.getMergeValueResult = getMergeValueResult;
+exports.isObject = isObject;
 const source_maps_1 = require("./source-maps");
 exports.NX_SPREAD_TOKEN = '...';
 /**

package/dist/src/tasks-runner/create-task-graph.d.ts

@@ -1,9 +1,20 @@
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
 import { TargetDependencies } from '../config/nx-json';
+/**
+ * For each task, the overrides every `dependsOn` edge into it would give it,
+ * whether or not that edge created the task. `from` is the task the edge
+ * leaves; an edge crossing a project without the target is recorded against
+ * the task it started from.
+ */
+export type DependencyOverrides = Record<string, Array<{
+    from: string;
+    overrides: Record<string, unknown>;
+}>>;
 export declare class ProcessTasks {
     private readonly extraTargetDependencies;
     private readonly projectGraph;
+    private readonly recordDependencyOverrides;
     private readonly seen;
     readonly tasks: {
         [id: string]: Task;
@@ -14,18 +25,30 @@ export declare class ProcessTasks {
     readonly continuousDependencies: {
         [k: string]: string[];
     };
+    readonly dependencyOverrides: DependencyOverrides;
     private readonly allTargetNames;
-    constructor(extraTargetDependencies: TargetDependencies, projectGraph: ProjectGraph);
+    constructor(extraTargetDependencies: TargetDependencies, projectGraph: ProjectGraph, recordDependencyOverrides?: boolean);
     processTasks(projectNames: string[], targets: string[], configuration: string, overrides: Record<string, unknown>, excludeTaskDependencies: boolean): string[];
     processTask(task: Task, projectUsedToDeriveDependencies: string, configuration: string, overrides: Record<string, unknown>): void;
     private processTasksForMultipleProjects;
     private processTasksForSingleProject;
     private processTasksForDependencies;
+    private recordEdge;
     private createDummyTask;
     createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Record<string, unknown>): Task;
     resolveConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string | undefined): string;
 }
 export declare function createTaskGraph(projectGraph: ProjectGraph, extraTargetDependencies: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Record<string, unknown>, excludeTaskDependencies?: boolean): TaskGraph;
+/** `createTaskGraph`, plus the overrides each dependency edge would give. */
+export declare function createTaskGraphWithDependencyOverrides(projectGraph: ProjectGraph, extraTargetDependencies: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Record<string, unknown>, excludeTaskDependencies?: boolean): {
+    taskGraph: TaskGraph;
+    dependencyOverrides: DependencyOverrides;
+};
+/**
+ * `taskGraph` pruned to `keep`, as if built from `initial` alone: a kept dependency
+ * takes the overrides its edges give it. Undefined when those edges disagree or are missing.
+ */
+export declare function filterTaskGraphToSelection(projectGraph: ProjectGraph, taskGraph: TaskGraph, dependencyOverrides: DependencyOverrides, initial: Set<string>, keep: Set<string>): TaskGraph | undefined;
 /**
  * This function is used to filter out the dummy tasks from the dependencies
  * It will manipulate the dependencies object in place

package/dist/src/tasks-runner/create-task-graph.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProcessTasks = void 0;
 exports.createTaskGraph = createTaskGraph;
+exports.createTaskGraphWithDependencyOverrides = createTaskGraphWithDependencyOverrides;
+exports.filterTaskGraphToSelection = filterTaskGraphToSelection;
 exports.filterDummyTasks = filterDummyTasks;
 exports.getNonDummyDeps = getNonDummyDeps;
 const utils_1 = require("./utils");
@@ -10,13 +12,15 @@ const output_1 = require("../utils/output");
 const task_graph_utils_1 = require("./task-graph-utils");
 const DUMMY_TASK_TARGET = '__nx_dummy_task__';
 class ProcessTasks {
-    constructor(extraTargetDependencies, projectGraph) {
+    constructor(extraTargetDependencies, projectGraph, recordDependencyOverrides = false) {
         this.extraTargetDependencies = extraTargetDependencies;
         this.projectGraph = projectGraph;
+        this.recordDependencyOverrides = recordDependencyOverrides;
         this.seen = new Set();
         this.tasks = {};
         this.dependencies = {};
         this.continuousDependencies = {};
+        this.dependencyOverrides = {};
         const allTargetNames = new Set();
         for (const projectName in projectGraph.nodes) {
             const project = projectGraph.nodes[projectName];
@@ -126,6 +130,7 @@ class ProcessTasks {
                 this.processTask(newTask, newTask.target.project, configuration, overrides);
             }
             if (task.id !== selfTaskId) {
+                this.recordEdge(task, selfTaskId, taskOverrides);
                 if (this.tasks[selfTaskId].continuous) {
                     this.continuousDependencies[task.id].push(selfTaskId);
                 }
@@ -149,6 +154,7 @@ class ProcessTasks {
                 const depTargetId = (0, utils_1.createTaskId)(depProject.name, dependencyConfig.target, resolvedConfiguration);
                 const depTargetConfiguration = this.projectGraph.nodes[depProject.name].data.targets[dependencyConfig.target];
                 if (task.id !== depTargetId) {
+                    this.recordEdge(task, depTargetId, taskOverrides);
                     if (depTargetConfiguration.continuous) {
                         this.continuousDependencies[task.id].push(depTargetId);
                     }
@@ -180,6 +186,14 @@ class ProcessTasks {
             }
         }
     }
+    recordEdge(task, dependencyId, overrides) {
+        if (!this.recordDependencyOverrides) {
+            return;
+        }
+        // A dummy task keeps its creator's target, so `from` is the real task the edge started from.
+        const from = (0, utils_1.createTaskId)(task.target.project, task.target.target, task.target.configuration);
+        (this.dependencyOverrides[dependencyId] ??= []).push({ from, overrides });
+    }
     createDummyTask(id, task) {
         return {
             ...task,
@@ -208,6 +222,7 @@ class ProcessTasks {
             cache: project.data.targets[target].cache ?? false,
             parallelism: project.data.targets[target].parallelism ?? true,
             continuous: project.data.targets[target].continuous ?? false,
+            ultracache: project.data.targets[target].ultracache,
         };
     }
     resolveConfiguration(project, target, configuration) {
@@ -220,7 +235,46 @@ class ProcessTasks {
 }
 exports.ProcessTasks = ProcessTasks;
 function createTaskGraph(projectGraph, extraTargetDependencies, projectNames, targets, configuration, overrides, excludeTaskDependencies = false) {
-    const p = new ProcessTasks(extraTargetDependencies, projectGraph);
+    return buildTaskGraph(new ProcessTasks(extraTargetDependencies, projectGraph), projectNames, targets, configuration, overrides, excludeTaskDependencies);
+}
+/** `createTaskGraph`, plus the overrides each dependency edge would give. */
+function createTaskGraphWithDependencyOverrides(projectGraph, extraTargetDependencies, projectNames, targets, configuration, overrides, excludeTaskDependencies = false) {
+    const p = new ProcessTasks(extraTargetDependencies, projectGraph, true);
+    const taskGraph = buildTaskGraph(p, projectNames, targets, configuration, overrides, excludeTaskDependencies);
+    return { taskGraph, dependencyOverrides: p.dependencyOverrides };
+}
+/**
+ * `taskGraph` pruned to `keep`, as if built from `initial` alone: a kept dependency
+ * takes the overrides its edges give it. Undefined when those edges disagree or are missing.
+ */
+function filterTaskGraphToSelection(projectGraph, taskGraph, dependencyOverrides, initial, keep) {
+    const tasks = {};
+    for (const id of keep) {
+        const task = taskGraph.tasks[id];
+        if (initial.has(id)) {
+            tasks[id] = { ...task };
+            continue;
+        }
+        const edges = dependencyOverrides[id] ?? [];
+        if (!edges.length) {
+            return undefined;
+        }
+        const first = JSON.stringify(edges[0].overrides);
+        if (edges.some((e) => JSON.stringify(e.overrides) !== first)) {
+            return undefined;
+        }
+        const project = projectGraph.nodes[task.target.project];
+        const overrides = interpolateOverrides(edges[0].overrides, project.name, project.data);
+        tasks[id] = {
+            ...task,
+            overrides,
+            outputs: (0, utils_1.getOutputs)(projectGraph.nodes, task.target, overrides),
+        };
+    }
+    const pruned = (0, utils_1.removeTasksFromTaskGraph)(taskGraph, Object.keys(taskGraph.tasks).filter((id) => !keep.has(id)));
+    return { ...pruned, tasks };
+}
+function buildTaskGraph(p, projectNames, targets, configuration, overrides, excludeTaskDependencies) {
     const roots = p.processTasks(projectNames, targets, configuration, overrides, excludeTaskDependencies);
     return {
         roots,

package/dist/src/tasks-runner/forked-process-task-runner.js

@@ -144,7 +144,7 @@ class ForkedProcessTaskRunner {
         // Register forked process for metrics collection
         const pid = p.getPid();
         if (pid) {
-            (0, task_io_service_1.registerTaskProcessStart)(task.id, pid);
+            (0, task_io_service_1.registerTaskProcessStart)(task, pid);
         }
         p.send({
             targetDescription: task.target,
@@ -181,7 +181,7 @@ class ForkedProcessTaskRunner {
             });
             // Register forked process for metrics collection
             if (p.pid) {
-                (0, task_io_service_1.registerTaskProcessStart)(task.id, p.pid);
+                (0, task_io_service_1.registerTaskProcessStart)(task, p.pid);
             }
             // Send message to run the executor
             p.send({
@@ -224,7 +224,7 @@ class ForkedProcessTaskRunner {
             });
             // Register forked process for metrics collection
             if (p.pid) {
-                (0, task_io_service_1.registerTaskProcessStart)(task.id, p.pid);
+                (0, task_io_service_1.registerTaskProcessStart)(task, p.pid);
             }
             const cp = new node_child_process_1.NodeChildProcessWithDirectOutput(p, temporaryOutputPath);
             this.processes.add(cp);

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

@@ -1,7 +1,12 @@
 import type { NxJsonConfiguration } from '../config/nx-json';
 import { Task, TaskGraph } from '../config/task-graph';
 import { LifeCycle, TaskResult } from './life-cycle';
+import type { IoSnapshots } from '../native';
 import type { ProjectGraph } from '../config/project-graph';
 import { RunningTask } from './running-tasks/running-task';
-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>>>;
+export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle, 
+/** The set to hash from, e.g. from `importIoSnapshots`; omitted hashes natively. */
+ioSnapshots?: IoSnapshots): Promise<Array<Promise<TaskResult[]>>>;
+export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle, 
+/** The set to hash from, e.g. from `importIoSnapshots`; omitted hashes natively. */
+ioSnapshots?: IoSnapshots): Promise<Record<string, Promise<RunningTask>>>;